engineShaders top-level property
Every shader the engine asks for, in WGSL, beside the
reflection a GPUShaderModule cannot be asked for.
Implementation
final WebGpuSectionStages engineShaders = (
vertex: <String, WebGpuStage>{
'MeshVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(2)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(3)
var morph_texture_smp: sampler;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e40 = (*t);
let _e44 = (*rowStep);
row = ((f32((_e40 * 3i)) + 0.5f) * _e44);
let _e46 = (*column);
let _e47 = row;
let _e49 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e46, _e47), 0f);
let _e51 = (*weight);
let _e53 = (*position_1);
(*position_1) = (_e53 + (_e49.xyz * _e51));
let _e55 = (*column);
let _e56 = row;
let _e57 = (*rowStep);
let _e60 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e55, (_e56 + _e57)), 0f);
let _e62 = (*weight);
let _e64 = (*normal_1);
(*normal_1) = (_e64 + (_e60.xyz * _e62));
let _e66 = (*column);
let _e67 = row;
let _e68 = (*rowStep);
let _e72 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e66, (_e67 + (_e68 * 2f))), 0f);
let _e74 = (*weight);
let _e76 = (*tangent_1);
let _e78 = (_e76.xyz + (_e72.xyz * _e74));
(*tangent_1)[0u] = _e78.x;
(*tangent_1)[1u] = _e78.y;
(*tangent_1)[2u] = _e78.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e32 = gl_VertexIndex_1;
let _e37 = morph_info.morph_params[1u];
return ((f32(_e32) + 0.5f) * _e37);
}
fn MorphCount_u0028_() -> i32 {
let _e34 = morph_info.morph_params[0u];
return i32((_e34 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e47 = MorphCount_u0028_();
count = _e47;
let _e48 = count;
if (_e48 <= 0i) {
return;
}
let _e50 = MorphColumn_u0028_();
column_1 = _e50;
let _e53 = morph_info.morph_params[2u];
rowStep_1 = _e53;
i = 0i;
loop {
let _e54 = i;
if (_e54 < 8i) {
let _e56 = i;
let _e57 = count;
if (_e56 >= _e57) {
break;
}
let _e59 = i;
let _e61 = i;
let _e72 = morph_info.morph_weights[(_e59 / 4i)][(_e61 - (i32(floor((f32(_e61) / f32(4i)))) * 4i))];
weight_1 = _e72;
let _e73 = weight_1;
if (_e73 == 0f) {
continue;
}
let _e75 = i;
param = _e75;
let _e76 = weight_1;
param_1 = _e76;
let _e77 = column_1;
param_2 = _e77;
let _e78 = rowStep_1;
param_3 = _e78;
let _e79 = (*position_2);
param_4 = _e79;
let _e80 = (*normal_2);
param_5 = _e80;
let _e81 = (*tangent_2);
param_6 = _e81;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e82 = param_4;
(*position_2) = _e82;
let _e83 = param_5;
(*normal_2) = _e83;
let _e84 = param_6;
(*tangent_2) = _e84;
continue;
} else {
break;
}
continuing {
let _e85 = i;
i = (_e85 + 1i);
}
}
return;
}
fn main_1() {
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var world: vec4<f32>;
let _e39 = position_3;
morphed_position = _e39;
let _e40 = normal_3;
morphed_normal = _e40;
let _e41 = tangent_3;
morphed_tangent = _e41;
let _e42 = morphed_position;
param_7 = _e42;
let _e43 = morphed_normal;
param_8 = _e43;
let _e44 = morphed_tangent;
param_9 = _e44;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e45 = param_7;
morphed_position = _e45;
let _e46 = param_8;
morphed_normal = _e46;
let _e47 = param_9;
morphed_tangent = _e47;
let _e49 = frame_info.model;
let _e50 = morphed_position;
world = (_e49 * vec4<f32>(_e50.x, _e50.y, _e50.z, 1f));
let _e56 = world;
v_world_position = _e56.xyz;
let _e59 = frame_info.normal_matrix;
let _e67 = morphed_normal;
v_normal = (mat3x3<f32>(_e59[0].xyz, _e59[1].xyz, _e59[2].xyz) * _e67);
let _e69 = texcoord_1;
v_texcoord = _e69;
let _e71 = frame_info.model;
let _e79 = morphed_tangent;
let _e81 = (mat3x3<f32>(_e71[0].xyz, _e71[1].xyz, _e71[2].xyz) * _e79.xyz);
let _e83 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e81.x, _e81.y, _e81.z, _e83);
let _e88 = color_1;
v_color = _e88;
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e90 = frame_info.mvp;
let _e91 = morphed_position;
unnamed.gl_Position = (_e90 * vec4<f32>(_e91.x, _e91.y, _e91.z, 1f));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
position_3 = position;
normal_3 = normal;
tangent_3 = tangent;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e21 = v_world_position;
let _e22 = v_normal;
let _e23 = v_texcoord;
let _e24 = v_tangent;
let _e25 = v_color;
let _e26 = v_lightmap_uv;
let _e27 = unnamed.gl_Position;
return VertexOutput(_e21, _e22, _e23, _e24, _e25, _e26, _e27);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'DebugLineVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct LineInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_line_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> line_info: LineInfo;
var<private> position_1: vec3<f32>;
fn main_1() {
let _e8 = color_1;
v_line_color = _e8;
let _e10 = line_info.view_projection;
let _e11 = position_1;
unnamed.gl_Position = (_e10 * vec4<f32>(_e11.x, _e11.y, _e11.z, 1f));
return;
}
@vertex
fn main(@location(1) color: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
color_1 = color;
position_1 = position;
main_1();
let _e7 = v_line_color;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'color',
location: 1,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'LineInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'FullscreenVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(5) member: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e8 = texcoord_1;
v_uv = _e8;
let _e9 = position_1;
unnamed.gl_Position = vec4<f32>(_e9.x, _e9.y, 0f, 1f);
return;
}
@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e7 = v_uv;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'texcoord',
location: 1,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'MeshSkinnedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct SkinInfo {
joint_matrices: array<mat4x4<f32>, 64>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(3) member_2: vec4<f32>,
@location(4) member_3: vec2<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(3)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_texture_smp: sampler;
var<private> weights_1: vec4<f32>;
@group(0) @binding(2)
var<uniform> skin_info: SkinInfo;
var<private> joints_1: vec4<f32>;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e46 = (*t);
let _e50 = (*rowStep);
row = ((f32((_e46 * 3i)) + 0.5f) * _e50);
let _e52 = (*column);
let _e53 = row;
let _e55 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e52, _e53), 0f);
let _e57 = (*weight);
let _e59 = (*position_1);
(*position_1) = (_e59 + (_e55.xyz * _e57));
let _e61 = (*column);
let _e62 = row;
let _e63 = (*rowStep);
let _e66 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e61, (_e62 + _e63)), 0f);
let _e68 = (*weight);
let _e70 = (*normal_1);
(*normal_1) = (_e70 + (_e66.xyz * _e68));
let _e72 = (*column);
let _e73 = row;
let _e74 = (*rowStep);
let _e78 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e72, (_e73 + (_e74 * 2f))), 0f);
let _e80 = (*weight);
let _e82 = (*tangent_1);
let _e84 = (_e82.xyz + (_e78.xyz * _e80));
(*tangent_1)[0u] = _e84.x;
(*tangent_1)[1u] = _e84.y;
(*tangent_1)[2u] = _e84.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e38 = gl_VertexIndex_1;
let _e43 = morph_info.morph_params[1u];
return ((f32(_e38) + 0.5f) * _e43);
}
fn MorphCount_u0028_() -> i32 {
let _e40 = morph_info.morph_params[0u];
return i32((_e40 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e53 = MorphCount_u0028_();
count = _e53;
let _e54 = count;
if (_e54 <= 0i) {
return;
}
let _e56 = MorphColumn_u0028_();
column_1 = _e56;
let _e59 = morph_info.morph_params[2u];
rowStep_1 = _e59;
i = 0i;
loop {
let _e60 = i;
if (_e60 < 8i) {
let _e62 = i;
let _e63 = count;
if (_e62 >= _e63) {
break;
}
let _e65 = i;
let _e67 = i;
let _e78 = morph_info.morph_weights[(_e65 / 4i)][(_e67 - (i32(floor((f32(_e67) / f32(4i)))) * 4i))];
weight_1 = _e78;
let _e79 = weight_1;
if (_e79 == 0f) {
continue;
}
let _e81 = i;
param = _e81;
let _e82 = weight_1;
param_1 = _e82;
let _e83 = column_1;
param_2 = _e83;
let _e84 = rowStep_1;
param_3 = _e84;
let _e85 = (*position_2);
param_4 = _e85;
let _e86 = (*normal_2);
param_5 = _e86;
let _e87 = (*tangent_2);
param_6 = _e87;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e88 = param_4;
(*position_2) = _e88;
let _e89 = param_5;
(*normal_2) = _e89;
let _e90 = param_6;
(*tangent_2) = _e90;
continue;
} else {
break;
}
continuing {
let _e91 = i;
i = (_e91 + 1i);
}
}
return;
}
fn SkinMatrix_u0028_() -> mat4x4<f32> {
var total: f32;
var w: vec4<f32>;
var local: vec4<f32>;
let _e42 = weights_1[0u];
let _e44 = weights_1[1u];
let _e47 = weights_1[2u];
let _e50 = weights_1[3u];
total = (((_e42 + _e44) + _e47) + _e50);
let _e52 = total;
if (_e52 > 0.00001f) {
let _e54 = weights_1;
let _e55 = total;
local = (_e54 / vec4(_e55));
} else {
local = vec4<f32>(1f, 0f, 0f, 0f);
}
let _e58 = local;
w = _e58;
let _e60 = w[0u];
let _e62 = joints_1[0u];
let _e66 = skin_info.joint_matrices[i32(_e62)];
let _e67 = (_e66 * _e60);
let _e69 = w[1u];
let _e71 = joints_1[1u];
let _e75 = skin_info.joint_matrices[i32(_e71)];
let _e76 = (_e75 * _e69);
let _e89 = mat4x4<f32>((_e67[0] + _e76[0]), (_e67[1] + _e76[1]), (_e67[2] + _e76[2]), (_e67[3] + _e76[3]));
let _e91 = w[2u];
let _e93 = joints_1[2u];
let _e97 = skin_info.joint_matrices[i32(_e93)];
let _e98 = (_e97 * _e91);
let _e111 = mat4x4<f32>((_e89[0] + _e98[0]), (_e89[1] + _e98[1]), (_e89[2] + _e98[2]), (_e89[3] + _e98[3]));
let _e113 = w[3u];
let _e115 = joints_1[3u];
let _e119 = skin_info.joint_matrices[i32(_e115)];
let _e120 = (_e119 * _e113);
return mat4x4<f32>((_e111[0] + _e120[0]), (_e111[1] + _e120[1]), (_e111[2] + _e120[2]), (_e111[3] + _e120[3]));
}
fn main_1() {
var skin: mat4x4<f32>;
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var skinnedModel: mat4x4<f32>;
var world: vec4<f32>;
var skinRotation: mat3x3<f32>;
let _e48 = SkinMatrix_u0028_();
skin = _e48;
let _e49 = position_3;
morphed_position = _e49;
let _e50 = normal_3;
morphed_normal = _e50;
let _e51 = tangent_3;
morphed_tangent = _e51;
let _e52 = morphed_position;
param_7 = _e52;
let _e53 = morphed_normal;
param_8 = _e53;
let _e54 = morphed_tangent;
param_9 = _e54;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e55 = param_7;
morphed_position = _e55;
let _e56 = param_8;
morphed_normal = _e56;
let _e57 = param_9;
morphed_tangent = _e57;
let _e59 = frame_info.model;
let _e60 = skin;
skinnedModel = (_e59 * _e60);
let _e62 = skinnedModel;
let _e63 = morphed_position;
world = (_e62 * vec4<f32>(_e63.x, _e63.y, _e63.z, 1f));
let _e69 = world;
v_world_position = _e69.xyz;
let _e71 = skin;
skinRotation = mat3x3<f32>(_e71[0].xyz, _e71[1].xyz, _e71[2].xyz);
let _e80 = frame_info.normal_matrix;
let _e88 = skinRotation;
let _e89 = morphed_normal;
v_normal = (mat3x3<f32>(_e80[0].xyz, _e80[1].xyz, _e80[2].xyz) * (_e88 * _e89));
let _e93 = frame_info.model;
let _e101 = skinRotation;
let _e102 = morphed_tangent;
let _e105 = (mat3x3<f32>(_e93[0].xyz, _e93[1].xyz, _e93[2].xyz) * (_e101 * _e102.xyz));
let _e107 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e105.x, _e105.y, _e105.z, _e107);
let _e112 = texcoord_1;
v_texcoord = _e112;
let _e113 = color_1;
v_color = _e113;
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e115 = frame_info.mvp;
let _e116 = skin;
let _e117 = morphed_position;
unnamed.gl_Position = (_e115 * (_e116 * vec4<f32>(_e117.x, _e117.y, _e117.z, 1f)));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(6) weights: vec4<f32>, @location(5) joints: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
weights_1 = weights;
joints_1 = joints;
position_3 = position;
normal_3 = normal;
tangent_3 = tangent;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e25 = v_world_position;
let _e26 = v_normal;
let _e27 = v_tangent;
let _e28 = v_texcoord;
let _e29 = v_color;
let _e30 = v_lightmap_uv;
let _e31 = unnamed.gl_Position;
return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'joints',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'weights',
location: 6,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'SkinInfo',
group: 0,
binding: 2,
sizeInBytes: 4096,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'joint_matrices',
offsetInBytes: 0,
sizeInBytes: 4096,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MeshInstancedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct MorphInstanceInfo {
instance_params: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(5)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(6)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> morph_instance_info: MorphInstanceInfo;
@group(0) @binding(3)
var morph_instance_weights_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_instance_weights_smp: sampler;
var<private> i_row0_1: vec4<f32>;
var<private> i_row1_1: vec4<f32>;
var<private> i_row2_1: vec4<f32>;
var<private> position_4: vec3<f32>;
var<private> normal_4: vec3<f32>;
var<private> tangent_4: vec4<f32>;
var<private> gl_InstanceIndex_1: i32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e48 = (*t);
let _e52 = (*rowStep);
row = ((f32((_e48 * 3i)) + 0.5f) * _e52);
let _e54 = (*column);
let _e55 = row;
let _e57 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e54, _e55), 0f);
let _e59 = (*weight);
let _e61 = (*position_1);
(*position_1) = (_e61 + (_e57.xyz * _e59));
let _e63 = (*column);
let _e64 = row;
let _e65 = (*rowStep);
let _e68 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e63, (_e64 + _e65)), 0f);
let _e70 = (*weight);
let _e72 = (*normal_1);
(*normal_1) = (_e72 + (_e68.xyz * _e70));
let _e74 = (*column);
let _e75 = row;
let _e76 = (*rowStep);
let _e80 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e74, (_e75 + (_e76 * 2f))), 0f);
let _e82 = (*weight);
let _e84 = (*tangent_1);
let _e86 = (_e84.xyz + (_e80.xyz * _e82));
(*tangent_1)[0u] = _e86.x;
(*tangent_1)[1u] = _e86.y;
(*tangent_1)[2u] = _e86.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e40 = gl_VertexIndex_1;
let _e45 = morph_info.morph_params[1u];
return ((f32(_e40) + 0.5f) * _e45);
}
fn MorphCount_u0028_() -> i32 {
let _e42 = morph_info.morph_params[0u];
return i32((_e42 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e55 = MorphCount_u0028_();
count = _e55;
let _e56 = count;
if (_e56 <= 0i) {
return;
}
let _e58 = MorphColumn_u0028_();
column_1 = _e58;
let _e61 = morph_info.morph_params[2u];
rowStep_1 = _e61;
i = 0i;
loop {
let _e62 = i;
if (_e62 < 8i) {
let _e64 = i;
let _e65 = count;
if (_e64 >= _e65) {
break;
}
let _e67 = i;
let _e69 = i;
let _e80 = morph_info.morph_weights[(_e67 / 4i)][(_e69 - (i32(floor((f32(_e69) / f32(4i)))) * 4i))];
weight_1 = _e80;
let _e81 = weight_1;
if (_e81 == 0f) {
continue;
}
let _e83 = i;
param = _e83;
let _e84 = weight_1;
param_1 = _e84;
let _e85 = column_1;
param_2 = _e85;
let _e86 = rowStep_1;
param_3 = _e86;
let _e87 = (*position_2);
param_4 = _e87;
let _e88 = (*normal_2);
param_5 = _e88;
let _e89 = (*tangent_2);
param_6 = _e89;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e90 = param_4;
(*position_2) = _e90;
let _e91 = param_5;
(*normal_2) = _e91;
let _e92 = param_6;
(*tangent_2) = _e92;
continue;
} else {
break;
}
continuing {
let _e93 = i;
i = (_e93 + 1i);
}
}
return;
}
fn ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(instance: ptr<function, i32>, position_3: ptr<function, vec3<f32>>, normal_3: ptr<function, vec3<f32>>, tangent_3: ptr<function, vec4<f32>>) {
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var count_1: i32;
var deltaColumn: f32;
var deltaRowStep: f32;
var row_1: f32;
var i_1: i32;
var column_2: f32;
var weight_2: f32;
var param_10: i32;
var param_11: f32;
var param_12: f32;
var param_13: f32;
var param_14: vec3<f32>;
var param_15: vec3<f32>;
var param_16: vec4<f32>;
let _e63 = morph_instance_info.instance_params[0u];
if (_e63 < 0.5f) {
let _e65 = (*position_3);
param_7 = _e65;
let _e66 = (*normal_3);
param_8 = _e66;
let _e67 = (*tangent_3);
param_9 = _e67;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e68 = param_7;
(*position_3) = _e68;
let _e69 = param_8;
(*normal_3) = _e69;
let _e70 = param_9;
(*tangent_3) = _e70;
return;
}
let _e71 = MorphCount_u0028_();
count_1 = _e71;
let _e72 = count_1;
if (_e72 <= 0i) {
return;
}
let _e74 = MorphColumn_u0028_();
deltaColumn = _e74;
let _e77 = morph_info.morph_params[2u];
deltaRowStep = _e77;
let _e78 = (*instance);
let _e83 = morph_instance_info.instance_params[2u];
row_1 = ((f32(_e78) + 0.5f) * _e83);
i_1 = 0i;
loop {
let _e85 = i_1;
if (_e85 < 8i) {
let _e87 = i_1;
let _e88 = count_1;
if (_e87 >= _e88) {
break;
}
let _e90 = i_1;
let _e96 = morph_instance_info.instance_params[1u];
column_2 = ((f32((_e90 / 4i)) + 0.5f) * _e96);
let _e98 = column_2;
let _e99 = row_1;
let _e101 = textureSampleLevel(morph_instance_weights_tex, morph_instance_weights_smp, vec2<f32>(_e98, _e99), 0f);
let _e102 = i_1;
let _e109 = (_e102 - (i32(floor((f32(_e102) / f32(4i)))) * 4i));
weight_2 = select(select(select(_e101[0i], _e101[1i], (1i == _e109)), _e101[2i], (2i == _e109)), _e101[3i], (3i == _e109));
let _e124 = weight_2;
if (_e124 == 0f) {
continue;
}
let _e126 = i_1;
param_10 = _e126;
let _e127 = weight_2;
param_11 = _e127;
let _e128 = deltaColumn;
param_12 = _e128;
let _e129 = deltaRowStep;
param_13 = _e129;
let _e130 = (*position_3);
param_14 = _e130;
let _e131 = (*normal_3);
param_15 = _e131;
let _e132 = (*tangent_3);
param_16 = _e132;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m_10), (¶m_11), (¶m_12), (¶m_13), (¶m_14), (¶m_15), (¶m_16));
let _e133 = param_14;
(*position_3) = _e133;
let _e134 = param_15;
(*normal_3) = _e134;
let _e135 = param_16;
(*tangent_3) = _e135;
continue;
} else {
break;
}
continuing {
let _e136 = i_1;
i_1 = (_e136 + 1i);
}
}
return;
}
fn main_1() {
var instance_1: mat4x4<f32>;
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_17: i32;
var param_18: vec3<f32>;
var param_19: vec3<f32>;
var param_20: vec4<f32>;
var local: vec4<f32>;
var world: vec4<f32>;
var rotation: mat3x3<f32>;
let _e52 = i_row0_1[0u];
let _e54 = i_row1_1[0u];
let _e56 = i_row2_1[0u];
let _e57 = vec4<f32>(_e52, _e54, _e56, 0f);
let _e59 = i_row0_1[1u];
let _e61 = i_row1_1[1u];
let _e63 = i_row2_1[1u];
let _e64 = vec4<f32>(_e59, _e61, _e63, 0f);
let _e66 = i_row0_1[2u];
let _e68 = i_row1_1[2u];
let _e70 = i_row2_1[2u];
let _e71 = vec4<f32>(_e66, _e68, _e70, 0f);
let _e73 = i_row0_1[3u];
let _e75 = i_row1_1[3u];
let _e77 = i_row2_1[3u];
let _e78 = vec4<f32>(_e73, _e75, _e77, 1f);
instance_1 = mat4x4<f32>(vec4<f32>(_e57.x, _e57.y, _e57.z, _e57.w), vec4<f32>(_e64.x, _e64.y, _e64.z, _e64.w), vec4<f32>(_e71.x, _e71.y, _e71.z, _e71.w), vec4<f32>(_e78.x, _e78.y, _e78.z, _e78.w));
let _e100 = position_4;
morphed_position = _e100;
let _e101 = normal_4;
morphed_normal = _e101;
let _e102 = tangent_4;
morphed_tangent = _e102;
let _e103 = gl_InstanceIndex_1;
param_17 = _e103;
let _e104 = morphed_position;
param_18 = _e104;
let _e105 = morphed_normal;
param_19 = _e105;
let _e106 = morphed_tangent;
param_20 = _e106;
ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m_17), (¶m_18), (¶m_19), (¶m_20));
let _e107 = param_18;
morphed_position = _e107;
let _e108 = param_19;
morphed_normal = _e108;
let _e109 = param_20;
morphed_tangent = _e109;
let _e110 = instance_1;
let _e111 = morphed_position;
local = (_e110 * vec4<f32>(_e111.x, _e111.y, _e111.z, 1f));
let _e118 = frame_info.model;
let _e119 = local;
world = (_e118 * _e119);
let _e121 = world;
v_world_position = _e121.xyz;
let _e123 = instance_1;
rotation = mat3x3<f32>(_e123[0].xyz, _e123[1].xyz, _e123[2].xyz);
let _e132 = frame_info.normal_matrix;
let _e140 = rotation;
let _e141 = morphed_normal;
v_normal = (mat3x3<f32>(_e132[0].xyz, _e132[1].xyz, _e132[2].xyz) * normalize((_e140 * _e141)));
let _e145 = texcoord_1;
v_texcoord = _e145;
let _e147 = frame_info.model;
let _e155 = rotation;
let _e156 = morphed_tangent;
let _e159 = (mat3x3<f32>(_e147[0].xyz, _e147[1].xyz, _e147[2].xyz) * (_e155 * _e156.xyz));
let _e161 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e159.x, _e159.y, _e159.z, _e161);
let _e166 = color_1;
let _e167 = i_color_1;
v_color = (_e166 * _e167);
v_lightmap_uv = vec2<f32>(0f, 0f);
let _e170 = frame_info.mvp;
let _e171 = local;
unnamed.gl_Position = (_e170 * _e171);
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(5) i_row0_: vec4<f32>, @location(6) i_row1_: vec4<f32>, @location(7) i_row2_: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @builtin(instance_index) gl_InstanceIndex: u32, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>, @location(8) i_color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
i_row0_1 = i_row0_;
i_row1_1 = i_row1_;
i_row2_1 = i_row2_;
position_4 = position;
normal_4 = normal;
tangent_4 = tangent;
gl_InstanceIndex_1 = i32(gl_InstanceIndex);
texcoord_1 = texcoord;
color_1 = color;
i_color_1 = i_color;
main_1();
let _e32 = v_world_position;
let _e33 = v_normal;
let _e34 = v_texcoord;
let _e35 = v_tangent;
let _e36 = v_color;
let _e37 = v_lightmap_uv;
let _e38 = unnamed.gl_Position;
return VertexOutput(_e32, _e33, _e34, _e35, _e36, _e37, _e38);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row0',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row1',
location: 6,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_row2',
location: 7,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_color',
location: 8,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'MorphInstanceInfo',
group: 0,
binding: 2,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'instance_params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_instance_weights',
group: 0,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MeshLightmappedVertex': WebGpuStage(
wgsl: r'''
struct MorphInfo {
morph_weights: array<vec4<f32>, 2>,
morph_params: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
var<private> gl_VertexIndex_1: i32;
@group(0) @binding(2)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(3)
var morph_texture_smp: sampler;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> color_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, tangent_1: ptr<function, vec4<f32>>) {
var row: f32;
let _e40 = (*t);
let _e44 = (*rowStep);
row = ((f32((_e40 * 3i)) + 0.5f) * _e44);
let _e46 = (*column);
let _e47 = row;
let _e49 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e46, _e47), 0f);
let _e51 = (*weight);
let _e53 = (*position_1);
(*position_1) = (_e53 + (_e49.xyz * _e51));
let _e55 = (*column);
let _e56 = row;
let _e57 = (*rowStep);
let _e60 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e55, (_e56 + _e57)), 0f);
let _e62 = (*weight);
let _e64 = (*normal_1);
(*normal_1) = (_e64 + (_e60.xyz * _e62));
let _e66 = (*column);
let _e67 = row;
let _e68 = (*rowStep);
let _e72 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e66, (_e67 + (_e68 * 2f))), 0f);
let _e74 = (*weight);
let _e76 = (*tangent_1);
let _e78 = (_e76.xyz + (_e72.xyz * _e74));
(*tangent_1)[0u] = _e78.x;
(*tangent_1)[1u] = _e78.y;
(*tangent_1)[2u] = _e78.z;
return;
}
fn MorphColumn_u0028_() -> f32 {
let _e32 = gl_VertexIndex_1;
let _e37 = morph_info.morph_params[1u];
return ((f32(_e32) + 0.5f) * _e37);
}
fn MorphCount_u0028_() -> i32 {
let _e34 = morph_info.morph_params[0u];
return i32((_e34 + 0.5f));
}
fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
var count: i32;
var column_1: f32;
var rowStep_1: f32;
var i: i32;
var weight_1: f32;
var param: i32;
var param_1: f32;
var param_2: f32;
var param_3: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec4<f32>;
let _e47 = MorphCount_u0028_();
count = _e47;
let _e48 = count;
if (_e48 <= 0i) {
return;
}
let _e50 = MorphColumn_u0028_();
column_1 = _e50;
let _e53 = morph_info.morph_params[2u];
rowStep_1 = _e53;
i = 0i;
loop {
let _e54 = i;
if (_e54 < 8i) {
let _e56 = i;
let _e57 = count;
if (_e56 >= _e57) {
break;
}
let _e59 = i;
let _e61 = i;
let _e72 = morph_info.morph_weights[(_e59 / 4i)][(_e61 - (i32(floor((f32(_e61) / f32(4i)))) * 4i))];
weight_1 = _e72;
let _e73 = weight_1;
if (_e73 == 0f) {
continue;
}
let _e75 = i;
param = _e75;
let _e76 = weight_1;
param_1 = _e76;
let _e77 = column_1;
param_2 = _e77;
let _e78 = rowStep_1;
param_3 = _e78;
let _e79 = (*position_2);
param_4 = _e79;
let _e80 = (*normal_2);
param_5 = _e80;
let _e81 = (*tangent_2);
param_6 = _e81;
AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((¶m), (¶m_1), (¶m_2), (¶m_3), (¶m_4), (¶m_5), (¶m_6));
let _e82 = param_4;
(*position_2) = _e82;
let _e83 = param_5;
(*normal_2) = _e83;
let _e84 = param_6;
(*tangent_2) = _e84;
continue;
} else {
break;
}
continuing {
let _e85 = i;
i = (_e85 + 1i);
}
}
return;
}
fn main_1() {
var morphed_position: vec3<f32>;
var morphed_normal: vec3<f32>;
var morphed_tangent: vec4<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec4<f32>;
var world: vec4<f32>;
let _e39 = position_3;
morphed_position = _e39;
let _e40 = normal_3;
morphed_normal = _e40;
let _e41 = tangent_3;
morphed_tangent = _e41;
let _e42 = morphed_position;
param_7 = _e42;
let _e43 = morphed_normal;
param_8 = _e43;
let _e44 = morphed_tangent;
param_9 = _e44;
ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((¶m_7), (¶m_8), (¶m_9));
let _e45 = param_7;
morphed_position = _e45;
let _e46 = param_8;
morphed_normal = _e46;
let _e47 = param_9;
morphed_tangent = _e47;
let _e49 = frame_info.model;
let _e50 = morphed_position;
world = (_e49 * vec4<f32>(_e50.x, _e50.y, _e50.z, 1f));
let _e56 = world;
v_world_position = _e56.xyz;
let _e59 = frame_info.normal_matrix;
let _e67 = morphed_normal;
v_normal = (mat3x3<f32>(_e59[0].xyz, _e59[1].xyz, _e59[2].xyz) * _e67);
let _e69 = texcoord_1;
v_texcoord = _e69;
let _e71 = frame_info.model;
let _e79 = morphed_tangent;
let _e81 = (mat3x3<f32>(_e71[0].xyz, _e71[1].xyz, _e71[2].xyz) * _e79.xyz);
let _e83 = morphed_tangent[3u];
v_tangent = vec4<f32>(_e81.x, _e81.y, _e81.z, _e83);
v_color = vec4<f32>(1f, 1f, 1f, 1f);
let _e88 = color_1;
v_lightmap_uv = _e88.xy;
let _e91 = frame_info.mvp;
let _e92 = morphed_position;
unnamed.gl_Position = (_e91 * vec4<f32>(_e92.x, _e92.y, _e92.z, 1f));
return;
}
@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
gl_VertexIndex_1 = i32(gl_VertexIndex);
position_3 = position;
normal_3 = normal;
tangent_3 = tangent;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e21 = v_world_position;
let _e22 = v_normal;
let _e23 = v_texcoord;
let _e24 = v_tangent;
let _e25 = v_color;
let _e26 = v_lightmap_uv;
let _e27 = unnamed.gl_Position;
return VertexOutput(_e21, _e22, _e23, _e24, _e25, _e26, _e27);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MorphInfo',
group: 0,
binding: 1,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'morph_weights',
offsetInBytes: 0,
sizeInBytes: 32,
),
WebGpuBlockMember(
name: 'morph_params',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'morph_texture',
group: 0,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'PolylineVertex': WebGpuStage(
wgsl: r'''
struct MaterialParams {
viewport: vec4<f32>,
}
struct FrameInfo {
mvp: mat4x4<f32>,
model: mat4x4<f32>,
normal_matrix: mat4x4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@builtin(position) gl_Position: vec4<f32>,
@location(6) member: vec3<f32>,
@location(2) member_1: vec3<f32>,
@location(4) member_2: vec2<f32>,
@location(3) member_3: vec4<f32>,
@location(0) member_4: vec4<f32>,
@location(1) member_5: vec2<f32>,
}
@group(0) @binding(1)
var<uniform> params: MaterialParams;
var<private> tangent_1: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> position_1: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
fn ToPixels_u0028_vf4_u003b_vf2_u003b(clip: ptr<function, vec4<f32>>, viewport: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e32 = (*clip);
let _e35 = (*clip)[3u];
let _e38 = (*viewport);
return (((_e32.xy / vec2(_e35)) * _e38) * 0.5f);
}
fn InFront_u0028_vf4_u003b_vf4_u003b(from_: ptr<function, vec4<f32>>, to: ptr<function, vec4<f32>>) -> vec4<f32> {
var t: f32;
let _e34 = (*from_)[3u];
if (_e34 >= 0.0001f) {
let _e36 = (*from_);
return _e36;
}
let _e38 = (*from_)[3u];
let _e41 = (*to)[3u];
let _e43 = (*from_)[3u];
t = ((0.0001f - _e38) / (_e41 - _e43));
let _e46 = (*from_);
let _e47 = (*to);
let _e48 = t;
return mix(_e46, _e47, vec4(clamp(_e48, 0f, 1f)));
}
fn main_1() {
var viewport_1: vec2<f32>;
var halfWidth: f32;
var side: f32;
var here: vec4<f32>;
var before: vec4<f32>;
var after: vec4<f32>;
var local: vec4<f32>;
var param: vec4<f32>;
var param_1: vec4<f32>;
var param_2: vec4<f32>;
var param_3: vec4<f32>;
var param_4: vec4<f32>;
var param_5: vec4<f32>;
var param_6: vec4<f32>;
var param_7: vec4<f32>;
var dir: vec2<f32>;
var param_8: vec4<f32>;
var param_9: vec2<f32>;
var param_10: vec4<f32>;
var param_11: vec2<f32>;
var dirLength: f32;
var segmentNormal: vec2<f32>;
var local_1: vec2<f32>;
var offset: vec2<f32>;
let _e55 = params.viewport;
viewport_1 = _e55.xy;
let _e58 = tangent_1[3u];
halfWidth = abs(_e58);
let _e61 = tangent_1[3u];
side = select(1f, -1f, (_e61 < 0f));
let _e65 = frame_info.mvp;
let _e66 = position_1;
here = (_e65 * vec4<f32>(_e66.x, _e66.y, _e66.z, 1f));
let _e73 = frame_info.mvp;
let _e74 = normal_1;
before = (_e73 * vec4<f32>(_e74.x, _e74.y, _e74.z, 1f));
let _e81 = frame_info.mvp;
let _e82 = tangent_1;
let _e83 = _e82.xyz;
after = (_e81 * vec4<f32>(_e83.x, _e83.y, _e83.z, 1f));
let _e90 = here[3u];
if (_e90 < 0.0001f) {
let _e93 = after[3u];
if (_e93 >= 0.0001f) {
let _e95 = here;
param = _e95;
let _e96 = after;
param_1 = _e96;
let _e97 = InFront_u0028_vf4_u003b_vf4_u003b((¶m), (¶m_1));
local = _e97;
} else {
let _e98 = here;
param_2 = _e98;
let _e99 = before;
param_3 = _e99;
let _e100 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_2), (¶m_3));
local = _e100;
}
let _e101 = local;
here = _e101;
}
let _e102 = before;
param_4 = _e102;
let _e103 = here;
param_5 = _e103;
let _e104 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_4), (¶m_5));
before = _e104;
let _e105 = after;
param_6 = _e105;
let _e106 = here;
param_7 = _e106;
let _e107 = InFront_u0028_vf4_u003b_vf4_u003b((¶m_6), (¶m_7));
after = _e107;
let _e108 = after;
param_8 = _e108;
let _e109 = viewport_1;
param_9 = _e109;
let _e110 = ToPixels_u0028_vf4_u003b_vf2_u003b((¶m_8), (¶m_9));
let _e111 = before;
param_10 = _e111;
let _e112 = viewport_1;
param_11 = _e112;
let _e113 = ToPixels_u0028_vf4_u003b_vf2_u003b((¶m_10), (¶m_11));
dir = (_e110 - _e113);
let _e115 = dir;
dirLength = length(_e115);
let _e117 = dirLength;
if (_e117 > 0.000000001f) {
let _e120 = dir[1u];
let _e123 = dir[0u];
let _e125 = dirLength;
local_1 = (vec2<f32>(-(_e120), _e123) / vec2(_e125));
} else {
local_1 = vec2<f32>(1f, 0f);
}
let _e128 = local_1;
segmentNormal = _e128;
let _e129 = segmentNormal;
let _e130 = halfWidth;
let _e132 = side;
offset = ((_e129 * _e130) * _e132);
let _e134 = here;
let _e136 = offset;
let _e137 = viewport_1;
let _e141 = here[3u];
let _e143 = (_e134.xy + ((_e136 / (_e137 * 0.5f)) * _e141));
let _e144 = here;
let _e145 = _e144.zw;
unnamed.gl_Position = vec4<f32>(_e143.x, _e143.y, _e145.x, _e145.y);
let _e153 = frame_info.model;
let _e154 = position_1;
v_world_position = (_e153 * vec4<f32>(_e154.x, _e154.y, _e154.z, 1f)).xyz;
let _e162 = frame_info.normal_matrix;
v_normal = normalize((mat3x3<f32>(_e162[0].xyz, _e162[1].xyz, _e162[2].xyz) * vec3<f32>(0f, 1f, 0f)));
let _e172 = texcoord_1;
v_texcoord = _e172;
v_tangent = vec4<f32>(1f, 0f, 0f, 1f);
let _e173 = color_1;
v_color = _e173;
v_lightmap_uv = vec2<f32>(0f, 0f);
return;
}
@vertex
fn main(@location(3) tangent: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
tangent_1 = tangent;
position_1 = position;
normal_1 = normal;
texcoord_1 = texcoord;
color_1 = color;
main_1();
let _e18 = unnamed.gl_Position;
let _e19 = v_world_position;
let _e20 = v_normal;
let _e21 = v_texcoord;
let _e22 = v_tangent;
let _e23 = v_color;
let _e24 = v_lightmap_uv;
return VertexOutput(_e18, _e19, _e20, _e21, _e22, _e23, _e24);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'tangent',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'color',
location: 4,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FrameInfo',
group: 0,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
WebGpuBlockMember(
name: 'model',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'normal_matrix',
offsetInBytes: 128,
sizeInBytes: 64,
),
],
),
WebGpuBlock(
name: 'MaterialParams',
group: 0,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'viewport',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct ParticleInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@location(5) member_1: vec2<f32>,
@location(6) member_2: vec3<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_world_position: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_info: ParticleInfo;
fn main_1() {
let _e11 = color_1;
v_color = _e11;
let _e12 = texcoord_1;
v_uv = _e12;
let _e13 = position_1;
v_world_position = _e13;
let _e15 = particle_info.view_projection;
let _e16 = position_1;
unnamed.gl_Position = (_e15 * vec4<f32>(_e16.x, _e16.y, _e16.z, 1f));
return;
}
@vertex
fn main(@location(1) color: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
color_1 = color;
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e11 = v_color;
let _e12 = v_uv;
let _e13 = v_world_position;
let _e14 = unnamed.gl_Position;
return VertexOutput(_e11, _e12, _e13, _e14);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'color',
location: 1,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ParticleInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleMeshVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct ParticleMeshInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@location(6) member_1: vec3<f32>,
@location(2) member_2: vec3<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> i_position_1: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> i_scale_1: f32;
var<private> v_color: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_mesh_info: ParticleMeshInfo;
fn main_1() {
var world: vec3<f32>;
let _e14 = i_position_1;
let _e15 = position_1;
let _e16 = i_scale_1;
world = (_e14 + (_e15 * _e16));
let _e19 = i_color_1;
v_color = _e19;
let _e20 = world;
v_world_position = _e20;
let _e21 = normal_1;
v_normal = _e21;
let _e23 = particle_mesh_info.view_projection;
let _e24 = world;
unnamed.gl_Position = (_e23 * vec4<f32>(_e24.x, _e24.y, _e24.z, 1f));
return;
}
@vertex
fn main(@location(2) i_position: vec3<f32>, @location(0) position: vec3<f32>, @location(4) i_scale: f32, @location(3) i_color: vec4<f32>, @location(1) normal: vec3<f32>) -> VertexOutput {
i_position_1 = i_position;
position_1 = position;
i_scale_1 = i_scale;
i_color_1 = i_color;
normal_1 = normal;
main_1();
let _e15 = v_color;
let _e16 = v_world_position;
let _e17 = v_normal;
let _e18 = unnamed.gl_Position;
return VertexOutput(_e15, _e16, _e17, _e18);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_position',
location: 2,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_color',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_scale',
location: 4,
format: VertexFormat.float32,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ParticleMeshInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ShadowTileResetVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(5) member: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e7 = texcoord_1;
v_uv = _e7;
let _e8 = position_1;
unnamed.gl_Position = vec4<f32>(_e8.x, _e8.y, 1f, 1f);
return;
}
@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e7 = v_uv;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'texcoord',
location: 1,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(4) member: vec3<f32>,
@location(7) member_1: vec4<f32>,
@location(2) member_2: vec4<f32>,
@location(3) member_3: vec4<f32>,
@location(5) member_4: vec4<f32>,
@location(1) member_5: vec4<f32>,
@location(0) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_zenith: vec4<f32>;
var<private> zenith_1: vec4<f32>;
var<private> v_horizon: vec4<f32>;
var<private> horizon_1: vec4<f32>;
var<private> v_nadir: vec4<f32>;
var<private> nadir_1: vec4<f32>;
var<private> v_sun: vec4<f32>;
var<private> sun_1: vec4<f32>;
var<private> v_glow: vec4<f32>;
var<private> glow_1: vec4<f32>;
var<private> v_disc: vec4<f32>;
var<private> disc_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e20 = corner_ray_1;
v_ray = _e20;
let _e21 = zenith_1;
v_zenith = _e21;
let _e22 = horizon_1;
v_horizon = _e22;
let _e23 = nadir_1;
v_nadir = _e23;
let _e24 = sun_1;
v_sun = _e24;
let _e25 = glow_1;
v_glow = _e25;
let _e26 = disc_1;
v_disc = _e26;
let _e27 = position_1;
unnamed.gl_Position = vec4<f32>(_e27.x, _e27.y, 0.999999f, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) zenith: vec4<f32>, @location(3) horizon: vec4<f32>, @location(4) nadir: vec4<f32>, @location(5) sun: vec4<f32>, @location(6) glow: vec4<f32>, @location(7) disc: vec4<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
zenith_1 = zenith;
horizon_1 = horizon;
nadir_1 = nadir;
sun_1 = sun;
glow_1 = glow;
disc_1 = disc;
position_1 = position;
main_1();
let _e25 = v_ray;
let _e26 = v_zenith;
let _e27 = v_horizon;
let _e28 = v_nadir;
let _e29 = v_sun;
let _e30 = v_glow;
let _e31 = v_disc;
let _e32 = unnamed.gl_Position;
return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31, _e32);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'zenith',
location: 2,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'horizon',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'nadir',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'sun',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'glow',
location: 6,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'disc',
location: 7,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyCubeVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(4) member: vec3<f32>,
@location(6) member_1: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_tint: vec4<f32>;
var<private> tint_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e10 = corner_ray_1;
v_ray = _e10;
let _e11 = tint_1;
v_tint = _e11;
let _e12 = position_1;
unnamed.gl_Position = vec4<f32>(_e12.x, _e12.y, 0.999999f, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) tint: vec4<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
tint_1 = tint;
position_1 = position;
main_1();
let _e10 = v_ray;
let _e11 = v_tint;
let _e12 = unnamed.gl_Position;
return VertexOutput(_e10, _e11, _e12);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'tint',
location: 2,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'VertexTextureProbeVertex': WebGpuStage(
wgsl: r'''
struct ProbeInfo {
at: vec4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_sampled: vec4<f32>;
@group(0) @binding(1)
var probe_texture_tex: texture_2d<f32>;
@group(0) @binding(2)
var probe_texture_smp: sampler;
@group(0) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;
fn main_1() {
let _e11 = probe_info.at;
let _e13 = textureSampleLevel(probe_texture_tex, probe_texture_smp, _e11.xy, 0f);
v_sampled = _e13;
let _e14 = position_1;
unnamed.gl_Position = vec4<f32>(_e14.x, _e14.y, _e14.z, 1f);
return;
}
@vertex
fn main(@location(0) position: vec3<f32>) -> VertexOutput {
position_1 = position;
main_1();
let _e5 = v_sampled;
let _e6 = unnamed.gl_Position;
return VertexOutput(_e5, _e6);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ProbeInfo',
group: 0,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'at', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'probe_texture',
group: 0,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
},
fragment: <String, WebGpuStage>{
'Unlit': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e60 = (*n)[0u];
let _e63 = (*n)[1u];
let _e67 = (*n)[2u];
let _e70 = (*n);
(*n) = (_e70 / vec3(((abs(_e60) + abs(_e63)) + abs(_e67))));
let _e73 = (*n);
e = _e73.xy;
let _e76 = (*n)[2u];
if (_e76 < 0f) {
let _e78 = (*n);
let _e84 = (*n)[0u];
let _e88 = (*n)[1u];
e = ((vec2(1f) - abs(_e78.yx)) * vec2<f32>(select(-1f, 1f, (_e84 >= 0f)), select(-1f, 1f, (_e88 >= 0f))));
}
let _e93 = e;
return ((_e93 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e57 = v_world_position_1;
let _e59 = fog_info.eye;
let _e63 = fog_info.forward;
return dot((_e57 - _e59.xyz), _e63.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var geometric: vec3<f32>;
var param: vec3<f32>;
let _e60 = g_debug_surface_on;
if _e60 {
let _e61 = g_debug_surface;
let _e62 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e61.x, _e61.y, _e61.z, _e62);
return;
}
let _e67 = v_normal_1;
geometric = normalize(_e67);
let _e69 = gl_FrontFacing_1;
if !(_e69) {
let _e71 = geometric;
geometric = -(_e71);
}
let _e73 = geometric;
param = _e73;
let _e74 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e75 = (*roughness);
let _e77 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e74.x, _e74.y, clamp(_e75, 0f, 1f), _e77);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e57 = v_world_position_1;
let _e59 = fog_info.eye;
return distance(_e57, _e59.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e62 = fog_info.fog[3u];
density = _e62;
let _e63 = density;
if (_e63 <= 0f) {
let _e65 = (*color);
return _e65;
}
let _e66 = EyeDistance_u0028_();
d = _e66;
let _e68 = fog_info.fog;
let _e70 = (*color);
let _e71 = density;
let _e73 = d;
return mix(_e68.xyz, _e70, vec3(clamp(exp((-(_e71) * _e73)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e62 = (*linearColor);
param_1 = _e62;
let _e63 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e64 = (*alpha);
frag_color = vec4<f32>(_e63.x, _e63.y, _e63.z, _e64);
let _e69 = (*roughness_1);
param_2 = _e69;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_1: ptr<function, f32>) {
var param_3: vec3<f32>;
var param_4: f32;
var param_5: f32;
let _e62 = (*linearColor_1);
param_3 = _e62;
let _e63 = (*alpha_1);
param_4 = _e63;
param_5 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_3), (¶m_4), (¶m_5));
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e58 = (*srgb);
let _e61 = (*srgb);
let _e66 = (*srgb);
return mix((_e58 / vec3(12.92f)), pow(((_e61 + 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), _e66));
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s: Surface;
var param_6: vec3<f32>;
var param_7: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise: f32;
let _e64 = v_texcoord_1;
let _e65 = textureSample(base_color_texture_tex, base_color_texture_smp, _e64);
texel = _e65;
let _e66 = texel;
param_6 = _e66.xyz;
let _e68 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e70 = frag_info.base_color;
param_7 = _e70.xyz;
let _e72 = SrgbToLinear_u0028_vf3_u003b((¶m_7));
let _e74 = v_color_1;
s.albedo = ((_e68 * _e72) * _e74.xyz);
let _e79 = texel[3u];
let _e82 = frag_info.base_color[3u];
let _e85 = v_color_1[3u];
s.alpha = ((_e79 * _e82) * _e85);
let _e90 = frag_info.material2_[0u];
cutoff = _e90;
let _e91 = cutoff;
if (_e91 >= 0f) {
let _e94 = s.alpha;
let _e95 = cutoff;
if (_e94 < _e95) {
discard;
}
} else {
let _e97 = cutoff;
if (_e97 < -1.5f) {
let _e99 = v_world_position_1;
anchored = floor((_e99 * 16f));
let _e102 = anchored;
noise = fract((sin(dot(_e102, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e108 = s.alpha;
let _e109 = noise;
if (_e108 < _e109) {
discard;
}
}
}
let _e111 = v_normal_1;
s.n = normalize(_e111);
let _e114 = gl_FrontFacing_1;
if !(_e114) {
let _e117 = s.n;
s.n = -(_e117);
}
let _e121 = frag_info.camera_position;
let _e123 = v_world_position_1;
s.v = normalize((_e121.xyz - _e123));
let _e128 = s.n;
let _e130 = s.v;
s.n_dot_v = max(dot(_e128, _e130), 0.0001f);
let _e136 = frag_info.material[0u];
s.metallic = clamp(_e136, 0f, 1f);
let _e141 = frag_info.material[1u];
s.roughness = clamp(_e141, 0.02f, 1f);
let _e145 = frag_info.ambient_ground;
let _e148 = frag_info.ambient_sky;
let _e152 = s.n[1u];
let _e159 = frag_info.material[2u];
s.ambient = (mix(_e145.xyz, _e148.xyz, vec3(((_e152 * 0.5f) + 0.5f))) * _e159);
let _e164 = frag_info.frame_params[0u];
s.exposure = max(_e164, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e169 = s;
return _e169;
}
fn main_1() {
var s_1: Surface;
var param_8: vec3<f32>;
var param_9: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e60 = ReadSurface_u0028_();
s_1 = _e60;
let _e62 = s_1.albedo;
param_8 = _e62;
let _e64 = s_1.alpha;
param_9 = _e64;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Xray': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e55 = v_world_position_1;
let _e57 = fog_info.eye;
return distance(_e55, _e57.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e60 = fog_info.fog[3u];
density = _e60;
let _e61 = density;
if (_e61 <= 0f) {
let _e63 = (*color);
return _e63;
}
let _e64 = EyeDistance_u0028_();
d = _e64;
let _e66 = fog_info.fog;
let _e68 = (*color);
let _e69 = density;
let _e71 = d;
return mix(_e66.xyz, _e68, vec3(clamp(exp((-(_e69) * _e71)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param: vec3<f32>;
var param_1: f32;
let _e60 = (*linearColor);
param = _e60;
let _e61 = ApplyFog_u0028_vf3_u003b((¶m));
let _e62 = (*alpha);
frag_color = vec4<f32>(_e61.x, _e61.y, _e61.z, _e62);
let _e67 = (*roughness_1);
param_1 = _e67;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_1));
return;
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_1: ptr<function, f32>) {
var param_2: vec3<f32>;
var param_3: f32;
var param_4: f32;
let _e60 = (*linearColor_1);
param_2 = _e60;
let _e61 = (*alpha_1);
param_3 = _e61;
param_4 = 1f;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_2), (¶m_3), (¶m_4));
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e56 = (*srgb);
let _e59 = (*srgb);
let _e64 = (*srgb);
return mix((_e56 / vec3(12.92f)), pow(((_e59 + 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), _e64));
}
fn ReadSurface_u0028_() -> Surface {
var texel: vec4<f32>;
var s: Surface;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise: f32;
let _e62 = v_texcoord_1;
let _e63 = textureSample(base_color_texture_tex, base_color_texture_smp, _e62);
texel = _e63;
let _e64 = texel;
param_5 = _e64.xyz;
let _e66 = SrgbToLinear_u0028_vf3_u003b((¶m_5));
let _e68 = frag_info.base_color;
param_6 = _e68.xyz;
let _e70 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e72 = v_color_1;
s.albedo = ((_e66 * _e70) * _e72.xyz);
let _e77 = texel[3u];
let _e80 = frag_info.base_color[3u];
let _e83 = v_color_1[3u];
s.alpha = ((_e77 * _e80) * _e83);
let _e88 = frag_info.material2_[0u];
cutoff = _e88;
let _e89 = cutoff;
if (_e89 >= 0f) {
let _e92 = s.alpha;
let _e93 = cutoff;
if (_e92 < _e93) {
discard;
}
} else {
let _e95 = cutoff;
if (_e95 < -1.5f) {
let _e97 = v_world_position_1;
anchored = floor((_e97 * 16f));
let _e100 = anchored;
noise = fract((sin(dot(_e100, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e106 = s.alpha;
let _e107 = noise;
if (_e106 < _e107) {
discard;
}
}
}
let _e109 = v_normal_1;
s.n = normalize(_e109);
let _e112 = gl_FrontFacing_1;
if !(_e112) {
let _e115 = s.n;
s.n = -(_e115);
}
let _e119 = frag_info.camera_position;
let _e121 = v_world_position_1;
s.v = normalize((_e119.xyz - _e121));
let _e126 = s.n;
let _e128 = s.v;
s.n_dot_v = max(dot(_e126, _e128), 0.0001f);
let _e134 = frag_info.material[0u];
s.metallic = clamp(_e134, 0f, 1f);
let _e139 = frag_info.material[1u];
s.roughness = clamp(_e139, 0.02f, 1f);
let _e143 = frag_info.ambient_ground;
let _e146 = frag_info.ambient_sky;
let _e150 = s.n[1u];
let _e157 = frag_info.material[2u];
s.ambient = (mix(_e143.xyz, _e146.xyz, vec3(((_e150 * 0.5f) + 0.5f))) * _e157);
let _e162 = frag_info.frame_params[0u];
s.exposure = max(_e162, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e167 = s;
return _e167;
}
fn main_1() {
var s_1: Surface;
var param_7: vec3<f32>;
var param_8: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e58 = ReadSurface_u0028_();
s_1 = _e58;
let _e60 = s_1.albedo;
param_7 = _e60;
let _e62 = s_1.alpha;
param_8 = _e62;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_7), (¶m_8));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Lambert': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(8)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(20)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_texture_smp: sampler;
@group(1) @binding(18)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(10)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(16)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(14)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(22)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var shadow_texture_smp: sampler;
@group(1) @binding(12)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var metallic_roughness_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e148 = (*n)[0u];
let _e151 = (*n)[1u];
let _e155 = (*n)[2u];
let _e158 = (*n);
(*n) = (_e158 / vec3(((abs(_e148) + abs(_e151)) + abs(_e155))));
let _e161 = (*n);
e = _e161.xy;
let _e164 = (*n)[2u];
if (_e164 < 0f) {
let _e166 = (*n);
let _e172 = (*n)[0u];
let _e176 = (*n)[1u];
e = ((vec2(1f) - abs(_e166.yx)) * vec2<f32>(select(-1f, 1f, (_e172 >= 0f)), select(-1f, 1f, (_e176 >= 0f))));
}
let _e181 = e;
return ((_e181 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e145 = v_world_position_1;
let _e147 = fog_info.eye;
let _e151 = fog_info.forward;
return dot((_e145 - _e147.xyz), _e151.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var geometric: vec3<f32>;
var param: vec3<f32>;
let _e148 = g_debug_surface_on;
if _e148 {
let _e149 = g_debug_surface;
let _e150 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e149.x, _e149.y, _e149.z, _e150);
return;
}
let _e155 = v_normal_1;
geometric = normalize(_e155);
let _e157 = gl_FrontFacing_1;
if !(_e157) {
let _e159 = geometric;
geometric = -(_e159);
}
let _e161 = geometric;
param = _e161;
let _e162 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e163 = (*roughness);
let _e165 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e162.x, _e162.y, clamp(_e163, 0f, 1f), _e165);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e145 = v_world_position_1;
let _e147 = fog_info.eye;
return distance(_e145, _e147.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e150 = fog_info.fog[3u];
density = _e150;
let _e151 = density;
if (_e151 <= 0f) {
let _e153 = (*color);
return _e153;
}
let _e154 = EyeDistance_u0028_();
d = _e154;
let _e156 = fog_info.fog;
let _e158 = (*color);
let _e159 = density;
let _e161 = d;
return mix(_e156.xyz, _e158, vec3(clamp(exp((-(_e159) * _e161)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e150 = (*linearColor);
param_1 = _e150;
let _e151 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e152 = (*alpha);
frag_color = vec4<f32>(_e151.x, _e151.y, _e151.z, _e152);
let _e157 = (*roughness_1);
param_2 = _e157;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
let _e148 = (*s).albedo;
return _e148;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e146 = (*i);
if (_e146 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e148 = (*i);
if (_e148 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e150 = (*i);
if (_e150 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e152 = (*i);
if (_e152 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e154 = (*i);
if (_e154 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e156 = (*i);
if (_e156 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e158 = (*i);
if (_e158 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_3: i32;
let _e151 = (*i_1);
param_3 = _e151;
let _e152 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e152;
let _e154 = p[0u];
let _e155 = (*ca);
let _e158 = p[1u];
let _e159 = (*sa);
let _e163 = p[0u];
let _e164 = (*sa);
let _e167 = p[1u];
let _e168 = (*ca);
let _e172 = (*radius);
return (vec2<f32>(((_e154 * _e155) - (_e158 * _e159)), ((_e163 * _e164) + (_e167 * _e168))) * _e172);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e154 = point_shadow.params[0u];
inset = _e154;
let _e155 = (*uv);
let _e156 = (*offset);
let _e158 = inset;
let _e159 = inset;
local = clamp((_e155 + _e156), vec2(_e158), vec2((1f - _e159)));
let _e164 = local;
let _e165 = (*tile);
atlas = ((_e164 + _e165) * vec2<f32>(0.16666667f, 0.16666667f));
let _e170 = point_shadow.params3_[0u];
if (_e170 > 0.5f) {
let _e173 = atlas[1u];
atlas[1u] = (1f - _e173);
}
let _e176 = atlas;
let _e177 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e176, 0f);
let _e179 = atlas;
let _e180 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e179, 0f);
let _e183 = (*range);
return (min(_e177.x, _e180.x) * _e183);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
let _e155 = (*uv_1);
param_4 = _e155;
let _e156 = (*offset_1);
param_5 = _e156;
let _e157 = (*tile_1);
param_6 = _e157;
let _e158 = (*range_1);
param_7 = _e158;
let _e159 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e159;
let _e160 = stored;
let _e161 = (*range_1);
if (_e160 >= (_e161 * 0.999f)) {
return 1f;
}
let _e164 = (*receiver);
let _e165 = stored;
return select(1f, 0f, (_e164 > _e165));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_12: i32;
var param_13: f32;
var param_14: f32;
var param_15: f32;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e176 = point_shadow.params2_[1u];
lightRadius = _e176;
let _e179 = point_shadow.params2_[0u];
minRadius = _e179;
let _e182 = point_shadow.params2_[2u];
maxRadius = _e182;
let _e183 = lightRadius;
if (_e183 <= 0f) {
let _e185 = (*uv_2);
param_8 = _e185;
param_9 = vec2<f32>(0f, 0f);
let _e186 = (*tile_2);
param_10 = _e186;
let _e187 = (*range_2);
param_11 = _e187;
let _e188 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e188;
let _e189 = minRadius;
return _e189;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e190 = i_2;
if (_e190 < 8i) {
let _e192 = i_2;
param_12 = _e192;
let _e193 = (*ca_1);
param_13 = _e193;
let _e194 = (*sa_1);
param_14 = _e194;
let _e195 = maxRadius;
param_15 = _e195;
let _e196 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e197 = (*uv_2);
param_16 = _e197;
param_17 = _e196;
let _e198 = (*tile_2);
param_18 = _e198;
let _e199 = (*range_2);
param_19 = _e199;
let _e200 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e200;
let _e201 = stored_1;
let _e202 = (*range_2);
if (_e201 >= (_e202 * 0.999f)) {
continue;
}
let _e205 = stored_1;
let _e206 = (*receiver_1);
if (_e205 >= _e206) {
continue;
}
let _e208 = stored_1;
let _e209 = sum;
sum = (_e209 + _e208);
let _e211 = count;
count = (_e211 + 1f);
continue;
} else {
break;
}
continuing {
let _e213 = i_2;
i_2 = (_e213 + 1i);
}
}
let _e215 = count;
if (_e215 < 0.5f) {
return -1f;
}
let _e217 = sum;
let _e218 = count;
blocker = max((_e217 / _e218), 0.0001f);
let _e221 = blocker;
(*blockerOut) = _e221;
let _e222 = lightRadius;
let _e223 = (*receiver_1);
let _e224 = blocker;
let _e228 = blocker;
world = ((_e222 * max((_e223 - _e224), 0f)) / _e228);
let _e230 = world;
let _e231 = (*receiver_1);
let _e233 = (*tanHalf);
let _e236 = minRadius;
let _e237 = maxRadius;
return clamp((_e230 / ((2f * _e231) * _e233)), _e236, _e237);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var param_23: f32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: vec2<f32>;
var param_31: f32;
var param_32: f32;
var i_3: i32;
var param_33: i32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: vec2<f32>;
var param_40: f32;
var param_41: f32;
var phi_1541_: bool;
var phi_1603_: bool;
let _e198 = (*lightIndex);
let _e202 = point_shadow.slots[_e198][0u];
slot = i32((_e202 + 0.5f));
let _e205 = (*lightIndex);
let _e209 = point_shadow.slots[_e205][0u];
if (_e209 < 0f) {
return 1f;
}
let _e213 = point_shadow.params[2u];
strength = _e213;
let _e214 = strength;
if (_e214 <= 0f) {
return 1f;
}
let _e216 = slot;
let _e219 = point_shadow.lights[_e216];
let _e221 = (*world_1);
toLight = (_e219.xyz - _e221);
let _e223 = toLight;
toLightLength = max(length(_e223), 0.000001f);
let _e226 = (*normal);
let _e227 = toLight;
let _e228 = toLightLength;
nDotL = max(dot(_e226, (_e227 / vec3(_e228))), 0.15f);
let _e233 = nDotL;
let _e234 = nDotL;
let _e239 = nDotL;
let _e240 = nDotL;
slope = min((sqrt(max((1f - (_e233 * _e234)), 0f)) / (_e239 * _e240)), 8f);
let _e244 = toLightLength;
let _e246 = (*lightIndex);
let _e250 = point_shadow.slots[_e246][2u];
let _e255 = point_shadow.params3_[1u];
texel = (((2f * _e244) * max(_e250, 0.0001f)) * _e255);
let _e257 = (*world_1);
let _e258 = (*normal);
let _e259 = texel;
let _e263 = point_shadow.params[3u];
let _e265 = slope;
origin = (_e257 + (((_e258 * _e259) * _e263) * (1f + _e265)));
let _e269 = origin;
let _e270 = slot;
let _e273 = point_shadow.lights[_e270];
toFragment = (_e269 - _e273.xyz);
let _e276 = toFragment;
distance_ = length(_e276);
let _e278 = slot;
let _e282 = point_shadow.lights[_e278][3u];
range_3 = max(_e282, 0.0001f);
let _e284 = distance_;
let _e285 = range_3;
if (_e284 >= _e285) {
return 1f;
}
face = 0i;
let _e287 = (*lightIndex);
let _e291 = point_shadow.slots[_e287][1u];
if (_e291 < 0.5f) {
let _e293 = toFragment;
a = abs(_e293);
let _e296 = a[0u];
let _e298 = a[1u];
let _e299 = (_e296 >= _e298);
phi_1541_ = _e299;
if _e299 {
let _e301 = a[0u];
let _e303 = a[2u];
phi_1541_ = (_e301 >= _e303);
}
let _e306 = phi_1541_;
if _e306 {
let _e308 = toFragment[0u];
face = select(1i, 0i, (_e308 > 0f));
} else {
let _e312 = a[1u];
let _e314 = a[2u];
if (_e312 >= _e314) {
let _e317 = toFragment[1u];
face = select(3i, 2i, (_e317 > 0f));
} else {
let _e321 = toFragment[2u];
face = select(5i, 4i, (_e321 > 0f));
}
}
}
let _e324 = slot;
let _e326 = face;
let _e330 = point_shadow.faces[((_e324 * 6i) + _e326)];
let _e331 = origin;
clip = (_e330 * vec4<f32>(_e331.x, _e331.y, _e331.z, 1f));
let _e338 = clip[3u];
if (_e338 <= 0f) {
return 1f;
}
let _e340 = clip;
let _e343 = clip[3u];
ndc = (_e340.xy / vec2(_e343));
let _e347 = ndc[0u];
let _e349 = (abs(_e347) > 1f);
phi_1603_ = _e349;
if !(_e349) {
let _e352 = ndc[1u];
phi_1603_ = (abs(_e352) > 1f);
}
let _e356 = phi_1603_;
if _e356 {
return 1f;
}
let _e358 = ndc[0u];
let _e362 = ndc[1u];
uv_3 = vec2<f32>(((_e358 * 0.5f) + 0.5f), (0.5f - (_e362 * 0.5f)));
let _e366 = face;
let _e368 = slot;
tile_3 = vec2<f32>(f32(_e366), f32(_e368));
let _e371 = distance_;
let _e374 = point_shadow.params[1u];
receiver_2 = (_e371 - _e374);
let _e376 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e376.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e382 = noise;
angle = (_e382 * 6.2831855f);
let _e384 = angle;
ca_2 = cos(_e384);
let _e386 = angle;
sa_2 = sin(_e386);
let _e388 = (*lightIndex);
let _e392 = point_shadow.slots[_e388][2u];
tanHalf_1 = max(_e392, 0.0001f);
blocker_1 = -1f;
let _e394 = uv_3;
param_20 = _e394;
let _e395 = tile_3;
param_21 = _e395;
let _e396 = range_3;
param_22 = _e396;
let _e397 = receiver_2;
param_23 = _e397;
let _e398 = ca_2;
param_24 = _e398;
let _e399 = sa_2;
param_25 = _e399;
let _e400 = tanHalf_1;
param_26 = _e400;
let _e401 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22), (¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27));
let _e402 = param_27;
blocker_1 = _e402;
radius_1 = _e401;
let _e405 = point_shadow.params2_[3u];
if (_e405 > 0.5f) {
g_debug_surface_on = true;
let _e407 = radius_1;
if (_e407 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e409 = radius_1;
let _e412 = point_shadow.params2_[2u];
let _e416 = blocker_1;
let _e417 = range_3;
local_1 = vec3<f32>(clamp((_e409 / max(_e412, 0.000001f)), 0f, 1f), clamp((_e416 / _e417), 0f, 1f), 0f);
}
let _e421 = local_1;
g_debug_surface = _e421;
}
let _e422 = radius_1;
if (_e422 < 0f) {
return 1f;
}
let _e424 = uv_3;
param_28 = _e424;
param_29 = vec2<f32>(0f, 0f);
let _e425 = tile_3;
param_30 = _e425;
let _e426 = range_3;
param_31 = _e426;
let _e427 = receiver_2;
param_32 = _e427;
let _e428 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e428;
let _e429 = radius_1;
if (_e429 > 0f) {
i_3 = 0i;
loop {
let _e431 = i_3;
if (_e431 < 8i) {
let _e433 = i_3;
param_33 = _e433;
let _e434 = ca_2;
param_34 = _e434;
let _e435 = sa_2;
param_35 = _e435;
let _e436 = radius_1;
param_36 = _e436;
let _e437 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e438 = uv_3;
param_37 = _e438;
param_38 = _e437;
let _e439 = tile_3;
param_39 = _e439;
let _e440 = range_3;
param_40 = _e440;
let _e441 = receiver_2;
param_41 = _e441;
let _e442 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e443 = lit;
lit = (_e443 + _e442);
continue;
} else {
break;
}
continuing {
let _e445 = i_3;
i_3 = (_e445 + 1i);
}
}
let _e447 = lit;
lit = (_e447 * 0.11111111f);
}
let _e449 = lit;
let _e450 = strength;
return mix(1f, _e449, clamp(_e450, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var nDotL_1: f32;
var slope_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var rowX: f32;
var texelMetres: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2041_: bool;
var phi_2052_: bool;
var phi_2171_: bool;
var phi_2178_: bool;
var phi_2185_: bool;
let _e188 = frag_info.shadow_params[3u];
strength_1 = _e188;
let _e189 = strength_1;
if (_e189 <= 0f) {
return 1f;
}
let _e191 = (*lightIndex_1);
let _e194 = frag_info.frame_params[2u];
if (_e191 != i32((_e194 + 0.5f))) {
return 1f;
}
let _e199 = (*light_1).n_dot_l;
nDotL_1 = max(_e199, 0.15f);
let _e201 = nDotL_1;
let _e202 = nDotL_1;
let _e207 = nDotL_1;
let _e208 = nDotL_1;
slope_1 = min((sqrt(max((1f - (_e201 * _e202)), 0f)) / (_e207 * _e208)), 8f);
let _e214 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e214 + 0.5f));
let _e217 = v_world_position_1;
let _e219 = frag_info.camera_position;
viewDistance = length((_e217 - _e219.xyz));
cascade = 0i;
let _e223 = cascadeCount;
let _e224 = (_e223 > 1i);
phi_2041_ = _e224;
if _e224 {
let _e225 = viewDistance;
let _e228 = frag_info.shadow_cascades[0u];
phi_2041_ = (_e225 > _e228);
}
let _e231 = phi_2041_;
if _e231 {
cascade = 1i;
}
let _e232 = cascadeCount;
let _e233 = (_e232 > 2i);
phi_2052_ = _e233;
if _e233 {
let _e234 = viewDistance;
let _e237 = frag_info.shadow_cascades[1u];
phi_2052_ = (_e234 > _e237);
}
let _e240 = phi_2052_;
if _e240 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e241 = attempt;
if (_e241 < 3i) {
let _e243 = cascade;
let _e244 = attempt;
which = (_e243 + _e244);
let _e246 = which;
let _e247 = cascadeCount;
if (_e246 >= _e247) {
break;
}
let _e249 = which;
if (_e249 == 0i) {
let _e252 = frag_info.shadow_matrix;
local_2 = _e252;
} else {
let _e253 = which;
if (_e253 == 1i) {
let _e256 = frag_info.shadow_matrix_far;
local_3 = _e256;
} else {
let _e258 = frag_info.shadow_matrix_farthest;
local_3 = _e258;
}
let _e259 = local_3;
local_2 = _e259;
}
let _e260 = local_2;
matrix = _e260;
let _e263 = matrix[0][0u];
let _e266 = matrix[1][0u];
let _e269 = matrix[2][0u];
rowX = length(vec3<f32>(_e263, _e266, _e269));
let _e274 = frag_info.shadow_cascades[3u];
let _e276 = rowX;
texelMetres = ((2f * _e274) / max(_e276, 0.000001f));
let _e279 = v_world_position_1;
let _e281 = (*s_1).n;
let _e284 = frag_info.shadow_params[2u];
let _e285 = texelMetres;
let _e286 = slope_1;
origin_1 = (_e279 + (_e281 * (_e284 + (_e285 * (1f + _e286)))));
let _e292 = matrix;
let _e293 = origin_1;
lightSpace = (_e292 * vec4<f32>(_e293.x, _e293.y, _e293.z, 1f));
let _e300 = lightSpace[3u];
if (_e300 <= 0f) {
continue;
}
let _e302 = lightSpace;
let _e305 = lightSpace[3u];
candidate = (_e302.xyz / vec3(_e305));
let _e309 = candidate[0u];
let _e313 = candidate[1u];
inTile = vec2<f32>(((_e309 * 0.5f) + 0.5f), (0.5f - (_e313 * 0.5f)));
let _e318 = inTile[0u];
let _e319 = (_e318 < 0f);
phi_2171_ = _e319;
if !(_e319) {
let _e322 = inTile[0u];
phi_2171_ = (_e322 > 1f);
}
let _e325 = phi_2171_;
phi_2178_ = _e325;
if !(_e325) {
let _e328 = inTile[1u];
phi_2178_ = (_e328 < 0f);
}
let _e331 = phi_2178_;
phi_2185_ = _e331;
if !(_e331) {
let _e334 = inTile[1u];
phi_2185_ = (_e334 > 1f);
}
let _e337 = phi_2185_;
if _e337 {
continue;
}
let _e339 = candidate[2u];
if (_e339 > 1f) {
let _e341 = which;
let _e342 = cascadeCount;
if (_e341 < (_e342 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e347 = inTile[0u];
let _e348 = which;
let _e351 = cascadeCount;
let _e355 = inTile[1u];
uv_4 = vec2<f32>(((_e347 + f32(_e348)) / f32(_e351)), _e355);
let _e357 = candidate;
projected = _e357;
let _e358 = which;
cascade = _e358;
found = true;
break;
} else {
break;
}
continuing {
let _e359 = attempt;
attempt = (_e359 + 1i);
}
}
let _e361 = found;
if !(_e361) {
return 1f;
}
let _e365 = frag_info.shadow_params[1u];
bias = _e365;
let _e368 = frag_info.shadow_params[0u];
let _e371 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e368, _e371);
let _e375 = frag_info.ambient_ground[3u];
softness = _e375;
lit_1 = 0f;
let _e376 = softness;
if (_e376 <= 0f) {
y = -1i;
loop {
let _e378 = y;
if (_e378 <= 1i) {
x = -1i;
loop {
let _e380 = x;
if (_e380 <= 1i) {
let _e382 = uv_4;
let _e383 = x;
let _e385 = y;
let _e388 = texel_1;
let _e391 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e382 + (vec2<f32>(f32(_e383), f32(_e385)) * _e388)), 0f);
occluder = _e391.x;
let _e394 = projected[2u];
let _e395 = bias;
let _e397 = occluder;
let _e400 = lit_1;
lit_1 = (_e400 + select(1f, 0f, ((_e394 - _e395) > _e397)));
continue;
} else {
break;
}
continuing {
let _e402 = x;
x = (_e402 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e404 = y;
y = (_e404 + 1i);
}
}
let _e406 = lit_1;
lit_1 = (_e406 * 0.11111111f);
} else {
let _e408 = softness;
searchRadius = clamp((_e408 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e411 = i_4;
if (_e411 < 5i) {
let _e413 = uv_4;
let _e414 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e416 = indexable[_e414];
let _e417 = texel_1;
let _e419 = searchRadius;
let _e422 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e413 + ((_e416 * _e417) * _e419)), 0f);
occluder_1 = _e422.x;
let _e425 = projected[2u];
let _e426 = bias;
let _e428 = occluder_1;
if ((_e425 - _e426) > _e428) {
let _e430 = occluder_1;
let _e431 = blockerSum;
blockerSum = (_e431 + _e430);
let _e433 = blockerCount;
blockerCount = (_e433 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e435 = i_4;
i_4 = (_e435 + 1i);
}
}
let _e437 = blockerCount;
if (_e437 <= 0f) {
return 1f;
}
let _e440 = projected[2u];
let _e441 = blockerSum;
let _e442 = blockerCount;
gap = max((_e440 - (_e441 / _e442)), 0f);
let _e446 = gap;
let _e447 = softness;
radius_2 = clamp((_e446 * _e447), 1f, 16f);
i_5 = 0i;
loop {
let _e450 = i_5;
if (_e450 < 5i) {
let _e452 = uv_4;
let _e453 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e455 = indexable_1[_e453];
let _e456 = texel_1;
let _e458 = radius_2;
let _e461 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e452 + ((_e455 * _e456) * _e458)), 0f);
occluder_2 = _e461.x;
let _e464 = projected[2u];
let _e465 = bias;
let _e467 = occluder_2;
let _e470 = lit_1;
lit_1 = (_e470 + select(1f, 0f, ((_e464 - _e465) > _e467)));
continue;
} else {
break;
}
continuing {
let _e472 = i_5;
i_5 = (_e472 + 1i);
}
}
let _e474 = lit_1;
lit_1 = (_e474 * 0.2f);
}
let _e476 = lit_1;
let _e477 = strength_1;
return mix(1f, _e476, clamp(_e477, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_42: Surface;
var param_43: LightSample;
var param_44: i32;
let _e151 = (*s_2);
param_42 = _e151;
let _e152 = (*light_2);
param_43 = _e152;
let _e153 = (*index);
param_44 = _e153;
let _e154 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_42), (¶m_43), (¶m_44));
return _e154;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e146 = (*index_1);
return (_e146 < 8i);
}
fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
var attenuation: f32;
var ratio: f32;
var window: f32;
let _e150 = (*distance_1);
let _e151 = (*distance_1);
attenuation = (1f / max((_e150 * _e151), 0.0001f));
let _e155 = (*range_4);
if (_e155 > 0f) {
let _e157 = (*distance_1);
let _e158 = (*range_4);
ratio = (_e157 / _e158);
let _e160 = ratio;
let _e161 = ratio;
let _e163 = ratio;
let _e165 = ratio;
window = clamp((1f - (((_e160 * _e161) * _e163) * _e165)), 0f, 1f);
let _e169 = window;
let _e170 = window;
let _e172 = attenuation;
attenuation = (_e172 * (_e169 * _e170));
}
let _e174 = attenuation;
return _e174;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e162 = (*halfWidth);
let _e163 = (*halfHeight);
n_1 = cross(_e162, _e163);
let _e165 = n_1;
nLen = length(_e165);
let _e167 = nLen;
if (_e167 < 0.000000000001f) {
let _e169 = (*centre);
return _e169;
}
let _e170 = nLen;
let _e171 = n_1;
n_1 = (_e171 / vec3(_e170));
let _e174 = (*centre);
let _e175 = (*world_2);
toPlane = (_e174 - _e175);
let _e177 = (*mirror);
let _e178 = n_1;
denom = dot(_e177, _e178);
let _e180 = denom;
if (abs(_e180) < 0.00001f) {
let _e183 = toPlane;
let _e184 = n_1;
let _e185 = toPlane;
let _e186 = n_1;
onPlane = (_e183 - (_e184 * dot(_e185, _e186)));
} else {
let _e190 = toPlane;
let _e191 = n_1;
let _e193 = denom;
t = (dot(_e190, _e191) / _e193);
let _e195 = t;
if (_e195 > 0f) {
let _e197 = (*mirror);
let _e198 = t;
local_4 = (_e197 * _e198);
} else {
let _e200 = toPlane;
let _e201 = n_1;
let _e202 = toPlane;
let _e203 = n_1;
local_4 = (_e200 - (_e201 * dot(_e202, _e203)));
}
let _e207 = local_4;
onPlane = _e207;
}
let _e208 = onPlane;
let _e209 = toPlane;
offset_2 = (_e208 - _e209);
let _e211 = (*halfWidth);
let _e212 = (*halfWidth);
wLen2_ = max(dot(_e211, _e212), 0.000000000001f);
let _e215 = (*halfHeight);
let _e216 = (*halfHeight);
hLen2_ = max(dot(_e215, _e216), 0.000000000001f);
let _e219 = offset_2;
let _e220 = (*halfWidth);
let _e222 = wLen2_;
u = clamp((dot(_e219, _e220) / _e222), -1f, 1f);
let _e225 = offset_2;
let _e226 = (*halfHeight);
let _e228 = hLen2_;
v = clamp((dot(_e225, _e226) / _e228), -1f, 1f);
let _e231 = (*centre);
let _e232 = (*halfWidth);
let _e233 = u;
let _e236 = (*halfHeight);
let _e237 = v;
return ((_e231 + (_e232 * _e233)) + (_e236 * _e237));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_1: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e154 = i_6;
if (_e154 < 4i) {
let _e156 = i_6;
let _e158 = (*corners)[_e156];
a_1 = normalize(_e158);
let _e160 = i_6;
let _e164 = (*corners)[((_e160 + 1i) & 3i)];
b = normalize(_e164);
let _e166 = a_1;
let _e167 = b;
angle_1 = acos(clamp(dot(_e166, _e167), -1f, 1f));
let _e171 = a_1;
let _e172 = b;
axis = cross(_e171, _e172);
let _e174 = axis;
len = length(_e174);
let _e176 = len;
if (_e176 > 0.000001f) {
let _e178 = angle_1;
let _e179 = axis;
let _e180 = len;
let _e183 = (*n_2);
let _e186 = total;
total = (_e186 + (_e178 * dot((_e179 / vec3(_e180)), _e183)));
}
continue;
} else {
break;
}
continuing {
let _e188 = i_6;
i_6 = (_e188 + 1i);
}
}
let _e190 = total;
return max((-(_e190) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e151 = (*slot_1);
let _e152 = (*slot_1);
lane = (_e151 - ((_e152 / 4i) * 4i));
let _e156 = lane;
if (_e156 == 0i) {
let _e159 = (*four)[0u];
local_5 = _e159;
} else {
let _e160 = lane;
if (_e160 == 1i) {
let _e163 = (*four)[1u];
local_6 = _e163;
} else {
let _e164 = lane;
if (_e164 == 2i) {
let _e167 = (*four)[2u];
local_7 = _e167;
} else {
let _e169 = (*four)[3u];
local_7 = _e169;
}
let _e170 = local_7;
local_6 = _e170;
}
let _e171 = local_6;
local_5 = _e171;
}
let _e172 = local_5;
return _e172;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_45: vec4<f32>;
var param_46: i32;
let _e148 = (*slot_2);
let _e152 = light_list_info.scales[(_e148 / 4i)];
param_45 = _e152;
let _e153 = (*slot_2);
param_46 = _e153;
let _e154 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_45), (¶m_46));
return _e154;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_47: vec4<f32>;
var param_48: i32;
let _e148 = (*slot_3);
let _e152 = light_list_info.indices[(_e148 / 4i)];
param_47 = _e152;
let _e153 = (*slot_3);
param_48 = _e153;
let _e154 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_47), (¶m_48));
return _e154;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_49: i32;
var u_1: f32;
var param_50: i32;
var type_38: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_51: array<vec3<f32>, 4>;
var param_52: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_53: vec3<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var param_56: vec3<f32>;
var param_57: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_58: f32;
var param_59: f32;
var cosAngle: f32;
let _e188 = (*index_2);
if (_e188 < 8i) {
let _e190 = (*index_2);
let _e193 = frag_info.light_position[_e190];
position = _e193;
let _e194 = (*index_2);
let _e197 = frag_info.light_color[_e194];
color_1 = _e197;
let _e198 = (*index_2);
let _e201 = frag_info.light_direction[_e198];
direction = _e201;
let _e202 = (*index_2);
let _e205 = frag_info.light_cone[_e202];
cone = _e205;
} else {
let _e206 = (*index_2);
slot_4 = (_e206 - 8i);
let _e208 = slot_4;
param_49 = _e208;
let _e209 = LightListRow_u0028_i1_u003b((¶m_49));
let _e213 = light_list_info.list[2u];
v_1 = ((_e209 + 0.5f) * _e213);
let _e217 = light_list_info.list[1u];
u_1 = _e217;
let _e218 = u_1;
let _e220 = v_1;
let _e222 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e218), _e220), 0f);
position = _e222;
let _e223 = u_1;
let _e225 = v_1;
let _e227 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e223), _e225), 0f);
color_1 = _e227;
let _e228 = u_1;
let _e230 = v_1;
let _e232 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e228), _e230), 0f);
direction = _e232;
let _e233 = u_1;
let _e235 = v_1;
let _e237 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e233), _e235), 0f);
cone = _e237;
let _e238 = slot_4;
param_50 = _e238;
let _e239 = LightListScale_u0028_i1_u003b((¶m_50));
let _e241 = color_1[3u];
color_1[3u] = (_e241 * _e239);
}
let _e245 = position[3u];
type_38 = _e245;
let _e246 = type_38;
if (_e246 > 2.5f) {
let _e248 = direction;
halfWidth_1 = _e248.xyz;
let _e250 = cone;
halfHeight_1 = _e250.xyz;
let _e252 = position;
let _e254 = v_world_position_1;
toCentre = (_e252.xyz - _e254);
let _e256 = toCentre;
let _e257 = halfWidth_1;
let _e259 = halfHeight_1;
corners_1[0i] = ((_e256 - _e257) - _e259);
let _e262 = toCentre;
let _e263 = halfWidth_1;
let _e265 = halfHeight_1;
corners_1[1i] = ((_e262 + _e263) - _e265);
let _e268 = toCentre;
let _e269 = halfWidth_1;
let _e271 = halfHeight_1;
corners_1[2i] = ((_e268 + _e269) + _e271);
let _e274 = toCentre;
let _e275 = halfWidth_1;
let _e277 = halfHeight_1;
corners_1[3i] = ((_e274 - _e275) + _e277);
let _e280 = corners_1;
param_51 = _e280;
let _e282 = (*s_3).n;
param_52 = _e282;
let _e283 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_51), (¶m_52));
formFactor = _e283;
let _e284 = halfWidth_1;
let _e285 = halfHeight_1;
area = (length(cross(_e284, _e285)) * 4f);
let _e289 = area;
if (_e289 > 0.000000001f) {
let _e291 = area;
local_8 = (1f / _e291);
} else {
local_8 = 0f;
}
let _e293 = local_8;
radiance = _e293;
let _e294 = toCentre;
distance_2 = length(_e294);
let _e297 = direction[3u];
if (_e297 > 0f) {
let _e299 = distance_2;
let _e301 = direction[3u];
ratio_1 = (_e299 / _e301);
let _e303 = ratio_1;
let _e304 = ratio_1;
let _e306 = ratio_1;
let _e308 = ratio_1;
window_1 = clamp((1f - (((_e303 * _e304) * _e306) * _e308)), 0f, 1f);
let _e312 = window_1;
let _e313 = window_1;
let _e315 = radiance;
radiance = (_e315 * (_e312 * _e313));
}
let _e318 = (*s_3).v;
let _e321 = (*s_3).n;
mirror_1 = reflect(-(_e318), _e321);
let _e323 = position;
param_53 = _e323.xyz;
let _e325 = halfWidth_1;
param_54 = _e325;
let _e326 = halfHeight_1;
param_55 = _e326;
let _e327 = v_world_position_1;
param_56 = _e327;
let _e328 = mirror_1;
param_57 = _e328;
let _e329 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57));
representative = _e329;
let _e330 = representative;
let _e331 = v_world_position_1;
toPoint = (_e330 - _e331);
let _e333 = toPoint;
pointDistance = length(_e333);
let _e335 = pointDistance;
if (_e335 > 0.000001f) {
let _e337 = toPoint;
let _e338 = pointDistance;
local_9 = (_e337 / vec3(_e338));
} else {
let _e342 = (*s_3).n;
local_9 = _e342;
}
let _e343 = local_9;
light_3.l = _e343;
let _e346 = light_3.l;
let _e348 = (*s_3).v;
light_3.h = normalize((_e346 + _e348));
let _e352 = formFactor;
light_3.n_dot_l = _e352;
let _e355 = (*s_3).n;
let _e357 = light_3.h;
light_3.n_dot_h = max(dot(_e355, _e357), 0f);
let _e362 = (*s_3).v;
let _e364 = light_3.h;
light_3.v_dot_h = max(dot(_e362, _e364), 0f);
let _e368 = color_1;
let _e371 = color_1[3u];
let _e373 = radiance;
light_3.radiance = ((_e368.xyz * _e371) * _e373);
let _e376 = light_3;
return _e376;
}
let _e377 = direction;
aim = normalize(_e377.xyz);
attenuation_1 = 1f;
let _e380 = type_38;
if (_e380 < 0.5f) {
let _e382 = aim;
light_3.l = -(_e382);
} else {
let _e385 = position;
let _e387 = v_world_position_1;
toLight_1 = (_e385.xyz - _e387);
let _e389 = toLight_1;
distance_3 = length(_e389);
let _e391 = distance_3;
if (_e391 < 0.000001f) {
let _e394 = (*s_3).n;
light_3.l = _e394;
let _e397 = (*s_3).n;
light_3.h = _e397;
light_3.radiance = vec3<f32>(0f, 0f, 0f);
light_3.n_dot_l = 0f;
light_3.n_dot_h = 0f;
light_3.v_dot_h = 0f;
let _e403 = light_3;
return _e403;
}
let _e404 = toLight_1;
let _e405 = distance_3;
light_3.l = (_e404 / vec3(_e405));
let _e409 = distance_3;
param_58 = _e409;
let _e411 = direction[3u];
param_59 = _e411;
let _e412 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_58), (¶m_59));
attenuation_1 = _e412;
let _e413 = type_38;
if (_e413 > 1.5f) {
let _e415 = aim;
let _e417 = light_3.l;
cosAngle = dot(_e415, -(_e417));
let _e420 = cosAngle;
let _e422 = cone[1u];
let _e425 = cone[0u];
let _e427 = cone[1u];
let _e431 = attenuation_1;
attenuation_1 = (_e431 * clamp(((_e420 - _e422) / (_e425 - _e427)), 0f, 1f));
}
}
let _e434 = light_3.l;
let _e436 = (*s_3).v;
light_3.h = normalize((_e434 + _e436));
let _e441 = (*s_3).n;
let _e443 = light_3.l;
light_3.n_dot_l = max(dot(_e441, _e443), 0f);
let _e448 = (*s_3).n;
let _e450 = light_3.h;
light_3.n_dot_h = max(dot(_e448, _e450), 0f);
let _e455 = (*s_3).v;
let _e457 = light_3.h;
light_3.v_dot_h = max(dot(_e455, _e457), 0f);
let _e461 = color_1;
let _e464 = color_1[3u];
let _e466 = attenuation_1;
light_3.radiance = ((_e461.xyz * _e464) * _e466);
let _e469 = light_3;
return _e469;
}
fn LightCount_u0028_() -> i32 {
let _e147 = frag_info.frame_params[1u];
let _e153 = light_list_info.list[0u];
return (clamp(i32((_e147 + 0.5f)), 0i, 8i) + clamp(i32((_e153 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_60: i32;
var param_61: Surface;
var visibility: f32;
var param_62: i32;
var local_10: f32;
var param_63: Surface;
var param_64: LightSample;
var param_65: i32;
var param_66: vec3<f32>;
var param_67: vec3<f32>;
var param_68: i32;
var param_69: Surface;
var param_70: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e163 = LightCount_u0028_();
count_1 = _e163;
i_7 = 0i;
loop {
let _e164 = i_7;
if (_e164 < 32i) {
let _e166 = i_7;
let _e167 = count_1;
if (_e166 >= _e167) {
break;
}
let _e169 = i_7;
param_60 = _e169;
let _e170 = (*s_4);
param_61 = _e170;
let _e171 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_60), (¶m_61));
light_4 = _e171;
let _e173 = light_4.n_dot_l;
if (_e173 <= 0f) {
continue;
}
let _e175 = i_7;
param_62 = _e175;
let _e176 = LightHasShadow_u0028_i1_u003b((¶m_62));
if _e176 {
let _e177 = (*s_4);
param_63 = _e177;
let _e178 = light_4;
param_64 = _e178;
let _e179 = i_7;
param_65 = _e179;
let _e180 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_63), (¶m_64), (¶m_65));
let _e181 = v_world_position_1;
param_66 = _e181;
let _e183 = (*s_4).n;
param_67 = _e183;
let _e184 = i_7;
param_68 = _e184;
let _e185 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_66), (¶m_67), (¶m_68));
local_10 = (_e180 * _e185);
} else {
local_10 = 1f;
}
let _e187 = local_10;
visibility = _e187;
let _e188 = visibility;
if (_e188 <= 0f) {
continue;
}
let _e190 = (*s_4);
param_69 = _e190;
let _e191 = light_4;
param_70 = _e191;
let _e192 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_69), (¶m_70));
let _e194 = light_4.radiance;
let _e197 = light_4.n_dot_l;
let _e199 = visibility;
let _e201 = total_1;
total_1 = (_e201 + (((_e192 * _e194) * _e197) * _e199));
continue;
} else {
break;
}
continuing {
let _e203 = i_7;
i_7 = (_e203 + 1i);
}
}
let _e205 = total_1;
return _e205;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e146 = v_lightmap_uv_1;
let _e147 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e146);
texel_2 = _e147;
let _e148 = texel_2;
let _e151 = texel_2[3u];
return ((_e148.xyz * _e151) * 8f);
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e146 = (*srgb);
let _e149 = (*srgb);
let _e154 = (*srgb);
return mix((_e146 / vec3(12.92f)), pow(((_e149 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e154));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_71: vec3<f32>;
let _e148 = v_texcoord_1;
let _e149 = textureSample(emissive_texture_tex, emissive_texture_smp, _e148);
param_71 = _e149.xyz;
let _e151 = SrgbToLinear_u0028_vf3_u003b((¶m_71));
emissive = _e151;
let _e152 = emissive;
let _e154 = frag_info.emissive;
let _e159 = frag_info.material2_[3u];
(*s_5).emissive = ((_e152 * _e154.xyz) * _e159);
return;
}
fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var occlusion: f32;
let _e147 = v_texcoord_1;
let _e148 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e147);
occlusion = _e148.x;
let _e150 = occlusion;
let _e153 = frag_info.material2_[2u];
(*s_6).occlusion = mix(1f, _e150, clamp(_e153, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e150 = v_texcoord_1;
let _e151 = textureSample(normal_texture_tex, normal_texture_smp, _e150);
sampledTexel = _e151;
let _e152 = v_tangent_1;
t_1 = _e152.xyz;
let _e154 = t_1;
let _e156 = (*s_7).n;
let _e158 = (*s_7).n;
let _e159 = t_1;
t_1 = (_e154 - (_e156 * dot(_e158, _e159)));
let _e163 = t_1;
let _e164 = t_1;
if (dot(_e163, _e164) < 0.000000000001f) {
return;
}
let _e167 = t_1;
t_1 = normalize(_e167);
let _e170 = (*s_7).n;
let _e171 = t_1;
let _e174 = v_tangent_1[3u];
b_1 = (cross(_e170, _e171) * _e174);
let _e176 = gl_FrontFacing_1;
if !(_e176) {
let _e178 = t_1;
t_1 = -(_e178);
}
let _e180 = sampledTexel;
sampled = ((_e180.xyz * 2f) - vec3(1f));
let _e187 = frag_info.material2_[1u];
let _e188 = sampled;
let _e190 = (_e188.xy * _e187);
sampled[0u] = _e190.x;
sampled[1u] = _e190.y;
let _e195 = t_1;
let _e197 = sampled[0u];
let _e199 = b_1;
let _e201 = sampled[1u];
let _e205 = (*s_7).n;
let _e207 = sampled[2u];
(*s_7).n = normalize((((_e195 * _e197) + (_e199 * _e201)) + (_e205 * _e207)));
let _e213 = (*s_7).n;
let _e215 = (*s_7).v;
(*s_7).n_dot_v = max(dot(_e213, _e215), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var param_72: Surface;
var param_73: Surface;
var param_74: Surface;
let _e149 = (*s_8);
param_72 = _e149;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_72));
let _e150 = param_72;
(*s_8) = _e150;
let _e151 = (*s_8);
param_73 = _e151;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_73));
let _e152 = param_73;
(*s_8) = _e152;
let _e153 = (*s_8);
param_74 = _e153;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_74));
let _e154 = param_74;
(*s_8) = _e154;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_9: Surface;
var param_75: vec3<f32>;
var param_76: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e152 = v_texcoord_1;
let _e153 = textureSample(base_color_texture_tex, base_color_texture_smp, _e152);
texel_3 = _e153;
let _e154 = texel_3;
param_75 = _e154.xyz;
let _e156 = SrgbToLinear_u0028_vf3_u003b((¶m_75));
let _e158 = frag_info.base_color;
param_76 = _e158.xyz;
let _e160 = SrgbToLinear_u0028_vf3_u003b((¶m_76));
let _e162 = v_color_1;
s_9.albedo = ((_e156 * _e160) * _e162.xyz);
let _e167 = texel_3[3u];
let _e170 = frag_info.base_color[3u];
let _e173 = v_color_1[3u];
s_9.alpha = ((_e167 * _e170) * _e173);
let _e178 = frag_info.material2_[0u];
cutoff = _e178;
let _e179 = cutoff;
if (_e179 >= 0f) {
let _e182 = s_9.alpha;
let _e183 = cutoff;
if (_e182 < _e183) {
discard;
}
} else {
let _e185 = cutoff;
if (_e185 < -1.5f) {
let _e187 = v_world_position_1;
anchored = floor((_e187 * 16f));
let _e190 = anchored;
noise_1 = fract((sin(dot(_e190, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e196 = s_9.alpha;
let _e197 = noise_1;
if (_e196 < _e197) {
discard;
}
}
}
let _e199 = v_normal_1;
s_9.n = normalize(_e199);
let _e202 = gl_FrontFacing_1;
if !(_e202) {
let _e205 = s_9.n;
s_9.n = -(_e205);
}
let _e209 = frag_info.camera_position;
let _e211 = v_world_position_1;
s_9.v = normalize((_e209.xyz - _e211));
let _e216 = s_9.n;
let _e218 = s_9.v;
s_9.n_dot_v = max(dot(_e216, _e218), 0.0001f);
let _e224 = frag_info.material[0u];
s_9.metallic = clamp(_e224, 0f, 1f);
let _e229 = frag_info.material[1u];
s_9.roughness = clamp(_e229, 0.02f, 1f);
let _e233 = frag_info.ambient_ground;
let _e236 = frag_info.ambient_sky;
let _e240 = s_9.n[1u];
let _e247 = frag_info.material[2u];
s_9.ambient = (mix(_e233.xyz, _e236.xyz, vec3(((_e240 * 0.5f) + 0.5f))) * _e247);
let _e252 = frag_info.frame_params[0u];
s_9.exposure = max(_e252, 0f);
s_9.occlusion = 1f;
s_9.emissive = vec3<f32>(0f, 0f, 0f);
let _e257 = s_9;
return _e257;
}
fn main_1() {
var s_10: Surface;
var param_77: Surface;
var ambient: vec3<f32>;
var param_78: Surface;
var param_79: vec3<f32>;
var param_80: f32;
var param_81: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e152 = ReadSurface_u0028_();
s_10 = _e152;
let _e153 = s_10;
param_77 = _e153;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_77));
let _e154 = param_77;
s_10 = _e154;
let _e156 = s_10.albedo;
let _e158 = s_10.ambient;
let _e159 = SampleLightmap_u0028_();
let _e163 = s_10.occlusion;
ambient = ((_e156 * (_e158 + _e159)) * _e163);
let _e165 = s_10;
param_78 = _e165;
let _e166 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_78));
let _e168 = s_10.occlusion;
let _e170 = ambient;
let _e173 = s_10.emissive;
param_79 = (((_e166 * _e168) + _e170) + _e173);
let _e176 = s_10.alpha;
param_80 = _e176;
let _e178 = s_10.roughness;
param_81 = _e178;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_79), (¶m_80), (¶m_81));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e18 = frag_surface;
let _e19 = frag_color;
return FragmentOutput(_e18, _e19);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BlinnPhong': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(8)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(20)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_texture_smp: sampler;
@group(1) @binding(18)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(10)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(12)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(16)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(14)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(22)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var shadow_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e149 = (*n)[0u];
let _e152 = (*n)[1u];
let _e156 = (*n)[2u];
let _e159 = (*n);
(*n) = (_e159 / vec3(((abs(_e149) + abs(_e152)) + abs(_e156))));
let _e162 = (*n);
e = _e162.xy;
let _e165 = (*n)[2u];
if (_e165 < 0f) {
let _e167 = (*n);
let _e173 = (*n)[0u];
let _e177 = (*n)[1u];
e = ((vec2(1f) - abs(_e167.yx)) * vec2<f32>(select(-1f, 1f, (_e173 >= 0f)), select(-1f, 1f, (_e177 >= 0f))));
}
let _e182 = e;
return ((_e182 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e146 = v_world_position_1;
let _e148 = fog_info.eye;
let _e152 = fog_info.forward;
return dot((_e146 - _e148.xyz), _e152.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var geometric: vec3<f32>;
var param: vec3<f32>;
let _e149 = g_debug_surface_on;
if _e149 {
let _e150 = g_debug_surface;
let _e151 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e150.x, _e150.y, _e150.z, _e151);
return;
}
let _e156 = v_normal_1;
geometric = normalize(_e156);
let _e158 = gl_FrontFacing_1;
if !(_e158) {
let _e160 = geometric;
geometric = -(_e160);
}
let _e162 = geometric;
param = _e162;
let _e163 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e164 = (*roughness);
let _e166 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e163.x, _e163.y, clamp(_e164, 0f, 1f), _e166);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e146 = v_world_position_1;
let _e148 = fog_info.eye;
return distance(_e146, _e148.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e151 = fog_info.fog[3u];
density = _e151;
let _e152 = density;
if (_e152 <= 0f) {
let _e154 = (*color);
return _e154;
}
let _e155 = EyeDistance_u0028_();
d = _e155;
let _e157 = fog_info.fog;
let _e159 = (*color);
let _e160 = density;
let _e162 = d;
return mix(_e157.xyz, _e159, vec3(clamp(exp((-(_e160) * _e162)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e151 = (*linearColor);
param_1 = _e151;
let _e152 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e153 = (*alpha);
frag_color = vec4<f32>(_e152.x, _e152.y, _e152.z, _e153);
let _e158 = (*roughness_1);
param_2 = _e158;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var shininess: f32;
var specular: f32;
let _e151 = (*s).roughness;
shininess = mix(256f, 4f, _e151);
let _e154 = (*light).n_dot_h;
let _e155 = shininess;
let _e159 = frag_info.material[3u];
specular = (pow(_e154, _e155) * _e159);
let _e162 = (*s).albedo;
let _e163 = specular;
return (_e162 + vec3(_e163));
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e147 = (*i);
if (_e147 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e149 = (*i);
if (_e149 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e151 = (*i);
if (_e151 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e153 = (*i);
if (_e153 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e155 = (*i);
if (_e155 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e157 = (*i);
if (_e157 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e159 = (*i);
if (_e159 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_3: i32;
let _e152 = (*i_1);
param_3 = _e152;
let _e153 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e153;
let _e155 = p[0u];
let _e156 = (*ca);
let _e159 = p[1u];
let _e160 = (*sa);
let _e164 = p[0u];
let _e165 = (*sa);
let _e168 = p[1u];
let _e169 = (*ca);
let _e173 = (*radius);
return (vec2<f32>(((_e155 * _e156) - (_e159 * _e160)), ((_e164 * _e165) + (_e168 * _e169))) * _e173);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e155 = point_shadow.params[0u];
inset = _e155;
let _e156 = (*uv);
let _e157 = (*offset);
let _e159 = inset;
let _e160 = inset;
local = clamp((_e156 + _e157), vec2(_e159), vec2((1f - _e160)));
let _e165 = local;
let _e166 = (*tile);
atlas = ((_e165 + _e166) * vec2<f32>(0.16666667f, 0.16666667f));
let _e171 = point_shadow.params3_[0u];
if (_e171 > 0.5f) {
let _e174 = atlas[1u];
atlas[1u] = (1f - _e174);
}
let _e177 = atlas;
let _e178 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e177, 0f);
let _e180 = atlas;
let _e181 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e180, 0f);
let _e184 = (*range);
return (min(_e178.x, _e181.x) * _e184);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
let _e156 = (*uv_1);
param_4 = _e156;
let _e157 = (*offset_1);
param_5 = _e157;
let _e158 = (*tile_1);
param_6 = _e158;
let _e159 = (*range_1);
param_7 = _e159;
let _e160 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e160;
let _e161 = stored;
let _e162 = (*range_1);
if (_e161 >= (_e162 * 0.999f)) {
return 1f;
}
let _e165 = (*receiver);
let _e166 = stored;
return select(1f, 0f, (_e165 > _e166));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_12: i32;
var param_13: f32;
var param_14: f32;
var param_15: f32;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e177 = point_shadow.params2_[1u];
lightRadius = _e177;
let _e180 = point_shadow.params2_[0u];
minRadius = _e180;
let _e183 = point_shadow.params2_[2u];
maxRadius = _e183;
let _e184 = lightRadius;
if (_e184 <= 0f) {
let _e186 = (*uv_2);
param_8 = _e186;
param_9 = vec2<f32>(0f, 0f);
let _e187 = (*tile_2);
param_10 = _e187;
let _e188 = (*range_2);
param_11 = _e188;
let _e189 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e189;
let _e190 = minRadius;
return _e190;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e191 = i_2;
if (_e191 < 8i) {
let _e193 = i_2;
param_12 = _e193;
let _e194 = (*ca_1);
param_13 = _e194;
let _e195 = (*sa_1);
param_14 = _e195;
let _e196 = maxRadius;
param_15 = _e196;
let _e197 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e198 = (*uv_2);
param_16 = _e198;
param_17 = _e197;
let _e199 = (*tile_2);
param_18 = _e199;
let _e200 = (*range_2);
param_19 = _e200;
let _e201 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e201;
let _e202 = stored_1;
let _e203 = (*range_2);
if (_e202 >= (_e203 * 0.999f)) {
continue;
}
let _e206 = stored_1;
let _e207 = (*receiver_1);
if (_e206 >= _e207) {
continue;
}
let _e209 = stored_1;
let _e210 = sum;
sum = (_e210 + _e209);
let _e212 = count;
count = (_e212 + 1f);
continue;
} else {
break;
}
continuing {
let _e214 = i_2;
i_2 = (_e214 + 1i);
}
}
let _e216 = count;
if (_e216 < 0.5f) {
return -1f;
}
let _e218 = sum;
let _e219 = count;
blocker = max((_e218 / _e219), 0.0001f);
let _e222 = blocker;
(*blockerOut) = _e222;
let _e223 = lightRadius;
let _e224 = (*receiver_1);
let _e225 = blocker;
let _e229 = blocker;
world = ((_e223 * max((_e224 - _e225), 0f)) / _e229);
let _e231 = world;
let _e232 = (*receiver_1);
let _e234 = (*tanHalf);
let _e237 = minRadius;
let _e238 = maxRadius;
return clamp((_e231 / ((2f * _e232) * _e234)), _e237, _e238);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var param_23: f32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: vec2<f32>;
var param_31: f32;
var param_32: f32;
var i_3: i32;
var param_33: i32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: vec2<f32>;
var param_40: f32;
var param_41: f32;
var phi_1544_: bool;
var phi_1606_: bool;
let _e199 = (*lightIndex);
let _e203 = point_shadow.slots[_e199][0u];
slot = i32((_e203 + 0.5f));
let _e206 = (*lightIndex);
let _e210 = point_shadow.slots[_e206][0u];
if (_e210 < 0f) {
return 1f;
}
let _e214 = point_shadow.params[2u];
strength = _e214;
let _e215 = strength;
if (_e215 <= 0f) {
return 1f;
}
let _e217 = slot;
let _e220 = point_shadow.lights[_e217];
let _e222 = (*world_1);
toLight = (_e220.xyz - _e222);
let _e224 = toLight;
toLightLength = max(length(_e224), 0.000001f);
let _e227 = (*normal);
let _e228 = toLight;
let _e229 = toLightLength;
nDotL = max(dot(_e227, (_e228 / vec3(_e229))), 0.15f);
let _e234 = nDotL;
let _e235 = nDotL;
let _e240 = nDotL;
let _e241 = nDotL;
slope = min((sqrt(max((1f - (_e234 * _e235)), 0f)) / (_e240 * _e241)), 8f);
let _e245 = toLightLength;
let _e247 = (*lightIndex);
let _e251 = point_shadow.slots[_e247][2u];
let _e256 = point_shadow.params3_[1u];
texel = (((2f * _e245) * max(_e251, 0.0001f)) * _e256);
let _e258 = (*world_1);
let _e259 = (*normal);
let _e260 = texel;
let _e264 = point_shadow.params[3u];
let _e266 = slope;
origin = (_e258 + (((_e259 * _e260) * _e264) * (1f + _e266)));
let _e270 = origin;
let _e271 = slot;
let _e274 = point_shadow.lights[_e271];
toFragment = (_e270 - _e274.xyz);
let _e277 = toFragment;
distance_ = length(_e277);
let _e279 = slot;
let _e283 = point_shadow.lights[_e279][3u];
range_3 = max(_e283, 0.0001f);
let _e285 = distance_;
let _e286 = range_3;
if (_e285 >= _e286) {
return 1f;
}
face = 0i;
let _e288 = (*lightIndex);
let _e292 = point_shadow.slots[_e288][1u];
if (_e292 < 0.5f) {
let _e294 = toFragment;
a = abs(_e294);
let _e297 = a[0u];
let _e299 = a[1u];
let _e300 = (_e297 >= _e299);
phi_1544_ = _e300;
if _e300 {
let _e302 = a[0u];
let _e304 = a[2u];
phi_1544_ = (_e302 >= _e304);
}
let _e307 = phi_1544_;
if _e307 {
let _e309 = toFragment[0u];
face = select(1i, 0i, (_e309 > 0f));
} else {
let _e313 = a[1u];
let _e315 = a[2u];
if (_e313 >= _e315) {
let _e318 = toFragment[1u];
face = select(3i, 2i, (_e318 > 0f));
} else {
let _e322 = toFragment[2u];
face = select(5i, 4i, (_e322 > 0f));
}
}
}
let _e325 = slot;
let _e327 = face;
let _e331 = point_shadow.faces[((_e325 * 6i) + _e327)];
let _e332 = origin;
clip = (_e331 * vec4<f32>(_e332.x, _e332.y, _e332.z, 1f));
let _e339 = clip[3u];
if (_e339 <= 0f) {
return 1f;
}
let _e341 = clip;
let _e344 = clip[3u];
ndc = (_e341.xy / vec2(_e344));
let _e348 = ndc[0u];
let _e350 = (abs(_e348) > 1f);
phi_1606_ = _e350;
if !(_e350) {
let _e353 = ndc[1u];
phi_1606_ = (abs(_e353) > 1f);
}
let _e357 = phi_1606_;
if _e357 {
return 1f;
}
let _e359 = ndc[0u];
let _e363 = ndc[1u];
uv_3 = vec2<f32>(((_e359 * 0.5f) + 0.5f), (0.5f - (_e363 * 0.5f)));
let _e367 = face;
let _e369 = slot;
tile_3 = vec2<f32>(f32(_e367), f32(_e369));
let _e372 = distance_;
let _e375 = point_shadow.params[1u];
receiver_2 = (_e372 - _e375);
let _e377 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e377.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e383 = noise;
angle = (_e383 * 6.2831855f);
let _e385 = angle;
ca_2 = cos(_e385);
let _e387 = angle;
sa_2 = sin(_e387);
let _e389 = (*lightIndex);
let _e393 = point_shadow.slots[_e389][2u];
tanHalf_1 = max(_e393, 0.0001f);
blocker_1 = -1f;
let _e395 = uv_3;
param_20 = _e395;
let _e396 = tile_3;
param_21 = _e396;
let _e397 = range_3;
param_22 = _e397;
let _e398 = receiver_2;
param_23 = _e398;
let _e399 = ca_2;
param_24 = _e399;
let _e400 = sa_2;
param_25 = _e400;
let _e401 = tanHalf_1;
param_26 = _e401;
let _e402 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22), (¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27));
let _e403 = param_27;
blocker_1 = _e403;
radius_1 = _e402;
let _e406 = point_shadow.params2_[3u];
if (_e406 > 0.5f) {
g_debug_surface_on = true;
let _e408 = radius_1;
if (_e408 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e410 = radius_1;
let _e413 = point_shadow.params2_[2u];
let _e417 = blocker_1;
let _e418 = range_3;
local_1 = vec3<f32>(clamp((_e410 / max(_e413, 0.000001f)), 0f, 1f), clamp((_e417 / _e418), 0f, 1f), 0f);
}
let _e422 = local_1;
g_debug_surface = _e422;
}
let _e423 = radius_1;
if (_e423 < 0f) {
return 1f;
}
let _e425 = uv_3;
param_28 = _e425;
param_29 = vec2<f32>(0f, 0f);
let _e426 = tile_3;
param_30 = _e426;
let _e427 = range_3;
param_31 = _e427;
let _e428 = receiver_2;
param_32 = _e428;
let _e429 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e429;
let _e430 = radius_1;
if (_e430 > 0f) {
i_3 = 0i;
loop {
let _e432 = i_3;
if (_e432 < 8i) {
let _e434 = i_3;
param_33 = _e434;
let _e435 = ca_2;
param_34 = _e435;
let _e436 = sa_2;
param_35 = _e436;
let _e437 = radius_1;
param_36 = _e437;
let _e438 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e439 = uv_3;
param_37 = _e439;
param_38 = _e438;
let _e440 = tile_3;
param_39 = _e440;
let _e441 = range_3;
param_40 = _e441;
let _e442 = receiver_2;
param_41 = _e442;
let _e443 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e444 = lit;
lit = (_e444 + _e443);
continue;
} else {
break;
}
continuing {
let _e446 = i_3;
i_3 = (_e446 + 1i);
}
}
let _e448 = lit;
lit = (_e448 * 0.11111111f);
}
let _e450 = lit;
let _e451 = strength;
return mix(1f, _e450, clamp(_e451, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var nDotL_1: f32;
var slope_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var rowX: f32;
var texelMetres: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2067_: bool;
var phi_2078_: bool;
var phi_2197_: bool;
var phi_2204_: bool;
var phi_2211_: bool;
let _e189 = frag_info.shadow_params[3u];
strength_1 = _e189;
let _e190 = strength_1;
if (_e190 <= 0f) {
return 1f;
}
let _e192 = (*lightIndex_1);
let _e195 = frag_info.frame_params[2u];
if (_e192 != i32((_e195 + 0.5f))) {
return 1f;
}
let _e200 = (*light_1).n_dot_l;
nDotL_1 = max(_e200, 0.15f);
let _e202 = nDotL_1;
let _e203 = nDotL_1;
let _e208 = nDotL_1;
let _e209 = nDotL_1;
slope_1 = min((sqrt(max((1f - (_e202 * _e203)), 0f)) / (_e208 * _e209)), 8f);
let _e215 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e215 + 0.5f));
let _e218 = v_world_position_1;
let _e220 = frag_info.camera_position;
viewDistance = length((_e218 - _e220.xyz));
cascade = 0i;
let _e224 = cascadeCount;
let _e225 = (_e224 > 1i);
phi_2067_ = _e225;
if _e225 {
let _e226 = viewDistance;
let _e229 = frag_info.shadow_cascades[0u];
phi_2067_ = (_e226 > _e229);
}
let _e232 = phi_2067_;
if _e232 {
cascade = 1i;
}
let _e233 = cascadeCount;
let _e234 = (_e233 > 2i);
phi_2078_ = _e234;
if _e234 {
let _e235 = viewDistance;
let _e238 = frag_info.shadow_cascades[1u];
phi_2078_ = (_e235 > _e238);
}
let _e241 = phi_2078_;
if _e241 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e242 = attempt;
if (_e242 < 3i) {
let _e244 = cascade;
let _e245 = attempt;
which = (_e244 + _e245);
let _e247 = which;
let _e248 = cascadeCount;
if (_e247 >= _e248) {
break;
}
let _e250 = which;
if (_e250 == 0i) {
let _e253 = frag_info.shadow_matrix;
local_2 = _e253;
} else {
let _e254 = which;
if (_e254 == 1i) {
let _e257 = frag_info.shadow_matrix_far;
local_3 = _e257;
} else {
let _e259 = frag_info.shadow_matrix_farthest;
local_3 = _e259;
}
let _e260 = local_3;
local_2 = _e260;
}
let _e261 = local_2;
matrix = _e261;
let _e264 = matrix[0][0u];
let _e267 = matrix[1][0u];
let _e270 = matrix[2][0u];
rowX = length(vec3<f32>(_e264, _e267, _e270));
let _e275 = frag_info.shadow_cascades[3u];
let _e277 = rowX;
texelMetres = ((2f * _e275) / max(_e277, 0.000001f));
let _e280 = v_world_position_1;
let _e282 = (*s_1).n;
let _e285 = frag_info.shadow_params[2u];
let _e286 = texelMetres;
let _e287 = slope_1;
origin_1 = (_e280 + (_e282 * (_e285 + (_e286 * (1f + _e287)))));
let _e293 = matrix;
let _e294 = origin_1;
lightSpace = (_e293 * vec4<f32>(_e294.x, _e294.y, _e294.z, 1f));
let _e301 = lightSpace[3u];
if (_e301 <= 0f) {
continue;
}
let _e303 = lightSpace;
let _e306 = lightSpace[3u];
candidate = (_e303.xyz / vec3(_e306));
let _e310 = candidate[0u];
let _e314 = candidate[1u];
inTile = vec2<f32>(((_e310 * 0.5f) + 0.5f), (0.5f - (_e314 * 0.5f)));
let _e319 = inTile[0u];
let _e320 = (_e319 < 0f);
phi_2197_ = _e320;
if !(_e320) {
let _e323 = inTile[0u];
phi_2197_ = (_e323 > 1f);
}
let _e326 = phi_2197_;
phi_2204_ = _e326;
if !(_e326) {
let _e329 = inTile[1u];
phi_2204_ = (_e329 < 0f);
}
let _e332 = phi_2204_;
phi_2211_ = _e332;
if !(_e332) {
let _e335 = inTile[1u];
phi_2211_ = (_e335 > 1f);
}
let _e338 = phi_2211_;
if _e338 {
continue;
}
let _e340 = candidate[2u];
if (_e340 > 1f) {
let _e342 = which;
let _e343 = cascadeCount;
if (_e342 < (_e343 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e348 = inTile[0u];
let _e349 = which;
let _e352 = cascadeCount;
let _e356 = inTile[1u];
uv_4 = vec2<f32>(((_e348 + f32(_e349)) / f32(_e352)), _e356);
let _e358 = candidate;
projected = _e358;
let _e359 = which;
cascade = _e359;
found = true;
break;
} else {
break;
}
continuing {
let _e360 = attempt;
attempt = (_e360 + 1i);
}
}
let _e362 = found;
if !(_e362) {
return 1f;
}
let _e366 = frag_info.shadow_params[1u];
bias = _e366;
let _e369 = frag_info.shadow_params[0u];
let _e372 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e369, _e372);
let _e376 = frag_info.ambient_ground[3u];
softness = _e376;
lit_1 = 0f;
let _e377 = softness;
if (_e377 <= 0f) {
y = -1i;
loop {
let _e379 = y;
if (_e379 <= 1i) {
x = -1i;
loop {
let _e381 = x;
if (_e381 <= 1i) {
let _e383 = uv_4;
let _e384 = x;
let _e386 = y;
let _e389 = texel_1;
let _e392 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e383 + (vec2<f32>(f32(_e384), f32(_e386)) * _e389)), 0f);
occluder = _e392.x;
let _e395 = projected[2u];
let _e396 = bias;
let _e398 = occluder;
let _e401 = lit_1;
lit_1 = (_e401 + select(1f, 0f, ((_e395 - _e396) > _e398)));
continue;
} else {
break;
}
continuing {
let _e403 = x;
x = (_e403 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e405 = y;
y = (_e405 + 1i);
}
}
let _e407 = lit_1;
lit_1 = (_e407 * 0.11111111f);
} else {
let _e409 = softness;
searchRadius = clamp((_e409 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e412 = i_4;
if (_e412 < 5i) {
let _e414 = uv_4;
let _e415 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e417 = indexable[_e415];
let _e418 = texel_1;
let _e420 = searchRadius;
let _e423 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e414 + ((_e417 * _e418) * _e420)), 0f);
occluder_1 = _e423.x;
let _e426 = projected[2u];
let _e427 = bias;
let _e429 = occluder_1;
if ((_e426 - _e427) > _e429) {
let _e431 = occluder_1;
let _e432 = blockerSum;
blockerSum = (_e432 + _e431);
let _e434 = blockerCount;
blockerCount = (_e434 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e436 = i_4;
i_4 = (_e436 + 1i);
}
}
let _e438 = blockerCount;
if (_e438 <= 0f) {
return 1f;
}
let _e441 = projected[2u];
let _e442 = blockerSum;
let _e443 = blockerCount;
gap = max((_e441 - (_e442 / _e443)), 0f);
let _e447 = gap;
let _e448 = softness;
radius_2 = clamp((_e447 * _e448), 1f, 16f);
i_5 = 0i;
loop {
let _e451 = i_5;
if (_e451 < 5i) {
let _e453 = uv_4;
let _e454 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e456 = indexable_1[_e454];
let _e457 = texel_1;
let _e459 = radius_2;
let _e462 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e453 + ((_e456 * _e457) * _e459)), 0f);
occluder_2 = _e462.x;
let _e465 = projected[2u];
let _e466 = bias;
let _e468 = occluder_2;
let _e471 = lit_1;
lit_1 = (_e471 + select(1f, 0f, ((_e465 - _e466) > _e468)));
continue;
} else {
break;
}
continuing {
let _e473 = i_5;
i_5 = (_e473 + 1i);
}
}
let _e475 = lit_1;
lit_1 = (_e475 * 0.2f);
}
let _e477 = lit_1;
let _e478 = strength_1;
return mix(1f, _e477, clamp(_e478, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_42: Surface;
var param_43: LightSample;
var param_44: i32;
let _e152 = (*s_2);
param_42 = _e152;
let _e153 = (*light_2);
param_43 = _e153;
let _e154 = (*index);
param_44 = _e154;
let _e155 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_42), (¶m_43), (¶m_44));
return _e155;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e147 = (*index_1);
return (_e147 < 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 _e151 = (*distance_1);
let _e152 = (*distance_1);
attenuation = (1f / max((_e151 * _e152), 0.0001f));
let _e156 = (*range_4);
if (_e156 > 0f) {
let _e158 = (*distance_1);
let _e159 = (*range_4);
ratio = (_e158 / _e159);
let _e161 = ratio;
let _e162 = ratio;
let _e164 = ratio;
let _e166 = ratio;
window = clamp((1f - (((_e161 * _e162) * _e164) * _e166)), 0f, 1f);
let _e170 = window;
let _e171 = window;
let _e173 = attenuation;
attenuation = (_e173 * (_e170 * _e171));
}
let _e175 = attenuation;
return _e175;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e163 = (*halfWidth);
let _e164 = (*halfHeight);
n_1 = cross(_e163, _e164);
let _e166 = n_1;
nLen = length(_e166);
let _e168 = nLen;
if (_e168 < 0.000000000001f) {
let _e170 = (*centre);
return _e170;
}
let _e171 = nLen;
let _e172 = n_1;
n_1 = (_e172 / vec3(_e171));
let _e175 = (*centre);
let _e176 = (*world_2);
toPlane = (_e175 - _e176);
let _e178 = (*mirror);
let _e179 = n_1;
denom = dot(_e178, _e179);
let _e181 = denom;
if (abs(_e181) < 0.00001f) {
let _e184 = toPlane;
let _e185 = n_1;
let _e186 = toPlane;
let _e187 = n_1;
onPlane = (_e184 - (_e185 * dot(_e186, _e187)));
} else {
let _e191 = toPlane;
let _e192 = n_1;
let _e194 = denom;
t = (dot(_e191, _e192) / _e194);
let _e196 = t;
if (_e196 > 0f) {
let _e198 = (*mirror);
let _e199 = t;
local_4 = (_e198 * _e199);
} else {
let _e201 = toPlane;
let _e202 = n_1;
let _e203 = toPlane;
let _e204 = n_1;
local_4 = (_e201 - (_e202 * dot(_e203, _e204)));
}
let _e208 = local_4;
onPlane = _e208;
}
let _e209 = onPlane;
let _e210 = toPlane;
offset_2 = (_e209 - _e210);
let _e212 = (*halfWidth);
let _e213 = (*halfWidth);
wLen2_ = max(dot(_e212, _e213), 0.000000000001f);
let _e216 = (*halfHeight);
let _e217 = (*halfHeight);
hLen2_ = max(dot(_e216, _e217), 0.000000000001f);
let _e220 = offset_2;
let _e221 = (*halfWidth);
let _e223 = wLen2_;
u = clamp((dot(_e220, _e221) / _e223), -1f, 1f);
let _e226 = offset_2;
let _e227 = (*halfHeight);
let _e229 = hLen2_;
v = clamp((dot(_e226, _e227) / _e229), -1f, 1f);
let _e232 = (*centre);
let _e233 = (*halfWidth);
let _e234 = u;
let _e237 = (*halfHeight);
let _e238 = v;
return ((_e232 + (_e233 * _e234)) + (_e237 * _e238));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_1: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e155 = i_6;
if (_e155 < 4i) {
let _e157 = i_6;
let _e159 = (*corners)[_e157];
a_1 = normalize(_e159);
let _e161 = i_6;
let _e165 = (*corners)[((_e161 + 1i) & 3i)];
b = normalize(_e165);
let _e167 = a_1;
let _e168 = b;
angle_1 = acos(clamp(dot(_e167, _e168), -1f, 1f));
let _e172 = a_1;
let _e173 = b;
axis = cross(_e172, _e173);
let _e175 = axis;
len = length(_e175);
let _e177 = len;
if (_e177 > 0.000001f) {
let _e179 = angle_1;
let _e180 = axis;
let _e181 = len;
let _e184 = (*n_2);
let _e187 = total;
total = (_e187 + (_e179 * dot((_e180 / vec3(_e181)), _e184)));
}
continue;
} else {
break;
}
continuing {
let _e189 = i_6;
i_6 = (_e189 + 1i);
}
}
let _e191 = total;
return max((-(_e191) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e152 = (*slot_1);
let _e153 = (*slot_1);
lane = (_e152 - ((_e153 / 4i) * 4i));
let _e157 = lane;
if (_e157 == 0i) {
let _e160 = (*four)[0u];
local_5 = _e160;
} else {
let _e161 = lane;
if (_e161 == 1i) {
let _e164 = (*four)[1u];
local_6 = _e164;
} else {
let _e165 = lane;
if (_e165 == 2i) {
let _e168 = (*four)[2u];
local_7 = _e168;
} else {
let _e170 = (*four)[3u];
local_7 = _e170;
}
let _e171 = local_7;
local_6 = _e171;
}
let _e172 = local_6;
local_5 = _e172;
}
let _e173 = local_5;
return _e173;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_45: vec4<f32>;
var param_46: i32;
let _e149 = (*slot_2);
let _e153 = light_list_info.scales[(_e149 / 4i)];
param_45 = _e153;
let _e154 = (*slot_2);
param_46 = _e154;
let _e155 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_45), (¶m_46));
return _e155;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_47: vec4<f32>;
var param_48: i32;
let _e149 = (*slot_3);
let _e153 = light_list_info.indices[(_e149 / 4i)];
param_47 = _e153;
let _e154 = (*slot_3);
param_48 = _e154;
let _e155 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_47), (¶m_48));
return _e155;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_49: i32;
var u_1: f32;
var param_50: i32;
var type_38: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_51: array<vec3<f32>, 4>;
var param_52: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_53: vec3<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var param_56: vec3<f32>;
var param_57: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_58: f32;
var param_59: f32;
var cosAngle: f32;
let _e189 = (*index_2);
if (_e189 < 8i) {
let _e191 = (*index_2);
let _e194 = frag_info.light_position[_e191];
position = _e194;
let _e195 = (*index_2);
let _e198 = frag_info.light_color[_e195];
color_1 = _e198;
let _e199 = (*index_2);
let _e202 = frag_info.light_direction[_e199];
direction = _e202;
let _e203 = (*index_2);
let _e206 = frag_info.light_cone[_e203];
cone = _e206;
} else {
let _e207 = (*index_2);
slot_4 = (_e207 - 8i);
let _e209 = slot_4;
param_49 = _e209;
let _e210 = LightListRow_u0028_i1_u003b((¶m_49));
let _e214 = light_list_info.list[2u];
v_1 = ((_e210 + 0.5f) * _e214);
let _e218 = light_list_info.list[1u];
u_1 = _e218;
let _e219 = u_1;
let _e221 = v_1;
let _e223 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e219), _e221), 0f);
position = _e223;
let _e224 = u_1;
let _e226 = v_1;
let _e228 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e224), _e226), 0f);
color_1 = _e228;
let _e229 = u_1;
let _e231 = v_1;
let _e233 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e229), _e231), 0f);
direction = _e233;
let _e234 = u_1;
let _e236 = v_1;
let _e238 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e234), _e236), 0f);
cone = _e238;
let _e239 = slot_4;
param_50 = _e239;
let _e240 = LightListScale_u0028_i1_u003b((¶m_50));
let _e242 = color_1[3u];
color_1[3u] = (_e242 * _e240);
}
let _e246 = position[3u];
type_38 = _e246;
let _e247 = type_38;
if (_e247 > 2.5f) {
let _e249 = direction;
halfWidth_1 = _e249.xyz;
let _e251 = cone;
halfHeight_1 = _e251.xyz;
let _e253 = position;
let _e255 = v_world_position_1;
toCentre = (_e253.xyz - _e255);
let _e257 = toCentre;
let _e258 = halfWidth_1;
let _e260 = halfHeight_1;
corners_1[0i] = ((_e257 - _e258) - _e260);
let _e263 = toCentre;
let _e264 = halfWidth_1;
let _e266 = halfHeight_1;
corners_1[1i] = ((_e263 + _e264) - _e266);
let _e269 = toCentre;
let _e270 = halfWidth_1;
let _e272 = halfHeight_1;
corners_1[2i] = ((_e269 + _e270) + _e272);
let _e275 = toCentre;
let _e276 = halfWidth_1;
let _e278 = halfHeight_1;
corners_1[3i] = ((_e275 - _e276) + _e278);
let _e281 = corners_1;
param_51 = _e281;
let _e283 = (*s_3).n;
param_52 = _e283;
let _e284 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_51), (¶m_52));
formFactor = _e284;
let _e285 = halfWidth_1;
let _e286 = halfHeight_1;
area = (length(cross(_e285, _e286)) * 4f);
let _e290 = area;
if (_e290 > 0.000000001f) {
let _e292 = area;
local_8 = (1f / _e292);
} else {
local_8 = 0f;
}
let _e294 = local_8;
radiance = _e294;
let _e295 = toCentre;
distance_2 = length(_e295);
let _e298 = direction[3u];
if (_e298 > 0f) {
let _e300 = distance_2;
let _e302 = direction[3u];
ratio_1 = (_e300 / _e302);
let _e304 = ratio_1;
let _e305 = ratio_1;
let _e307 = ratio_1;
let _e309 = ratio_1;
window_1 = clamp((1f - (((_e304 * _e305) * _e307) * _e309)), 0f, 1f);
let _e313 = window_1;
let _e314 = window_1;
let _e316 = radiance;
radiance = (_e316 * (_e313 * _e314));
}
let _e319 = (*s_3).v;
let _e322 = (*s_3).n;
mirror_1 = reflect(-(_e319), _e322);
let _e324 = position;
param_53 = _e324.xyz;
let _e326 = halfWidth_1;
param_54 = _e326;
let _e327 = halfHeight_1;
param_55 = _e327;
let _e328 = v_world_position_1;
param_56 = _e328;
let _e329 = mirror_1;
param_57 = _e329;
let _e330 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57));
representative = _e330;
let _e331 = representative;
let _e332 = v_world_position_1;
toPoint = (_e331 - _e332);
let _e334 = toPoint;
pointDistance = length(_e334);
let _e336 = pointDistance;
if (_e336 > 0.000001f) {
let _e338 = toPoint;
let _e339 = pointDistance;
local_9 = (_e338 / vec3(_e339));
} else {
let _e343 = (*s_3).n;
local_9 = _e343;
}
let _e344 = local_9;
light_3.l = _e344;
let _e347 = light_3.l;
let _e349 = (*s_3).v;
light_3.h = normalize((_e347 + _e349));
let _e353 = formFactor;
light_3.n_dot_l = _e353;
let _e356 = (*s_3).n;
let _e358 = light_3.h;
light_3.n_dot_h = max(dot(_e356, _e358), 0f);
let _e363 = (*s_3).v;
let _e365 = light_3.h;
light_3.v_dot_h = max(dot(_e363, _e365), 0f);
let _e369 = color_1;
let _e372 = color_1[3u];
let _e374 = radiance;
light_3.radiance = ((_e369.xyz * _e372) * _e374);
let _e377 = light_3;
return _e377;
}
let _e378 = direction;
aim = normalize(_e378.xyz);
attenuation_1 = 1f;
let _e381 = type_38;
if (_e381 < 0.5f) {
let _e383 = aim;
light_3.l = -(_e383);
} else {
let _e386 = position;
let _e388 = v_world_position_1;
toLight_1 = (_e386.xyz - _e388);
let _e390 = toLight_1;
distance_3 = length(_e390);
let _e392 = distance_3;
if (_e392 < 0.000001f) {
let _e395 = (*s_3).n;
light_3.l = _e395;
let _e398 = (*s_3).n;
light_3.h = _e398;
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 _e404 = light_3;
return _e404;
}
let _e405 = toLight_1;
let _e406 = distance_3;
light_3.l = (_e405 / vec3(_e406));
let _e410 = distance_3;
param_58 = _e410;
let _e412 = direction[3u];
param_59 = _e412;
let _e413 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_58), (¶m_59));
attenuation_1 = _e413;
let _e414 = type_38;
if (_e414 > 1.5f) {
let _e416 = aim;
let _e418 = light_3.l;
cosAngle = dot(_e416, -(_e418));
let _e421 = cosAngle;
let _e423 = cone[1u];
let _e426 = cone[0u];
let _e428 = cone[1u];
let _e432 = attenuation_1;
attenuation_1 = (_e432 * clamp(((_e421 - _e423) / (_e426 - _e428)), 0f, 1f));
}
}
let _e435 = light_3.l;
let _e437 = (*s_3).v;
light_3.h = normalize((_e435 + _e437));
let _e442 = (*s_3).n;
let _e444 = light_3.l;
light_3.n_dot_l = max(dot(_e442, _e444), 0f);
let _e449 = (*s_3).n;
let _e451 = light_3.h;
light_3.n_dot_h = max(dot(_e449, _e451), 0f);
let _e456 = (*s_3).v;
let _e458 = light_3.h;
light_3.v_dot_h = max(dot(_e456, _e458), 0f);
let _e462 = color_1;
let _e465 = color_1[3u];
let _e467 = attenuation_1;
light_3.radiance = ((_e462.xyz * _e465) * _e467);
let _e470 = light_3;
return _e470;
}
fn LightCount_u0028_() -> i32 {
let _e148 = frag_info.frame_params[1u];
let _e154 = light_list_info.list[0u];
return (clamp(i32((_e148 + 0.5f)), 0i, 8i) + clamp(i32((_e154 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_60: i32;
var param_61: Surface;
var visibility: f32;
var param_62: i32;
var local_10: f32;
var param_63: Surface;
var param_64: LightSample;
var param_65: i32;
var param_66: vec3<f32>;
var param_67: vec3<f32>;
var param_68: i32;
var param_69: Surface;
var param_70: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e164 = LightCount_u0028_();
count_1 = _e164;
i_7 = 0i;
loop {
let _e165 = i_7;
if (_e165 < 32i) {
let _e167 = i_7;
let _e168 = count_1;
if (_e167 >= _e168) {
break;
}
let _e170 = i_7;
param_60 = _e170;
let _e171 = (*s_4);
param_61 = _e171;
let _e172 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_60), (¶m_61));
light_4 = _e172;
let _e174 = light_4.n_dot_l;
if (_e174 <= 0f) {
continue;
}
let _e176 = i_7;
param_62 = _e176;
let _e177 = LightHasShadow_u0028_i1_u003b((¶m_62));
if _e177 {
let _e178 = (*s_4);
param_63 = _e178;
let _e179 = light_4;
param_64 = _e179;
let _e180 = i_7;
param_65 = _e180;
let _e181 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_63), (¶m_64), (¶m_65));
let _e182 = v_world_position_1;
param_66 = _e182;
let _e184 = (*s_4).n;
param_67 = _e184;
let _e185 = i_7;
param_68 = _e185;
let _e186 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_66), (¶m_67), (¶m_68));
local_10 = (_e181 * _e186);
} else {
local_10 = 1f;
}
let _e188 = local_10;
visibility = _e188;
let _e189 = visibility;
if (_e189 <= 0f) {
continue;
}
let _e191 = (*s_4);
param_69 = _e191;
let _e192 = light_4;
param_70 = _e192;
let _e193 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_69), (¶m_70));
let _e195 = light_4.radiance;
let _e198 = light_4.n_dot_l;
let _e200 = visibility;
let _e202 = total_1;
total_1 = (_e202 + (((_e193 * _e195) * _e198) * _e200));
continue;
} else {
break;
}
continuing {
let _e204 = i_7;
i_7 = (_e204 + 1i);
}
}
let _e206 = total_1;
return _e206;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e147 = v_lightmap_uv_1;
let _e148 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e147);
texel_2 = _e148;
let _e149 = texel_2;
let _e152 = texel_2[3u];
return ((_e149.xyz * _e152) * 8f);
}
fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e148 = v_texcoord_1;
let _e149 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e148);
orm = _e149.xyz;
let _e152 = (*s_5).metallic;
let _e154 = orm[2u];
(*s_5).metallic = clamp((_e152 * _e154), 0f, 1f);
let _e159 = (*s_5).roughness;
let _e161 = orm[1u];
(*s_5).roughness = clamp((_e159 * _e161), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e147 = (*srgb);
let _e150 = (*srgb);
let _e155 = (*srgb);
return mix((_e147 / vec3(12.92f)), pow(((_e150 + 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 ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_71: vec3<f32>;
let _e149 = v_texcoord_1;
let _e150 = textureSample(emissive_texture_tex, emissive_texture_smp, _e149);
param_71 = _e150.xyz;
let _e152 = SrgbToLinear_u0028_vf3_u003b((¶m_71));
emissive = _e152;
let _e153 = emissive;
let _e155 = frag_info.emissive;
let _e160 = frag_info.material2_[3u];
(*s_6).emissive = ((_e153 * _e155.xyz) * _e160);
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 _e148 = v_texcoord_1;
let _e149 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e148);
occlusion = _e149.x;
let _e151 = occlusion;
let _e154 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e151, clamp(_e154, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e151 = v_texcoord_1;
let _e152 = textureSample(normal_texture_tex, normal_texture_smp, _e151);
sampledTexel = _e152;
let _e153 = v_tangent_1;
t_1 = _e153.xyz;
let _e155 = t_1;
let _e157 = (*s_8).n;
let _e159 = (*s_8).n;
let _e160 = t_1;
t_1 = (_e155 - (_e157 * dot(_e159, _e160)));
let _e164 = t_1;
let _e165 = t_1;
if (dot(_e164, _e165) < 0.000000000001f) {
return;
}
let _e168 = t_1;
t_1 = normalize(_e168);
let _e171 = (*s_8).n;
let _e172 = t_1;
let _e175 = v_tangent_1[3u];
b_1 = (cross(_e171, _e172) * _e175);
let _e177 = gl_FrontFacing_1;
if !(_e177) {
let _e179 = t_1;
t_1 = -(_e179);
}
let _e181 = sampledTexel;
sampled = ((_e181.xyz * 2f) - vec3(1f));
let _e188 = frag_info.material2_[1u];
let _e189 = sampled;
let _e191 = (_e189.xy * _e188);
sampled[0u] = _e191.x;
sampled[1u] = _e191.y;
let _e196 = t_1;
let _e198 = sampled[0u];
let _e200 = b_1;
let _e202 = sampled[1u];
let _e206 = (*s_8).n;
let _e208 = sampled[2u];
(*s_8).n = normalize((((_e196 * _e198) + (_e200 * _e202)) + (_e206 * _e208)));
let _e214 = (*s_8).n;
let _e216 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e214, _e216), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
var param_72: Surface;
var param_73: Surface;
var param_74: Surface;
let _e150 = (*s_9);
param_72 = _e150;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_72));
let _e151 = param_72;
(*s_9) = _e151;
let _e152 = (*s_9);
param_73 = _e152;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_73));
let _e153 = param_73;
(*s_9) = _e153;
let _e154 = (*s_9);
param_74 = _e154;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_74));
let _e155 = param_74;
(*s_9) = _e155;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_75: vec3<f32>;
var param_76: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e153 = v_texcoord_1;
let _e154 = textureSample(base_color_texture_tex, base_color_texture_smp, _e153);
texel_3 = _e154;
let _e155 = texel_3;
param_75 = _e155.xyz;
let _e157 = SrgbToLinear_u0028_vf3_u003b((¶m_75));
let _e159 = frag_info.base_color;
param_76 = _e159.xyz;
let _e161 = SrgbToLinear_u0028_vf3_u003b((¶m_76));
let _e163 = v_color_1;
s_10.albedo = ((_e157 * _e161) * _e163.xyz);
let _e168 = texel_3[3u];
let _e171 = frag_info.base_color[3u];
let _e174 = v_color_1[3u];
s_10.alpha = ((_e168 * _e171) * _e174);
let _e179 = frag_info.material2_[0u];
cutoff = _e179;
let _e180 = cutoff;
if (_e180 >= 0f) {
let _e183 = s_10.alpha;
let _e184 = cutoff;
if (_e183 < _e184) {
discard;
}
} else {
let _e186 = cutoff;
if (_e186 < -1.5f) {
let _e188 = v_world_position_1;
anchored = floor((_e188 * 16f));
let _e191 = anchored;
noise_1 = fract((sin(dot(_e191, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e197 = s_10.alpha;
let _e198 = noise_1;
if (_e197 < _e198) {
discard;
}
}
}
let _e200 = v_normal_1;
s_10.n = normalize(_e200);
let _e203 = gl_FrontFacing_1;
if !(_e203) {
let _e206 = s_10.n;
s_10.n = -(_e206);
}
let _e210 = frag_info.camera_position;
let _e212 = v_world_position_1;
s_10.v = normalize((_e210.xyz - _e212));
let _e217 = s_10.n;
let _e219 = s_10.v;
s_10.n_dot_v = max(dot(_e217, _e219), 0.0001f);
let _e225 = frag_info.material[0u];
s_10.metallic = clamp(_e225, 0f, 1f);
let _e230 = frag_info.material[1u];
s_10.roughness = clamp(_e230, 0.02f, 1f);
let _e234 = frag_info.ambient_ground;
let _e237 = frag_info.ambient_sky;
let _e241 = s_10.n[1u];
let _e248 = frag_info.material[2u];
s_10.ambient = (mix(_e234.xyz, _e237.xyz, vec3(((_e241 * 0.5f) + 0.5f))) * _e248);
let _e253 = frag_info.frame_params[0u];
s_10.exposure = max(_e253, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e258 = s_10;
return _e258;
}
fn main_1() {
var s_11: Surface;
var param_77: Surface;
var param_78: Surface;
var ambient: vec3<f32>;
var param_79: Surface;
var param_80: vec3<f32>;
var param_81: f32;
var param_82: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e154 = ReadSurface_u0028_();
s_11 = _e154;
let _e155 = s_11;
param_77 = _e155;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_77));
let _e156 = param_77;
s_11 = _e156;
let _e157 = s_11;
param_78 = _e157;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_78));
let _e158 = param_78;
s_11 = _e158;
let _e160 = s_11.albedo;
let _e162 = s_11.ambient;
let _e163 = SampleLightmap_u0028_();
let _e167 = s_11.occlusion;
ambient = ((_e160 * (_e162 + _e163)) * _e167);
let _e169 = s_11;
param_79 = _e169;
let _e170 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_79));
let _e172 = s_11.occlusion;
let _e174 = ambient;
let _e177 = s_11.emissive;
param_80 = (((_e170 * _e172) + _e174) + _e177);
let _e180 = s_11.alpha;
param_81 = _e180;
let _e182 = s_11.roughness;
param_82 = _e182;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_80), (¶m_81), (¶m_82));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e18 = frag_surface;
let _e19 = frag_color;
return FragmentOutput(_e18, _e19);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Pbr': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(10)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(22)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var point_shadow_texture_smp: sampler;
@group(1) @binding(20)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(12)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(14)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(18)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(16)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(24)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var shadow_texture_smp: sampler;
@group(1) @binding(8)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(9)
var environment_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e166 = (*n)[0u];
let _e169 = (*n)[1u];
let _e173 = (*n)[2u];
let _e176 = (*n);
(*n) = (_e176 / vec3(((abs(_e166) + abs(_e169)) + abs(_e173))));
let _e179 = (*n);
e = _e179.xy;
let _e182 = (*n)[2u];
if (_e182 < 0f) {
let _e184 = (*n);
let _e190 = (*n)[0u];
let _e194 = (*n)[1u];
e = ((vec2(1f) - abs(_e184.yx)) * vec2<f32>(select(-1f, 1f, (_e190 >= 0f)), select(-1f, 1f, (_e194 >= 0f))));
}
let _e199 = e;
return ((_e199 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e163 = v_world_position_1;
let _e165 = fog_info.eye;
let _e169 = fog_info.forward;
return dot((_e163 - _e165.xyz), _e169.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var geometric: vec3<f32>;
var param: vec3<f32>;
let _e166 = g_debug_surface_on;
if _e166 {
let _e167 = g_debug_surface;
let _e168 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e167.x, _e167.y, _e167.z, _e168);
return;
}
let _e173 = v_normal_1;
geometric = normalize(_e173);
let _e175 = gl_FrontFacing_1;
if !(_e175) {
let _e177 = geometric;
geometric = -(_e177);
}
let _e179 = geometric;
param = _e179;
let _e180 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e181 = (*roughness);
let _e183 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e180.x, _e180.y, clamp(_e181, 0f, 1f), _e183);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e163 = v_world_position_1;
let _e165 = fog_info.eye;
return distance(_e163, _e165.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e168 = fog_info.fog[3u];
density = _e168;
let _e169 = density;
if (_e169 <= 0f) {
let _e171 = (*color);
return _e171;
}
let _e172 = EyeDistance_u0028_();
d = _e172;
let _e174 = fog_info.fog;
let _e176 = (*color);
let _e177 = density;
let _e179 = d;
return mix(_e174.xyz, _e176, vec3(clamp(exp((-(_e177) * _e179)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e168 = (*linearColor);
param_1 = _e168;
let _e169 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e170 = (*alpha);
frag_color = vec4<f32>(_e169.x, _e169.y, _e169.z, _e170);
let _e175 = (*roughness_1);
param_2 = _e175;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
var f: f32;
let _e166 = (*v_dot_h);
f = pow((1f - _e166), 5f);
let _e169 = (*f0_);
let _e170 = (*f0_);
let _e172 = f;
return (_e169 + ((vec3<f32>(1f, 1f, 1f) - _e170) * _e172));
}
fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_1: ptr<function, f32>) -> f32 {
var a2_: f32;
var lambda_v: f32;
var lambda_l: f32;
let _e169 = (*alpha_1);
let _e170 = (*alpha_1);
a2_ = (_e169 * _e170);
let _e172 = (*n_dot_l);
let _e173 = (*n_dot_v);
let _e174 = (*n_dot_v);
let _e176 = a2_;
let _e179 = a2_;
lambda_v = (_e172 * sqrt((((_e173 * _e174) * (1f - _e176)) + _e179)));
let _e183 = (*n_dot_v);
let _e184 = (*n_dot_l);
let _e185 = (*n_dot_l);
let _e187 = a2_;
let _e190 = a2_;
lambda_l = (_e183 * sqrt((((_e184 * _e185) * (1f - _e187)) + _e190)));
let _e194 = lambda_v;
let _e195 = lambda_l;
return (0.5f / max((_e194 + _e195), 0.00001f));
}
fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_2: ptr<function, f32>) -> f32 {
var a: f32;
var k: f32;
let _e167 = (*n_dot_h);
let _e168 = (*alpha_2);
a = (_e167 * _e168);
let _e170 = (*alpha_2);
let _e171 = (*n_dot_h);
let _e172 = (*n_dot_h);
let _e175 = a;
let _e176 = a;
k = (_e170 / max(((1f - (_e171 * _e172)) + (_e175 * _e176)), 0.000001f));
let _e181 = k;
let _e182 = k;
return ((_e181 * _e182) * 0.31830987f);
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var alpha_3: f32;
var f0_1: vec3<f32>;
var diffuseColor: vec3<f32>;
var d_1: f32;
var param_3: f32;
var param_4: f32;
var vis: f32;
var param_5: f32;
var param_6: f32;
var param_7: f32;
var f_1: vec3<f32>;
var param_8: vec3<f32>;
var param_9: f32;
var specular: vec3<f32>;
var diffuse: vec3<f32>;
let _e181 = (*s).roughness;
let _e183 = (*s).roughness;
alpha_3 = (_e181 * _e183);
let _e186 = (*s).albedo;
let _e188 = (*s).metallic;
f0_1 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e186, vec3(_e188));
let _e192 = (*s).albedo;
let _e194 = (*s).metallic;
diffuseColor = (_e192 * (1f - _e194));
let _e198 = (*light).n_dot_h;
param_3 = _e198;
let _e199 = alpha_3;
param_4 = _e199;
let _e200 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_3), (¶m_4));
d_1 = _e200;
let _e202 = (*s).n_dot_v;
param_5 = _e202;
let _e204 = (*light).n_dot_l;
param_6 = _e204;
let _e205 = alpha_3;
param_7 = _e205;
let _e206 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
vis = _e206;
let _e207 = f0_1;
param_8 = _e207;
let _e209 = (*light).v_dot_h;
param_9 = _e209;
let _e210 = F_Schlick_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
f_1 = _e210;
let _e211 = d_1;
let _e212 = vis;
let _e214 = f_1;
let _e218 = frag_info.material[3u];
specular = ((_e214 * (_e211 * _e212)) * _e218);
let _e220 = diffuseColor;
let _e221 = f_1;
diffuse = ((_e220 * (vec3<f32>(1f, 1f, 1f) - _e221)) / vec3(3.1415927f));
let _e226 = diffuse;
let _e227 = specular;
return ((_e226 + _e227) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e164 = (*i);
if (_e164 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e166 = (*i);
if (_e166 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e168 = (*i);
if (_e168 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e170 = (*i);
if (_e170 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e172 = (*i);
if (_e172 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e174 = (*i);
if (_e174 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e176 = (*i);
if (_e176 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_10: i32;
let _e169 = (*i_1);
param_10 = _e169;
let _e170 = PointShadowDiskTap_u0028_i1_u003b((¶m_10));
p = _e170;
let _e172 = p[0u];
let _e173 = (*ca);
let _e176 = p[1u];
let _e177 = (*sa);
let _e181 = p[0u];
let _e182 = (*sa);
let _e185 = p[1u];
let _e186 = (*ca);
let _e190 = (*radius);
return (vec2<f32>(((_e172 * _e173) - (_e176 * _e177)), ((_e181 * _e182) + (_e185 * _e186))) * _e190);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e172 = point_shadow.params[0u];
inset = _e172;
let _e173 = (*uv);
let _e174 = (*offset);
let _e176 = inset;
let _e177 = inset;
local = clamp((_e173 + _e174), vec2(_e176), vec2((1f - _e177)));
let _e182 = local;
let _e183 = (*tile);
atlas = ((_e182 + _e183) * vec2<f32>(0.16666667f, 0.16666667f));
let _e188 = point_shadow.params3_[0u];
if (_e188 > 0.5f) {
let _e191 = atlas[1u];
atlas[1u] = (1f - _e191);
}
let _e194 = atlas;
let _e195 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e194, 0f);
let _e197 = atlas;
let _e198 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e197, 0f);
let _e201 = (*range);
return (min(_e195.x, _e198.x) * _e201);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_11: vec2<f32>;
var param_12: vec2<f32>;
var param_13: vec2<f32>;
var param_14: f32;
let _e173 = (*uv_1);
param_11 = _e173;
let _e174 = (*offset_1);
param_12 = _e174;
let _e175 = (*tile_1);
param_13 = _e175;
let _e176 = (*range_1);
param_14 = _e176;
let _e177 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_11), (¶m_12), (¶m_13), (¶m_14));
stored = _e177;
let _e178 = stored;
let _e179 = (*range_1);
if (_e178 >= (_e179 * 0.999f)) {
return 1f;
}
let _e182 = (*receiver);
let _e183 = stored;
return select(1f, 0f, (_e182 > _e183));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_15: vec2<f32>;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_19: i32;
var param_20: f32;
var param_21: f32;
var param_22: f32;
var param_23: vec2<f32>;
var param_24: vec2<f32>;
var param_25: vec2<f32>;
var param_26: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e194 = point_shadow.params2_[1u];
lightRadius = _e194;
let _e197 = point_shadow.params2_[0u];
minRadius = _e197;
let _e200 = point_shadow.params2_[2u];
maxRadius = _e200;
let _e201 = lightRadius;
if (_e201 <= 0f) {
let _e203 = (*uv_2);
param_15 = _e203;
param_16 = vec2<f32>(0f, 0f);
let _e204 = (*tile_2);
param_17 = _e204;
let _e205 = (*range_2);
param_18 = _e205;
let _e206 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
(*blockerOut) = _e206;
let _e207 = minRadius;
return _e207;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e208 = i_2;
if (_e208 < 8i) {
let _e210 = i_2;
param_19 = _e210;
let _e211 = (*ca_1);
param_20 = _e211;
let _e212 = (*sa_1);
param_21 = _e212;
let _e213 = maxRadius;
param_22 = _e213;
let _e214 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
let _e215 = (*uv_2);
param_23 = _e215;
param_24 = _e214;
let _e216 = (*tile_2);
param_25 = _e216;
let _e217 = (*range_2);
param_26 = _e217;
let _e218 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
stored_1 = _e218;
let _e219 = stored_1;
let _e220 = (*range_2);
if (_e219 >= (_e220 * 0.999f)) {
continue;
}
let _e223 = stored_1;
let _e224 = (*receiver_1);
if (_e223 >= _e224) {
continue;
}
let _e226 = stored_1;
let _e227 = sum;
sum = (_e227 + _e226);
let _e229 = count;
count = (_e229 + 1f);
continue;
} else {
break;
}
continuing {
let _e231 = i_2;
i_2 = (_e231 + 1i);
}
}
let _e233 = count;
if (_e233 < 0.5f) {
return -1f;
}
let _e235 = sum;
let _e236 = count;
blocker = max((_e235 / _e236), 0.0001f);
let _e239 = blocker;
(*blockerOut) = _e239;
let _e240 = lightRadius;
let _e241 = (*receiver_1);
let _e242 = blocker;
let _e246 = blocker;
world = ((_e240 * max((_e241 - _e242), 0f)) / _e246);
let _e248 = world;
let _e249 = (*receiver_1);
let _e251 = (*tanHalf);
let _e254 = minRadius;
let _e255 = maxRadius;
return clamp((_e248 / ((2f * _e249) * _e251)), _e254, _e255);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a_1: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_27: vec2<f32>;
var param_28: vec2<f32>;
var param_29: f32;
var param_30: f32;
var param_31: f32;
var param_32: f32;
var param_33: f32;
var param_34: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_35: vec2<f32>;
var param_36: vec2<f32>;
var param_37: vec2<f32>;
var param_38: f32;
var param_39: f32;
var i_3: i32;
var param_40: i32;
var param_41: f32;
var param_42: f32;
var param_43: f32;
var param_44: vec2<f32>;
var param_45: vec2<f32>;
var param_46: vec2<f32>;
var param_47: f32;
var param_48: f32;
var phi_1564_: bool;
var phi_1626_: bool;
let _e216 = (*lightIndex);
let _e220 = point_shadow.slots[_e216][0u];
slot = i32((_e220 + 0.5f));
let _e223 = (*lightIndex);
let _e227 = point_shadow.slots[_e223][0u];
if (_e227 < 0f) {
return 1f;
}
let _e231 = point_shadow.params[2u];
strength = _e231;
let _e232 = strength;
if (_e232 <= 0f) {
return 1f;
}
let _e234 = slot;
let _e237 = point_shadow.lights[_e234];
let _e239 = (*world_1);
toLight = (_e237.xyz - _e239);
let _e241 = toLight;
toLightLength = max(length(_e241), 0.000001f);
let _e244 = (*normal);
let _e245 = toLight;
let _e246 = toLightLength;
nDotL = max(dot(_e244, (_e245 / vec3(_e246))), 0.15f);
let _e251 = nDotL;
let _e252 = nDotL;
let _e257 = nDotL;
let _e258 = nDotL;
slope = min((sqrt(max((1f - (_e251 * _e252)), 0f)) / (_e257 * _e258)), 8f);
let _e262 = toLightLength;
let _e264 = (*lightIndex);
let _e268 = point_shadow.slots[_e264][2u];
let _e273 = point_shadow.params3_[1u];
texel = (((2f * _e262) * max(_e268, 0.0001f)) * _e273);
let _e275 = (*world_1);
let _e276 = (*normal);
let _e277 = texel;
let _e281 = point_shadow.params[3u];
let _e283 = slope;
origin = (_e275 + (((_e276 * _e277) * _e281) * (1f + _e283)));
let _e287 = origin;
let _e288 = slot;
let _e291 = point_shadow.lights[_e288];
toFragment = (_e287 - _e291.xyz);
let _e294 = toFragment;
distance_ = length(_e294);
let _e296 = slot;
let _e300 = point_shadow.lights[_e296][3u];
range_3 = max(_e300, 0.0001f);
let _e302 = distance_;
let _e303 = range_3;
if (_e302 >= _e303) {
return 1f;
}
face = 0i;
let _e305 = (*lightIndex);
let _e309 = point_shadow.slots[_e305][1u];
if (_e309 < 0.5f) {
let _e311 = toFragment;
a_1 = abs(_e311);
let _e314 = a_1[0u];
let _e316 = a_1[1u];
let _e317 = (_e314 >= _e316);
phi_1564_ = _e317;
if _e317 {
let _e319 = a_1[0u];
let _e321 = a_1[2u];
phi_1564_ = (_e319 >= _e321);
}
let _e324 = phi_1564_;
if _e324 {
let _e326 = toFragment[0u];
face = select(1i, 0i, (_e326 > 0f));
} else {
let _e330 = a_1[1u];
let _e332 = a_1[2u];
if (_e330 >= _e332) {
let _e335 = toFragment[1u];
face = select(3i, 2i, (_e335 > 0f));
} else {
let _e339 = toFragment[2u];
face = select(5i, 4i, (_e339 > 0f));
}
}
}
let _e342 = slot;
let _e344 = face;
let _e348 = point_shadow.faces[((_e342 * 6i) + _e344)];
let _e349 = origin;
clip = (_e348 * vec4<f32>(_e349.x, _e349.y, _e349.z, 1f));
let _e356 = clip[3u];
if (_e356 <= 0f) {
return 1f;
}
let _e358 = clip;
let _e361 = clip[3u];
ndc = (_e358.xy / vec2(_e361));
let _e365 = ndc[0u];
let _e367 = (abs(_e365) > 1f);
phi_1626_ = _e367;
if !(_e367) {
let _e370 = ndc[1u];
phi_1626_ = (abs(_e370) > 1f);
}
let _e374 = phi_1626_;
if _e374 {
return 1f;
}
let _e376 = ndc[0u];
let _e380 = ndc[1u];
uv_3 = vec2<f32>(((_e376 * 0.5f) + 0.5f), (0.5f - (_e380 * 0.5f)));
let _e384 = face;
let _e386 = slot;
tile_3 = vec2<f32>(f32(_e384), f32(_e386));
let _e389 = distance_;
let _e392 = point_shadow.params[1u];
receiver_2 = (_e389 - _e392);
let _e394 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e394.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e400 = noise;
angle = (_e400 * 6.2831855f);
let _e402 = angle;
ca_2 = cos(_e402);
let _e404 = angle;
sa_2 = sin(_e404);
let _e406 = (*lightIndex);
let _e410 = point_shadow.slots[_e406][2u];
tanHalf_1 = max(_e410, 0.0001f);
blocker_1 = -1f;
let _e412 = uv_3;
param_27 = _e412;
let _e413 = tile_3;
param_28 = _e413;
let _e414 = range_3;
param_29 = _e414;
let _e415 = receiver_2;
param_30 = _e415;
let _e416 = ca_2;
param_31 = _e416;
let _e417 = sa_2;
param_32 = _e417;
let _e418 = tanHalf_1;
param_33 = _e418;
let _e419 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_27), (¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32), (¶m_33), (¶m_34));
let _e420 = param_34;
blocker_1 = _e420;
radius_1 = _e419;
let _e423 = point_shadow.params2_[3u];
if (_e423 > 0.5f) {
g_debug_surface_on = true;
let _e425 = radius_1;
if (_e425 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e427 = radius_1;
let _e430 = point_shadow.params2_[2u];
let _e434 = blocker_1;
let _e435 = range_3;
local_1 = vec3<f32>(clamp((_e427 / max(_e430, 0.000001f)), 0f, 1f), clamp((_e434 / _e435), 0f, 1f), 0f);
}
let _e439 = local_1;
g_debug_surface = _e439;
}
let _e440 = radius_1;
if (_e440 < 0f) {
return 1f;
}
let _e442 = uv_3;
param_35 = _e442;
param_36 = vec2<f32>(0f, 0f);
let _e443 = tile_3;
param_37 = _e443;
let _e444 = range_3;
param_38 = _e444;
let _e445 = receiver_2;
param_39 = _e445;
let _e446 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
lit = _e446;
let _e447 = radius_1;
if (_e447 > 0f) {
i_3 = 0i;
loop {
let _e449 = i_3;
if (_e449 < 8i) {
let _e451 = i_3;
param_40 = _e451;
let _e452 = ca_2;
param_41 = _e452;
let _e453 = sa_2;
param_42 = _e453;
let _e454 = radius_1;
param_43 = _e454;
let _e455 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43));
let _e456 = uv_3;
param_44 = _e456;
param_45 = _e455;
let _e457 = tile_3;
param_46 = _e457;
let _e458 = range_3;
param_47 = _e458;
let _e459 = receiver_2;
param_48 = _e459;
let _e460 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_44), (¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e461 = lit;
lit = (_e461 + _e460);
continue;
} else {
break;
}
continuing {
let _e463 = i_3;
i_3 = (_e463 + 1i);
}
}
let _e465 = lit;
lit = (_e465 * 0.11111111f);
}
let _e467 = lit;
let _e468 = strength;
return mix(1f, _e467, clamp(_e468, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var nDotL_1: f32;
var slope_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var rowX: f32;
var texelMetres: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2087_: bool;
var phi_2098_: bool;
var phi_2217_: bool;
var phi_2224_: bool;
var phi_2231_: bool;
let _e206 = frag_info.shadow_params[3u];
strength_1 = _e206;
let _e207 = strength_1;
if (_e207 <= 0f) {
return 1f;
}
let _e209 = (*lightIndex_1);
let _e212 = frag_info.frame_params[2u];
if (_e209 != i32((_e212 + 0.5f))) {
return 1f;
}
let _e217 = (*light_1).n_dot_l;
nDotL_1 = max(_e217, 0.15f);
let _e219 = nDotL_1;
let _e220 = nDotL_1;
let _e225 = nDotL_1;
let _e226 = nDotL_1;
slope_1 = min((sqrt(max((1f - (_e219 * _e220)), 0f)) / (_e225 * _e226)), 8f);
let _e232 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e232 + 0.5f));
let _e235 = v_world_position_1;
let _e237 = frag_info.camera_position;
viewDistance = length((_e235 - _e237.xyz));
cascade = 0i;
let _e241 = cascadeCount;
let _e242 = (_e241 > 1i);
phi_2087_ = _e242;
if _e242 {
let _e243 = viewDistance;
let _e246 = frag_info.shadow_cascades[0u];
phi_2087_ = (_e243 > _e246);
}
let _e249 = phi_2087_;
if _e249 {
cascade = 1i;
}
let _e250 = cascadeCount;
let _e251 = (_e250 > 2i);
phi_2098_ = _e251;
if _e251 {
let _e252 = viewDistance;
let _e255 = frag_info.shadow_cascades[1u];
phi_2098_ = (_e252 > _e255);
}
let _e258 = phi_2098_;
if _e258 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e259 = attempt;
if (_e259 < 3i) {
let _e261 = cascade;
let _e262 = attempt;
which = (_e261 + _e262);
let _e264 = which;
let _e265 = cascadeCount;
if (_e264 >= _e265) {
break;
}
let _e267 = which;
if (_e267 == 0i) {
let _e270 = frag_info.shadow_matrix;
local_2 = _e270;
} else {
let _e271 = which;
if (_e271 == 1i) {
let _e274 = frag_info.shadow_matrix_far;
local_3 = _e274;
} else {
let _e276 = frag_info.shadow_matrix_farthest;
local_3 = _e276;
}
let _e277 = local_3;
local_2 = _e277;
}
let _e278 = local_2;
matrix = _e278;
let _e281 = matrix[0][0u];
let _e284 = matrix[1][0u];
let _e287 = matrix[2][0u];
rowX = length(vec3<f32>(_e281, _e284, _e287));
let _e292 = frag_info.shadow_cascades[3u];
let _e294 = rowX;
texelMetres = ((2f * _e292) / max(_e294, 0.000001f));
let _e297 = v_world_position_1;
let _e299 = (*s_1).n;
let _e302 = frag_info.shadow_params[2u];
let _e303 = texelMetres;
let _e304 = slope_1;
origin_1 = (_e297 + (_e299 * (_e302 + (_e303 * (1f + _e304)))));
let _e310 = matrix;
let _e311 = origin_1;
lightSpace = (_e310 * vec4<f32>(_e311.x, _e311.y, _e311.z, 1f));
let _e318 = lightSpace[3u];
if (_e318 <= 0f) {
continue;
}
let _e320 = lightSpace;
let _e323 = lightSpace[3u];
candidate = (_e320.xyz / vec3(_e323));
let _e327 = candidate[0u];
let _e331 = candidate[1u];
inTile = vec2<f32>(((_e327 * 0.5f) + 0.5f), (0.5f - (_e331 * 0.5f)));
let _e336 = inTile[0u];
let _e337 = (_e336 < 0f);
phi_2217_ = _e337;
if !(_e337) {
let _e340 = inTile[0u];
phi_2217_ = (_e340 > 1f);
}
let _e343 = phi_2217_;
phi_2224_ = _e343;
if !(_e343) {
let _e346 = inTile[1u];
phi_2224_ = (_e346 < 0f);
}
let _e349 = phi_2224_;
phi_2231_ = _e349;
if !(_e349) {
let _e352 = inTile[1u];
phi_2231_ = (_e352 > 1f);
}
let _e355 = phi_2231_;
if _e355 {
continue;
}
let _e357 = candidate[2u];
if (_e357 > 1f) {
let _e359 = which;
let _e360 = cascadeCount;
if (_e359 < (_e360 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e365 = inTile[0u];
let _e366 = which;
let _e369 = cascadeCount;
let _e373 = inTile[1u];
uv_4 = vec2<f32>(((_e365 + f32(_e366)) / f32(_e369)), _e373);
let _e375 = candidate;
projected = _e375;
let _e376 = which;
cascade = _e376;
found = true;
break;
} else {
break;
}
continuing {
let _e377 = attempt;
attempt = (_e377 + 1i);
}
}
let _e379 = found;
if !(_e379) {
return 1f;
}
let _e383 = frag_info.shadow_params[1u];
bias = _e383;
let _e386 = frag_info.shadow_params[0u];
let _e389 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e386, _e389);
let _e393 = frag_info.ambient_ground[3u];
softness = _e393;
lit_1 = 0f;
let _e394 = softness;
if (_e394 <= 0f) {
y = -1i;
loop {
let _e396 = y;
if (_e396 <= 1i) {
x = -1i;
loop {
let _e398 = x;
if (_e398 <= 1i) {
let _e400 = uv_4;
let _e401 = x;
let _e403 = y;
let _e406 = texel_1;
let _e409 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e400 + (vec2<f32>(f32(_e401), f32(_e403)) * _e406)), 0f);
occluder = _e409.x;
let _e412 = projected[2u];
let _e413 = bias;
let _e415 = occluder;
let _e418 = lit_1;
lit_1 = (_e418 + select(1f, 0f, ((_e412 - _e413) > _e415)));
continue;
} else {
break;
}
continuing {
let _e420 = x;
x = (_e420 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e422 = y;
y = (_e422 + 1i);
}
}
let _e424 = lit_1;
lit_1 = (_e424 * 0.11111111f);
} else {
let _e426 = softness;
searchRadius = clamp((_e426 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e429 = i_4;
if (_e429 < 5i) {
let _e431 = uv_4;
let _e432 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e434 = indexable[_e432];
let _e435 = texel_1;
let _e437 = searchRadius;
let _e440 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e431 + ((_e434 * _e435) * _e437)), 0f);
occluder_1 = _e440.x;
let _e443 = projected[2u];
let _e444 = bias;
let _e446 = occluder_1;
if ((_e443 - _e444) > _e446) {
let _e448 = occluder_1;
let _e449 = blockerSum;
blockerSum = (_e449 + _e448);
let _e451 = blockerCount;
blockerCount = (_e451 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e453 = i_4;
i_4 = (_e453 + 1i);
}
}
let _e455 = blockerCount;
if (_e455 <= 0f) {
return 1f;
}
let _e458 = projected[2u];
let _e459 = blockerSum;
let _e460 = blockerCount;
gap = max((_e458 - (_e459 / _e460)), 0f);
let _e464 = gap;
let _e465 = softness;
radius_2 = clamp((_e464 * _e465), 1f, 16f);
i_5 = 0i;
loop {
let _e468 = i_5;
if (_e468 < 5i) {
let _e470 = uv_4;
let _e471 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e473 = indexable_1[_e471];
let _e474 = texel_1;
let _e476 = radius_2;
let _e479 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e470 + ((_e473 * _e474) * _e476)), 0f);
occluder_2 = _e479.x;
let _e482 = projected[2u];
let _e483 = bias;
let _e485 = occluder_2;
let _e488 = lit_1;
lit_1 = (_e488 + select(1f, 0f, ((_e482 - _e483) > _e485)));
continue;
} else {
break;
}
continuing {
let _e490 = i_5;
i_5 = (_e490 + 1i);
}
}
let _e492 = lit_1;
lit_1 = (_e492 * 0.2f);
}
let _e494 = lit_1;
let _e495 = strength_1;
return mix(1f, _e494, clamp(_e495, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_49: Surface;
var param_50: LightSample;
var param_51: i32;
let _e169 = (*s_2);
param_49 = _e169;
let _e170 = (*light_2);
param_50 = _e170;
let _e171 = (*index);
param_51 = _e171;
let _e172 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_49), (¶m_50), (¶m_51));
return _e172;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e164 = (*index_1);
return (_e164 < 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 _e168 = (*distance_1);
let _e169 = (*distance_1);
attenuation = (1f / max((_e168 * _e169), 0.0001f));
let _e173 = (*range_4);
if (_e173 > 0f) {
let _e175 = (*distance_1);
let _e176 = (*range_4);
ratio = (_e175 / _e176);
let _e178 = ratio;
let _e179 = ratio;
let _e181 = ratio;
let _e183 = ratio;
window = clamp((1f - (((_e178 * _e179) * _e181) * _e183)), 0f, 1f);
let _e187 = window;
let _e188 = window;
let _e190 = attenuation;
attenuation = (_e190 * (_e187 * _e188));
}
let _e192 = attenuation;
return _e192;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e180 = (*halfWidth);
let _e181 = (*halfHeight);
n_1 = cross(_e180, _e181);
let _e183 = n_1;
nLen = length(_e183);
let _e185 = nLen;
if (_e185 < 0.000000000001f) {
let _e187 = (*centre);
return _e187;
}
let _e188 = nLen;
let _e189 = n_1;
n_1 = (_e189 / vec3(_e188));
let _e192 = (*centre);
let _e193 = (*world_2);
toPlane = (_e192 - _e193);
let _e195 = (*mirror);
let _e196 = n_1;
denom = dot(_e195, _e196);
let _e198 = denom;
if (abs(_e198) < 0.00001f) {
let _e201 = toPlane;
let _e202 = n_1;
let _e203 = toPlane;
let _e204 = n_1;
onPlane = (_e201 - (_e202 * dot(_e203, _e204)));
} else {
let _e208 = toPlane;
let _e209 = n_1;
let _e211 = denom;
t = (dot(_e208, _e209) / _e211);
let _e213 = t;
if (_e213 > 0f) {
let _e215 = (*mirror);
let _e216 = t;
local_4 = (_e215 * _e216);
} else {
let _e218 = toPlane;
let _e219 = n_1;
let _e220 = toPlane;
let _e221 = n_1;
local_4 = (_e218 - (_e219 * dot(_e220, _e221)));
}
let _e225 = local_4;
onPlane = _e225;
}
let _e226 = onPlane;
let _e227 = toPlane;
offset_2 = (_e226 - _e227);
let _e229 = (*halfWidth);
let _e230 = (*halfWidth);
wLen2_ = max(dot(_e229, _e230), 0.000000000001f);
let _e233 = (*halfHeight);
let _e234 = (*halfHeight);
hLen2_ = max(dot(_e233, _e234), 0.000000000001f);
let _e237 = offset_2;
let _e238 = (*halfWidth);
let _e240 = wLen2_;
u = clamp((dot(_e237, _e238) / _e240), -1f, 1f);
let _e243 = offset_2;
let _e244 = (*halfHeight);
let _e246 = hLen2_;
v = clamp((dot(_e243, _e244) / _e246), -1f, 1f);
let _e249 = (*centre);
let _e250 = (*halfWidth);
let _e251 = u;
let _e254 = (*halfHeight);
let _e255 = v;
return ((_e249 + (_e250 * _e251)) + (_e254 * _e255));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_2: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e172 = i_6;
if (_e172 < 4i) {
let _e174 = i_6;
let _e176 = (*corners)[_e174];
a_2 = normalize(_e176);
let _e178 = i_6;
let _e182 = (*corners)[((_e178 + 1i) & 3i)];
b = normalize(_e182);
let _e184 = a_2;
let _e185 = b;
angle_1 = acos(clamp(dot(_e184, _e185), -1f, 1f));
let _e189 = a_2;
let _e190 = b;
axis = cross(_e189, _e190);
let _e192 = axis;
len = length(_e192);
let _e194 = len;
if (_e194 > 0.000001f) {
let _e196 = angle_1;
let _e197 = axis;
let _e198 = len;
let _e201 = (*n_2);
let _e204 = total;
total = (_e204 + (_e196 * dot((_e197 / vec3(_e198)), _e201)));
}
continue;
} else {
break;
}
continuing {
let _e206 = i_6;
i_6 = (_e206 + 1i);
}
}
let _e208 = total;
return max((-(_e208) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e169 = (*slot_1);
let _e170 = (*slot_1);
lane = (_e169 - ((_e170 / 4i) * 4i));
let _e174 = lane;
if (_e174 == 0i) {
let _e177 = (*four)[0u];
local_5 = _e177;
} else {
let _e178 = lane;
if (_e178 == 1i) {
let _e181 = (*four)[1u];
local_6 = _e181;
} else {
let _e182 = lane;
if (_e182 == 2i) {
let _e185 = (*four)[2u];
local_7 = _e185;
} else {
let _e187 = (*four)[3u];
local_7 = _e187;
}
let _e188 = local_7;
local_6 = _e188;
}
let _e189 = local_6;
local_5 = _e189;
}
let _e190 = local_5;
return _e190;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_52: vec4<f32>;
var param_53: i32;
let _e166 = (*slot_2);
let _e170 = light_list_info.scales[(_e166 / 4i)];
param_52 = _e170;
let _e171 = (*slot_2);
param_53 = _e171;
let _e172 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_52), (¶m_53));
return _e172;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_54: vec4<f32>;
var param_55: i32;
let _e166 = (*slot_3);
let _e170 = light_list_info.indices[(_e166 / 4i)];
param_54 = _e170;
let _e171 = (*slot_3);
param_55 = _e171;
let _e172 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_54), (¶m_55));
return _e172;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_56: i32;
var u_1: f32;
var param_57: i32;
var type_39: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_58: array<vec3<f32>, 4>;
var param_59: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_60: vec3<f32>;
var param_61: vec3<f32>;
var param_62: vec3<f32>;
var param_63: vec3<f32>;
var param_64: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_65: f32;
var param_66: f32;
var cosAngle: f32;
let _e206 = (*index_2);
if (_e206 < 8i) {
let _e208 = (*index_2);
let _e211 = frag_info.light_position[_e208];
position = _e211;
let _e212 = (*index_2);
let _e215 = frag_info.light_color[_e212];
color_1 = _e215;
let _e216 = (*index_2);
let _e219 = frag_info.light_direction[_e216];
direction = _e219;
let _e220 = (*index_2);
let _e223 = frag_info.light_cone[_e220];
cone = _e223;
} else {
let _e224 = (*index_2);
slot_4 = (_e224 - 8i);
let _e226 = slot_4;
param_56 = _e226;
let _e227 = LightListRow_u0028_i1_u003b((¶m_56));
let _e231 = light_list_info.list[2u];
v_1 = ((_e227 + 0.5f) * _e231);
let _e235 = light_list_info.list[1u];
u_1 = _e235;
let _e236 = u_1;
let _e238 = v_1;
let _e240 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e236), _e238), 0f);
position = _e240;
let _e241 = u_1;
let _e243 = v_1;
let _e245 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e241), _e243), 0f);
color_1 = _e245;
let _e246 = u_1;
let _e248 = v_1;
let _e250 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e246), _e248), 0f);
direction = _e250;
let _e251 = u_1;
let _e253 = v_1;
let _e255 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e251), _e253), 0f);
cone = _e255;
let _e256 = slot_4;
param_57 = _e256;
let _e257 = LightListScale_u0028_i1_u003b((¶m_57));
let _e259 = color_1[3u];
color_1[3u] = (_e259 * _e257);
}
let _e263 = position[3u];
type_39 = _e263;
let _e264 = type_39;
if (_e264 > 2.5f) {
let _e266 = direction;
halfWidth_1 = _e266.xyz;
let _e268 = cone;
halfHeight_1 = _e268.xyz;
let _e270 = position;
let _e272 = v_world_position_1;
toCentre = (_e270.xyz - _e272);
let _e274 = toCentre;
let _e275 = halfWidth_1;
let _e277 = halfHeight_1;
corners_1[0i] = ((_e274 - _e275) - _e277);
let _e280 = toCentre;
let _e281 = halfWidth_1;
let _e283 = halfHeight_1;
corners_1[1i] = ((_e280 + _e281) - _e283);
let _e286 = toCentre;
let _e287 = halfWidth_1;
let _e289 = halfHeight_1;
corners_1[2i] = ((_e286 + _e287) + _e289);
let _e292 = toCentre;
let _e293 = halfWidth_1;
let _e295 = halfHeight_1;
corners_1[3i] = ((_e292 - _e293) + _e295);
let _e298 = corners_1;
param_58 = _e298;
let _e300 = (*s_3).n;
param_59 = _e300;
let _e301 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_58), (¶m_59));
formFactor = _e301;
let _e302 = halfWidth_1;
let _e303 = halfHeight_1;
area = (length(cross(_e302, _e303)) * 4f);
let _e307 = area;
if (_e307 > 0.000000001f) {
let _e309 = area;
local_8 = (1f / _e309);
} else {
local_8 = 0f;
}
let _e311 = local_8;
radiance = _e311;
let _e312 = toCentre;
distance_2 = length(_e312);
let _e315 = direction[3u];
if (_e315 > 0f) {
let _e317 = distance_2;
let _e319 = direction[3u];
ratio_1 = (_e317 / _e319);
let _e321 = ratio_1;
let _e322 = ratio_1;
let _e324 = ratio_1;
let _e326 = ratio_1;
window_1 = clamp((1f - (((_e321 * _e322) * _e324) * _e326)), 0f, 1f);
let _e330 = window_1;
let _e331 = window_1;
let _e333 = radiance;
radiance = (_e333 * (_e330 * _e331));
}
let _e336 = (*s_3).v;
let _e339 = (*s_3).n;
mirror_1 = reflect(-(_e336), _e339);
let _e341 = position;
param_60 = _e341.xyz;
let _e343 = halfWidth_1;
param_61 = _e343;
let _e344 = halfHeight_1;
param_62 = _e344;
let _e345 = v_world_position_1;
param_63 = _e345;
let _e346 = mirror_1;
param_64 = _e346;
let _e347 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_60), (¶m_61), (¶m_62), (¶m_63), (¶m_64));
representative = _e347;
let _e348 = representative;
let _e349 = v_world_position_1;
toPoint = (_e348 - _e349);
let _e351 = toPoint;
pointDistance = length(_e351);
let _e353 = pointDistance;
if (_e353 > 0.000001f) {
let _e355 = toPoint;
let _e356 = pointDistance;
local_9 = (_e355 / vec3(_e356));
} else {
let _e360 = (*s_3).n;
local_9 = _e360;
}
let _e361 = local_9;
light_3.l = _e361;
let _e364 = light_3.l;
let _e366 = (*s_3).v;
light_3.h = normalize((_e364 + _e366));
let _e370 = formFactor;
light_3.n_dot_l = _e370;
let _e373 = (*s_3).n;
let _e375 = light_3.h;
light_3.n_dot_h = max(dot(_e373, _e375), 0f);
let _e380 = (*s_3).v;
let _e382 = light_3.h;
light_3.v_dot_h = max(dot(_e380, _e382), 0f);
let _e386 = color_1;
let _e389 = color_1[3u];
let _e391 = radiance;
light_3.radiance = ((_e386.xyz * _e389) * _e391);
let _e394 = light_3;
return _e394;
}
let _e395 = direction;
aim = normalize(_e395.xyz);
attenuation_1 = 1f;
let _e398 = type_39;
if (_e398 < 0.5f) {
let _e400 = aim;
light_3.l = -(_e400);
} else {
let _e403 = position;
let _e405 = v_world_position_1;
toLight_1 = (_e403.xyz - _e405);
let _e407 = toLight_1;
distance_3 = length(_e407);
let _e409 = distance_3;
if (_e409 < 0.000001f) {
let _e412 = (*s_3).n;
light_3.l = _e412;
let _e415 = (*s_3).n;
light_3.h = _e415;
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 _e421 = light_3;
return _e421;
}
let _e422 = toLight_1;
let _e423 = distance_3;
light_3.l = (_e422 / vec3(_e423));
let _e427 = distance_3;
param_65 = _e427;
let _e429 = direction[3u];
param_66 = _e429;
let _e430 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_65), (¶m_66));
attenuation_1 = _e430;
let _e431 = type_39;
if (_e431 > 1.5f) {
let _e433 = aim;
let _e435 = light_3.l;
cosAngle = dot(_e433, -(_e435));
let _e438 = cosAngle;
let _e440 = cone[1u];
let _e443 = cone[0u];
let _e445 = cone[1u];
let _e449 = attenuation_1;
attenuation_1 = (_e449 * clamp(((_e438 - _e440) / (_e443 - _e445)), 0f, 1f));
}
}
let _e452 = light_3.l;
let _e454 = (*s_3).v;
light_3.h = normalize((_e452 + _e454));
let _e459 = (*s_3).n;
let _e461 = light_3.l;
light_3.n_dot_l = max(dot(_e459, _e461), 0f);
let _e466 = (*s_3).n;
let _e468 = light_3.h;
light_3.n_dot_h = max(dot(_e466, _e468), 0f);
let _e473 = (*s_3).v;
let _e475 = light_3.h;
light_3.v_dot_h = max(dot(_e473, _e475), 0f);
let _e479 = color_1;
let _e482 = color_1[3u];
let _e484 = attenuation_1;
light_3.radiance = ((_e479.xyz * _e482) * _e484);
let _e487 = light_3;
return _e487;
}
fn LightCount_u0028_() -> i32 {
let _e165 = frag_info.frame_params[1u];
let _e171 = light_list_info.list[0u];
return (clamp(i32((_e165 + 0.5f)), 0i, 8i) + clamp(i32((_e171 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_67: i32;
var param_68: Surface;
var visibility: f32;
var param_69: i32;
var local_10: f32;
var param_70: Surface;
var param_71: LightSample;
var param_72: i32;
var param_73: vec3<f32>;
var param_74: vec3<f32>;
var param_75: i32;
var param_76: Surface;
var param_77: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e181 = LightCount_u0028_();
count_1 = _e181;
i_7 = 0i;
loop {
let _e182 = i_7;
if (_e182 < 32i) {
let _e184 = i_7;
let _e185 = count_1;
if (_e184 >= _e185) {
break;
}
let _e187 = i_7;
param_67 = _e187;
let _e188 = (*s_4);
param_68 = _e188;
let _e189 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_67), (¶m_68));
light_4 = _e189;
let _e191 = light_4.n_dot_l;
if (_e191 <= 0f) {
continue;
}
let _e193 = i_7;
param_69 = _e193;
let _e194 = LightHasShadow_u0028_i1_u003b((¶m_69));
if _e194 {
let _e195 = (*s_4);
param_70 = _e195;
let _e196 = light_4;
param_71 = _e196;
let _e197 = i_7;
param_72 = _e197;
let _e198 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_70), (¶m_71), (¶m_72));
let _e199 = v_world_position_1;
param_73 = _e199;
let _e201 = (*s_4).n;
param_74 = _e201;
let _e202 = i_7;
param_75 = _e202;
let _e203 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_73), (¶m_74), (¶m_75));
local_10 = (_e198 * _e203);
} else {
local_10 = 1f;
}
let _e205 = local_10;
visibility = _e205;
let _e206 = visibility;
if (_e206 <= 0f) {
continue;
}
let _e208 = (*s_4);
param_76 = _e208;
let _e209 = light_4;
param_77 = _e209;
let _e210 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_76), (¶m_77));
let _e212 = light_4.radiance;
let _e215 = light_4.n_dot_l;
let _e217 = visibility;
let _e219 = total_1;
total_1 = (_e219 + (((_e210 * _e212) * _e215) * _e217));
continue;
} else {
break;
}
continuing {
let _e221 = i_7;
i_7 = (_e221 + 1i);
}
}
let _e223 = total_1;
return _e223;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e164 = v_lightmap_uv_1;
let _e165 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e164);
texel_2 = _e165;
let _e166 = texel_2;
let _e169 = texel_2[3u];
return ((_e166.xyz * _e169) * 8f);
}
fn EnvBrdfApprox_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v_1: ptr<function, f32>) -> vec2<f32> {
var r: vec4<f32>;
var a004_: f32;
let _e167 = (*roughness_2);
r = ((vec4<f32>(-1f, -0.0275f, -0.572f, 0.022f) * _e167) + vec4<f32>(1f, 0.0425f, 1.04f, -0.04f));
let _e171 = r[0u];
let _e173 = r[0u];
let _e175 = (*n_dot_v_1);
let _e180 = r[0u];
let _e183 = r[1u];
a004_ = ((min((_e171 * _e173), exp2((-9.28f * _e175))) * _e180) + _e183);
let _e185 = a004_;
let _e187 = r;
return ((vec2<f32>(-1.04f, 1.04f) * _e185) + _e187.zw);
}
fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e165 = v_texcoord_1;
let _e166 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e165);
orm = _e166.xyz;
let _e169 = (*s_5).metallic;
let _e171 = orm[2u];
(*s_5).metallic = clamp((_e169 * _e171), 0f, 1f);
let _e176 = (*s_5).roughness;
let _e178 = orm[1u];
(*s_5).roughness = clamp((_e176 * _e178), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e164 = (*srgb);
let _e167 = (*srgb);
let _e172 = (*srgb);
return mix((_e164 / vec3(12.92f)), pow(((_e167 + 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), _e172));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_78: vec3<f32>;
let _e166 = v_texcoord_1;
let _e167 = textureSample(emissive_texture_tex, emissive_texture_smp, _e166);
param_78 = _e167.xyz;
let _e169 = SrgbToLinear_u0028_vf3_u003b((¶m_78));
emissive = _e169;
let _e170 = emissive;
let _e172 = frag_info.emissive;
let _e177 = frag_info.material2_[3u];
(*s_6).emissive = ((_e170 * _e172.xyz) * _e177);
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 _e165 = v_texcoord_1;
let _e166 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e165);
occlusion = _e166.x;
let _e168 = occlusion;
let _e171 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e168, clamp(_e171, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e168 = v_texcoord_1;
let _e169 = textureSample(normal_texture_tex, normal_texture_smp, _e168);
sampledTexel = _e169;
let _e170 = v_tangent_1;
t_1 = _e170.xyz;
let _e172 = t_1;
let _e174 = (*s_8).n;
let _e176 = (*s_8).n;
let _e177 = t_1;
t_1 = (_e172 - (_e174 * dot(_e176, _e177)));
let _e181 = t_1;
let _e182 = t_1;
if (dot(_e181, _e182) < 0.000000000001f) {
return;
}
let _e185 = t_1;
t_1 = normalize(_e185);
let _e188 = (*s_8).n;
let _e189 = t_1;
let _e192 = v_tangent_1[3u];
b_1 = (cross(_e188, _e189) * _e192);
let _e194 = gl_FrontFacing_1;
if !(_e194) {
let _e196 = t_1;
t_1 = -(_e196);
}
let _e198 = sampledTexel;
sampled = ((_e198.xyz * 2f) - vec3(1f));
let _e205 = frag_info.material2_[1u];
let _e206 = sampled;
let _e208 = (_e206.xy * _e205);
sampled[0u] = _e208.x;
sampled[1u] = _e208.y;
let _e213 = t_1;
let _e215 = sampled[0u];
let _e217 = b_1;
let _e219 = sampled[1u];
let _e223 = (*s_8).n;
let _e225 = sampled[2u];
(*s_8).n = normalize((((_e213 * _e215) + (_e217 * _e219)) + (_e223 * _e225)));
let _e231 = (*s_8).n;
let _e233 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e231, _e233), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
var param_79: Surface;
var param_80: Surface;
var param_81: Surface;
let _e167 = (*s_9);
param_79 = _e167;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_79));
let _e168 = param_79;
(*s_9) = _e168;
let _e169 = (*s_9);
param_80 = _e169;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_80));
let _e170 = param_80;
(*s_9) = _e170;
let _e171 = (*s_9);
param_81 = _e171;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_81));
let _e172 = param_81;
(*s_9) = _e172;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_82: vec3<f32>;
var param_83: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e170 = v_texcoord_1;
let _e171 = textureSample(base_color_texture_tex, base_color_texture_smp, _e170);
texel_3 = _e171;
let _e172 = texel_3;
param_82 = _e172.xyz;
let _e174 = SrgbToLinear_u0028_vf3_u003b((¶m_82));
let _e176 = frag_info.base_color;
param_83 = _e176.xyz;
let _e178 = SrgbToLinear_u0028_vf3_u003b((¶m_83));
let _e180 = v_color_1;
s_10.albedo = ((_e174 * _e178) * _e180.xyz);
let _e185 = texel_3[3u];
let _e188 = frag_info.base_color[3u];
let _e191 = v_color_1[3u];
s_10.alpha = ((_e185 * _e188) * _e191);
let _e196 = frag_info.material2_[0u];
cutoff = _e196;
let _e197 = cutoff;
if (_e197 >= 0f) {
let _e200 = s_10.alpha;
let _e201 = cutoff;
if (_e200 < _e201) {
discard;
}
} else {
let _e203 = cutoff;
if (_e203 < -1.5f) {
let _e205 = v_world_position_1;
anchored = floor((_e205 * 16f));
let _e208 = anchored;
noise_1 = fract((sin(dot(_e208, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e214 = s_10.alpha;
let _e215 = noise_1;
if (_e214 < _e215) {
discard;
}
}
}
let _e217 = v_normal_1;
s_10.n = normalize(_e217);
let _e220 = gl_FrontFacing_1;
if !(_e220) {
let _e223 = s_10.n;
s_10.n = -(_e223);
}
let _e227 = frag_info.camera_position;
let _e229 = v_world_position_1;
s_10.v = normalize((_e227.xyz - _e229));
let _e234 = s_10.n;
let _e236 = s_10.v;
s_10.n_dot_v = max(dot(_e234, _e236), 0.0001f);
let _e242 = frag_info.material[0u];
s_10.metallic = clamp(_e242, 0f, 1f);
let _e247 = frag_info.material[1u];
s_10.roughness = clamp(_e247, 0.02f, 1f);
let _e251 = frag_info.ambient_ground;
let _e254 = frag_info.ambient_sky;
let _e258 = s_10.n[1u];
let _e265 = frag_info.material[2u];
s_10.ambient = (mix(_e251.xyz, _e254.xyz, vec3(((_e258 * 0.5f) + 0.5f))) * _e265);
let _e270 = frag_info.frame_params[0u];
s_10.exposure = max(_e270, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e275 = s_10;
return _e275;
}
fn main_1() {
var s_11: Surface;
var param_84: Surface;
var param_85: Surface;
var metallic: f32;
var diffuseColor_1: vec3<f32>;
var ambient: vec3<f32>;
var levels: f32;
var f0_2: vec3<f32>;
var reflected: vec3<f32>;
var irradiance: vec3<f32>;
var prefiltered: vec3<f32>;
var ab: vec2<f32>;
var param_86: f32;
var param_87: f32;
var param_88: Surface;
var param_89: vec3<f32>;
var param_90: f32;
var param_91: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e181 = ReadSurface_u0028_();
s_11 = _e181;
let _e182 = s_11;
param_84 = _e182;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_84));
let _e183 = param_84;
s_11 = _e183;
let _e184 = s_11;
param_85 = _e184;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_85));
let _e185 = param_85;
s_11 = _e185;
let _e187 = s_11.metallic;
metallic = clamp(_e187, 0f, 1f);
let _e190 = s_11.albedo;
let _e191 = metallic;
diffuseColor_1 = (_e190 * (1f - _e191));
let _e194 = diffuseColor_1;
let _e196 = s_11.ambient;
let _e199 = s_11.occlusion;
ambient = ((_e194 * _e196) * _e199);
let _e203 = frag_info.frame_params[3u];
levels = _e203;
let _e204 = levels;
if (_e204 > 0f) {
let _e207 = s_11.albedo;
let _e208 = metallic;
f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e207, vec3(_e208));
let _e212 = s_11.v;
let _e215 = s_11.n;
reflected = reflect(-(_e212), _e215);
let _e218 = s_11.n;
let _e219 = levels;
let _e220 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e218, _e219);
irradiance = _e220.xyz;
let _e222 = reflected;
let _e224 = s_11.roughness;
let _e225 = levels;
let _e227 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e222, (_e224 * _e225));
prefiltered = _e227.xyz;
let _e230 = s_11.roughness;
param_86 = _e230;
let _e232 = s_11.n_dot_v;
param_87 = _e232;
let _e233 = EnvBrdfApprox_u0028_f1_u003b_f1_u003b((¶m_86), (¶m_87));
ab = _e233;
let _e234 = diffuseColor_1;
let _e235 = irradiance;
let _e237 = prefiltered;
let _e238 = f0_2;
let _e240 = ab[0u];
let _e243 = ab[1u];
let _e250 = frag_info.material[2u];
let _e253 = s_11.occlusion;
ambient = ((((_e234 * _e235) + (_e237 * ((_e238 * _e240) + vec3(_e243)))) * _e250) * _e253);
}
let _e255 = diffuseColor_1;
let _e256 = SampleLightmap_u0028_();
let _e259 = s_11.occlusion;
let _e261 = ambient;
ambient = (_e261 + ((_e255 * _e256) * _e259));
let _e263 = s_11;
param_88 = _e263;
let _e264 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_88));
let _e266 = s_11.occlusion;
let _e268 = ambient;
let _e271 = s_11.emissive;
param_89 = (((_e264 * _e266) + _e268) + _e271);
let _e274 = s_11.alpha;
param_90 = _e274;
let _e276 = s_11.roughness;
param_91 = _e276;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_89), (¶m_90), (¶m_91));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e18 = frag_surface;
let _e19 = frag_color;
return FragmentOutput(_e18, _e19);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'environment_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 24,
samplerBinding: 25,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Toon': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct LightListInfo {
list: vec4<f32>,
indices: array<vec4<f32>, 6>,
scales: array<vec4<f32>, 6>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(8)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var light_list_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(20)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var point_shadow_texture_smp: sampler;
@group(1) @binding(18)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(10)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(12)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(16)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var occlusion_texture_smp: sampler;
@group(1) @binding(6)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var emissive_texture_smp: sampler;
@group(1) @binding(14)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(22)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var shadow_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e153 = (*n)[0u];
let _e156 = (*n)[1u];
let _e160 = (*n)[2u];
let _e163 = (*n);
(*n) = (_e163 / vec3(((abs(_e153) + abs(_e156)) + abs(_e160))));
let _e166 = (*n);
e = _e166.xy;
let _e169 = (*n)[2u];
if (_e169 < 0f) {
let _e171 = (*n);
let _e177 = (*n)[0u];
let _e181 = (*n)[1u];
e = ((vec2(1f) - abs(_e171.yx)) * vec2<f32>(select(-1f, 1f, (_e177 >= 0f)), select(-1f, 1f, (_e181 >= 0f))));
}
let _e186 = e;
return ((_e186 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e150 = v_world_position_1;
let _e152 = fog_info.eye;
let _e156 = fog_info.forward;
return dot((_e150 - _e152.xyz), _e156.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var geometric: vec3<f32>;
var param: vec3<f32>;
let _e153 = g_debug_surface_on;
if _e153 {
let _e154 = g_debug_surface;
let _e155 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e154.x, _e154.y, _e154.z, _e155);
return;
}
let _e160 = v_normal_1;
geometric = normalize(_e160);
let _e162 = gl_FrontFacing_1;
if !(_e162) {
let _e164 = geometric;
geometric = -(_e164);
}
let _e166 = geometric;
param = _e166;
let _e167 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e168 = (*roughness);
let _e170 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e167.x, _e167.y, clamp(_e168, 0f, 1f), _e170);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e150 = v_world_position_1;
let _e152 = fog_info.eye;
return distance(_e150, _e152.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e155 = fog_info.fog[3u];
density = _e155;
let _e156 = density;
if (_e156 <= 0f) {
let _e158 = (*color);
return _e158;
}
let _e159 = EyeDistance_u0028_();
d = _e159;
let _e161 = fog_info.fog;
let _e163 = (*color);
let _e164 = density;
let _e166 = d;
return mix(_e161.xyz, _e163, vec3(clamp(exp((-(_e164) * _e166)), 0f, 1f)));
}
fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>, roughness_1: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e155 = (*linearColor);
param_1 = _e155;
let _e156 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e157 = (*alpha);
frag_color = vec4<f32>(_e156.x, _e156.y, _e156.z, _e157);
let _e162 = (*roughness_1);
param_2 = _e162;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
var bands: f32;
var quantized: f32;
var fraction: f32;
var ramp: f32;
let _e157 = (*s).roughness;
bands = mix(5f, 2f, _e157);
let _e160 = (*light).n_dot_l;
let _e161 = bands;
let _e164 = bands;
quantized = (floor((_e160 * _e161)) / _e164);
let _e167 = (*light).n_dot_l;
let _e168 = bands;
fraction = fract((_e167 * _e168));
let _e171 = fraction;
let _e173 = bands;
let _e175 = quantized;
quantized = (_e175 + (smoothstep(0.85f, 1f, _e171) / _e173));
let _e177 = quantized;
let _e179 = (*light).n_dot_l;
ramp = (_e177 / max(_e179, 0.001f));
let _e183 = (*s).albedo;
let _e184 = ramp;
return (_e183 * _e184);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e151 = (*i);
if (_e151 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e153 = (*i);
if (_e153 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e155 = (*i);
if (_e155 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e157 = (*i);
if (_e157 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e159 = (*i);
if (_e159 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e161 = (*i);
if (_e161 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e163 = (*i);
if (_e163 == 6i) {
return vec2<f32>(-0.38277543f, 0.27676845f);
}
return vec2<f32>(0.974844f, 0.7564838f);
}
fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
var p: vec2<f32>;
var param_3: i32;
let _e156 = (*i_1);
param_3 = _e156;
let _e157 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e157;
let _e159 = p[0u];
let _e160 = (*ca);
let _e163 = p[1u];
let _e164 = (*sa);
let _e168 = p[0u];
let _e169 = (*sa);
let _e172 = p[1u];
let _e173 = (*ca);
let _e177 = (*radius);
return (vec2<f32>(((_e159 * _e160) - (_e163 * _e164)), ((_e168 * _e169) + (_e172 * _e173))) * _e177);
}
fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
var inset: f32;
var local: vec2<f32>;
var atlas: vec2<f32>;
let _e159 = point_shadow.params[0u];
inset = _e159;
let _e160 = (*uv);
let _e161 = (*offset);
let _e163 = inset;
let _e164 = inset;
local = clamp((_e160 + _e161), vec2(_e163), vec2((1f - _e164)));
let _e169 = local;
let _e170 = (*tile);
atlas = ((_e169 + _e170) * vec2<f32>(0.16666667f, 0.16666667f));
let _e175 = point_shadow.params3_[0u];
if (_e175 > 0.5f) {
let _e178 = atlas[1u];
atlas[1u] = (1f - _e178);
}
let _e181 = atlas;
let _e182 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e181, 0f);
let _e184 = atlas;
let _e185 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e184, 0f);
let _e188 = (*range);
return (min(_e182.x, _e185.x) * _e188);
}
fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
var stored: f32;
var param_4: vec2<f32>;
var param_5: vec2<f32>;
var param_6: vec2<f32>;
var param_7: f32;
let _e160 = (*uv_1);
param_4 = _e160;
let _e161 = (*offset_1);
param_5 = _e161;
let _e162 = (*tile_1);
param_6 = _e162;
let _e163 = (*range_1);
param_7 = _e163;
let _e164 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e164;
let _e165 = stored;
let _e166 = (*range_1);
if (_e165 >= (_e166 * 0.999f)) {
return 1f;
}
let _e169 = (*receiver);
let _e170 = stored;
return select(1f, 0f, (_e169 > _e170));
}
fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
var lightRadius: f32;
var minRadius: f32;
var maxRadius: f32;
var param_8: vec2<f32>;
var param_9: vec2<f32>;
var param_10: vec2<f32>;
var param_11: f32;
var sum: f32;
var count: f32;
var i_2: i32;
var stored_1: f32;
var param_12: i32;
var param_13: f32;
var param_14: f32;
var param_15: f32;
var param_16: vec2<f32>;
var param_17: vec2<f32>;
var param_18: vec2<f32>;
var param_19: f32;
var blocker: f32;
var world: f32;
(*blockerOut) = -1f;
let _e181 = point_shadow.params2_[1u];
lightRadius = _e181;
let _e184 = point_shadow.params2_[0u];
minRadius = _e184;
let _e187 = point_shadow.params2_[2u];
maxRadius = _e187;
let _e188 = lightRadius;
if (_e188 <= 0f) {
let _e190 = (*uv_2);
param_8 = _e190;
param_9 = vec2<f32>(0f, 0f);
let _e191 = (*tile_2);
param_10 = _e191;
let _e192 = (*range_2);
param_11 = _e192;
let _e193 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e193;
let _e194 = minRadius;
return _e194;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e195 = i_2;
if (_e195 < 8i) {
let _e197 = i_2;
param_12 = _e197;
let _e198 = (*ca_1);
param_13 = _e198;
let _e199 = (*sa_1);
param_14 = _e199;
let _e200 = maxRadius;
param_15 = _e200;
let _e201 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e202 = (*uv_2);
param_16 = _e202;
param_17 = _e201;
let _e203 = (*tile_2);
param_18 = _e203;
let _e204 = (*range_2);
param_19 = _e204;
let _e205 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e205;
let _e206 = stored_1;
let _e207 = (*range_2);
if (_e206 >= (_e207 * 0.999f)) {
continue;
}
let _e210 = stored_1;
let _e211 = (*receiver_1);
if (_e210 >= _e211) {
continue;
}
let _e213 = stored_1;
let _e214 = sum;
sum = (_e214 + _e213);
let _e216 = count;
count = (_e216 + 1f);
continue;
} else {
break;
}
continuing {
let _e218 = i_2;
i_2 = (_e218 + 1i);
}
}
let _e220 = count;
if (_e220 < 0.5f) {
return -1f;
}
let _e222 = sum;
let _e223 = count;
blocker = max((_e222 / _e223), 0.0001f);
let _e226 = blocker;
(*blockerOut) = _e226;
let _e227 = lightRadius;
let _e228 = (*receiver_1);
let _e229 = blocker;
let _e233 = blocker;
world = ((_e227 * max((_e228 - _e229), 0f)) / _e233);
let _e235 = world;
let _e236 = (*receiver_1);
let _e238 = (*tanHalf);
let _e241 = minRadius;
let _e242 = maxRadius;
return clamp((_e235 / ((2f * _e236) * _e238)), _e241, _e242);
}
fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
var slot: i32;
var strength: f32;
var toLight: vec3<f32>;
var toLightLength: f32;
var nDotL: f32;
var slope: f32;
var texel: f32;
var origin: vec3<f32>;
var toFragment: vec3<f32>;
var distance_: f32;
var range_3: f32;
var face: i32;
var a: vec3<f32>;
var clip: vec4<f32>;
var ndc: vec2<f32>;
var uv_3: vec2<f32>;
var tile_3: vec2<f32>;
var receiver_2: f32;
var noise: f32;
var angle: f32;
var ca_2: f32;
var sa_2: f32;
var tanHalf_1: f32;
var blocker_1: f32;
var radius_1: f32;
var param_20: vec2<f32>;
var param_21: vec2<f32>;
var param_22: f32;
var param_23: f32;
var param_24: f32;
var param_25: f32;
var param_26: f32;
var param_27: f32;
var local_1: vec3<f32>;
var lit: f32;
var param_28: vec2<f32>;
var param_29: vec2<f32>;
var param_30: vec2<f32>;
var param_31: f32;
var param_32: f32;
var i_3: i32;
var param_33: i32;
var param_34: f32;
var param_35: f32;
var param_36: f32;
var param_37: vec2<f32>;
var param_38: vec2<f32>;
var param_39: vec2<f32>;
var param_40: f32;
var param_41: f32;
var phi_1544_: bool;
var phi_1606_: bool;
let _e203 = (*lightIndex);
let _e207 = point_shadow.slots[_e203][0u];
slot = i32((_e207 + 0.5f));
let _e210 = (*lightIndex);
let _e214 = point_shadow.slots[_e210][0u];
if (_e214 < 0f) {
return 1f;
}
let _e218 = point_shadow.params[2u];
strength = _e218;
let _e219 = strength;
if (_e219 <= 0f) {
return 1f;
}
let _e221 = slot;
let _e224 = point_shadow.lights[_e221];
let _e226 = (*world_1);
toLight = (_e224.xyz - _e226);
let _e228 = toLight;
toLightLength = max(length(_e228), 0.000001f);
let _e231 = (*normal);
let _e232 = toLight;
let _e233 = toLightLength;
nDotL = max(dot(_e231, (_e232 / vec3(_e233))), 0.15f);
let _e238 = nDotL;
let _e239 = nDotL;
let _e244 = nDotL;
let _e245 = nDotL;
slope = min((sqrt(max((1f - (_e238 * _e239)), 0f)) / (_e244 * _e245)), 8f);
let _e249 = toLightLength;
let _e251 = (*lightIndex);
let _e255 = point_shadow.slots[_e251][2u];
let _e260 = point_shadow.params3_[1u];
texel = (((2f * _e249) * max(_e255, 0.0001f)) * _e260);
let _e262 = (*world_1);
let _e263 = (*normal);
let _e264 = texel;
let _e268 = point_shadow.params[3u];
let _e270 = slope;
origin = (_e262 + (((_e263 * _e264) * _e268) * (1f + _e270)));
let _e274 = origin;
let _e275 = slot;
let _e278 = point_shadow.lights[_e275];
toFragment = (_e274 - _e278.xyz);
let _e281 = toFragment;
distance_ = length(_e281);
let _e283 = slot;
let _e287 = point_shadow.lights[_e283][3u];
range_3 = max(_e287, 0.0001f);
let _e289 = distance_;
let _e290 = range_3;
if (_e289 >= _e290) {
return 1f;
}
face = 0i;
let _e292 = (*lightIndex);
let _e296 = point_shadow.slots[_e292][1u];
if (_e296 < 0.5f) {
let _e298 = toFragment;
a = abs(_e298);
let _e301 = a[0u];
let _e303 = a[1u];
let _e304 = (_e301 >= _e303);
phi_1544_ = _e304;
if _e304 {
let _e306 = a[0u];
let _e308 = a[2u];
phi_1544_ = (_e306 >= _e308);
}
let _e311 = phi_1544_;
if _e311 {
let _e313 = toFragment[0u];
face = select(1i, 0i, (_e313 > 0f));
} else {
let _e317 = a[1u];
let _e319 = a[2u];
if (_e317 >= _e319) {
let _e322 = toFragment[1u];
face = select(3i, 2i, (_e322 > 0f));
} else {
let _e326 = toFragment[2u];
face = select(5i, 4i, (_e326 > 0f));
}
}
}
let _e329 = slot;
let _e331 = face;
let _e335 = point_shadow.faces[((_e329 * 6i) + _e331)];
let _e336 = origin;
clip = (_e335 * vec4<f32>(_e336.x, _e336.y, _e336.z, 1f));
let _e343 = clip[3u];
if (_e343 <= 0f) {
return 1f;
}
let _e345 = clip;
let _e348 = clip[3u];
ndc = (_e345.xy / vec2(_e348));
let _e352 = ndc[0u];
let _e354 = (abs(_e352) > 1f);
phi_1606_ = _e354;
if !(_e354) {
let _e357 = ndc[1u];
phi_1606_ = (abs(_e357) > 1f);
}
let _e361 = phi_1606_;
if _e361 {
return 1f;
}
let _e363 = ndc[0u];
let _e367 = ndc[1u];
uv_3 = vec2<f32>(((_e363 * 0.5f) + 0.5f), (0.5f - (_e367 * 0.5f)));
let _e371 = face;
let _e373 = slot;
tile_3 = vec2<f32>(f32(_e371), f32(_e373));
let _e376 = distance_;
let _e379 = point_shadow.params[1u];
receiver_2 = (_e376 - _e379);
let _e381 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e381.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e387 = noise;
angle = (_e387 * 6.2831855f);
let _e389 = angle;
ca_2 = cos(_e389);
let _e391 = angle;
sa_2 = sin(_e391);
let _e393 = (*lightIndex);
let _e397 = point_shadow.slots[_e393][2u];
tanHalf_1 = max(_e397, 0.0001f);
blocker_1 = -1f;
let _e399 = uv_3;
param_20 = _e399;
let _e400 = tile_3;
param_21 = _e400;
let _e401 = range_3;
param_22 = _e401;
let _e402 = receiver_2;
param_23 = _e402;
let _e403 = ca_2;
param_24 = _e403;
let _e404 = sa_2;
param_25 = _e404;
let _e405 = tanHalf_1;
param_26 = _e405;
let _e406 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_20), (¶m_21), (¶m_22), (¶m_23), (¶m_24), (¶m_25), (¶m_26), (¶m_27));
let _e407 = param_27;
blocker_1 = _e407;
radius_1 = _e406;
let _e410 = point_shadow.params2_[3u];
if (_e410 > 0.5f) {
g_debug_surface_on = true;
let _e412 = radius_1;
if (_e412 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e414 = radius_1;
let _e417 = point_shadow.params2_[2u];
let _e421 = blocker_1;
let _e422 = range_3;
local_1 = vec3<f32>(clamp((_e414 / max(_e417, 0.000001f)), 0f, 1f), clamp((_e421 / _e422), 0f, 1f), 0f);
}
let _e426 = local_1;
g_debug_surface = _e426;
}
let _e427 = radius_1;
if (_e427 < 0f) {
return 1f;
}
let _e429 = uv_3;
param_28 = _e429;
param_29 = vec2<f32>(0f, 0f);
let _e430 = tile_3;
param_30 = _e430;
let _e431 = range_3;
param_31 = _e431;
let _e432 = receiver_2;
param_32 = _e432;
let _e433 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e433;
let _e434 = radius_1;
if (_e434 > 0f) {
i_3 = 0i;
loop {
let _e436 = i_3;
if (_e436 < 8i) {
let _e438 = i_3;
param_33 = _e438;
let _e439 = ca_2;
param_34 = _e439;
let _e440 = sa_2;
param_35 = _e440;
let _e441 = radius_1;
param_36 = _e441;
let _e442 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e443 = uv_3;
param_37 = _e443;
param_38 = _e442;
let _e444 = tile_3;
param_39 = _e444;
let _e445 = range_3;
param_40 = _e445;
let _e446 = receiver_2;
param_41 = _e446;
let _e447 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e448 = lit;
lit = (_e448 + _e447);
continue;
} else {
break;
}
continuing {
let _e450 = i_3;
i_3 = (_e450 + 1i);
}
}
let _e452 = lit;
lit = (_e452 * 0.11111111f);
}
let _e454 = lit;
let _e455 = strength;
return mix(1f, _e454, clamp(_e455, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var nDotL_1: f32;
var slope_1: f32;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var rowX: f32;
var texelMetres: f32;
var origin_1: vec3<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var softness: f32;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var searchRadius: f32;
var blockerSum: f32;
var blockerCount: f32;
var i_4: i32;
var occluder_1: f32;
var indexable: array<vec2<f32>, 5>;
var gap: f32;
var radius_2: f32;
var i_5: i32;
var occluder_2: f32;
var indexable_1: array<vec2<f32>, 5>;
var phi_2067_: bool;
var phi_2078_: bool;
var phi_2197_: bool;
var phi_2204_: bool;
var phi_2211_: bool;
let _e193 = frag_info.shadow_params[3u];
strength_1 = _e193;
let _e194 = strength_1;
if (_e194 <= 0f) {
return 1f;
}
let _e196 = (*lightIndex_1);
let _e199 = frag_info.frame_params[2u];
if (_e196 != i32((_e199 + 0.5f))) {
return 1f;
}
let _e204 = (*light_1).n_dot_l;
nDotL_1 = max(_e204, 0.15f);
let _e206 = nDotL_1;
let _e207 = nDotL_1;
let _e212 = nDotL_1;
let _e213 = nDotL_1;
slope_1 = min((sqrt(max((1f - (_e206 * _e207)), 0f)) / (_e212 * _e213)), 8f);
let _e219 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e219 + 0.5f));
let _e222 = v_world_position_1;
let _e224 = frag_info.camera_position;
viewDistance = length((_e222 - _e224.xyz));
cascade = 0i;
let _e228 = cascadeCount;
let _e229 = (_e228 > 1i);
phi_2067_ = _e229;
if _e229 {
let _e230 = viewDistance;
let _e233 = frag_info.shadow_cascades[0u];
phi_2067_ = (_e230 > _e233);
}
let _e236 = phi_2067_;
if _e236 {
cascade = 1i;
}
let _e237 = cascadeCount;
let _e238 = (_e237 > 2i);
phi_2078_ = _e238;
if _e238 {
let _e239 = viewDistance;
let _e242 = frag_info.shadow_cascades[1u];
phi_2078_ = (_e239 > _e242);
}
let _e245 = phi_2078_;
if _e245 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e246 = attempt;
if (_e246 < 3i) {
let _e248 = cascade;
let _e249 = attempt;
which = (_e248 + _e249);
let _e251 = which;
let _e252 = cascadeCount;
if (_e251 >= _e252) {
break;
}
let _e254 = which;
if (_e254 == 0i) {
let _e257 = frag_info.shadow_matrix;
local_2 = _e257;
} else {
let _e258 = which;
if (_e258 == 1i) {
let _e261 = frag_info.shadow_matrix_far;
local_3 = _e261;
} else {
let _e263 = frag_info.shadow_matrix_farthest;
local_3 = _e263;
}
let _e264 = local_3;
local_2 = _e264;
}
let _e265 = local_2;
matrix = _e265;
let _e268 = matrix[0][0u];
let _e271 = matrix[1][0u];
let _e274 = matrix[2][0u];
rowX = length(vec3<f32>(_e268, _e271, _e274));
let _e279 = frag_info.shadow_cascades[3u];
let _e281 = rowX;
texelMetres = ((2f * _e279) / max(_e281, 0.000001f));
let _e284 = v_world_position_1;
let _e286 = (*s_1).n;
let _e289 = frag_info.shadow_params[2u];
let _e290 = texelMetres;
let _e291 = slope_1;
origin_1 = (_e284 + (_e286 * (_e289 + (_e290 * (1f + _e291)))));
let _e297 = matrix;
let _e298 = origin_1;
lightSpace = (_e297 * vec4<f32>(_e298.x, _e298.y, _e298.z, 1f));
let _e305 = lightSpace[3u];
if (_e305 <= 0f) {
continue;
}
let _e307 = lightSpace;
let _e310 = lightSpace[3u];
candidate = (_e307.xyz / vec3(_e310));
let _e314 = candidate[0u];
let _e318 = candidate[1u];
inTile = vec2<f32>(((_e314 * 0.5f) + 0.5f), (0.5f - (_e318 * 0.5f)));
let _e323 = inTile[0u];
let _e324 = (_e323 < 0f);
phi_2197_ = _e324;
if !(_e324) {
let _e327 = inTile[0u];
phi_2197_ = (_e327 > 1f);
}
let _e330 = phi_2197_;
phi_2204_ = _e330;
if !(_e330) {
let _e333 = inTile[1u];
phi_2204_ = (_e333 < 0f);
}
let _e336 = phi_2204_;
phi_2211_ = _e336;
if !(_e336) {
let _e339 = inTile[1u];
phi_2211_ = (_e339 > 1f);
}
let _e342 = phi_2211_;
if _e342 {
continue;
}
let _e344 = candidate[2u];
if (_e344 > 1f) {
let _e346 = which;
let _e347 = cascadeCount;
if (_e346 < (_e347 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e352 = inTile[0u];
let _e353 = which;
let _e356 = cascadeCount;
let _e360 = inTile[1u];
uv_4 = vec2<f32>(((_e352 + f32(_e353)) / f32(_e356)), _e360);
let _e362 = candidate;
projected = _e362;
let _e363 = which;
cascade = _e363;
found = true;
break;
} else {
break;
}
continuing {
let _e364 = attempt;
attempt = (_e364 + 1i);
}
}
let _e366 = found;
if !(_e366) {
return 1f;
}
let _e370 = frag_info.shadow_params[1u];
bias = _e370;
let _e373 = frag_info.shadow_params[0u];
let _e376 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e373, _e376);
let _e380 = frag_info.ambient_ground[3u];
softness = _e380;
lit_1 = 0f;
let _e381 = softness;
if (_e381 <= 0f) {
y = -1i;
loop {
let _e383 = y;
if (_e383 <= 1i) {
x = -1i;
loop {
let _e385 = x;
if (_e385 <= 1i) {
let _e387 = uv_4;
let _e388 = x;
let _e390 = y;
let _e393 = texel_1;
let _e396 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e387 + (vec2<f32>(f32(_e388), f32(_e390)) * _e393)), 0f);
occluder = _e396.x;
let _e399 = projected[2u];
let _e400 = bias;
let _e402 = occluder;
let _e405 = lit_1;
lit_1 = (_e405 + select(1f, 0f, ((_e399 - _e400) > _e402)));
continue;
} else {
break;
}
continuing {
let _e407 = x;
x = (_e407 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e409 = y;
y = (_e409 + 1i);
}
}
let _e411 = lit_1;
lit_1 = (_e411 * 0.11111111f);
} else {
let _e413 = softness;
searchRadius = clamp((_e413 * 0.25f), 2f, 16f);
blockerSum = 0f;
blockerCount = 0f;
i_4 = 0i;
loop {
let _e416 = i_4;
if (_e416 < 5i) {
let _e418 = uv_4;
let _e419 = i_4;
indexable = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e421 = indexable[_e419];
let _e422 = texel_1;
let _e424 = searchRadius;
let _e427 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e418 + ((_e421 * _e422) * _e424)), 0f);
occluder_1 = _e427.x;
let _e430 = projected[2u];
let _e431 = bias;
let _e433 = occluder_1;
if ((_e430 - _e431) > _e433) {
let _e435 = occluder_1;
let _e436 = blockerSum;
blockerSum = (_e436 + _e435);
let _e438 = blockerCount;
blockerCount = (_e438 + 1f);
}
continue;
} else {
break;
}
continuing {
let _e440 = i_4;
i_4 = (_e440 + 1i);
}
}
let _e442 = blockerCount;
if (_e442 <= 0f) {
return 1f;
}
let _e445 = projected[2u];
let _e446 = blockerSum;
let _e447 = blockerCount;
gap = max((_e445 - (_e446 / _e447)), 0f);
let _e451 = gap;
let _e452 = softness;
radius_2 = clamp((_e451 * _e452), 1f, 16f);
i_5 = 0i;
loop {
let _e455 = i_5;
if (_e455 < 5i) {
let _e457 = uv_4;
let _e458 = i_5;
indexable_1 = array<vec2<f32>, 5>(vec2<f32>(0f, 0f), vec2<f32>(0.7071f, 0.7071f), vec2<f32>(-0.7071f, 0.7071f), vec2<f32>(0.7071f, -0.7071f), vec2<f32>(-0.7071f, -0.7071f));
let _e460 = indexable_1[_e458];
let _e461 = texel_1;
let _e463 = radius_2;
let _e466 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e457 + ((_e460 * _e461) * _e463)), 0f);
occluder_2 = _e466.x;
let _e469 = projected[2u];
let _e470 = bias;
let _e472 = occluder_2;
let _e475 = lit_1;
lit_1 = (_e475 + select(1f, 0f, ((_e469 - _e470) > _e472)));
continue;
} else {
break;
}
continuing {
let _e477 = i_5;
i_5 = (_e477 + 1i);
}
}
let _e479 = lit_1;
lit_1 = (_e479 * 0.2f);
}
let _e481 = lit_1;
let _e482 = strength_1;
return mix(1f, _e481, clamp(_e482, 0f, 1f));
}
fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
var param_42: Surface;
var param_43: LightSample;
var param_44: i32;
let _e156 = (*s_2);
param_42 = _e156;
let _e157 = (*light_2);
param_43 = _e157;
let _e158 = (*index);
param_44 = _e158;
let _e159 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_42), (¶m_43), (¶m_44));
return _e159;
}
fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
let _e151 = (*index_1);
return (_e151 < 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 _e155 = (*distance_1);
let _e156 = (*distance_1);
attenuation = (1f / max((_e155 * _e156), 0.0001f));
let _e160 = (*range_4);
if (_e160 > 0f) {
let _e162 = (*distance_1);
let _e163 = (*range_4);
ratio = (_e162 / _e163);
let _e165 = ratio;
let _e166 = ratio;
let _e168 = ratio;
let _e170 = ratio;
window = clamp((1f - (((_e165 * _e166) * _e168) * _e170)), 0f, 1f);
let _e174 = window;
let _e175 = window;
let _e177 = attenuation;
attenuation = (_e177 * (_e174 * _e175));
}
let _e179 = attenuation;
return _e179;
}
fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
var n_1: vec3<f32>;
var nLen: f32;
var toPlane: vec3<f32>;
var denom: f32;
var onPlane: vec3<f32>;
var t: f32;
var local_4: vec3<f32>;
var offset_2: vec3<f32>;
var wLen2_: f32;
var hLen2_: f32;
var u: f32;
var v: f32;
let _e167 = (*halfWidth);
let _e168 = (*halfHeight);
n_1 = cross(_e167, _e168);
let _e170 = n_1;
nLen = length(_e170);
let _e172 = nLen;
if (_e172 < 0.000000000001f) {
let _e174 = (*centre);
return _e174;
}
let _e175 = nLen;
let _e176 = n_1;
n_1 = (_e176 / vec3(_e175));
let _e179 = (*centre);
let _e180 = (*world_2);
toPlane = (_e179 - _e180);
let _e182 = (*mirror);
let _e183 = n_1;
denom = dot(_e182, _e183);
let _e185 = denom;
if (abs(_e185) < 0.00001f) {
let _e188 = toPlane;
let _e189 = n_1;
let _e190 = toPlane;
let _e191 = n_1;
onPlane = (_e188 - (_e189 * dot(_e190, _e191)));
} else {
let _e195 = toPlane;
let _e196 = n_1;
let _e198 = denom;
t = (dot(_e195, _e196) / _e198);
let _e200 = t;
if (_e200 > 0f) {
let _e202 = (*mirror);
let _e203 = t;
local_4 = (_e202 * _e203);
} else {
let _e205 = toPlane;
let _e206 = n_1;
let _e207 = toPlane;
let _e208 = n_1;
local_4 = (_e205 - (_e206 * dot(_e207, _e208)));
}
let _e212 = local_4;
onPlane = _e212;
}
let _e213 = onPlane;
let _e214 = toPlane;
offset_2 = (_e213 - _e214);
let _e216 = (*halfWidth);
let _e217 = (*halfWidth);
wLen2_ = max(dot(_e216, _e217), 0.000000000001f);
let _e220 = (*halfHeight);
let _e221 = (*halfHeight);
hLen2_ = max(dot(_e220, _e221), 0.000000000001f);
let _e224 = offset_2;
let _e225 = (*halfWidth);
let _e227 = wLen2_;
u = clamp((dot(_e224, _e225) / _e227), -1f, 1f);
let _e230 = offset_2;
let _e231 = (*halfHeight);
let _e233 = hLen2_;
v = clamp((dot(_e230, _e231) / _e233), -1f, 1f);
let _e236 = (*centre);
let _e237 = (*halfWidth);
let _e238 = u;
let _e241 = (*halfHeight);
let _e242 = v;
return ((_e236 + (_e237 * _e238)) + (_e241 * _e242));
}
fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_2: ptr<function, vec3<f32>>) -> f32 {
var total: f32;
var i_6: i32;
var a_1: vec3<f32>;
var b: vec3<f32>;
var angle_1: f32;
var axis: vec3<f32>;
var len: f32;
total = 0f;
i_6 = 0i;
loop {
let _e159 = i_6;
if (_e159 < 4i) {
let _e161 = i_6;
let _e163 = (*corners)[_e161];
a_1 = normalize(_e163);
let _e165 = i_6;
let _e169 = (*corners)[((_e165 + 1i) & 3i)];
b = normalize(_e169);
let _e171 = a_1;
let _e172 = b;
angle_1 = acos(clamp(dot(_e171, _e172), -1f, 1f));
let _e176 = a_1;
let _e177 = b;
axis = cross(_e176, _e177);
let _e179 = axis;
len = length(_e179);
let _e181 = len;
if (_e181 > 0.000001f) {
let _e183 = angle_1;
let _e184 = axis;
let _e185 = len;
let _e188 = (*n_2);
let _e191 = total;
total = (_e191 + (_e183 * dot((_e184 / vec3(_e185)), _e188)));
}
continue;
} else {
break;
}
continuing {
let _e193 = i_6;
i_6 = (_e193 + 1i);
}
}
let _e195 = total;
return max((-(_e195) * 0.5f), 0f);
}
fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
var lane: i32;
var local_5: f32;
var local_6: f32;
var local_7: f32;
let _e156 = (*slot_1);
let _e157 = (*slot_1);
lane = (_e156 - ((_e157 / 4i) * 4i));
let _e161 = lane;
if (_e161 == 0i) {
let _e164 = (*four)[0u];
local_5 = _e164;
} else {
let _e165 = lane;
if (_e165 == 1i) {
let _e168 = (*four)[1u];
local_6 = _e168;
} else {
let _e169 = lane;
if (_e169 == 2i) {
let _e172 = (*four)[2u];
local_7 = _e172;
} else {
let _e174 = (*four)[3u];
local_7 = _e174;
}
let _e175 = local_7;
local_6 = _e175;
}
let _e176 = local_6;
local_5 = _e176;
}
let _e177 = local_5;
return _e177;
}
fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
var param_45: vec4<f32>;
var param_46: i32;
let _e153 = (*slot_2);
let _e157 = light_list_info.scales[(_e153 / 4i)];
param_45 = _e157;
let _e158 = (*slot_2);
param_46 = _e158;
let _e159 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_45), (¶m_46));
return _e159;
}
fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
var param_47: vec4<f32>;
var param_48: i32;
let _e153 = (*slot_3);
let _e157 = light_list_info.indices[(_e153 / 4i)];
param_47 = _e157;
let _e158 = (*slot_3);
param_48 = _e158;
let _e159 = LightListLane_u0028_vf4_u003b_i1_u003b((¶m_47), (¶m_48));
return _e159;
}
fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
var position: vec4<f32>;
var color_1: vec4<f32>;
var direction: vec4<f32>;
var cone: vec4<f32>;
var slot_4: i32;
var v_1: f32;
var param_49: i32;
var u_1: f32;
var param_50: i32;
var type_38: f32;
var halfWidth_1: vec3<f32>;
var halfHeight_1: vec3<f32>;
var toCentre: vec3<f32>;
var corners_1: array<vec3<f32>, 4>;
var formFactor: f32;
var param_51: array<vec3<f32>, 4>;
var param_52: vec3<f32>;
var area: f32;
var radiance: f32;
var local_8: f32;
var distance_2: f32;
var ratio_1: f32;
var window_1: f32;
var mirror_1: vec3<f32>;
var representative: vec3<f32>;
var param_53: vec3<f32>;
var param_54: vec3<f32>;
var param_55: vec3<f32>;
var param_56: vec3<f32>;
var param_57: vec3<f32>;
var toPoint: vec3<f32>;
var pointDistance: f32;
var light_3: LightSample;
var local_9: vec3<f32>;
var aim: vec3<f32>;
var attenuation_1: f32;
var toLight_1: vec3<f32>;
var distance_3: f32;
var param_58: f32;
var param_59: f32;
var cosAngle: f32;
let _e193 = (*index_2);
if (_e193 < 8i) {
let _e195 = (*index_2);
let _e198 = frag_info.light_position[_e195];
position = _e198;
let _e199 = (*index_2);
let _e202 = frag_info.light_color[_e199];
color_1 = _e202;
let _e203 = (*index_2);
let _e206 = frag_info.light_direction[_e203];
direction = _e206;
let _e207 = (*index_2);
let _e210 = frag_info.light_cone[_e207];
cone = _e210;
} else {
let _e211 = (*index_2);
slot_4 = (_e211 - 8i);
let _e213 = slot_4;
param_49 = _e213;
let _e214 = LightListRow_u0028_i1_u003b((¶m_49));
let _e218 = light_list_info.list[2u];
v_1 = ((_e214 + 0.5f) * _e218);
let _e222 = light_list_info.list[1u];
u_1 = _e222;
let _e223 = u_1;
let _e225 = v_1;
let _e227 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e223), _e225), 0f);
position = _e227;
let _e228 = u_1;
let _e230 = v_1;
let _e232 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e228), _e230), 0f);
color_1 = _e232;
let _e233 = u_1;
let _e235 = v_1;
let _e237 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e233), _e235), 0f);
direction = _e237;
let _e238 = u_1;
let _e240 = v_1;
let _e242 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e238), _e240), 0f);
cone = _e242;
let _e243 = slot_4;
param_50 = _e243;
let _e244 = LightListScale_u0028_i1_u003b((¶m_50));
let _e246 = color_1[3u];
color_1[3u] = (_e246 * _e244);
}
let _e250 = position[3u];
type_38 = _e250;
let _e251 = type_38;
if (_e251 > 2.5f) {
let _e253 = direction;
halfWidth_1 = _e253.xyz;
let _e255 = cone;
halfHeight_1 = _e255.xyz;
let _e257 = position;
let _e259 = v_world_position_1;
toCentre = (_e257.xyz - _e259);
let _e261 = toCentre;
let _e262 = halfWidth_1;
let _e264 = halfHeight_1;
corners_1[0i] = ((_e261 - _e262) - _e264);
let _e267 = toCentre;
let _e268 = halfWidth_1;
let _e270 = halfHeight_1;
corners_1[1i] = ((_e267 + _e268) - _e270);
let _e273 = toCentre;
let _e274 = halfWidth_1;
let _e276 = halfHeight_1;
corners_1[2i] = ((_e273 + _e274) + _e276);
let _e279 = toCentre;
let _e280 = halfWidth_1;
let _e282 = halfHeight_1;
corners_1[3i] = ((_e279 - _e280) + _e282);
let _e285 = corners_1;
param_51 = _e285;
let _e287 = (*s_3).n;
param_52 = _e287;
let _e288 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((¶m_51), (¶m_52));
formFactor = _e288;
let _e289 = halfWidth_1;
let _e290 = halfHeight_1;
area = (length(cross(_e289, _e290)) * 4f);
let _e294 = area;
if (_e294 > 0.000000001f) {
let _e296 = area;
local_8 = (1f / _e296);
} else {
local_8 = 0f;
}
let _e298 = local_8;
radiance = _e298;
let _e299 = toCentre;
distance_2 = length(_e299);
let _e302 = direction[3u];
if (_e302 > 0f) {
let _e304 = distance_2;
let _e306 = direction[3u];
ratio_1 = (_e304 / _e306);
let _e308 = ratio_1;
let _e309 = ratio_1;
let _e311 = ratio_1;
let _e313 = ratio_1;
window_1 = clamp((1f - (((_e308 * _e309) * _e311) * _e313)), 0f, 1f);
let _e317 = window_1;
let _e318 = window_1;
let _e320 = radiance;
radiance = (_e320 * (_e317 * _e318));
}
let _e323 = (*s_3).v;
let _e326 = (*s_3).n;
mirror_1 = reflect(-(_e323), _e326);
let _e328 = position;
param_53 = _e328.xyz;
let _e330 = halfWidth_1;
param_54 = _e330;
let _e331 = halfHeight_1;
param_55 = _e331;
let _e332 = v_world_position_1;
param_56 = _e332;
let _e333 = mirror_1;
param_57 = _e333;
let _e334 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_53), (¶m_54), (¶m_55), (¶m_56), (¶m_57));
representative = _e334;
let _e335 = representative;
let _e336 = v_world_position_1;
toPoint = (_e335 - _e336);
let _e338 = toPoint;
pointDistance = length(_e338);
let _e340 = pointDistance;
if (_e340 > 0.000001f) {
let _e342 = toPoint;
let _e343 = pointDistance;
local_9 = (_e342 / vec3(_e343));
} else {
let _e347 = (*s_3).n;
local_9 = _e347;
}
let _e348 = local_9;
light_3.l = _e348;
let _e351 = light_3.l;
let _e353 = (*s_3).v;
light_3.h = normalize((_e351 + _e353));
let _e357 = formFactor;
light_3.n_dot_l = _e357;
let _e360 = (*s_3).n;
let _e362 = light_3.h;
light_3.n_dot_h = max(dot(_e360, _e362), 0f);
let _e367 = (*s_3).v;
let _e369 = light_3.h;
light_3.v_dot_h = max(dot(_e367, _e369), 0f);
let _e373 = color_1;
let _e376 = color_1[3u];
let _e378 = radiance;
light_3.radiance = ((_e373.xyz * _e376) * _e378);
let _e381 = light_3;
return _e381;
}
let _e382 = direction;
aim = normalize(_e382.xyz);
attenuation_1 = 1f;
let _e385 = type_38;
if (_e385 < 0.5f) {
let _e387 = aim;
light_3.l = -(_e387);
} else {
let _e390 = position;
let _e392 = v_world_position_1;
toLight_1 = (_e390.xyz - _e392);
let _e394 = toLight_1;
distance_3 = length(_e394);
let _e396 = distance_3;
if (_e396 < 0.000001f) {
let _e399 = (*s_3).n;
light_3.l = _e399;
let _e402 = (*s_3).n;
light_3.h = _e402;
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 _e408 = light_3;
return _e408;
}
let _e409 = toLight_1;
let _e410 = distance_3;
light_3.l = (_e409 / vec3(_e410));
let _e414 = distance_3;
param_58 = _e414;
let _e416 = direction[3u];
param_59 = _e416;
let _e417 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_58), (¶m_59));
attenuation_1 = _e417;
let _e418 = type_38;
if (_e418 > 1.5f) {
let _e420 = aim;
let _e422 = light_3.l;
cosAngle = dot(_e420, -(_e422));
let _e425 = cosAngle;
let _e427 = cone[1u];
let _e430 = cone[0u];
let _e432 = cone[1u];
let _e436 = attenuation_1;
attenuation_1 = (_e436 * clamp(((_e425 - _e427) / (_e430 - _e432)), 0f, 1f));
}
}
let _e439 = light_3.l;
let _e441 = (*s_3).v;
light_3.h = normalize((_e439 + _e441));
let _e446 = (*s_3).n;
let _e448 = light_3.l;
light_3.n_dot_l = max(dot(_e446, _e448), 0f);
let _e453 = (*s_3).n;
let _e455 = light_3.h;
light_3.n_dot_h = max(dot(_e453, _e455), 0f);
let _e460 = (*s_3).v;
let _e462 = light_3.h;
light_3.v_dot_h = max(dot(_e460, _e462), 0f);
let _e466 = color_1;
let _e469 = color_1[3u];
let _e471 = attenuation_1;
light_3.radiance = ((_e466.xyz * _e469) * _e471);
let _e474 = light_3;
return _e474;
}
fn LightCount_u0028_() -> i32 {
let _e152 = frag_info.frame_params[1u];
let _e158 = light_list_info.list[0u];
return (clamp(i32((_e152 + 0.5f)), 0i, 8i) + clamp(i32((_e158 + 0.5f)), 0i, 24i));
}
fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
var total_1: vec3<f32>;
var count_1: i32;
var i_7: i32;
var light_4: LightSample;
var param_60: i32;
var param_61: Surface;
var visibility: f32;
var param_62: i32;
var local_10: f32;
var param_63: Surface;
var param_64: LightSample;
var param_65: i32;
var param_66: vec3<f32>;
var param_67: vec3<f32>;
var param_68: i32;
var param_69: Surface;
var param_70: LightSample;
total_1 = vec3<f32>(0f, 0f, 0f);
let _e168 = LightCount_u0028_();
count_1 = _e168;
i_7 = 0i;
loop {
let _e169 = i_7;
if (_e169 < 32i) {
let _e171 = i_7;
let _e172 = count_1;
if (_e171 >= _e172) {
break;
}
let _e174 = i_7;
param_60 = _e174;
let _e175 = (*s_4);
param_61 = _e175;
let _e176 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_60), (¶m_61));
light_4 = _e176;
let _e178 = light_4.n_dot_l;
if (_e178 <= 0f) {
continue;
}
let _e180 = i_7;
param_62 = _e180;
let _e181 = LightHasShadow_u0028_i1_u003b((¶m_62));
if _e181 {
let _e182 = (*s_4);
param_63 = _e182;
let _e183 = light_4;
param_64 = _e183;
let _e184 = i_7;
param_65 = _e184;
let _e185 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b((¶m_63), (¶m_64), (¶m_65));
let _e186 = v_world_position_1;
param_66 = _e186;
let _e188 = (*s_4).n;
param_67 = _e188;
let _e189 = i_7;
param_68 = _e189;
let _e190 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_66), (¶m_67), (¶m_68));
local_10 = (_e185 * _e190);
} else {
local_10 = 1f;
}
let _e192 = local_10;
visibility = _e192;
let _e193 = visibility;
if (_e193 <= 0f) {
continue;
}
let _e195 = (*s_4);
param_69 = _e195;
let _e196 = light_4;
param_70 = _e196;
let _e197 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b((¶m_69), (¶m_70));
let _e199 = light_4.radiance;
let _e202 = light_4.n_dot_l;
let _e204 = visibility;
let _e206 = total_1;
total_1 = (_e206 + (((_e197 * _e199) * _e202) * _e204));
continue;
} else {
break;
}
continuing {
let _e208 = i_7;
i_7 = (_e208 + 1i);
}
}
let _e210 = total_1;
return _e210;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e151 = v_lightmap_uv_1;
let _e152 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e151);
texel_2 = _e152;
let _e153 = texel_2;
let _e156 = texel_2[3u];
return ((_e153.xyz * _e156) * 8f);
}
fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) {
var orm: vec3<f32>;
let _e152 = v_texcoord_1;
let _e153 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e152);
orm = _e153.xyz;
let _e156 = (*s_5).metallic;
let _e158 = orm[2u];
(*s_5).metallic = clamp((_e156 * _e158), 0f, 1f);
let _e163 = (*s_5).roughness;
let _e165 = orm[1u];
(*s_5).roughness = clamp((_e163 * _e165), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e151 = (*srgb);
let _e154 = (*srgb);
let _e159 = (*srgb);
return mix((_e151 / vec3(12.92f)), pow(((_e154 + 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), _e159));
}
fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
var emissive: vec3<f32>;
var param_71: vec3<f32>;
let _e153 = v_texcoord_1;
let _e154 = textureSample(emissive_texture_tex, emissive_texture_smp, _e153);
param_71 = _e154.xyz;
let _e156 = SrgbToLinear_u0028_vf3_u003b((¶m_71));
emissive = _e156;
let _e157 = emissive;
let _e159 = frag_info.emissive;
let _e164 = frag_info.material2_[3u];
(*s_6).emissive = ((_e157 * _e159.xyz) * _e164);
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 _e152 = v_texcoord_1;
let _e153 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e152);
occlusion = _e153.x;
let _e155 = occlusion;
let _e158 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e155, clamp(_e158, 0f, 1f));
return;
}
fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
var sampledTexel: vec4<f32>;
var t_1: vec3<f32>;
var b_1: vec3<f32>;
var sampled: vec3<f32>;
let _e155 = v_texcoord_1;
let _e156 = textureSample(normal_texture_tex, normal_texture_smp, _e155);
sampledTexel = _e156;
let _e157 = v_tangent_1;
t_1 = _e157.xyz;
let _e159 = t_1;
let _e161 = (*s_8).n;
let _e163 = (*s_8).n;
let _e164 = t_1;
t_1 = (_e159 - (_e161 * dot(_e163, _e164)));
let _e168 = t_1;
let _e169 = t_1;
if (dot(_e168, _e169) < 0.000000000001f) {
return;
}
let _e172 = t_1;
t_1 = normalize(_e172);
let _e175 = (*s_8).n;
let _e176 = t_1;
let _e179 = v_tangent_1[3u];
b_1 = (cross(_e175, _e176) * _e179);
let _e181 = gl_FrontFacing_1;
if !(_e181) {
let _e183 = t_1;
t_1 = -(_e183);
}
let _e185 = sampledTexel;
sampled = ((_e185.xyz * 2f) - vec3(1f));
let _e192 = frag_info.material2_[1u];
let _e193 = sampled;
let _e195 = (_e193.xy * _e192);
sampled[0u] = _e195.x;
sampled[1u] = _e195.y;
let _e200 = t_1;
let _e202 = sampled[0u];
let _e204 = b_1;
let _e206 = sampled[1u];
let _e210 = (*s_8).n;
let _e212 = sampled[2u];
(*s_8).n = normalize((((_e200 * _e202) + (_e204 * _e206)) + (_e210 * _e212)));
let _e218 = (*s_8).n;
let _e220 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e218, _e220), 0.0001f);
return;
}
fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
var param_72: Surface;
var param_73: Surface;
var param_74: Surface;
let _e154 = (*s_9);
param_72 = _e154;
ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_72));
let _e155 = param_72;
(*s_9) = _e155;
let _e156 = (*s_9);
param_73 = _e156;
ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_73));
let _e157 = param_73;
(*s_9) = _e157;
let _e158 = (*s_9);
param_74 = _e158;
ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_74));
let _e159 = param_74;
(*s_9) = _e159;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_75: vec3<f32>;
var param_76: vec3<f32>;
var cutoff: f32;
var anchored: vec3<f32>;
var noise_1: f32;
let _e157 = v_texcoord_1;
let _e158 = textureSample(base_color_texture_tex, base_color_texture_smp, _e157);
texel_3 = _e158;
let _e159 = texel_3;
param_75 = _e159.xyz;
let _e161 = SrgbToLinear_u0028_vf3_u003b((¶m_75));
let _e163 = frag_info.base_color;
param_76 = _e163.xyz;
let _e165 = SrgbToLinear_u0028_vf3_u003b((¶m_76));
let _e167 = v_color_1;
s_10.albedo = ((_e161 * _e165) * _e167.xyz);
let _e172 = texel_3[3u];
let _e175 = frag_info.base_color[3u];
let _e178 = v_color_1[3u];
s_10.alpha = ((_e172 * _e175) * _e178);
let _e183 = frag_info.material2_[0u];
cutoff = _e183;
let _e184 = cutoff;
if (_e184 >= 0f) {
let _e187 = s_10.alpha;
let _e188 = cutoff;
if (_e187 < _e188) {
discard;
}
} else {
let _e190 = cutoff;
if (_e190 < -1.5f) {
let _e192 = v_world_position_1;
anchored = floor((_e192 * 16f));
let _e195 = anchored;
noise_1 = fract((sin(dot(_e195, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
let _e201 = s_10.alpha;
let _e202 = noise_1;
if (_e201 < _e202) {
discard;
}
}
}
let _e204 = v_normal_1;
s_10.n = normalize(_e204);
let _e207 = gl_FrontFacing_1;
if !(_e207) {
let _e210 = s_10.n;
s_10.n = -(_e210);
}
let _e214 = frag_info.camera_position;
let _e216 = v_world_position_1;
s_10.v = normalize((_e214.xyz - _e216));
let _e221 = s_10.n;
let _e223 = s_10.v;
s_10.n_dot_v = max(dot(_e221, _e223), 0.0001f);
let _e229 = frag_info.material[0u];
s_10.metallic = clamp(_e229, 0f, 1f);
let _e234 = frag_info.material[1u];
s_10.roughness = clamp(_e234, 0.02f, 1f);
let _e238 = frag_info.ambient_ground;
let _e241 = frag_info.ambient_sky;
let _e245 = s_10.n[1u];
let _e252 = frag_info.material[2u];
s_10.ambient = (mix(_e238.xyz, _e241.xyz, vec3(((_e245 * 0.5f) + 0.5f))) * _e252);
let _e257 = frag_info.frame_params[0u];
s_10.exposure = max(_e257, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e262 = s_10;
return _e262;
}
fn main_1() {
var s_11: Surface;
var param_77: Surface;
var param_78: Surface;
var rim: f32;
var ambient: vec3<f32>;
var param_79: Surface;
var param_80: vec3<f32>;
var param_81: f32;
var param_82: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e159 = ReadSurface_u0028_();
s_11 = _e159;
let _e160 = s_11;
param_77 = _e160;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_77));
let _e161 = param_77;
s_11 = _e161;
let _e162 = s_11;
param_78 = _e162;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_78));
let _e163 = param_78;
s_11 = _e163;
let _e165 = s_11.n_dot_v;
let _e170 = frag_info.material[3u];
rim = (pow((1f - _e165), 3f) * _e170);
let _e173 = s_11.albedo;
let _e175 = s_11.ambient;
let _e176 = SampleLightmap_u0028_();
let _e180 = s_11.occlusion;
ambient = ((_e173 * (_e175 + _e176)) * _e180);
let _e182 = s_11;
param_79 = _e182;
let _e183 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_79));
let _e185 = s_11.occlusion;
let _e187 = ambient;
let _e189 = rim;
let _e194 = s_11.emissive;
param_80 = ((((_e183 * _e185) + _e187) + vec3((_e189 * 0.35f))) + _e194);
let _e197 = s_11.alpha;
param_81 = _e197;
let _e199 = s_11.roughness;
param_82 = _e199;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_80), (¶m_81), (¶m_82));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e18 = frag_surface;
let _e19 = frag_color;
return FragmentOutput(_e18, _e19);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'LightListInfo',
group: 1,
binding: 2,
sizeInBytes: 208,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'indices',
offsetInBytes: 16,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'scales',
offsetInBytes: 112,
sizeInBytes: 96,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 3,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 4,
samplerBinding: 5,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 6,
samplerBinding: 7,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'light_list_texture',
group: 1,
textureBinding: 8,
samplerBinding: 9,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 10,
samplerBinding: 11,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 12,
samplerBinding: 13,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 14,
samplerBinding: 15,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 16,
samplerBinding: 17,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 18,
samplerBinding: 19,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 20,
samplerBinding: 21,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 22,
samplerBinding: 23,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Normals': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> 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 _e36 = (*n)[0u];
let _e39 = (*n)[1u];
let _e43 = (*n)[2u];
let _e46 = (*n);
(*n) = (_e46 / vec3(((abs(_e36) + abs(_e39)) + abs(_e43))));
let _e49 = (*n);
e = _e49.xy;
let _e52 = (*n)[2u];
if (_e52 < 0f) {
let _e54 = (*n);
let _e60 = (*n)[0u];
let _e64 = (*n)[1u];
e = ((vec2(1f) - abs(_e54.yx)) * vec2<f32>(select(-1f, 1f, (_e60 >= 0f)), select(-1f, 1f, (_e64 >= 0f))));
}
let _e69 = e;
return ((_e69 * 0.5f) + vec2(0.5f));
}
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 WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var geometric: vec3<f32>;
var param: vec3<f32>;
let _e36 = g_debug_surface_on;
if _e36 {
let _e37 = g_debug_surface;
let _e38 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e37.x, _e37.y, _e37.z, _e38);
return;
}
let _e43 = v_normal_1;
geometric = normalize(_e43);
let _e45 = gl_FrontFacing_1;
if !(_e45) {
let _e47 = geometric;
geometric = -(_e47);
}
let _e49 = geometric;
param = _e49;
let _e50 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e51 = (*roughness);
let _e53 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e50.x, _e50.y, clamp(_e51, 0f, 1f), _e53);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e34 = (*srgb);
let _e37 = (*srgb);
let _e42 = (*srgb);
return mix((_e34 / vec3(12.92f)), pow(((_e37 + 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), _e42));
}
fn WriteDisplayColor_u0028_vf3_u003b_f1_u003b(displayColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e37 = (*displayColor);
param_1 = _e37;
let _e38 = SrgbToLinear_u0028_vf3_u003b((¶m_1));
let _e39 = (*alpha);
frag_color = vec4<f32>(_e38.x, _e38.y, _e38.z, _e39);
param_2 = 1f;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn main_1() {
var n_1: vec3<f32>;
var param_3: vec3<f32>;
var param_4: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e36 = v_normal_1;
n_1 = normalize(_e36);
let _e38 = n_1;
param_3 = ((_e38 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
param_4 = 1f;
WriteDisplayColor_u0028_vf3_u003b_f1_u003b((¶m_3), (¶m_4));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
gl_FrontFacing_1 = gl_FrontFacing;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'DebugLine': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_line_color_1: vec4<f32>;
fn main_1() {
let _e2 = v_line_color_1;
frag_color = _e2;
return;
}
@fragment
fn main(@location(0) v_line_color: vec4<f32>) -> @location(0) vec4<f32> {
v_line_color_1 = v_line_color;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'BloomThreshold': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Luminance_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e24 = (*color);
return dot(_e24, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var texel: vec2<f32>;
var s0_: vec3<f32>;
var s1_: vec3<f32>;
var s2_: vec3<f32>;
var s3_: vec3<f32>;
var w0_: f32;
var param: vec3<f32>;
var w1_: f32;
var param_1: vec3<f32>;
var w2_: f32;
var param_2: vec3<f32>;
var w3_: f32;
var param_3: vec3<f32>;
var color_1: vec3<f32>;
var threshold: f32;
var knee: f32;
var brightness: f32;
var param_4: vec3<f32>;
var soft: f32;
var contribution: f32;
let _e44 = bloom_info.params;
texel = _e44.xy;
let _e46 = v_uv_1;
let _e47 = texel;
let _e50 = textureSample(source_texture_tex, source_texture_smp, (_e46 + (_e47 * vec2<f32>(-0.5f, -0.5f))));
s0_ = _e50.xyz;
let _e52 = v_uv_1;
let _e53 = texel;
let _e56 = textureSample(source_texture_tex, source_texture_smp, (_e52 + (_e53 * vec2<f32>(0.5f, -0.5f))));
s1_ = _e56.xyz;
let _e58 = v_uv_1;
let _e59 = texel;
let _e62 = textureSample(source_texture_tex, source_texture_smp, (_e58 + (_e59 * vec2<f32>(-0.5f, 0.5f))));
s2_ = _e62.xyz;
let _e64 = v_uv_1;
let _e65 = texel;
let _e68 = textureSample(source_texture_tex, source_texture_smp, (_e64 + (_e65 * vec2<f32>(0.5f, 0.5f))));
s3_ = _e68.xyz;
let _e70 = s0_;
param = _e70;
let _e71 = Luminance_u0028_vf3_u003b((¶m));
w0_ = (1f / (1f + _e71));
let _e74 = s1_;
param_1 = _e74;
let _e75 = Luminance_u0028_vf3_u003b((¶m_1));
w1_ = (1f / (1f + _e75));
let _e78 = s2_;
param_2 = _e78;
let _e79 = Luminance_u0028_vf3_u003b((¶m_2));
w2_ = (1f / (1f + _e79));
let _e82 = s3_;
param_3 = _e82;
let _e83 = Luminance_u0028_vf3_u003b((¶m_3));
w3_ = (1f / (1f + _e83));
let _e86 = s0_;
let _e87 = w0_;
let _e89 = s1_;
let _e90 = w1_;
let _e93 = s2_;
let _e94 = w2_;
let _e97 = s3_;
let _e98 = w3_;
let _e101 = w0_;
let _e102 = w1_;
let _e104 = w2_;
let _e106 = w3_;
color_1 = (((((_e86 * _e87) + (_e89 * _e90)) + (_e93 * _e94)) + (_e97 * _e98)) / vec3((((_e101 + _e102) + _e104) + _e106)));
let _e112 = bloom_info.params[2u];
threshold = _e112;
let _e115 = bloom_info.params[3u];
knee = max(_e115, 0.0001f);
let _e117 = color_1;
param_4 = _e117;
let _e118 = Luminance_u0028_vf3_u003b((¶m_4));
brightness = _e118;
let _e119 = brightness;
let _e120 = threshold;
let _e122 = knee;
let _e124 = knee;
soft = clamp(((_e119 - _e120) + _e122), 0f, (2f * _e124));
let _e127 = soft;
let _e128 = soft;
let _e130 = knee;
soft = ((_e127 * _e128) / (4f * _e130));
let _e133 = soft;
let _e134 = brightness;
let _e135 = threshold;
let _e138 = brightness;
contribution = (max(_e133, (_e134 - _e135)) / max(_e138, 0.0001f));
let _e141 = color_1;
let _e142 = contribution;
let _e143 = (_e141 * _e142);
frag_color = vec4<f32>(_e143.x, _e143.y, _e143.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BloomDownsample': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var t: vec2<f32>;
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var d: vec3<f32>;
var e: vec3<f32>;
var f: vec3<f32>;
var g: vec3<f32>;
var h: vec3<f32>;
var i: vec3<f32>;
var j: vec3<f32>;
var k: vec3<f32>;
var l: vec3<f32>;
var m: vec3<f32>;
var result: vec3<f32>;
let _e42 = bloom_info.params;
t = _e42.xy;
let _e44 = v_uv_1;
let _e45 = t;
let _e48 = textureSample(source_texture_tex, source_texture_smp, (_e44 + (vec2<f32>(-2f, 2f) * _e45)));
a = _e48.xyz;
let _e50 = v_uv_1;
let _e51 = t;
let _e54 = textureSample(source_texture_tex, source_texture_smp, (_e50 + (vec2<f32>(0f, 2f) * _e51)));
b = _e54.xyz;
let _e56 = v_uv_1;
let _e57 = t;
let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (vec2<f32>(2f, 2f) * _e57)));
c = _e60.xyz;
let _e62 = v_uv_1;
let _e63 = t;
let _e66 = textureSample(source_texture_tex, source_texture_smp, (_e62 + (vec2<f32>(-2f, 0f) * _e63)));
d = _e66.xyz;
let _e68 = v_uv_1;
let _e69 = textureSample(source_texture_tex, source_texture_smp, _e68);
e = _e69.xyz;
let _e71 = v_uv_1;
let _e72 = t;
let _e75 = textureSample(source_texture_tex, source_texture_smp, (_e71 + (vec2<f32>(2f, 0f) * _e72)));
f = _e75.xyz;
let _e77 = v_uv_1;
let _e78 = t;
let _e81 = textureSample(source_texture_tex, source_texture_smp, (_e77 + (vec2<f32>(-2f, -2f) * _e78)));
g = _e81.xyz;
let _e83 = v_uv_1;
let _e84 = t;
let _e87 = textureSample(source_texture_tex, source_texture_smp, (_e83 + (vec2<f32>(0f, -2f) * _e84)));
h = _e87.xyz;
let _e89 = v_uv_1;
let _e90 = t;
let _e93 = textureSample(source_texture_tex, source_texture_smp, (_e89 + (vec2<f32>(2f, -2f) * _e90)));
i = _e93.xyz;
let _e95 = v_uv_1;
let _e96 = t;
let _e99 = textureSample(source_texture_tex, source_texture_smp, (_e95 + (vec2<f32>(-1f, 1f) * _e96)));
j = _e99.xyz;
let _e101 = v_uv_1;
let _e102 = t;
let _e105 = textureSample(source_texture_tex, source_texture_smp, (_e101 + (vec2<f32>(1f, 1f) * _e102)));
k = _e105.xyz;
let _e107 = v_uv_1;
let _e108 = t;
let _e111 = textureSample(source_texture_tex, source_texture_smp, (_e107 + (vec2<f32>(-1f, -1f) * _e108)));
l = _e111.xyz;
let _e113 = v_uv_1;
let _e114 = t;
let _e117 = textureSample(source_texture_tex, source_texture_smp, (_e113 + (vec2<f32>(1f, -1f) * _e114)));
m = _e117.xyz;
let _e119 = j;
let _e120 = k;
let _e122 = l;
let _e124 = m;
result = (((((_e119 + _e120) + _e122) + _e124) * 0.5f) * 0.25f);
let _e128 = a;
let _e129 = b;
let _e131 = d;
let _e133 = e;
let _e137 = result;
result = (_e137 + (((((_e128 + _e129) + _e131) + _e133) * 0.125f) * 0.25f));
let _e139 = b;
let _e140 = c;
let _e142 = e;
let _e144 = f;
let _e148 = result;
result = (_e148 + (((((_e139 + _e140) + _e142) + _e144) * 0.125f) * 0.25f));
let _e150 = d;
let _e151 = e;
let _e153 = g;
let _e155 = h;
let _e159 = result;
result = (_e159 + (((((_e150 + _e151) + _e153) + _e155) * 0.125f) * 0.25f));
let _e161 = e;
let _e162 = f;
let _e164 = h;
let _e166 = i;
let _e170 = result;
result = (_e170 + (((((_e161 + _e162) + _e164) + _e166) * 0.125f) * 0.25f));
let _e172 = result;
frag_color = vec4<f32>(_e172.x, _e172.y, _e172.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BloomUpsample': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
tint: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var t: vec2<f32>;
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var d: vec3<f32>;
var e: vec3<f32>;
var f: vec3<f32>;
var g: vec3<f32>;
var h: vec3<f32>;
var i: vec3<f32>;
var result: vec3<f32>;
let _e34 = bloom_info.params;
let _e38 = bloom_info.params[2u];
t = (_e34.xy * max(_e38, 0f));
let _e41 = v_uv_1;
let _e42 = t;
let _e45 = textureSample(source_texture_tex, source_texture_smp, (_e41 + (vec2<f32>(-1f, 1f) * _e42)));
a = _e45.xyz;
let _e47 = v_uv_1;
let _e48 = t;
let _e51 = textureSample(source_texture_tex, source_texture_smp, (_e47 + (vec2<f32>(0f, 1f) * _e48)));
b = _e51.xyz;
let _e53 = v_uv_1;
let _e54 = t;
let _e57 = textureSample(source_texture_tex, source_texture_smp, (_e53 + (vec2<f32>(1f, 1f) * _e54)));
c = _e57.xyz;
let _e59 = v_uv_1;
let _e60 = t;
let _e63 = textureSample(source_texture_tex, source_texture_smp, (_e59 + (vec2<f32>(-1f, 0f) * _e60)));
d = _e63.xyz;
let _e65 = v_uv_1;
let _e66 = textureSample(source_texture_tex, source_texture_smp, _e65);
e = _e66.xyz;
let _e68 = v_uv_1;
let _e69 = t;
let _e72 = textureSample(source_texture_tex, source_texture_smp, (_e68 + (vec2<f32>(1f, 0f) * _e69)));
f = _e72.xyz;
let _e74 = v_uv_1;
let _e75 = t;
let _e78 = textureSample(source_texture_tex, source_texture_smp, (_e74 + (vec2<f32>(-1f, -1f) * _e75)));
g = _e78.xyz;
let _e80 = v_uv_1;
let _e81 = t;
let _e84 = textureSample(source_texture_tex, source_texture_smp, (_e80 + (vec2<f32>(0f, -1f) * _e81)));
h = _e84.xyz;
let _e86 = v_uv_1;
let _e87 = t;
let _e90 = textureSample(source_texture_tex, source_texture_smp, (_e86 + (vec2<f32>(1f, -1f) * _e87)));
i = _e90.xyz;
let _e92 = e;
let _e94 = b;
let _e95 = d;
let _e97 = f;
let _e99 = h;
let _e103 = a;
let _e104 = c;
let _e106 = g;
let _e108 = i;
result = (((_e92 * 4f) + ((((_e94 + _e95) + _e97) + _e99) * 2f)) + (((_e103 + _e104) + _e106) + _e108));
let _e111 = result;
result = (_e111 * 0.0625f);
let _e114 = bloom_info.tint;
let _e116 = result;
result = (_e116 * _e114.xyz);
let _e118 = result;
frag_color = vec4<f32>(_e118.x, _e118.y, _e118.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'tint', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Composite': WebGpuStage(
wgsl: r'''
struct CompositeInfo {
params: vec4<f32>,
ao_texel: vec4<f32>,
look: vec4<f32>,
look_more: vec4<f32>,
output_encode: vec4<f32>,
lift: vec4<f32>,
gamma: vec4<f32>,
gain: vec4<f32>,
contact: vec4<f32>,
}
@group(1) @binding(7)
var lut_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var lut_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> composite_info: CompositeInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(9)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var scene_texture_smp: sampler;
@group(1) @binding(3)
var bloom_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var bloom_texture_smp: sampler;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
@group(1) @binding(5)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var contact_shadow_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
var x: i32;
var y: i32;
var index: i32;
var value: f32;
let _e143 = (*at)[0u];
x = i32((_e143 - (floor((_e143 / 4f)) * 4f)));
let _e150 = (*at)[1u];
y = i32((_e150 - (floor((_e150 / 4f)) * 4f)));
let _e156 = y;
let _e158 = x;
index = ((_e156 * 4i) + _e158);
value = 0f;
let _e160 = index;
if (_e160 == 0i) {
value = 0f;
} else {
let _e162 = index;
if (_e162 == 1i) {
value = 8f;
} else {
let _e164 = index;
if (_e164 == 2i) {
value = 2f;
} else {
let _e166 = index;
if (_e166 == 3i) {
value = 10f;
} else {
let _e168 = index;
if (_e168 == 4i) {
value = 12f;
} else {
let _e170 = index;
if (_e170 == 5i) {
value = 4f;
} else {
let _e172 = index;
if (_e172 == 6i) {
value = 14f;
} else {
let _e174 = index;
if (_e174 == 7i) {
value = 6f;
} else {
let _e176 = index;
if (_e176 == 8i) {
value = 3f;
} else {
let _e178 = index;
if (_e178 == 9i) {
value = 11f;
} else {
let _e180 = index;
if (_e180 == 10i) {
value = 1f;
} else {
let _e182 = index;
if (_e182 == 11i) {
value = 9f;
} else {
let _e184 = index;
if (_e184 == 12i) {
value = 15f;
} else {
let _e186 = index;
if (_e186 == 13i) {
value = 7f;
} else {
let _e188 = index;
if (_e188 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e190 = value;
return ((_e190 / 16f) - 0.5f);
}
fn Hash_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
let _e138 = (*at_1);
return fract((sin(dot(_e138, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}
fn SrgbToLinear_u0028_vf3_u003b(encoded: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e138 = (*encoded);
let _e141 = (*encoded);
let _e147 = (*encoded);
return mix((_e138 / vec3(12.92f)), pow(((max(_e141, 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), _e147));
}
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 _e150 = (*color);
c = clamp(_e150, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e152 = (*size);
sliceWidth = (1f / _e152);
let _e154 = (*size);
let _e155 = (*size);
texel = (1f / (_e154 * _e155));
let _e158 = texel;
let _e159 = (*size);
innerWidth = (_e158 * (_e159 - 1f));
let _e162 = texel;
let _e165 = c[0u];
let _e166 = innerWidth;
u = ((_e162 * 0.5f) + (_e165 * _e166));
let _e169 = (*size);
let _e172 = c[1u];
let _e173 = (*size);
let _e175 = (*size);
v = ((0.5f / _e169) + (_e172 * ((_e173 - 1f) / _e175)));
let _e180 = c[2u];
let _e181 = (*size);
slice = (_e180 * (_e181 - 1f));
let _e184 = slice;
lower = floor(_e184);
let _e186 = lower;
let _e188 = (*size);
upper = min((_e186 + 1f), (_e188 - 1f));
let _e191 = lower;
let _e192 = sliceWidth;
let _e194 = u;
let _e196 = v;
let _e198 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e191 * _e192) + _e194), _e196));
a = _e198.xyz;
let _e200 = upper;
let _e201 = sliceWidth;
let _e203 = u;
let _e205 = v;
let _e207 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e200 * _e201) + _e203), _e205));
b = _e207.xyz;
let _e209 = a;
let _e210 = b;
let _e211 = slice;
let _e212 = lower;
return mix(_e209, _e210, vec3((_e211 - _e212)));
}
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e138 = (*linear);
let _e140 = (*linear);
let _e145 = (*linear);
return mix((_e138 * 12.92f), ((pow(max(_e140, 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), _e145));
}
fn Luma_u0028_vf3_u003b(color_1: ptr<function, vec3<f32>>) -> f32 {
let _e138 = (*color_1);
return dot(_e138, 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 _e141 = (*color_2);
v_1 = clamp(log2(max(_e141, 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 _e145 = v_1;
v_1 = ((_e145 - vec3<f32>(-12.47393f, -12.47393f, -12.47393f)) / vec3(16.499998f));
let _e149 = v_1;
let _e150 = v_1;
v2_ = (_e149 * _e150);
let _e152 = v2_;
let _e153 = v2_;
v4_ = (_e152 * _e153);
let _e155 = v4_;
let _e157 = v2_;
let _e159 = v4_;
let _e161 = v_1;
let _e164 = v4_;
let _e167 = v2_;
let _e169 = v_1;
let _e172 = v2_;
let _e175 = v_1;
v_1 = ((((((((_e155 * 15.5f) * _e157) - ((_e159 * 40.14f) * _e161)) + (_e164 * 31.96f)) - ((_e167 * 6.868f) * _e169)) + (_e172 * 0.4298f)) + (_e175 * 0.1191f)) - vec3(0.00232f));
let _e180 = v_1;
return clamp(_e180, 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: vec3<f32>;
let _e140 = (*color_3);
param = (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(_e140, vec3<f32>(0f, 0f, 0f)));
let _e143 = AgxSigmoid_u0028_vf3_u003b((¶m));
v_2 = _e143;
let _e144 = 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)) * _e144);
let _e146 = v_2;
return clamp(pow(max(_e146, 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_1: vec3<f32>;
let _e139 = (*color_4);
param_1 = _e139;
let _e140 = TonemapAgx_u0028_vf3_u003b((¶m_1));
return _e140;
}
fn TonemapReinhard_u0028_vf3_u003b(color_5: ptr<function, vec3<f32>>) -> vec3<f32> {
var numerator: vec3<f32>;
let _e139 = (*color_5);
let _e140 = (*color_5);
numerator = (_e139 * (vec3<f32>(1f, 1f, 1f) + (_e140 / vec3<f32>(16f, 16f, 16f))));
let _e144 = numerator;
let _e145 = (*color_5);
return clamp((_e144 / (vec3<f32>(1f, 1f, 1f) + _e145)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}
fn TonemapAces_u0028_vf3_u003b(color_6: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e138 = (*color_6);
let _e139 = (*color_6);
let _e144 = (*color_6);
let _e145 = (*color_6);
return clamp(((_e138 * ((_e139 * 2.51f) + vec3(0.03f))) / ((_e144 * ((_e145 * 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: f32;
var peak: f32;
var newPeak: f32;
var desaturate: f32;
let _e145 = (*color_7)[0u];
let _e147 = (*color_7)[1u];
let _e149 = (*color_7)[2u];
minChannel = min(_e145, min(_e147, _e149));
let _e152 = minChannel;
if (_e152 < 0.08f) {
let _e154 = minChannel;
let _e155 = minChannel;
let _e157 = minChannel;
local = (_e154 - ((6.25f * _e155) * _e157));
} else {
local = 0.04f;
}
let _e160 = local;
offset = _e160;
let _e161 = offset;
let _e162 = (*color_7);
(*color_7) = (_e162 - vec3(_e161));
let _e166 = (*color_7)[0u];
let _e168 = (*color_7)[1u];
let _e170 = (*color_7)[2u];
peak = max(_e166, max(_e168, _e170));
let _e173 = peak;
if (_e173 < 0.76f) {
let _e175 = (*color_7);
return _e175;
}
let _e176 = peak;
newPeak = (1f - (0.0576f / ((_e176 + 0.24f) - 0.76f)));
let _e181 = newPeak;
let _e182 = peak;
let _e184 = (*color_7);
(*color_7) = (_e184 * (_e181 / _e182));
let _e186 = peak;
let _e187 = newPeak;
desaturate = (1f - (1f / ((0.15f * (_e186 - _e187)) + 1f)));
let _e193 = (*color_7);
let _e194 = newPeak;
let _e196 = desaturate;
return mix(_e193, vec3(_e194), vec3(_e196));
}
fn TonemapBy_u0028_vf3_u003b_i1_u003b(color_8: ptr<function, vec3<f32>>, curve: ptr<function, i32>) -> vec3<f32> {
var param_2: vec3<f32>;
var param_3: vec3<f32>;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var param_6: vec3<f32>;
let _e144 = (*curve);
if (_e144 == 1i) {
let _e146 = (*color_8);
param_2 = _e146;
let _e147 = TonemapNeutral_u0028_vf3_u003b((¶m_2));
return _e147;
}
let _e148 = (*curve);
if (_e148 == 2i) {
let _e150 = (*color_8);
param_3 = _e150;
let _e151 = TonemapAces_u0028_vf3_u003b((¶m_3));
return _e151;
}
let _e152 = (*curve);
if (_e152 == 3i) {
let _e154 = (*color_8);
param_4 = _e154;
let _e155 = TonemapAgx_u0028_vf3_u003b((¶m_4));
return _e155;
}
let _e156 = (*curve);
if (_e156 == 4i) {
let _e158 = (*color_8);
param_5 = _e158;
let _e159 = TonemapReinhard_u0028_vf3_u003b((¶m_5));
return _e159;
}
let _e160 = (*curve);
if (_e160 == 5i) {
let _e162 = (*color_8);
param_6 = _e162;
let _e163 = TonemapAgxFull_u0028_vf3_u003b((¶m_6));
return _e163;
}
let _e164 = (*color_8);
return _e164;
}
fn main_1() {
var dispersion: f32;
var fromCentre: vec2<f32>;
var step_uv: vec2<f32>;
var scene: vec4<f32>;
var bloom: vec3<f32>;
var half_texel: vec2<f32>;
var ao: f32;
var contact: f32;
var color_9: vec3<f32>;
var param_7: vec3<f32>;
var param_8: i32;
var contrast: f32;
var saturation: f32;
var temperature: f32;
var param_9: vec3<f32>;
var lift: vec3<f32>;
var gammaCurve: vec3<f32>;
var gain: vec3<f32>;
var balance: f32;
var tint: f32;
var lutStrength: f32;
var encodedIn: vec3<f32>;
var param_10: vec3<f32>;
var graded: vec3<f32>;
var param_11: vec3<f32>;
var param_12: f32;
var param_13: vec3<f32>;
var vignette: f32;
var fromCentre_1: vec2<f32>;
var aspect: f32;
var radius: f32;
var encoded_1: vec3<f32>;
var param_14: vec3<f32>;
var grain: f32;
var param_15: vec2<f32>;
var dither: f32;
var param_16: vec2<f32>;
let _e176 = composite_info.look[3u];
dispersion = _e176;
let _e177 = dispersion;
if (_e177 > 0f) {
let _e179 = v_uv_1;
fromCentre = (_e179 - vec2<f32>(0.5f, 0.5f));
let _e181 = fromCentre;
let _e182 = dispersion;
step_uv = (_e181 * _e182);
let _e184 = v_uv_1;
let _e185 = textureSample(scene_texture_tex, scene_texture_smp, _e184);
scene = _e185;
let _e186 = v_uv_1;
let _e187 = step_uv;
let _e189 = textureSample(scene_texture_tex, scene_texture_smp, (_e186 + _e187));
scene[0u] = _e189.x;
let _e192 = v_uv_1;
let _e193 = step_uv;
let _e195 = textureSample(scene_texture_tex, scene_texture_smp, (_e192 - _e193));
scene[2u] = _e195.z;
} else {
let _e198 = v_uv_1;
let _e199 = textureSample(scene_texture_tex, scene_texture_smp, _e198);
scene = _e199;
}
let _e200 = v_uv_1;
let _e201 = textureSample(bloom_texture_tex, bloom_texture_smp, _e200);
bloom = _e201.xyz;
let _e204 = composite_info.ao_texel;
half_texel = (_e204.xy * 0.5f);
let _e207 = v_uv_1;
let _e209 = half_texel[0u];
let _e211 = half_texel[1u];
let _e214 = textureSample(ao_texture_tex, ao_texture_smp, (_e207 + vec2<f32>(_e209, _e211)));
let _e216 = v_uv_1;
let _e218 = half_texel[0u];
let _e221 = half_texel[1u];
let _e224 = textureSample(ao_texture_tex, ao_texture_smp, (_e216 + vec2<f32>(-(_e218), _e221)));
let _e227 = v_uv_1;
let _e229 = half_texel[0u];
let _e231 = half_texel[1u];
let _e235 = textureSample(ao_texture_tex, ao_texture_smp, (_e227 + vec2<f32>(_e229, -(_e231))));
let _e238 = v_uv_1;
let _e240 = half_texel[0u];
let _e243 = half_texel[1u];
let _e247 = textureSample(ao_texture_tex, ao_texture_smp, (_e238 + vec2<f32>(-(_e240), -(_e243))));
ao = (0.25f * (((_e214.x + _e224.x) + _e235.x) + _e247.x));
let _e251 = ao;
let _e254 = composite_info.params[3u];
ao = mix(1f, _e251, clamp(_e254, 0f, 1f));
let _e257 = v_uv_1;
let _e258 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e257);
contact = _e258.x;
let _e260 = contact;
let _e263 = composite_info.contact[0u];
let _e266 = ao;
ao = (_e266 * mix(1f, _e260, clamp(_e263, 0f, 1f)));
let _e268 = scene;
let _e270 = ao;
let _e272 = bloom;
let _e275 = composite_info.params[1u];
color_9 = ((_e268.xyz * _e270) + (_e272 * _e275));
let _e280 = composite_info.params[0u];
let _e282 = color_9;
color_9 = (_e282 * max(_e280, 0f));
let _e286 = composite_info.params[2u];
let _e289 = color_9;
param_7 = _e289;
param_8 = i32((_e286 + 0.5f));
let _e290 = TonemapBy_u0028_vf3_u003b_i1_u003b((¶m_7), (¶m_8));
color_9 = _e290;
let _e293 = composite_info.look[0u];
contrast = _e293;
let _e296 = composite_info.look[1u];
saturation = _e296;
let _e299 = composite_info.look[2u];
temperature = _e299;
let _e300 = contrast;
if (_e300 != 1f) {
let _e302 = color_9;
let _e306 = contrast;
color_9 = (vec3<f32>(0.18f, 0.18f, 0.18f) * pow((max(_e302, vec3<f32>(0f, 0f, 0f)) / vec3(0.18f)), vec3(_e306)));
}
let _e310 = color_9;
param_9 = _e310;
let _e311 = Luma_u0028_vf3_u003b((¶m_9));
let _e313 = color_9;
let _e314 = saturation;
color_9 = mix(vec3(_e311), _e313, vec3(_e314));
let _e317 = temperature;
let _e320 = temperature;
let _e324 = color_9;
color_9 = (_e324 * vec3<f32>((1f + (_e317 * 0.1f)), 1f, (1f - (_e320 * 0.1f))));
let _e327 = composite_info.lift;
lift = _e327.xyz;
let _e330 = composite_info.gamma;
gammaCurve = _e330.xyz;
let _e333 = composite_info.gain;
gain = _e333.xyz;
let _e335 = color_9;
let _e336 = lift;
let _e339 = lift;
color_9 = ((_e335 * (vec3<f32>(1f, 1f, 1f) - _e336)) + _e339);
let _e341 = color_9;
color_9 = max(_e341, vec3<f32>(0f, 0f, 0f));
let _e343 = gammaCurve;
if any((_e343 != vec3<f32>(1f, 1f, 1f))) {
let _e346 = color_9;
let _e347 = gammaCurve;
color_9 = pow(_e346, (vec3<f32>(1f, 1f, 1f) / _e347));
}
let _e350 = gain;
let _e351 = color_9;
color_9 = (_e351 * _e350);
let _e355 = composite_info.output_encode[1u];
balance = _e355;
let _e358 = composite_info.output_encode[2u];
tint = _e358;
let _e359 = balance;
let _e361 = tint;
if ((_e359 != 0f) || (_e361 != 0f)) {
let _e364 = balance;
let _e367 = tint;
let _e370 = balance;
let _e374 = color_9;
color_9 = (_e374 * vec3<f32>((1f + (_e364 * 0.2f)), (1f + (_e367 * 0.15f)), (1f - (_e370 * 0.2f))));
let _e376 = tint;
let _e379 = color_9[0u];
color_9[0u] = (_e379 - (_e376 * 0.075f));
let _e382 = tint;
let _e385 = color_9[2u];
color_9[2u] = (_e385 - (_e382 * 0.075f));
}
let _e390 = composite_info.ao_texel[2u];
lutStrength = _e390;
let _e391 = lutStrength;
if (_e391 > 0f) {
let _e393 = color_9;
param_10 = clamp(_e393, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
let _e395 = LinearToSrgb_u0028_vf3_u003b((¶m_10));
encodedIn = _e395;
let _e398 = composite_info.ao_texel[3u];
let _e400 = encodedIn;
param_11 = _e400;
param_12 = max(_e398, 2f);
let _e401 = SampleLut_u0028_vf3_u003b_f1_u003b((¶m_11), (¶m_12));
param_13 = _e401;
let _e402 = SrgbToLinear_u0028_vf3_u003b((¶m_13));
graded = _e402;
let _e403 = color_9;
let _e404 = graded;
let _e405 = lutStrength;
color_9 = mix(_e403, _e404, vec3(clamp(_e405, 0f, 1f)));
}
let _e411 = composite_info.look_more[0u];
vignette = _e411;
let _e412 = vignette;
if (_e412 > 0f) {
let _e414 = v_uv_1;
fromCentre_1 = (_e414 - vec2<f32>(0.5f, 0.5f));
let _e418 = composite_info.look_more[3u];
aspect = max(_e418, 0.0001f);
let _e420 = aspect;
let _e423 = composite_info.look_more[1u];
let _e426 = fromCentre_1[0u];
fromCentre_1[0u] = (_e426 * mix(1f, _e420, _e423));
let _e429 = fromCentre_1;
radius = (length(_e429) * 1.4142135f);
let _e432 = vignette;
let _e434 = radius;
let _e437 = color_9;
color_9 = (_e437 * mix(1f, (1f - _e432), clamp(_e434, 0f, 1f)));
}
let _e439 = color_9;
param_14 = max(_e439, vec3<f32>(0f, 0f, 0f));
let _e441 = LinearToSrgb_u0028_vf3_u003b((¶m_14));
encoded_1 = _e441;
let _e444 = composite_info.look_more[2u];
grain = _e444;
let _e445 = grain;
if (_e445 > 0f) {
let _e447 = gl_FragCoord_1;
param_15 = _e447.xy;
let _e449 = Hash_u0028_vf2_u003b((¶m_15));
let _e451 = grain;
let _e454 = encoded_1;
encoded_1 = (_e454 + vec3(((_e449 - 0.5f) * _e451)));
}
let _e458 = composite_info.output_encode[0u];
dither = _e458;
let _e459 = dither;
if (_e459 > 0f) {
let _e461 = gl_FragCoord_1;
param_16 = _e461.xy;
let _e463 = BayerCell_u0028_vf2_u003b((¶m_16));
let _e465 = dither;
let _e468 = encoded_1;
encoded_1 = (_e468 + vec3(((_e463 + 0.03125f) * _e465)));
}
let _e470 = encoded_1;
let _e472 = scene[3u];
frag_color = vec4<f32>(_e470.x, _e470.y, _e470.z, _e472);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'CompositeInfo',
group: 1,
binding: 0,
sizeInBytes: 144,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ao_texel',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'look', offsetInBytes: 32, sizeInBytes: 16),
WebGpuBlockMember(
name: 'look_more',
offsetInBytes: 48,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'output_encode',
offsetInBytes: 64,
sizeInBytes: 16,
),
WebGpuBlockMember(name: 'lift', offsetInBytes: 80, sizeInBytes: 16),
WebGpuBlockMember(
name: 'gamma',
offsetInBytes: 96,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'gain',
offsetInBytes: 112,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'contact',
offsetInBytes: 128,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'ao_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'bloom_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'contact_shadow_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lut_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Fxaa': WebGpuStage(
wgsl: r'''
struct FxaaInfo {
params: vec4<f32>,
sharpen: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fxaa_info: FxaaInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn MinChannel_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> f32 {
let _e25 = (*v)[0u];
let _e27 = (*v)[1u];
let _e29 = (*v)[2u];
return min(_e25, min(_e27, _e29));
}
fn Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, n: ptr<function, vec3<f32>>, s: ptr<function, vec3<f32>>, w: ptr<function, vec3<f32>>, e: ptr<function, vec3<f32>>) -> vec3<f32> {
var strength: f32;
var lowest: vec3<f32>;
var highest: vec3<f32>;
var room: vec3<f32>;
var amount: f32;
var param: vec3<f32>;
var average: vec3<f32>;
let _e37 = fxaa_info.sharpen[0u];
strength = _e37;
let _e38 = strength;
if (_e38 <= 0f) {
let _e40 = (*centre);
return _e40;
}
let _e41 = (*centre);
let _e42 = (*n);
let _e43 = (*s);
let _e45 = (*w);
let _e46 = (*e);
lowest = min(_e41, min(min(_e42, _e43), min(_e45, _e46)));
let _e50 = (*centre);
let _e51 = (*n);
let _e52 = (*s);
let _e54 = (*w);
let _e55 = (*e);
highest = max(_e50, max(max(_e51, _e52), max(_e54, _e55)));
let _e59 = lowest;
let _e60 = highest;
let _e63 = highest;
room = (min(_e59, (vec3<f32>(1f, 1f, 1f) - _e60)) / max(_e63, vec3<f32>(0.00001f, 0.00001f, 0.00001f)));
let _e66 = room;
param = _e66;
let _e67 = MinChannel_u0028_vf3_u003b((¶m));
amount = clamp(sqrt(clamp(_e67, 0f, 1f)), 0f, 1f);
let _e71 = (*n);
let _e72 = (*s);
let _e74 = (*w);
let _e76 = (*e);
average = ((((_e71 + _e72) + _e74) + _e76) * 0.25f);
let _e79 = (*centre);
let _e80 = (*centre);
let _e81 = average;
let _e83 = amount;
let _e85 = strength;
return (_e79 + (((_e80 - _e81) * _e83) * _e85));
}
fn Weight_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e24 = (*color);
return dot(_e24, vec3<f32>(0.299f, 0.587f, 0.114f));
}
fn main_1() {
var texel: vec2<f32>;
var middle: vec3<f32>;
var mid: f32;
var param_1: vec3<f32>;
var northRgb: vec3<f32>;
var southRgb: vec3<f32>;
var westRgb: vec3<f32>;
var eastRgb: vec3<f32>;
var north: f32;
var param_2: vec3<f32>;
var south: f32;
var param_3: vec3<f32>;
var west: f32;
var param_4: vec3<f32>;
var east: f32;
var param_5: vec3<f32>;
var lowest_1: f32;
var highest_1: f32;
var contrast: f32;
var param_6: vec3<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var param_9: vec3<f32>;
var param_10: vec3<f32>;
var vertical: f32;
var horizontal: f32;
var horizontalEdge: bool;
var towards: f32;
var local: f32;
var away: f32;
var local_1: f32;
var step_length: f32;
var local_2: f32;
var average_1: f32;
var blend: f32;
var offset: vec2<f32>;
var local_3: vec2<f32>;
var smoothed: vec3<f32>;
var param_11: vec3<f32>;
var param_12: vec3<f32>;
var param_13: vec3<f32>;
var param_14: vec3<f32>;
var param_15: vec3<f32>;
let _e67 = fxaa_info.params;
texel = _e67.xy;
let _e69 = v_uv_1;
let _e70 = textureSampleLevel(source_texture_tex, source_texture_smp, _e69, 0f);
middle = _e70.xyz;
let _e72 = middle;
param_1 = _e72;
let _e73 = Weight_u0028_vf3_u003b((¶m_1));
mid = _e73;
let _e74 = v_uv_1;
let _e76 = texel[1u];
let _e80 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e74 + vec2<f32>(0f, -(_e76))), 0f);
northRgb = _e80.xyz;
let _e82 = v_uv_1;
let _e84 = texel[1u];
let _e87 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e82 + vec2<f32>(0f, _e84)), 0f);
southRgb = _e87.xyz;
let _e89 = v_uv_1;
let _e91 = texel[0u];
let _e95 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e89 + vec2<f32>(-(_e91), 0f)), 0f);
westRgb = _e95.xyz;
let _e97 = v_uv_1;
let _e99 = texel[0u];
let _e102 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e97 + vec2<f32>(_e99, 0f)), 0f);
eastRgb = _e102.xyz;
let _e104 = northRgb;
param_2 = _e104;
let _e105 = Weight_u0028_vf3_u003b((¶m_2));
north = _e105;
let _e106 = southRgb;
param_3 = _e106;
let _e107 = Weight_u0028_vf3_u003b((¶m_3));
south = _e107;
let _e108 = westRgb;
param_4 = _e108;
let _e109 = Weight_u0028_vf3_u003b((¶m_4));
west = _e109;
let _e110 = eastRgb;
param_5 = _e110;
let _e111 = Weight_u0028_vf3_u003b((¶m_5));
east = _e111;
let _e112 = mid;
let _e113 = north;
let _e114 = south;
let _e116 = west;
let _e117 = east;
lowest_1 = min(_e112, min(min(_e113, _e114), min(_e116, _e117)));
let _e121 = mid;
let _e122 = north;
let _e123 = south;
let _e125 = west;
let _e126 = east;
highest_1 = max(_e121, max(max(_e122, _e123), max(_e125, _e126)));
let _e130 = highest_1;
let _e131 = lowest_1;
contrast = (_e130 - _e131);
let _e133 = contrast;
let _e134 = highest_1;
let _e137 = fxaa_info.params[2u];
if (_e133 < max(0.0312f, (_e134 * _e137))) {
let _e141 = middle;
param_6 = _e141;
let _e142 = northRgb;
param_7 = _e142;
let _e143 = southRgb;
param_8 = _e143;
let _e144 = westRgb;
param_9 = _e144;
let _e145 = eastRgb;
param_10 = _e145;
let _e146 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_6), (¶m_7), (¶m_8), (¶m_9), (¶m_10));
frag_color = vec4<f32>(_e146.x, _e146.y, _e146.z, 1f);
return;
}
let _e151 = north;
let _e152 = south;
let _e154 = mid;
vertical = abs(((_e151 + _e152) - (2f * _e154)));
let _e158 = west;
let _e159 = east;
let _e161 = mid;
horizontal = abs(((_e158 + _e159) - (2f * _e161)));
let _e165 = vertical;
let _e166 = horizontal;
horizontalEdge = (_e165 >= _e166);
let _e168 = horizontalEdge;
if _e168 {
let _e169 = south;
let _e170 = mid;
local = (_e169 - _e170);
} else {
let _e172 = east;
let _e173 = mid;
local = (_e172 - _e173);
}
let _e175 = local;
towards = _e175;
let _e176 = horizontalEdge;
if _e176 {
let _e177 = north;
let _e178 = mid;
local_1 = (_e177 - _e178);
} else {
let _e180 = west;
let _e181 = mid;
local_1 = (_e180 - _e181);
}
let _e183 = local_1;
away = _e183;
let _e184 = horizontalEdge;
if _e184 {
let _e186 = texel[1u];
local_2 = _e186;
} else {
let _e188 = texel[0u];
local_2 = _e188;
}
let _e189 = local_2;
step_length = _e189;
let _e190 = away;
let _e192 = towards;
if (abs(_e190) > abs(_e192)) {
let _e195 = step_length;
step_length = -(_e195);
}
let _e197 = north;
let _e198 = south;
let _e200 = west;
let _e202 = east;
average_1 = ((((_e197 + _e198) + _e200) + _e202) * 0.25f);
let _e205 = average_1;
let _e206 = mid;
let _e209 = contrast;
blend = clamp((abs((_e205 - _e206)) / max(_e209, 0.00001f)), 0f, 1f);
let _e213 = blend;
let _e214 = blend;
let _e218 = fxaa_info.params[3u];
blend = ((_e213 * _e214) * _e218);
let _e220 = horizontalEdge;
if _e220 {
let _e221 = step_length;
let _e222 = blend;
local_3 = vec2<f32>(0f, (_e221 * _e222));
} else {
let _e225 = step_length;
let _e226 = blend;
local_3 = vec2<f32>((_e225 * _e226), 0f);
}
let _e229 = local_3;
offset = _e229;
let _e230 = v_uv_1;
let _e231 = offset;
let _e233 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e230 + _e231), 0f);
smoothed = _e233.xyz;
let _e235 = smoothed;
param_11 = _e235;
let _e236 = northRgb;
param_12 = _e236;
let _e237 = southRgb;
param_13 = _e237;
let _e238 = westRgb;
param_14 = _e238;
let _e239 = eastRgb;
param_15 = _e239;
let _e240 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((¶m_11), (¶m_12), (¶m_13), (¶m_14), (¶m_15));
frag_color = vec4<f32>(_e240.x, _e240.y, _e240.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FxaaInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'sharpen',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'MrtProbe': WebGpuStage(
wgsl: r'''
struct FragmentOutput {
@location(0) member: vec4<f32>,
@location(1) member_1: vec4<f32>,
}
var<private> out_first: vec4<f32>;
var<private> out_second: vec4<f32>;
var<private> v_uv_1: vec2<f32>;
fn main_1() {
out_first = vec4<f32>(0.25f, 0.5f, 0.75f, 1f);
out_second = vec4<f32>(0.75f, 0.5f, 0.25f, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> FragmentOutput {
v_uv_1 = v_uv;
main_1();
let _e4 = out_first;
let _e5 = out_second;
return FragmentOutput(_e4, _e5);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'ShadowDepth': WebGpuStage(
wgsl: r'''
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e17 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e17, 0f, 0f, 1f);
return;
}
@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
gl_FragCoord_1 = gl_FragCoord;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'Particle': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn main_1() {
var centred: vec2<f32>;
var radius: f32;
var falloff: f32;
var intensity: f32;
var fogged: f32;
let _e16 = v_uv_1;
centred = ((_e16 * 2f) - vec2(1f));
let _e20 = centred;
radius = length(_e20);
let _e22 = radius;
falloff = (1f - smoothstep(0f, 1f, _e22));
let _e25 = falloff;
let _e26 = falloff;
intensity = (_e25 * _e26);
fogged = 1f;
let _e30 = fog_info.fog[3u];
if (_e30 > 0f) {
let _e34 = fog_info.fog[3u];
let _e36 = v_world_position_1;
let _e38 = fog_info.eye;
fogged = clamp(exp((-(_e34) * distance(_e36, _e38.xyz))), 0f, 1f);
}
let _e44 = v_color_1;
let _e47 = v_color_1[3u];
let _e49 = intensity;
let _e51 = fogged;
let _e52 = (((_e44.xyz * _e47) * _e49) * _e51);
frag_color = vec4<f32>(_e52.x, _e52.y, _e52.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleTextured': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
@group(1) @binding(1)
var particle_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var particle_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var texel: vec4<f32>;
var fogged: f32;
var scale: f32;
let _e15 = v_uv_1;
let _e16 = textureSample(particle_texture_tex, particle_texture_smp, _e15);
texel = _e16;
fogged = 1f;
let _e19 = fog_info.fog[3u];
if (_e19 > 0f) {
let _e23 = fog_info.fog[3u];
let _e25 = v_world_position_1;
let _e27 = fog_info.eye;
fogged = clamp(exp((-(_e23) * distance(_e25, _e27.xyz))), 0f, 1f);
}
let _e34 = v_color_1[3u];
let _e36 = texel[3u];
let _e38 = fogged;
scale = ((_e34 * _e36) * _e38);
let _e40 = v_color_1;
let _e42 = texel;
let _e45 = scale;
let _e46 = ((_e40.xyz * _e42.xyz) * _e45);
frag_color = vec4<f32>(_e46.x, _e46.y, _e46.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_world_position_1 = v_world_position;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'particle_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Splat': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var power: f32;
var alpha: f32;
var colour: vec3<f32>;
var visibility: f32;
let _e17 = v_uv_1;
let _e18 = v_uv_1;
power = (-0.5f * dot(_e17, _e18));
let _e21 = power;
if (_e21 < -4.5f) {
discard;
}
let _e24 = v_color_1[3u];
let _e25 = power;
alpha = (_e24 * exp(_e25));
let _e28 = alpha;
if (_e28 < 0.003921569f) {
discard;
}
let _e30 = v_color_1;
colour = _e30.xyz;
let _e34 = fog_info.fog[3u];
if (_e34 > 0f) {
let _e38 = fog_info.fog[3u];
let _e40 = v_world_position_1;
let _e42 = fog_info.eye;
visibility = clamp(exp((-(_e38) * distance(_e40, _e42.xyz))), 0f, 1f);
let _e49 = fog_info.fog;
let _e51 = colour;
let _e52 = visibility;
colour = mix(_e49.xyz, _e51, vec3(_e52));
}
let _e55 = colour;
let _e56 = alpha;
let _e57 = (_e55 * _e56);
let _e58 = alpha;
frag_color = vec4<f32>(_e57.x, _e57.y, _e57.z, _e58);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(6) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
v_color_1 = v_color;
v_world_position_1 = v_world_position;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleMesh': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn main_1() {
var to_eye: vec3<f32>;
var distance_to_eye: f32;
var n: vec3<f32>;
var facing: f32;
var local: f32;
var intensity: f32;
var fogged: f32;
let _e19 = fog_info.eye;
let _e21 = v_world_position_1;
to_eye = (_e19.xyz - _e21);
let _e23 = to_eye;
distance_to_eye = length(_e23);
let _e25 = v_normal_1;
n = normalize(_e25);
let _e27 = distance_to_eye;
if (_e27 > 0f) {
let _e29 = n;
let _e30 = to_eye;
let _e31 = distance_to_eye;
local = abs(dot(_e29, (_e30 / vec3(_e31))));
} else {
local = 1f;
}
let _e36 = local;
facing = _e36;
let _e37 = facing;
intensity = mix(0.35f, 1f, _e37);
fogged = 1f;
let _e41 = fog_info.fog[3u];
if (_e41 > 0f) {
let _e45 = fog_info.fog[3u];
let _e47 = distance_to_eye;
fogged = clamp(exp((-(_e45) * _e47)), 0f, 1f);
}
let _e51 = v_color_1;
let _e54 = v_color_1[3u];
let _e56 = intensity;
let _e58 = fogged;
let _e59 = (((_e51.xyz * _e54) * _e56) * _e58);
frag_color = vec4<f32>(_e59.x, _e59.y, _e59.z, 1f);
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'Reflections': WebGpuStage(
wgsl: r'''
struct ReflectionInfo {
view_projection: mat4x4<f32>,
inverse_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> reflection_info: ReflectionInfo;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e57 = (*at);
let _e59 = reflection_info.camera;
let _e63 = reflection_info.forward;
return dot((_e57 - _e59.xyz), _e63.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e58 = (*ndc)[0u];
let _e62 = (*ndc)[1u];
return vec2<f32>(((_e58 * 0.5f) + 0.5f), (0.5f - (_e62 * 0.5f)));
}
fn UvOf_u0028_vf3_u003b(at_1: ptr<function, vec3<f32>>) -> vec2<f32> {
var clip: vec4<f32>;
var param: vec2<f32>;
let _e60 = reflection_info.view_projection;
let _e61 = (*at_1);
clip = (_e60 * vec4<f32>(_e61.x, _e61.y, _e61.z, 1f));
let _e68 = clip[3u];
if (_e68 <= 0f) {
return vec2<f32>(-1f, -1f);
}
let _e70 = clip;
let _e73 = clip[3u];
param = (_e70.xy / vec2(_e73));
let _e76 = UvFromNdc_u0028_vf2_u003b((¶m));
return _e76;
}
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 _e62 = (*at_2)[0u];
x = i32((_e62 - (floor((_e62 / 4f)) * 4f)));
let _e69 = (*at_2)[1u];
y = i32((_e69 - (floor((_e69 / 4f)) * 4f)));
let _e75 = y;
let _e77 = x;
index = ((_e75 * 4i) + _e77);
value = 0f;
let _e79 = index;
if (_e79 == 0i) {
value = 0f;
} else {
let _e81 = index;
if (_e81 == 1i) {
value = 8f;
} else {
let _e83 = index;
if (_e83 == 2i) {
value = 2f;
} else {
let _e85 = index;
if (_e85 == 3i) {
value = 10f;
} else {
let _e87 = index;
if (_e87 == 4i) {
value = 12f;
} else {
let _e89 = index;
if (_e89 == 5i) {
value = 4f;
} else {
let _e91 = index;
if (_e91 == 6i) {
value = 14f;
} else {
let _e93 = index;
if (_e93 == 7i) {
value = 6f;
} else {
let _e95 = index;
if (_e95 == 8i) {
value = 3f;
} else {
let _e97 = index;
if (_e97 == 9i) {
value = 11f;
} else {
let _e99 = index;
if (_e99 == 10i) {
value = 1f;
} else {
let _e101 = index;
if (_e101 == 11i) {
value = 9f;
} else {
let _e103 = index;
if (_e103 == 12i) {
value = 15f;
} else {
let _e105 = index;
if (_e105 == 13i) {
value = 7f;
} else {
let _e107 = index;
if (_e107 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e109 = value;
return (_e109 / 16f);
}
fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, origin: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>) {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
let _e63 = (*uv)[0u];
let _e67 = (*uv)[1u];
xy = vec2<f32>(((_e63 * 2f) - 1f), (1f - (_e67 * 2f)));
let _e72 = reflection_info.inverse_view_projection;
let _e73 = xy;
nearH = (_e72 * vec4<f32>(_e73.x, _e73.y, 0f, 1f));
let _e79 = reflection_info.inverse_view_projection;
let _e80 = xy;
farH = (_e79 * vec4<f32>(_e80.x, _e80.y, 1f, 1f));
let _e85 = nearH;
let _e88 = nearH[3u];
(*origin) = (_e85.xyz / vec3(_e88));
let _e91 = farH;
let _e94 = farH[3u];
let _e97 = (*origin);
(*along) = normalize(((_e91.xyz / vec3(_e94)) - _e97));
return;
}
fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var origin_1: vec3<f32>;
var along_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: vec3<f32>;
var param_3: vec3<f32>;
var axis: vec3<f32>;
let _e64 = (*uv_1);
param_1 = _e64;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_1), (¶m_2), (¶m_3));
let _e65 = param_2;
origin_1 = _e65;
let _e66 = param_3;
along_1 = _e66;
let _e68 = reflection_info.forward;
axis = _e68.xyz;
let _e70 = origin_1;
let _e71 = along_1;
let _e72 = (*depth);
let _e73 = origin_1;
let _e75 = reflection_info.camera;
let _e78 = axis;
let _e81 = along_1;
let _e82 = axis;
return (_e70 + (_e71 * ((_e72 - dot((_e73 - _e75.xyz), _e78)) / dot(_e81, _e82))));
}
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 _e61 = (*e);
(*e) = ((_e61 * 2f) - vec2(1f));
let _e65 = (*e);
let _e67 = (*e)[0u];
let _e71 = (*e)[1u];
n = vec3<f32>(_e65.x, _e65.y, ((1f - abs(_e67)) - abs(_e71)));
let _e78 = n[2u];
t = max(-(_e78), 0f);
let _e82 = n[0u];
if (_e82 >= 0f) {
let _e84 = t;
local = -(_e84);
} else {
let _e86 = t;
local = _e86;
}
let _e87 = local;
let _e89 = n[0u];
n[0u] = (_e89 + _e87);
let _e93 = n[1u];
if (_e93 >= 0f) {
let _e95 = t;
local_1 = -(_e95);
} else {
let _e97 = t;
local_1 = _e97;
}
let _e98 = local_1;
let _e100 = n[1u];
n[1u] = (_e100 + _e98);
let _e103 = n;
return normalize(_e103);
}
fn main_1() {
var surface: vec4<f32>;
var scene: vec3<f32>;
var debugOnly: bool;
var background: vec3<f32>;
var normal: vec3<f32>;
var param_4: vec2<f32>;
var roughness: f32;
var polish: f32;
var position: vec3<f32>;
var param_5: vec2<f32>;
var param_6: f32;
var rayOrigin: vec3<f32>;
var viewRay: vec3<f32>;
var param_7: vec2<f32>;
var param_8: vec3<f32>;
var param_9: 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_10: vec2<f32>;
var travelled: f32;
var march: vec3<f32>;
var reach: f32;
var hitColor: vec3<f32>;
var hit: f32;
var i: i32;
var uv_2: vec2<f32>;
var param_11: vec3<f32>;
var sceneDepth: f32;
var marchDepth: f32;
var param_12: vec3<f32>;
var seen: vec3<f32>;
var param_13: vec2<f32>;
var param_14: f32;
var behind: f32;
var seenNormal: vec3<f32>;
var param_15: vec2<f32>;
var lo: vec3<f32>;
var hi: vec3<f32>;
var j: i32;
var mid: vec3<f32>;
var at_3: vec2<f32>;
var param_16: vec3<f32>;
var d: f32;
var local_2: f32;
var param_17: vec3<f32>;
var hitUv: vec2<f32>;
var param_18: vec3<f32>;
var edge: vec2<f32>;
var border: f32;
var along_2: f32;
var fresnel: f32;
var reflection: vec3<f32>;
var local_3: vec3<f32>;
var phi_555_: bool;
var phi_562_: bool;
var phi_569_: bool;
var phi_620_: bool;
var phi_672_: bool;
let _e115 = v_uv_1;
let _e116 = textureSample(surface_texture_tex, surface_texture_smp, _e115);
surface = _e116;
let _e117 = v_uv_1;
let _e118 = textureSample(scene_texture_tex, scene_texture_smp, _e117);
scene = _e118.xyz;
let _e122 = reflection_info.screen[3u];
debugOnly = (_e122 > 0.5f);
let _e124 = debugOnly;
let _e125 = scene;
background = select(_e125, vec3<f32>(0f, 0f, 0f), vec3(_e124));
let _e129 = surface[3u];
if (_e129 <= 0f) {
let _e131 = background;
frag_color = vec4<f32>(_e131.x, _e131.y, _e131.z, 1f);
return;
}
let _e136 = surface;
param_4 = _e136.xy;
let _e138 = DecodeOctahedral_u0028_vf2_u003b((¶m_4));
normal = _e138;
let _e140 = surface[2u];
roughness = _e140;
let _e141 = roughness;
polish = (1f - smoothstep(0.05f, 0.25f, _e141));
let _e144 = polish;
if (_e144 <= 0f) {
let _e146 = background;
frag_color = vec4<f32>(_e146.x, _e146.y, _e146.z, 1f);
return;
}
let _e151 = v_uv_1;
param_5 = _e151;
let _e153 = surface[3u];
param_6 = _e153;
let _e154 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_5), (¶m_6));
position = _e154;
let _e155 = v_uv_1;
param_7 = _e155;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_7), (¶m_8), (¶m_9));
let _e156 = param_8;
rayOrigin = _e156;
let _e157 = param_9;
viewRay = _e157;
let _e158 = viewRay;
toEye = -(_e158);
let _e160 = normal;
let _e161 = toEye;
facing = dot(_e160, _e161);
let _e163 = facing;
if (_e163 <= 0.05f) {
let _e165 = background;
frag_color = vec4<f32>(_e165.x, _e165.y, _e165.z, 1f);
return;
}
let _e170 = toEye;
let _e172 = normal;
ray = reflect(-(_e170), _e172);
let _e176 = reflection_info.params[0u];
steps = i32(_e176);
let _e180 = reflection_info.params[1u];
stride = _e180;
let _e183 = reflection_info.params[2u];
thickness = _e183;
let _e186 = reflection_info.params[3u];
intensity = _e186;
let _e187 = gl_FragCoord_1;
param_10 = _e187.xy;
let _e189 = BayerCell_u0028_vf2_u003b((¶m_10));
jitter = (0.5f + _e189);
let _e191 = stride;
let _e192 = jitter;
travelled = (_e191 * _e192);
let _e194 = position;
let _e195 = normal;
let _e198 = ray;
let _e199 = travelled;
march = ((_e194 + (_e195 * 0.01f)) + (_e198 * _e199));
let _e202 = stride;
let _e203 = steps;
reach = (_e202 * (f32(_e203) + 0.5f));
hitColor = vec3<f32>(0f, 0f, 0f);
hit = 0f;
i = 0i;
loop {
let _e207 = i;
if (_e207 < 64i) {
let _e209 = i;
let _e210 = steps;
if (_e209 >= _e210) {
break;
}
let _e212 = march;
param_11 = _e212;
let _e213 = UvOf_u0028_vf3_u003b((¶m_11));
uv_2 = _e213;
let _e215 = uv_2[0u];
if (_e215 < -0.5f) {
break;
}
let _e218 = uv_2[0u];
let _e219 = (_e218 < 0f);
phi_555_ = _e219;
if !(_e219) {
let _e222 = uv_2[0u];
phi_555_ = (_e222 > 1f);
}
let _e225 = phi_555_;
phi_562_ = _e225;
if !(_e225) {
let _e228 = uv_2[1u];
phi_562_ = (_e228 < 0f);
}
let _e231 = phi_562_;
phi_569_ = _e231;
if !(_e231) {
let _e234 = uv_2[1u];
phi_569_ = (_e234 > 1f);
}
let _e237 = phi_569_;
if _e237 {
break;
}
let _e238 = uv_2;
let _e239 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e238, 0f);
sceneDepth = _e239.w;
let _e241 = march;
param_12 = _e241;
let _e242 = DepthOf_u0028_vf3_u003b((¶m_12));
marchDepth = _e242;
let _e243 = sceneDepth;
let _e245 = marchDepth;
let _e246 = sceneDepth;
if ((_e243 > 0f) && (_e245 > _e246)) {
let _e249 = uv_2;
param_13 = _e249;
let _e250 = sceneDepth;
param_14 = _e250;
let _e251 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_13), (¶m_14));
seen = _e251;
let _e252 = march;
let _e253 = seen;
behind = distance(_e252, _e253);
let _e255 = uv_2;
let _e256 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e255, 0f);
param_15 = _e256.xy;
let _e258 = DecodeOctahedral_u0028_vf2_u003b((¶m_15));
seenNormal = _e258;
let _e259 = behind;
let _e260 = thickness;
let _e261 = (_e259 < _e260);
phi_620_ = _e261;
if _e261 {
let _e262 = seenNormal;
let _e263 = ray;
phi_620_ = (dot(_e262, _e263) < 0f);
}
let _e267 = phi_620_;
if _e267 {
let _e268 = march;
let _e269 = ray;
let _e270 = stride;
lo = (_e268 - (_e269 * _e270));
let _e273 = march;
hi = _e273;
j = 0i;
loop {
let _e274 = j;
if (_e274 < 5i) {
let _e276 = lo;
let _e277 = hi;
mid = ((_e276 + _e277) * 0.5f);
let _e280 = mid;
param_16 = _e280;
let _e281 = UvOf_u0028_vf3_u003b((¶m_16));
at_3 = _e281;
let _e283 = at_3[0u];
if (_e283 < -0.5f) {
local_2 = 0f;
} else {
let _e285 = at_3;
let _e286 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e285, 0f);
local_2 = _e286.w;
}
let _e288 = local_2;
d = _e288;
let _e289 = d;
let _e290 = (_e289 > 0f);
phi_672_ = _e290;
if _e290 {
let _e291 = mid;
param_17 = _e291;
let _e292 = DepthOf_u0028_vf3_u003b((¶m_17));
let _e293 = d;
phi_672_ = (_e292 > _e293);
}
let _e296 = phi_672_;
if _e296 {
let _e297 = mid;
hi = _e297;
} else {
let _e298 = mid;
lo = _e298;
}
continue;
} else {
break;
}
continuing {
let _e299 = j;
j = (_e299 + 1i);
}
}
let _e301 = hi;
param_18 = _e301;
let _e302 = UvOf_u0028_vf3_u003b((¶m_18));
hitUv = _e302;
let _e304 = hitUv[0u];
if (_e304 < -0.5f) {
let _e306 = uv_2;
hitUv = _e306;
}
let _e307 = hitUv;
let _e308 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e307, 0f);
hitColor = _e308.xyz;
let _e310 = hitUv;
edge = abs(((_e310 * 2f) - vec2(1f)));
let _e316 = edge[0u];
let _e318 = edge[1u];
border = (1f - max(_e316, _e318));
let _e321 = travelled;
let _e322 = reach;
along_2 = clamp((1f - (_e321 / _e322)), 0f, 1f);
let _e326 = border;
let _e328 = along_2;
let _e330 = along_2;
hit = ((smoothstep(0f, 0.15f, _e326) * _e328) * _e330);
break;
}
}
let _e332 = ray;
let _e333 = stride;
let _e335 = march;
march = (_e335 + (_e332 * _e333));
let _e337 = stride;
let _e338 = travelled;
travelled = (_e338 + _e337);
continue;
} else {
break;
}
continuing {
let _e340 = i;
i = (_e340 + 1i);
}
}
let _e342 = facing;
fresnel = (0.04f + (0.96f * pow((1f - _e342), 5f)));
let _e347 = hitColor;
let _e348 = hit;
let _e350 = intensity;
let _e352 = polish;
let _e354 = fresnel;
reflection = ((((_e347 * _e348) * _e350) * _e352) * _e354);
let _e356 = debugOnly;
if _e356 {
let _e357 = reflection;
local_3 = _e357;
} else {
let _e358 = scene;
let _e359 = reflection;
local_3 = (_e358 + _e359);
}
let _e361 = local_3;
frag_color = vec4<f32>(_e361.x, _e361.y, _e361.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ReflectionInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Ssao': WebGpuStage(
wgsl: r'''
struct SsaoInfo {
inverse_view_projection: mat4x4<f32>,
view_projection: mat4x4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> ssao_info: SsaoInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e82 = (*at);
let _e84 = ssao_info.camera;
let _e88 = ssao_info.forward;
return dot((_e82 - _e84.xyz), _e88.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e83 = (*ndc)[0u];
let _e87 = (*ndc)[1u];
return vec2<f32>(((_e83 * 0.5f) + 0.5f), (0.5f - (_e87 * 0.5f)));
}
fn KernelTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec3<f32> {
let _e82 = (*i);
if (_e82 == 0i) {
return vec3<f32>(0.5381f, 0.1856f, 0.4319f);
}
let _e84 = (*i);
if (_e84 == 1i) {
return vec3<f32>(0.1379f, 0.2486f, 0.443f);
}
let _e86 = (*i);
if (_e86 == 2i) {
return vec3<f32>(0.3371f, 0.5679f, 0.0057f);
}
let _e88 = (*i);
if (_e88 == 3i) {
return vec3<f32>(-0.6999f, -0.0451f, 0.0019f);
}
let _e90 = (*i);
if (_e90 == 4i) {
return vec3<f32>(0.0689f, -0.1598f, -0.8547f);
}
let _e92 = (*i);
if (_e92 == 5i) {
return vec3<f32>(0.056f, 0.0069f, -0.1843f);
}
let _e94 = (*i);
if (_e94 == 6i) {
return vec3<f32>(-0.0146f, 0.1402f, 0.0762f);
}
let _e96 = (*i);
if (_e96 == 7i) {
return vec3<f32>(0.01f, -0.1924f, -0.0344f);
}
let _e98 = (*i);
if (_e98 == 8i) {
return vec3<f32>(-0.3577f, -0.5301f, -0.4358f);
}
let _e100 = (*i);
if (_e100 == 9i) {
return vec3<f32>(-0.3169f, 0.1063f, 0.0158f);
}
let _e102 = (*i);
if (_e102 == 10i) {
return vec3<f32>(0.0103f, -0.5869f, 0.0046f);
}
return vec3<f32>(-0.0897f, -0.494f, 0.3287f);
}
fn Rotation_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec2<f32> {
var pixel: vec2<f32>;
var oddX: bool;
var oddY: bool;
let _e85 = (*uv);
let _e87 = ssao_info.screen;
pixel = floor((_e85 / _e87.xy));
let _e92 = pixel[0u];
oddX = ((_e92 - (floor((_e92 / 2f)) * 2f)) >= 1f);
let _e99 = pixel[1u];
oddY = ((_e99 - (floor((_e99 / 2f)) * 2f)) >= 1f);
let _e105 = oddX;
let _e106 = oddY;
if (_e105 && _e106) {
return vec2<f32>(-0.7071f, -0.7071f);
}
let _e108 = oddX;
if _e108 {
return vec2<f32>(0.7071f, -0.7071f);
}
let _e109 = oddY;
if _e109 {
return vec2<f32>(-0.7071f, 0.7071f);
}
return vec2<f32>(1f, 0f);
}
fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var axis: vec3<f32>;
let _e90 = (*uv_1)[0u];
let _e94 = (*uv_1)[1u];
xy = vec2<f32>(((_e90 * 2f) - 1f), (1f - (_e94 * 2f)));
let _e99 = ssao_info.inverse_view_projection;
let _e100 = xy;
nearH = (_e99 * vec4<f32>(_e100.x, _e100.y, 0f, 1f));
let _e106 = ssao_info.inverse_view_projection;
let _e107 = xy;
farH = (_e106 * vec4<f32>(_e107.x, _e107.y, 1f, 1f));
let _e112 = nearH;
let _e115 = nearH[3u];
origin = (_e112.xyz / vec3(_e115));
let _e118 = farH;
let _e121 = farH[3u];
let _e124 = origin;
along = normalize(((_e118.xyz / vec3(_e121)) - _e124));
let _e128 = ssao_info.forward;
axis = _e128.xyz;
let _e130 = origin;
let _e131 = along;
let _e132 = (*depth);
let _e133 = origin;
let _e135 = ssao_info.camera;
let _e138 = axis;
let _e141 = along;
let _e142 = axis;
return (_e130 + (_e131 * ((_e132 - dot((_e133 - _e135.xyz), _e138)) / dot(_e141, _e142))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e86 = (*e);
(*e) = ((_e86 * 2f) - vec2(1f));
let _e90 = (*e);
let _e92 = (*e)[0u];
let _e96 = (*e)[1u];
n = vec3<f32>(_e90.x, _e90.y, ((1f - abs(_e92)) - abs(_e96)));
let _e103 = n[2u];
t = max(-(_e103), 0f);
let _e107 = n[0u];
if (_e107 >= 0f) {
let _e109 = t;
local = -(_e109);
} else {
let _e111 = t;
local = _e111;
}
let _e112 = local;
let _e114 = n[0u];
n[0u] = (_e114 + _e112);
let _e118 = n[1u];
if (_e118 >= 0f) {
let _e120 = t;
local_1 = -(_e120);
} else {
let _e122 = t;
local_1 = _e122;
}
let _e123 = local_1;
let _e125 = n[1u];
n[1u] = (_e125 + _e123);
let _e128 = n;
return normalize(_e128);
}
fn main_1() {
var surface: vec4<f32>;
var normal: vec3<f32>;
var param: vec2<f32>;
var radius: f32;
var samples: i32;
var origin_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: f32;
var rot: vec2<f32>;
var param_3: vec2<f32>;
var occluded: f32;
var i_1: i32;
var tap: vec3<f32>;
var param_4: i32;
var spun: vec3<f32>;
var at_1: vec3<f32>;
var clip: vec4<f32>;
var ndc_1: vec3<f32>;
var uv_2: vec2<f32>;
var param_5: vec2<f32>;
var there: vec4<f32>;
var param_6: vec3<f32>;
var seen: vec3<f32>;
var param_7: vec2<f32>;
var param_8: f32;
var phi_506_: bool;
let _e106 = v_uv_1;
let _e107 = textureSample(surface_texture_tex, surface_texture_smp, _e106);
surface = _e107;
let _e109 = surface[3u];
if (_e109 <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e111 = surface;
param = _e111.xy;
let _e113 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e113;
let _e116 = ssao_info.params[0u];
radius = max(_e116, 0.0001f);
let _e120 = ssao_info.params[1u];
samples = clamp(i32((_e120 + 0.5f)), 1i, 12i);
let _e124 = v_uv_1;
param_1 = _e124;
let _e126 = surface[3u];
param_2 = _e126;
let _e127 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_1), (¶m_2));
let _e128 = normal;
let _e131 = ssao_info.params[3u];
origin_1 = (_e127 + (_e128 * _e131));
let _e134 = v_uv_1;
param_3 = _e134;
let _e135 = Rotation_u0028_vf2_u003b((¶m_3));
rot = _e135;
occluded = 0f;
i_1 = 0i;
loop {
let _e136 = i_1;
if (_e136 < 12i) {
let _e138 = i_1;
let _e139 = samples;
if (_e138 >= _e139) {
break;
}
let _e141 = i_1;
param_4 = _e141;
let _e142 = KernelTap_u0028_i1_u003b((¶m_4));
tap = _e142;
let _e144 = tap[0u];
let _e146 = rot[0u];
let _e149 = tap[1u];
let _e151 = rot[1u];
let _e155 = tap[0u];
let _e157 = rot[1u];
let _e160 = tap[1u];
let _e162 = rot[0u];
let _e166 = tap[2u];
spun = vec3<f32>(((_e144 * _e146) - (_e149 * _e151)), ((_e155 * _e157) + (_e160 * _e162)), _e166);
let _e168 = spun;
let _e169 = normal;
if (dot(_e168, _e169) < 0f) {
let _e172 = spun;
spun = -(_e172);
}
let _e174 = origin_1;
let _e175 = spun;
let _e176 = radius;
at_1 = (_e174 + (_e175 * _e176));
let _e180 = ssao_info.view_projection;
let _e181 = at_1;
clip = (_e180 * vec4<f32>(_e181.x, _e181.y, _e181.z, 1f));
let _e188 = clip[3u];
if (_e188 <= 0f) {
continue;
}
let _e190 = clip;
let _e193 = clip[3u];
ndc_1 = (_e190.xyz / vec3(_e193));
let _e197 = ndc_1[0u];
let _e199 = (abs(_e197) > 1f);
phi_506_ = _e199;
if !(_e199) {
let _e202 = ndc_1[1u];
phi_506_ = (abs(_e202) > 1f);
}
let _e206 = phi_506_;
if _e206 {
continue;
}
let _e207 = ndc_1;
param_5 = _e207.xy;
let _e209 = UvFromNdc_u0028_vf2_u003b((¶m_5));
uv_2 = _e209;
let _e210 = uv_2;
let _e211 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e210, 0f);
there = _e211;
let _e213 = there[3u];
if (_e213 <= 0f) {
continue;
}
let _e216 = there[3u];
let _e217 = at_1;
param_6 = _e217;
let _e218 = DepthOf_u0028_vf3_u003b((¶m_6));
if (_e216 >= _e218) {
continue;
}
let _e220 = uv_2;
param_7 = _e220;
let _e222 = there[3u];
param_8 = _e222;
let _e223 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_7), (¶m_8));
seen = _e223;
let _e224 = radius;
let _e225 = seen;
let _e226 = origin_1;
let _e231 = occluded;
occluded = (_e231 + smoothstep(0f, 1f, (_e224 / max(distance(_e225, _e226), 0.0001f))));
continue;
} else {
break;
}
continuing {
let _e233 = i_1;
i_1 = (_e233 + 1i);
}
}
let _e235 = occluded;
let _e236 = samples;
frag_color = vec4(clamp((1f - (_e235 / f32(_e236))), 0f, 1f));
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'SsaoInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'SsaoBlur': WebGpuStage(
wgsl: r'''
struct SsaoBlurInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> blur_info: SsaoBlurInfo;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
fn main_1() {
var taps: f32;
var centre: f32;
var centreDepth: f32;
var falloff: f32;
var total: f32;
var weightSum: f32;
var i: i32;
var offset: f32;
var steps: array<vec2<f32>, 4>;
var s: i32;
var at: vec2<f32>;
var depth: f32;
var closeness: f32;
var weight: f32;
var blurred: f32;
let _e39 = blur_info.params[2u];
taps = _e39;
let _e40 = v_uv_1;
let _e41 = textureSample(ao_texture_tex, ao_texture_smp, _e40);
centre = _e41.x;
let _e43 = taps;
if (_e43 < 1f) {
let _e45 = centre;
frag_color = vec4<f32>(_e45, _e45, _e45, 1f);
return;
}
let _e47 = v_uv_1;
let _e48 = textureSample(surface_texture_tex, surface_texture_smp, _e47);
centreDepth = _e48.w;
let _e52 = blur_info.params[3u];
falloff = max(_e52, 0.0001f);
let _e54 = centre;
total = _e54;
weightSum = 1f;
i = 1i;
loop {
let _e55 = i;
if (_e55 <= 8i) {
let _e57 = i;
let _e59 = taps;
if (f32(_e57) > _e59) {
break;
}
let _e61 = i;
offset = f32(_e61);
let _e65 = blur_info.params[0u];
let _e66 = offset;
steps[0i] = vec2<f32>((_e65 * _e66), 0f);
let _e72 = blur_info.params[0u];
let _e74 = offset;
steps[1i] = vec2<f32>((-(_e72) * _e74), 0f);
let _e80 = blur_info.params[1u];
let _e81 = offset;
steps[2i] = vec2<f32>(0f, (_e80 * _e81));
let _e87 = blur_info.params[1u];
let _e89 = offset;
steps[3i] = vec2<f32>(0f, (-(_e87) * _e89));
s = 0i;
loop {
let _e93 = s;
if (_e93 < 4i) {
let _e95 = v_uv_1;
let _e96 = s;
let _e98 = steps[_e96];
at = (_e95 + _e98);
let _e100 = at;
let _e101 = textureSample(surface_texture_tex, surface_texture_smp, _e100);
depth = _e101.w;
let _e103 = depth;
let _e104 = centreDepth;
let _e108 = falloff;
let _e109 = centreDepth;
closeness = exp((-(abs((_e103 - _e104))) / (_e108 * max(_e109, 0.001f))));
let _e114 = closeness;
let _e115 = offset;
weight = (_e114 / _e115);
let _e117 = at;
let _e118 = textureSample(ao_texture_tex, ao_texture_smp, _e117);
let _e120 = weight;
let _e122 = total;
total = (_e122 + (_e118.x * _e120));
let _e124 = weight;
let _e125 = weightSum;
weightSum = (_e125 + _e124);
continue;
} else {
break;
}
continuing {
let _e127 = s;
s = (_e127 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e129 = i;
i = (_e129 + 1i);
}
}
let _e131 = total;
let _e132 = weightSum;
blurred = (_e131 / _e132);
let _e134 = blurred;
frag_color = vec4<f32>(_e134, _e134, _e134, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'SsaoBlurInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'ao_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ContactShadow': WebGpuStage(
wgsl: r'''
struct ContactShadowInfo {
inverse_view_projection: mat4x4<f32>,
view_projection: mat4x4<f32>,
params: vec4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
to_light: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> contact_info: ContactShadowInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e48 = (*ndc)[0u];
let _e52 = (*ndc)[1u];
return vec2<f32>(((_e48 * 0.5f) + 0.5f), (0.5f - (_e52 * 0.5f)));
}
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e47 = (*at);
let _e49 = contact_info.camera;
let _e53 = contact_info.forward;
return dot((_e47 - _e49.xyz), _e53.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 _e52 = (*at_1)[0u];
x = i32((_e52 - (floor((_e52 / 4f)) * 4f)));
let _e59 = (*at_1)[1u];
y = i32((_e59 - (floor((_e59 / 4f)) * 4f)));
let _e65 = y;
let _e67 = x;
index = ((_e65 * 4i) + _e67);
value = 0f;
let _e69 = index;
if (_e69 == 0i) {
value = 0f;
} else {
let _e71 = index;
if (_e71 == 1i) {
value = 8f;
} else {
let _e73 = index;
if (_e73 == 2i) {
value = 2f;
} else {
let _e75 = index;
if (_e75 == 3i) {
value = 10f;
} else {
let _e77 = index;
if (_e77 == 4i) {
value = 12f;
} else {
let _e79 = index;
if (_e79 == 5i) {
value = 4f;
} else {
let _e81 = index;
if (_e81 == 6i) {
value = 14f;
} else {
let _e83 = index;
if (_e83 == 7i) {
value = 6f;
} else {
let _e85 = index;
if (_e85 == 8i) {
value = 3f;
} else {
let _e87 = index;
if (_e87 == 9i) {
value = 11f;
} else {
let _e89 = index;
if (_e89 == 10i) {
value = 1f;
} else {
let _e91 = index;
if (_e91 == 11i) {
value = 9f;
} else {
let _e93 = index;
if (_e93 == 12i) {
value = 15f;
} else {
let _e95 = index;
if (_e95 == 13i) {
value = 7f;
} else {
let _e97 = index;
if (_e97 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e99 = value;
return (_e99 / 16f);
}
fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var axis: vec3<f32>;
let _e55 = (*uv)[0u];
let _e59 = (*uv)[1u];
xy = vec2<f32>(((_e55 * 2f) - 1f), (1f - (_e59 * 2f)));
let _e64 = contact_info.inverse_view_projection;
let _e65 = xy;
nearH = (_e64 * vec4<f32>(_e65.x, _e65.y, 0f, 1f));
let _e71 = contact_info.inverse_view_projection;
let _e72 = xy;
farH = (_e71 * vec4<f32>(_e72.x, _e72.y, 1f, 1f));
let _e77 = nearH;
let _e80 = nearH[3u];
origin = (_e77.xyz / vec3(_e80));
let _e83 = farH;
let _e86 = farH[3u];
let _e89 = origin;
along = normalize(((_e83.xyz / vec3(_e86)) - _e89));
let _e93 = contact_info.forward;
axis = _e93.xyz;
let _e95 = origin;
let _e96 = along;
let _e97 = (*depth);
let _e98 = origin;
let _e100 = contact_info.camera;
let _e103 = axis;
let _e106 = along;
let _e107 = axis;
return (_e95 + (_e96 * ((_e97 - dot((_e98 - _e100.xyz), _e103)) / dot(_e106, _e107))));
}
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 _e51 = (*e);
(*e) = ((_e51 * 2f) - vec2(1f));
let _e55 = (*e);
let _e57 = (*e)[0u];
let _e61 = (*e)[1u];
n = vec3<f32>(_e55.x, _e55.y, ((1f - abs(_e57)) - abs(_e61)));
let _e68 = n[2u];
t = max(-(_e68), 0f);
let _e72 = n[0u];
if (_e72 >= 0f) {
let _e74 = t;
local = -(_e74);
} else {
let _e76 = t;
local = _e76;
}
let _e77 = local;
let _e79 = n[0u];
n[0u] = (_e79 + _e77);
let _e83 = n[1u];
if (_e83 >= 0f) {
let _e85 = t;
local_1 = -(_e85);
} else {
let _e87 = t;
local_1 = _e87;
}
let _e88 = local_1;
let _e90 = n[1u];
n[1u] = (_e90 + _e88);
let _e93 = n;
return normalize(_e93);
}
fn main_1() {
var surface: vec4<f32>;
var normal: vec3<f32>;
var param: vec2<f32>;
var toLight: vec3<f32>;
var reach: f32;
var steps: i32;
var thickness: f32;
var origin_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: f32;
var stride: f32;
var jitter: f32;
var param_3: vec2<f32>;
var stepDepth: f32;
var param_4: vec3<f32>;
var param_5: vec3<f32>;
var tolerance: f32;
var i: i32;
var along_1: f32;
var at_2: vec3<f32>;
var clip: vec4<f32>;
var uv_1: vec2<f32>;
var param_6: vec2<f32>;
var there: vec4<f32>;
var marched: f32;
var param_7: vec3<f32>;
var gap: f32;
var phi_482_: bool;
var phi_489_: bool;
var phi_496_: bool;
let _e73 = v_uv_1;
let _e74 = textureSample(surface_texture_tex, surface_texture_smp, _e73);
surface = _e74;
let _e76 = surface[3u];
if (_e76 <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e78 = surface;
param = _e78.xy;
let _e80 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e80;
let _e82 = contact_info.to_light;
toLight = normalize(_e82.xyz);
let _e85 = normal;
let _e86 = toLight;
if (dot(_e85, _e86) <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e91 = contact_info.params[0u];
reach = max(_e91, 0.0001f);
let _e95 = contact_info.params[1u];
steps = clamp(i32((_e95 + 0.5f)), 1i, 16i);
let _e101 = contact_info.params[2u];
thickness = max(_e101, 0.0001f);
let _e103 = v_uv_1;
param_1 = _e103;
let _e105 = surface[3u];
param_2 = _e105;
let _e106 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_1), (¶m_2));
let _e107 = normal;
let _e110 = contact_info.params[3u];
origin_1 = (_e106 + (_e107 * _e110));
let _e113 = reach;
let _e114 = steps;
stride = (_e113 / f32(_e114));
let _e117 = gl_FragCoord_1;
param_3 = _e117.xy;
let _e119 = BayerCell_u0028_vf2_u003b((¶m_3));
jitter = _e119;
let _e120 = origin_1;
let _e121 = toLight;
let _e122 = stride;
param_4 = (_e120 + (_e121 * _e122));
let _e125 = DepthOf_u0028_vf3_u003b((¶m_4));
let _e126 = origin_1;
param_5 = _e126;
let _e127 = DepthOf_u0028_vf3_u003b((¶m_5));
stepDepth = abs((_e125 - _e127));
let _e130 = thickness;
let _e131 = stepDepth;
tolerance = max(_e130, (2f * _e131));
i = 0i;
loop {
let _e134 = i;
if (_e134 < 16i) {
let _e136 = i;
let _e137 = steps;
if (_e136 >= _e137) {
break;
}
let _e139 = i;
let _e142 = jitter;
along_1 = ((f32(_e139) + 1f) - _e142);
let _e144 = origin_1;
let _e145 = toLight;
let _e146 = stride;
let _e147 = along_1;
at_2 = (_e144 + (_e145 * (_e146 * _e147)));
let _e152 = contact_info.view_projection;
let _e153 = at_2;
clip = (_e152 * vec4<f32>(_e153.x, _e153.y, _e153.z, 1f));
let _e160 = clip[3u];
if (_e160 <= 0f) {
break;
}
let _e162 = clip;
let _e165 = clip[3u];
param_6 = (_e162.xy / vec2(_e165));
let _e168 = UvFromNdc_u0028_vf2_u003b((¶m_6));
uv_1 = _e168;
let _e170 = uv_1[0u];
let _e171 = (_e170 < 0f);
phi_482_ = _e171;
if !(_e171) {
let _e174 = uv_1[0u];
phi_482_ = (_e174 > 1f);
}
let _e177 = phi_482_;
phi_489_ = _e177;
if !(_e177) {
let _e180 = uv_1[1u];
phi_489_ = (_e180 < 0f);
}
let _e183 = phi_489_;
phi_496_ = _e183;
if !(_e183) {
let _e186 = uv_1[1u];
phi_496_ = (_e186 > 1f);
}
let _e189 = phi_496_;
if _e189 {
break;
}
let _e190 = uv_1;
let _e191 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e190, 0f);
there = _e191;
let _e193 = there[3u];
if (_e193 <= 0f) {
continue;
}
let _e195 = at_2;
param_7 = _e195;
let _e196 = DepthOf_u0028_vf3_u003b((¶m_7));
marched = _e196;
let _e197 = marched;
let _e199 = there[3u];
gap = (_e197 - _e199);
let _e201 = gap;
let _e203 = gap;
let _e204 = tolerance;
if ((_e201 > 0f) && (_e203 < _e204)) {
let _e207 = along_1;
let _e210 = steps;
frag_color = vec4((max((_e207 - 1f), 0f) / f32(_e210)));
return;
}
continue;
} else {
break;
}
continuing {
let _e214 = i;
i = (_e214 + 1i);
}
}
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ContactShadowInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'to_light',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'LightShafts': WebGpuStage(
wgsl: r'''
struct ShaftInfo {
inverse_view_projection: mat4x4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
scatter: vec4<f32>,
cascades: vec4<f32>,
sun: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> shaft_info: ShaftInfo;
@group(1) @binding(3)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var shadow_texture_smp: sampler;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
fn HenyeyGreenstein_u0028_f1_u003b_f1_u003b(cosine: ptr<function, f32>, g: ptr<function, f32>) -> f32 {
var g2_: f32;
var denominator: f32;
let _e55 = (*g);
let _e56 = (*g);
g2_ = (_e55 * _e56);
let _e58 = g2_;
let _e60 = (*g);
let _e62 = (*cosine);
denominator = max(((1f + _e58) - ((2f * _e60) * _e62)), 0.0001f);
let _e66 = g2_;
let _e68 = denominator;
let _e70 = denominator;
return ((1f - _e66) / ((12.566371f * _e68) * sqrt(_e70)));
}
fn LitAt_u0028_vf3_u003b_f1_u003b(world: ptr<function, vec3<f32>>, viewDistance: ptr<function, f32>) -> f32 {
var cascadeCount: i32;
var cascade: i32;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local: mat4x4<f32>;
var local_1: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var uv: vec2<f32>;
var stored: f32;
var phi_206_: bool;
var phi_217_: bool;
var phi_303_: bool;
var phi_310_: bool;
var phi_317_: bool;
let _e67 = shaft_info.cascades[2u];
cascadeCount = i32((_e67 + 0.5f));
cascade = 0i;
let _e70 = cascadeCount;
let _e71 = (_e70 > 1i);
phi_206_ = _e71;
if _e71 {
let _e72 = (*viewDistance);
let _e75 = shaft_info.cascades[0u];
phi_206_ = (_e72 > _e75);
}
let _e78 = phi_206_;
if _e78 {
cascade = 1i;
}
let _e79 = cascadeCount;
let _e80 = (_e79 > 2i);
phi_217_ = _e80;
if _e80 {
let _e81 = (*viewDistance);
let _e84 = shaft_info.cascades[1u];
phi_217_ = (_e81 > _e84);
}
let _e87 = phi_217_;
if _e87 {
cascade = 2i;
}
attempt = 0i;
loop {
let _e88 = attempt;
if (_e88 < 3i) {
let _e90 = cascade;
let _e91 = attempt;
which = (_e90 + _e91);
let _e93 = which;
let _e94 = cascadeCount;
if (_e93 >= _e94) {
break;
}
let _e96 = which;
if (_e96 == 0i) {
let _e99 = shaft_info.shadow_matrix;
local = _e99;
} else {
let _e100 = which;
if (_e100 == 1i) {
let _e103 = shaft_info.shadow_matrix_far;
local_1 = _e103;
} else {
let _e105 = shaft_info.shadow_matrix_farthest;
local_1 = _e105;
}
let _e106 = local_1;
local = _e106;
}
let _e107 = local;
matrix = _e107;
let _e108 = matrix;
let _e109 = (*world);
lightSpace = (_e108 * vec4<f32>(_e109.x, _e109.y, _e109.z, 1f));
let _e116 = lightSpace[3u];
if (_e116 <= 0f) {
continue;
}
let _e118 = lightSpace;
let _e121 = lightSpace[3u];
candidate = (_e118.xyz / vec3(_e121));
let _e125 = candidate[0u];
let _e129 = candidate[1u];
inTile = vec2<f32>(((_e125 * 0.5f) + 0.5f), (0.5f - (_e129 * 0.5f)));
let _e134 = inTile[0u];
let _e135 = (_e134 < 0f);
phi_303_ = _e135;
if !(_e135) {
let _e138 = inTile[0u];
phi_303_ = (_e138 > 1f);
}
let _e141 = phi_303_;
phi_310_ = _e141;
if !(_e141) {
let _e144 = inTile[1u];
phi_310_ = (_e144 < 0f);
}
let _e147 = phi_310_;
phi_317_ = _e147;
if !(_e147) {
let _e150 = inTile[1u];
phi_317_ = (_e150 > 1f);
}
let _e153 = phi_317_;
if _e153 {
continue;
}
let _e155 = candidate[2u];
if (_e155 > 1f) {
let _e157 = which;
let _e158 = cascadeCount;
if (_e157 < (_e158 - 1i)) {
continue;
}
candidate[2u] = 1f;
}
let _e163 = inTile[0u];
let _e164 = which;
let _e167 = cascadeCount;
let _e171 = inTile[1u];
uv = vec2<f32>(((_e163 + f32(_e164)) / f32(_e167)), _e171);
let _e173 = uv;
let _e174 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e173, 0f);
stored = _e174.x;
let _e177 = candidate[2u];
let _e180 = shaft_info.cascades[3u];
let _e182 = stored;
return select(1f, 0f, ((_e177 - _e180) > _e182));
} else {
break;
}
continuing {
let _e185 = attempt;
attempt = (_e185 + 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 _e57 = (*at)[0u];
x = i32((_e57 - (floor((_e57 / 4f)) * 4f)));
let _e64 = (*at)[1u];
y = i32((_e64 - (floor((_e64 / 4f)) * 4f)));
let _e70 = y;
let _e72 = x;
index = ((_e70 * 4i) + _e72);
value = 0f;
let _e74 = index;
if (_e74 == 0i) {
value = 0f;
} else {
let _e76 = index;
if (_e76 == 1i) {
value = 8f;
} else {
let _e78 = index;
if (_e78 == 2i) {
value = 2f;
} else {
let _e80 = index;
if (_e80 == 3i) {
value = 10f;
} else {
let _e82 = index;
if (_e82 == 4i) {
value = 12f;
} else {
let _e84 = index;
if (_e84 == 5i) {
value = 4f;
} else {
let _e86 = index;
if (_e86 == 6i) {
value = 14f;
} else {
let _e88 = index;
if (_e88 == 7i) {
value = 6f;
} else {
let _e90 = index;
if (_e90 == 8i) {
value = 3f;
} else {
let _e92 = index;
if (_e92 == 9i) {
value = 11f;
} else {
let _e94 = index;
if (_e94 == 10i) {
value = 1f;
} else {
let _e96 = index;
if (_e96 == 11i) {
value = 9f;
} else {
let _e98 = index;
if (_e98 == 12i) {
value = 15f;
} else {
let _e100 = index;
if (_e100 == 13i) {
value = 7f;
} else {
let _e102 = index;
if (_e102 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e104 = value;
return (_e104 / 16f);
}
fn main_1() {
var scene: vec4<f32>;
var steps: i32;
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var surfaceDepth: f32;
var cosine_1: f32;
var toSurface: f32;
var local_2: f32;
var distance_: f32;
var stride: f32;
var offset: f32;
var param: 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_1: vec3<f32>;
var lit: f32;
var param_1: vec3<f32>;
var param_2: f32;
var phase: f32;
var param_3: f32;
var param_4: f32;
var shaft: vec3<f32>;
let _e81 = v_uv_1;
let _e82 = textureSample(scene_texture_tex, scene_texture_smp, _e81);
scene = _e82;
let _e85 = shaft_info.forward[3u];
steps = i32((_e85 + 0.5f));
let _e88 = steps;
if (_e88 < 1i) {
let _e90 = scene;
frag_color = _e90;
return;
}
let _e92 = v_uv_1[0u];
let _e96 = v_uv_1[1u];
xy = vec2<f32>(((_e92 * 2f) - 1f), (1f - (_e96 * 2f)));
let _e101 = shaft_info.inverse_view_projection;
let _e102 = xy;
nearH = (_e101 * vec4<f32>(_e102.x, _e102.y, 0f, 1f));
let _e108 = shaft_info.inverse_view_projection;
let _e109 = xy;
farH = (_e108 * vec4<f32>(_e109.x, _e109.y, 1f, 1f));
let _e114 = nearH;
let _e117 = nearH[3u];
origin = (_e114.xyz / vec3(_e117));
let _e120 = farH;
let _e123 = farH[3u];
let _e126 = origin;
along = normalize(((_e120.xyz / vec3(_e123)) - _e126));
let _e129 = v_uv_1;
let _e130 = textureSample(surface_texture_tex, surface_texture_smp, _e129);
surfaceDepth = _e130.w;
let _e132 = along;
let _e134 = shaft_info.forward;
cosine_1 = max(dot(_e132, _e134.xyz), 0.0001f);
let _e138 = surfaceDepth;
if (_e138 > 0f) {
let _e140 = surfaceDepth;
let _e141 = cosine_1;
local_2 = (_e140 / _e141);
} else {
local_2 = 1000000000f;
}
let _e143 = local_2;
toSurface = _e143;
let _e146 = shaft_info.camera[3u];
let _e147 = toSurface;
distance_ = min(_e146, _e147);
let _e149 = distance_;
if (_e149 <= 0f) {
let _e151 = scene;
frag_color = _e151;
return;
}
let _e152 = distance_;
let _e153 = steps;
stride = (_e152 / f32(_e153));
let _e156 = gl_FragCoord_1;
param = _e156.xy;
let _e158 = BayerCell_u0028_vf2_u003b((¶m));
let _e159 = stride;
offset = (_e158 * _e159);
let _e163 = shaft_info.scatter[3u];
sigma = max(_e163, 0f);
let _e165 = sigma;
let _e167 = stride;
stepTransmittance = exp((-(_e165) * _e167));
let _e170 = sigma;
let _e172 = offset;
transmittance = exp((-(_e170) * _e172));
let _e176 = shaft_info.camera;
eye = _e176.xyz;
inscatter = 0f;
i = 0i;
loop {
let _e178 = i;
if (_e178 < 64i) {
let _e180 = i;
let _e181 = steps;
if (_e180 >= _e181) {
break;
}
let _e183 = offset;
let _e184 = i;
let _e186 = stride;
travelled = (_e183 + (f32(_e184) * _e186));
let _e189 = origin;
let _e190 = along;
let _e191 = travelled;
at_1 = (_e189 + (_e190 * _e191));
let _e194 = at_1;
let _e195 = eye;
let _e198 = at_1;
param_1 = _e198;
param_2 = length((_e194 - _e195));
let _e199 = LitAt_u0028_vf3_u003b_f1_u003b((¶m_1), (¶m_2));
lit = _e199;
let _e200 = transmittance;
let _e201 = stepTransmittance;
let _e204 = lit;
let _e206 = inscatter;
inscatter = (_e206 + ((_e200 * (1f - _e201)) * _e204));
let _e208 = stepTransmittance;
let _e209 = transmittance;
transmittance = (_e209 * _e208);
continue;
} else {
break;
}
continuing {
let _e211 = i;
i = (_e211 + 1i);
}
}
let _e213 = along;
let _e215 = shaft_info.sun;
param_3 = dot(_e213, _e215.xyz);
let _e220 = shaft_info.sun[3u];
param_4 = _e220;
let _e221 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((¶m_3), (¶m_4));
phase = _e221;
let _e223 = shaft_info.scatter;
let _e225 = phase;
let _e226 = inscatter;
shaft = (_e223.xyz * (_e225 * _e226));
let _e229 = scene;
let _e231 = shaft;
let _e232 = (_e229.xyz + _e231);
let _e234 = scene[3u];
frag_color = vec4<f32>(_e232.x, _e232.y, _e232.z, _e234);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShaftInfo',
group: 1,
binding: 0,
sizeInBytes: 336,
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),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'DepthOfField': WebGpuStage(
wgsl: r'''
struct DofInfo {
lens: vec4<f32>,
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> dof_info: DofInfo;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> gl_FragCoord_1: 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 _e58 = (*at)[0u];
x = i32((_e58 - (floor((_e58 / 4f)) * 4f)));
let _e65 = (*at)[1u];
y = i32((_e65 - (floor((_e65 / 4f)) * 4f)));
let _e71 = y;
let _e73 = x;
index = ((_e71 * 4i) + _e73);
value = 0f;
let _e75 = index;
if (_e75 == 0i) {
value = 0f;
} else {
let _e77 = index;
if (_e77 == 1i) {
value = 8f;
} else {
let _e79 = index;
if (_e79 == 2i) {
value = 2f;
} else {
let _e81 = index;
if (_e81 == 3i) {
value = 10f;
} else {
let _e83 = index;
if (_e83 == 4i) {
value = 12f;
} else {
let _e85 = index;
if (_e85 == 5i) {
value = 4f;
} else {
let _e87 = index;
if (_e87 == 6i) {
value = 14f;
} else {
let _e89 = index;
if (_e89 == 7i) {
value = 6f;
} else {
let _e91 = index;
if (_e91 == 8i) {
value = 3f;
} else {
let _e93 = index;
if (_e93 == 9i) {
value = 11f;
} else {
let _e95 = index;
if (_e95 == 10i) {
value = 1f;
} else {
let _e97 = index;
if (_e97 == 11i) {
value = 9f;
} else {
let _e99 = index;
if (_e99 == 12i) {
value = 15f;
} else {
let _e101 = index;
if (_e101 == 13i) {
value = 7f;
} else {
let _e103 = index;
if (_e103 == 14i) {
value = 13f;
} else {
value = 5f;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
let _e105 = value;
return (_e105 / 16f);
}
fn CircleAt_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {
var focus: f32;
var focal: f32;
var fnumber: f32;
var denominator: f32;
var ratio: f32;
var local: f32;
var diameter: f32;
let _e62 = dof_info.lens[0u];
focus = max(_e62, 0.001f);
let _e66 = dof_info.lens[1u];
focal = max(_e66, 0.0001f);
let _e70 = dof_info.lens[2u];
fnumber = max(_e70, 0.001f);
let _e72 = fnumber;
let _e73 = focus;
let _e74 = focal;
denominator = max((_e72 * (_e73 - _e74)), 0.000001f);
let _e78 = (*depth);
if (_e78 <= 0f) {
local = 1f;
} else {
let _e80 = (*depth);
let _e81 = focus;
let _e84 = (*depth);
local = (abs((_e80 - _e81)) / _e84);
}
let _e86 = local;
ratio = _e86;
let _e87 = ratio;
let _e88 = focal;
let _e89 = focal;
let _e92 = denominator;
diameter = ((_e87 * (_e88 * _e89)) / _e92);
let _e94 = diameter;
let _e98 = dof_info.params[3u];
let _e102 = dof_info.params[2u];
return min(((_e94 * 0.5f) * _e98), max(_e102, 0f));
}
fn main_1() {
var centre: vec4<f32>;
var samples: i32;
var centreDepth: f32;
var radius: f32;
var param: f32;
var total: vec3<f32>;
var weight: f32;
var centreFar: f32;
var turn: f32;
var param_1: 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_2: f32;
var tapFar: f32;
var tapReach: f32;
var local_1: f32;
var reach: f32;
let _e75 = v_uv_1;
let _e76 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e75, 0f);
centre = _e76;
let _e79 = dof_info.lens[3u];
samples = i32((_e79 + 0.5f));
let _e82 = samples;
if (_e82 < 1i) {
let _e84 = centre;
frag_color = _e84;
return;
}
let _e85 = v_uv_1;
let _e86 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e85, 0f);
centreDepth = _e86.w;
let _e88 = centreDepth;
param = _e88;
let _e89 = CircleAt_u0028_f1_u003b((¶m));
radius = _e89;
let _e90 = radius;
if (_e90 < 0.5f) {
let _e92 = centre;
frag_color = _e92;
return;
}
let _e93 = centre;
total = _e93.xyz;
weight = 1f;
let _e95 = centreDepth;
let _e97 = centreDepth;
centreFar = select(_e97, 1000000000f, (_e95 <= 0f));
let _e99 = gl_FragCoord_1;
param_1 = _e99.xy;
let _e101 = BayerCell_u0028_vf2_u003b((¶m_1));
turn = (6.2831855f * _e101);
i = 1i;
loop {
let _e103 = i;
if (_e103 <= 64i) {
let _e105 = i;
let _e106 = samples;
if (_e105 > _e106) {
break;
}
let _e108 = i;
let _e111 = samples;
t = ((f32(_e108) - 0.5f) / f32(_e111));
let _e114 = t;
let _e116 = radius;
r = (sqrt(_e114) * _e116);
let _e118 = i;
let _e121 = turn;
angle = ((f32(_e118) * 2.3999631f) + _e121);
let _e123 = v_uv_1;
let _e124 = angle;
let _e126 = angle;
let _e129 = r;
let _e132 = dof_info.params;
at_1 = (_e123 + ((vec2<f32>(cos(_e124), sin(_e126)) * _e129) * _e132.xy));
let _e136 = at_1;
let _e137 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e136, 0f);
tap = _e137;
let _e138 = at_1;
let _e139 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e138, 0f);
tapDepth = _e139.w;
let _e141 = tapDepth;
param_2 = _e141;
let _e142 = CircleAt_u0028_f1_u003b((¶m_2));
tapRadius = _e142;
let _e143 = tapDepth;
let _e145 = tapDepth;
tapFar = select(_e145, 1000000000f, (_e143 <= 0f));
let _e147 = tapFar;
let _e148 = centreFar;
if (_e147 > _e148) {
let _e150 = tapRadius;
let _e151 = radius;
local_1 = min(_e150, _e151);
} else {
let _e153 = tapRadius;
local_1 = _e153;
}
let _e154 = local_1;
tapReach = _e154;
let _e155 = tapReach;
let _e156 = r;
reach = clamp(((_e155 - _e156) + 0.5f), 0f, 1f);
let _e160 = tap;
let _e162 = reach;
let _e164 = total;
total = (_e164 + (_e160.xyz * _e162));
let _e166 = reach;
let _e167 = weight;
weight = (_e167 + _e166);
continue;
} else {
break;
}
continuing {
let _e169 = i;
i = (_e169 + 1i);
}
}
let _e171 = total;
let _e172 = weight;
let _e174 = (_e171 / vec3(_e172));
let _e176 = centre[3u];
frag_color = vec4<f32>(_e174.x, _e174.y, _e174.z, _e176);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
gl_FragCoord_1 = gl_FragCoord;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'DofInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'lens', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 16,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ViewportShade': WebGpuStage(
wgsl: r'''
struct ShadeInfo {
params: vec4<f32>,
screen: vec4<f32>,
light: vec4<f32>,
}
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> shade_info: ShadeInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e27 = (*e);
(*e) = ((_e27 * 2f) - vec2(1f));
let _e31 = (*e);
let _e33 = (*e)[0u];
let _e37 = (*e)[1u];
n = vec3<f32>(_e31.x, _e31.y, ((1f - abs(_e33)) - abs(_e37)));
let _e44 = n[2u];
t = max(-(_e44), 0f);
let _e48 = n[0u];
if (_e48 >= 0f) {
let _e50 = t;
local = -(_e50);
} else {
let _e52 = t;
local = _e52;
}
let _e53 = local;
let _e55 = n[0u];
n[0u] = (_e55 + _e53);
let _e59 = n[1u];
if (_e59 >= 0f) {
let _e61 = t;
local_1 = -(_e61);
} else {
let _e63 = t;
local_1 = _e63;
}
let _e64 = local_1;
let _e66 = n[1u];
n[1u] = (_e66 + _e64);
let _e69 = n;
return normalize(_e69);
}
fn main_1() {
var scene: vec4<f32>;
var mode: i32;
var mix_amount: f32;
var surface: vec4<f32>;
var depth: f32;
var normal: vec3<f32>;
var param: vec2<f32>;
var shaded: vec3<f32>;
var ambient: f32;
var lambert: f32;
var texel: vec2<f32>;
var depthEdge: f32;
var normalEdge: f32;
var offsets: array<vec2<f32>, 4>;
var i: i32;
var tap: vec4<f32>;
var param_1: vec2<f32>;
var depthHit: f32;
var normalHit: f32;
var edge: f32;
var texel_1: vec2<f32>;
var right: vec3<f32>;
var param_2: vec2<f32>;
var left: vec3<f32>;
var param_3: vec2<f32>;
var down: vec3<f32>;
var param_4: vec2<f32>;
var up: vec3<f32>;
var param_5: vec2<f32>;
var curvature: f32;
var cavity: f32;
var ridge: f32;
let _e54 = v_uv_1;
let _e55 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e54, 0f);
scene = _e55;
let _e58 = shade_info.params[0u];
mode = i32((_e58 + 0.5f));
let _e63 = shade_info.params[1u];
mix_amount = clamp(_e63, 0f, 1f);
let _e65 = mode;
let _e67 = mix_amount;
if ((_e65 < 1i) || (_e67 <= 0f)) {
let _e70 = scene;
frag_color = _e70;
return;
}
let _e71 = v_uv_1;
let _e72 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e71, 0f);
surface = _e72;
let _e74 = surface[3u];
depth = _e74;
let _e75 = depth;
if (_e75 <= 0f) {
let _e77 = scene;
frag_color = _e77;
return;
}
let _e78 = surface;
param = _e78.xy;
let _e80 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e80;
let _e81 = scene;
shaded = _e81.xyz;
let _e83 = mode;
if (_e83 == 1i) {
let _e85 = normal;
shaded = ((_e85 * 0.5f) + vec3(0.5f));
} else {
let _e89 = mode;
if (_e89 == 2i) {
let _e93 = shade_info.params[2u];
ambient = clamp(_e93, 0f, 1f);
let _e95 = normal;
let _e97 = shade_info.light;
lambert = max(dot(_e95, normalize(_e97.xyz)), 0f);
let _e102 = ambient;
let _e103 = ambient;
let _e105 = lambert;
shaded = vec3((_e102 + ((1f - _e103) * _e105)));
} else {
let _e109 = mode;
if (_e109 == 3i) {
let _e112 = shade_info.screen;
let _e116 = shade_info.screen[2u];
texel = (_e112.xy * max(_e116, 1f));
depthEdge = 0f;
normalEdge = 0f;
let _e120 = texel[0u];
let _e123 = texel[0u];
let _e127 = texel[1u];
let _e130 = texel[1u];
offsets = array<vec2<f32>, 4>(vec2<f32>(_e120, 0f), vec2<f32>(-(_e123), 0f), vec2<f32>(0f, _e127), vec2<f32>(0f, -(_e130)));
i = 0i;
loop {
let _e134 = i;
if (_e134 < 4i) {
let _e136 = v_uv_1;
let _e137 = i;
let _e139 = offsets[_e137];
let _e141 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e136 + _e139), 0f);
tap = _e141;
let _e143 = tap[3u];
if (_e143 <= 0f) {
depthEdge = 1f;
continue;
}
let _e145 = depthEdge;
let _e147 = tap[3u];
let _e148 = depth;
depthEdge = max(_e145, abs((_e147 - _e148)));
let _e152 = normalEdge;
let _e153 = tap;
param_1 = _e153.xy;
let _e155 = DecodeOctahedral_u0028_vf2_u003b((¶m_1));
let _e156 = normal;
normalEdge = max(_e152, (1f - dot(_e155, _e156)));
continue;
} else {
break;
}
continuing {
let _e160 = i;
i = (_e160 + 1i);
}
}
let _e164 = shade_info.params[2u];
let _e166 = depthEdge;
depthHit = step(max(_e164, 0.0001f), _e166);
let _e170 = shade_info.params[3u];
let _e172 = normalEdge;
normalHit = step(max(_e170, 0.0001f), _e172);
let _e174 = depthHit;
let _e175 = normalHit;
edge = max(_e174, _e175);
let _e177 = scene;
let _e179 = edge;
shaded = (_e177.xyz * (1f - _e179));
} else {
let _e182 = mode;
if (_e182 == 4i) {
let _e185 = shade_info.screen;
texel_1 = _e185.xy;
let _e187 = v_uv_1;
let _e189 = texel_1[0u];
let _e192 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e187 + vec2<f32>(_e189, 0f)), 0f);
param_2 = _e192.xy;
let _e194 = DecodeOctahedral_u0028_vf2_u003b((¶m_2));
right = _e194;
let _e195 = v_uv_1;
let _e197 = texel_1[0u];
let _e200 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e195 - vec2<f32>(_e197, 0f)), 0f);
param_3 = _e200.xy;
let _e202 = DecodeOctahedral_u0028_vf2_u003b((¶m_3));
left = _e202;
let _e203 = v_uv_1;
let _e205 = texel_1[1u];
let _e208 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e203 + vec2<f32>(0f, _e205)), 0f);
param_4 = _e208.xy;
let _e210 = DecodeOctahedral_u0028_vf2_u003b((¶m_4));
down = _e210;
let _e211 = v_uv_1;
let _e213 = texel_1[1u];
let _e216 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e211 - vec2<f32>(0f, _e213)), 0f);
param_5 = _e216.xy;
let _e218 = DecodeOctahedral_u0028_vf2_u003b((¶m_5));
up = _e218;
let _e220 = right[0u];
let _e222 = left[0u];
let _e225 = down[1u];
let _e227 = up[1u];
let _e232 = shade_info.params[2u];
curvature = (((_e220 - _e222) + (_e225 - _e227)) * max(_e232, 0f));
let _e235 = curvature;
let _e240 = shade_info.params[3u];
cavity = (clamp(-(_e235), 0f, 1f) * clamp(_e240, 0f, 1f));
let _e243 = curvature;
ridge = clamp(_e243, 0f, 1f);
let _e245 = ridge;
let _e248 = cavity;
shaded = vec3(clamp(((0.5f + (_e245 * 0.5f)) - _e248), 0f, 1f));
}
}
}
}
let _e252 = scene;
let _e254 = shaded;
let _e255 = mix_amount;
let _e257 = mix(_e252.xyz, _e254, vec3(_e255));
let _e259 = scene[3u];
frag_color = vec4<f32>(_e257.x, _e257.y, _e257.z, _e259);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShadeInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 16,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'light',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ProbePrefilter': WebGpuStage(
wgsl: r'''
struct ProbeInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var capture_texture_tex: texture_cube<f32>;
@group(1) @binding(2)
var capture_texture_smp: sampler;
fn FaceDirection_u0028_i1_u003b_vf2_u003b(face: ptr<function, i32>, st: ptr<function, vec2<f32>>) -> vec3<f32> {
var u: f32;
var v: f32;
let _e31 = (*st)[0u];
u = ((_e31 * 2f) - 1f);
let _e35 = (*st)[1u];
v = ((_e35 * 2f) - 1f);
let _e38 = (*face);
if (_e38 == 0i) {
let _e40 = v;
let _e42 = u;
return normalize(vec3<f32>(1f, -(_e40), -(_e42)));
}
let _e46 = (*face);
if (_e46 == 1i) {
let _e48 = v;
let _e50 = u;
return normalize(vec3<f32>(-1f, -(_e48), _e50));
}
let _e53 = (*face);
if (_e53 == 2i) {
let _e55 = u;
let _e56 = v;
return normalize(vec3<f32>(_e55, 1f, _e56));
}
let _e59 = (*face);
if (_e59 == 3i) {
let _e61 = u;
let _e62 = v;
return normalize(vec3<f32>(_e61, -1f, -(_e62)));
}
let _e66 = (*face);
if (_e66 == 4i) {
let _e68 = u;
let _e69 = v;
return normalize(vec3<f32>(_e68, -(_e69), 1f));
}
let _e73 = u;
let _e75 = v;
return normalize(vec3<f32>(-(_e73), -(_e75), -1f));
}
fn main_1() {
var face_1: i32;
var roughness: f32;
var lod: f32;
var samples: i32;
var axis: vec3<f32>;
var param: i32;
var param_1: vec2<f32>;
var alpha: f32;
var power: f32;
var up: vec3<f32>;
var right: vec3<f32>;
var ahead: vec3<f32>;
var sum: vec3<f32>;
var weight: f32;
var i: i32;
var z: f32;
var radius: f32;
var theta: f32;
var spread: f32;
var tap: vec3<f32>;
var dir: vec3<f32>;
var cosine: f32;
var local: vec3<f32>;
let _e51 = probe_info.params[0u];
face_1 = i32((_e51 + 0.5f));
let _e56 = probe_info.params[1u];
roughness = _e56;
let _e59 = probe_info.params[2u];
lod = _e59;
let _e62 = probe_info.params[3u];
samples = clamp(i32((_e62 + 0.5f)), 1i, 128i);
let _e66 = face_1;
param = _e66;
let _e67 = v_uv_1;
param_1 = _e67;
let _e68 = FaceDirection_u0028_i1_u003b_vf2_u003b((¶m), (¶m_1));
axis = _e68;
let _e69 = samples;
if (_e69 == 1i) {
let _e71 = axis;
let _e72 = lod;
let _e73 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e71, _e72);
let _e74 = _e73.xyz;
frag_color = vec4<f32>(_e74.x, _e74.y, _e74.z, 1f);
return;
}
let _e79 = roughness;
let _e80 = roughness;
alpha = max((_e79 * _e80), 0.001f);
let _e83 = alpha;
let _e84 = alpha;
power = ((2f / (_e83 * _e84)) - 2f);
let _e89 = axis[2u];
up = select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e89) < 0.999f)));
let _e94 = up;
let _e95 = axis;
right = normalize(cross(_e94, _e95));
let _e98 = axis;
let _e99 = right;
ahead = cross(_e98, _e99);
sum = vec3<f32>(0f, 0f, 0f);
weight = 0f;
i = 0i;
loop {
let _e101 = i;
if (_e101 < 128i) {
let _e103 = i;
let _e104 = samples;
if (_e103 >= _e104) {
break;
}
let _e106 = i;
let _e109 = samples;
z = (1f - ((f32(_e106) + 0.5f) / f32(_e109)));
let _e113 = z;
let _e114 = z;
radius = sqrt(max((1f - (_e113 * _e114)), 0f));
let _e119 = i;
theta = (2.3999631f * f32(_e119));
let _e122 = z;
let _e123 = power;
spread = pow(_e122, (1f / (_e123 + 1f)));
let _e127 = radius;
let _e128 = theta;
let _e131 = spread;
let _e134 = radius;
let _e135 = theta;
let _e138 = spread;
let _e141 = spread;
tap = normalize(vec3<f32>(((_e127 * cos(_e128)) * (1f - _e131)), ((_e134 * sin(_e135)) * (1f - _e138)), _e141));
let _e144 = right;
let _e146 = tap[0u];
let _e148 = ahead;
let _e150 = tap[1u];
let _e153 = axis;
let _e155 = tap[2u];
dir = (((_e144 * _e146) + (_e148 * _e150)) + (_e153 * _e155));
let _e158 = dir;
let _e159 = axis;
cosine = dot(_e158, _e159);
let _e161 = cosine;
if (_e161 <= 0f) {
continue;
}
let _e163 = dir;
let _e164 = lod;
let _e165 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e163, _e164);
let _e167 = cosine;
let _e169 = sum;
sum = (_e169 + (_e165.xyz * _e167));
let _e171 = cosine;
let _e172 = weight;
weight = (_e172 + _e171);
continue;
} else {
break;
}
continuing {
let _e174 = i;
i = (_e174 + 1i);
}
}
let _e176 = weight;
if (_e176 > 0f) {
let _e178 = sum;
let _e179 = weight;
local = (_e178 / vec3(_e179));
} else {
local = vec3<f32>(0f, 0f, 0f);
}
let _e182 = local;
frag_color = vec4<f32>(_e182.x, _e182.y, _e182.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ProbeInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'capture_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.cube,
),
],
),
'ShadowDistance': WebGpuStage(
wgsl: r'''
struct ShadowLight {
light: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(0)
var<uniform> shadow_light: ShadowLight;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var range: f32;
var distance_: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e22 = shadow_light.light[3u];
range = max(_e22, 0.0001f);
let _e24 = v_world_position_1;
let _e26 = shadow_light.light;
distance_ = length((_e24 - _e26.xyz));
let _e30 = distance_;
let _e31 = range;
frag_color = vec4<f32>(clamp((_e30 / _e31), 0f, 1f), 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ShadowLight',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'ShadowDepthMasked': WebGpuStage(
wgsl: r'''
struct MaskInfo {
mask: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> mask_info: MaskInfo;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var alpha: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e24 = v_texcoord_1;
let _e25 = textureSample(base_color_texture_tex, base_color_texture_smp, _e24);
let _e29 = mask_info.mask[1u];
alpha = (_e25.w * _e29);
let _e31 = alpha;
let _e34 = mask_info.mask[0u];
if (_e31 < _e34) {
discard;
}
let _e37 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e37, 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(4) v_texcoord: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
gl_FragCoord_1 = gl_FragCoord;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'MaskInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ShadowDistanceMasked': WebGpuStage(
wgsl: r'''
struct MaskInfo {
mask: vec4<f32>,
}
struct ShadowLight {
light: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> mask_info: MaskInfo;
@group(1) @binding(1)
var<uniform> shadow_light: ShadowLight;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var alpha: f32;
var range: f32;
var distance_: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e26 = v_texcoord_1;
let _e27 = textureSample(base_color_texture_tex, base_color_texture_smp, _e26);
let _e31 = mask_info.mask[1u];
alpha = (_e27.w * _e31);
let _e33 = alpha;
let _e36 = mask_info.mask[0u];
if (_e33 < _e36) {
discard;
}
let _e40 = shadow_light.light[3u];
range = max(_e40, 0.0001f);
let _e42 = v_world_position_1;
let _e44 = shadow_light.light;
distance_ = length((_e42 - _e44.xyz));
let _e48 = distance_;
let _e49 = range;
frag_color = vec4<f32>(clamp((_e48 / _e49), 0f, 1f), 0f, 0f, 1f);
return;
}
@fragment
fn main(@location(4) v_texcoord: vec2<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'MaskInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
],
),
WebGpuBlock(
name: 'ShadowLight',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ShadowTileReset': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_uv_1: vec2<f32>;
fn main_1() {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'Sky': WebGpuStage(
wgsl: r'''
var<private> v_ray_1: vec3<f32>;
var<private> v_zenith_1: vec4<f32>;
var<private> v_nadir_1: vec4<f32>;
var<private> v_horizon_1: vec4<f32>;
var<private> v_sun_1: vec4<f32>;
var<private> v_glow_1: vec4<f32>;
var<private> v_disc_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var direction: vec3<f32>;
var height: f32;
var far: vec3<f32>;
var local: vec3<f32>;
var t: f32;
var colour: vec3<f32>;
var towards: f32;
var disc: f32;
var local_1: f32;
let _e26 = v_ray_1;
direction = normalize(_e26);
let _e29 = direction[1u];
height = clamp(_e29, -1f, 1f);
let _e31 = height;
if (_e31 >= 0f) {
let _e33 = v_zenith_1;
local = _e33.xyz;
} else {
let _e35 = v_nadir_1;
local = _e35.xyz;
}
let _e37 = local;
far = _e37;
let _e38 = height;
t = abs(_e38);
let _e40 = t;
let _e41 = t;
let _e43 = t;
t = ((_e40 * _e41) * (3f - (2f * _e43)));
let _e47 = v_horizon_1;
let _e49 = far;
let _e50 = t;
colour = mix(_e47.xyz, _e49, vec3(_e50));
let _e53 = direction;
let _e54 = v_sun_1;
towards = dot(_e53, _e54.xyz);
let _e57 = towards;
if (_e57 > 0f) {
let _e59 = v_glow_1;
let _e62 = v_glow_1[3u];
let _e63 = towards;
let _e65 = v_sun_1[3u];
let _e69 = colour;
colour = (_e69 + (_e59.xyz * (_e62 * pow(_e63, _e65))));
}
let _e72 = v_disc_1[1u];
if (_e72 > 0f) {
let _e75 = v_disc_1[0u];
let _e77 = v_disc_1[1u];
let _e80 = v_disc_1[0u];
let _e81 = towards;
local_1 = smoothstep((_e75 - _e77), _e80, _e81);
} else {
let _e84 = v_disc_1[0u];
let _e85 = towards;
local_1 = step(_e84, _e85);
}
let _e87 = local_1;
disc = _e87;
let _e88 = v_glow_1;
let _e90 = disc;
let _e92 = v_disc_1[2u];
let _e95 = colour;
colour = (_e95 + (_e88.xyz * (_e90 * _e92)));
let _e97 = colour;
frag_color = vec4<f32>(_e97.x, _e97.y, _e97.z, 1f);
return;
}
@fragment
fn main(@location(4) v_ray: vec3<f32>, @location(7) v_zenith: vec4<f32>, @location(3) v_nadir: vec4<f32>, @location(2) v_horizon: vec4<f32>, @location(5) v_sun: vec4<f32>, @location(1) v_glow: vec4<f32>, @location(0) v_disc: vec4<f32>) -> @location(0) vec4<f32> {
v_ray_1 = v_ray;
v_zenith_1 = v_zenith;
v_nadir_1 = v_nadir;
v_horizon_1 = v_horizon;
v_sun_1 = v_sun;
v_glow_1 = v_glow;
v_disc_1 = v_disc;
main_1();
let _e15 = frag_color;
return _e15;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyCube': WebGpuStage(
wgsl: r'''
@group(1) @binding(0)
var sky_texture_tex: texture_cube<f32>;
@group(1) @binding(1)
var sky_texture_smp: sampler;
var<private> v_ray_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_tint_1: vec4<f32>;
fn main_1() {
var texel: vec3<f32>;
var linear: vec3<f32>;
let _e15 = v_ray_1;
let _e17 = textureSample(sky_texture_tex, sky_texture_smp, normalize(_e15));
texel = _e17.xyz;
let _e19 = texel;
let _e22 = texel;
let _e28 = texel;
linear = mix((_e19 / vec3(12.92f)), pow(((_e22 + vec3(0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e28));
let _e31 = linear;
let _e32 = v_tint_1;
let _e34 = (_e31 * _e32.xyz);
frag_color = vec4<f32>(_e34.x, _e34.y, _e34.z, 1f);
return;
}
@fragment
fn main(@location(4) v_ray: vec3<f32>, @location(6) v_tint: vec4<f32>) -> @location(0) vec4<f32> {
v_ray_1 = v_ray;
v_tint_1 = v_tint;
main_1();
let _e5 = frag_color;
return _e5;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'sky_texture',
group: 1,
textureBinding: 0,
samplerBinding: 1,
dimension: WebGpuTextureDimension.cube,
),
],
),
'Luminance': WebGpuStage(
wgsl: r'''
struct LuminanceInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> luminance_info: LuminanceInfo;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Luma_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e21 = (*color);
return dot(_e21, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var footprint: vec2<f32>;
var sum: f32;
var j: i32;
var i: i32;
var offset: vec2<f32>;
var param: vec3<f32>;
var mean: f32;
var stops: f32;
var encoded: f32;
let _e30 = luminance_info.params;
footprint = _e30.xy;
sum = 0f;
j = 0i;
loop {
let _e32 = j;
if (_e32 < 4i) {
i = 0i;
loop {
let _e34 = i;
if (_e34 < 4i) {
let _e36 = i;
let _e38 = j;
let _e47 = footprint;
offset = ((((vec2<f32>(f32(_e36), f32(_e38)) + vec2(0.5f)) / vec2(4f)) - vec2(0.5f)) * _e47);
let _e49 = v_uv_1;
let _e50 = offset;
let _e52 = textureSample(scene_texture_tex, scene_texture_smp, (_e49 + _e50));
param = _e52.xyz;
let _e54 = Luma_u0028_vf3_u003b((¶m));
let _e55 = sum;
sum = (_e55 + _e54);
continue;
} else {
break;
}
continuing {
let _e57 = i;
i = (_e57 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e59 = j;
j = (_e59 + 1i);
}
}
let _e61 = sum;
mean = (_e61 / 16f);
let _e63 = mean;
stops = log2(max(_e63, 0.000001f));
let _e66 = stops;
let _e69 = luminance_info.params[2u];
let _e73 = luminance_info.params[3u];
encoded = clamp(((_e66 - _e69) * _e73), 0f, 1f);
let _e76 = encoded;
frag_color = vec4<f32>(_e76, _e76, _e76, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'LuminanceInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'ObjectId': WebGpuStage(
wgsl: r'''
struct IdInfo {
id: vec4<f32>,
mask: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(0)
var<uniform> id_info: IdInfo;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn main_1() {
var cutoff: f32;
var alpha: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e26 = id_info.mask[0u];
cutoff = _e26;
let _e27 = cutoff;
if (_e27 >= 0f) {
let _e29 = v_texcoord_1;
let _e30 = textureSample(base_color_texture_tex, base_color_texture_smp, _e29);
let _e34 = id_info.mask[1u];
let _e37 = v_color_1[3u];
alpha = ((_e30.w * _e34) * _e37);
let _e39 = alpha;
let _e40 = cutoff;
if (_e39 < _e40) {
discard;
}
}
let _e43 = id_info.id;
let _e44 = _e43.xyz;
frag_color = vec4<f32>(_e44.x, _e44.y, _e44.z, 1f);
return;
}
@fragment
fn main(@location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'IdInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'id', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'mask', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'VertexTextureProbe': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_sampled_1: vec4<f32>;
fn main_1() {
let _e2 = v_sampled_1;
frag_color = _e2;
return;
}
@fragment
fn main(@location(0) v_sampled: vec4<f32>) -> @location(0) vec4<f32> {
v_sampled_1 = v_sampled;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
},
);