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,
),
],
),
'ParticleVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct ParticleInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@location(5) member_1: vec2<f32>,
@location(6) member_2: vec3<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_world_position: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_info: ParticleInfo;
fn main_1() {
let _e11 = color_1;
v_color = _e11;
let _e12 = texcoord_1;
v_uv = _e12;
let _e13 = position_1;
v_world_position = _e13;
let _e15 = particle_info.view_projection;
let _e16 = position_1;
unnamed.gl_Position = (_e15 * vec4<f32>(_e16.x, _e16.y, _e16.z, 1f));
return;
}
@vertex
fn main(@location(1) color: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
color_1 = color;
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e11 = v_color;
let _e12 = v_uv;
let _e13 = v_world_position;
let _e14 = unnamed.gl_Position;
return VertexOutput(_e11, _e12, _e13, _e14);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'color',
location: 1,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'texcoord',
location: 2,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ParticleInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ParticleMeshVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct ParticleMeshInfo {
view_projection: mat4x4<f32>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@location(6) member_1: vec3<f32>,
@location(2) member_2: vec3<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> i_position_1: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> i_scale_1: f32;
var<private> v_color: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_mesh_info: ParticleMeshInfo;
fn main_1() {
var world: vec3<f32>;
let _e14 = i_position_1;
let _e15 = position_1;
let _e16 = i_scale_1;
world = (_e14 + (_e15 * _e16));
let _e19 = i_color_1;
v_color = _e19;
let _e20 = world;
v_world_position = _e20;
let _e21 = normal_1;
v_normal = _e21;
let _e23 = particle_mesh_info.view_projection;
let _e24 = world;
unnamed.gl_Position = (_e23 * vec4<f32>(_e24.x, _e24.y, _e24.z, 1f));
return;
}
@vertex
fn main(@location(2) i_position: vec3<f32>, @location(0) position: vec3<f32>, @location(4) i_scale: f32, @location(3) i_color: vec4<f32>, @location(1) normal: vec3<f32>) -> VertexOutput {
i_position_1 = i_position;
position_1 = position;
i_scale_1 = i_scale;
i_color_1 = i_color;
normal_1 = normal;
main_1();
let _e15 = v_color;
let _e16 = v_world_position;
let _e17 = v_normal;
let _e18 = unnamed.gl_Position;
return VertexOutput(_e15, _e16, _e17, _e18);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'normal',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_position',
location: 2,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'i_color',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'i_scale',
location: 4,
format: VertexFormat.float32,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ParticleMeshInfo',
group: 0,
binding: 0,
sizeInBytes: 64,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'ShadowTileResetVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(5) member: vec2<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e7 = texcoord_1;
v_uv = _e7;
let _e8 = position_1;
unnamed.gl_Position = vec4<f32>(_e8.x, _e8.y, 1f, 1f);
return;
}
@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
texcoord_1 = texcoord;
position_1 = position;
main_1();
let _e7 = v_uv;
let _e8 = unnamed.gl_Position;
return VertexOutput(_e7, _e8);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'texcoord',
location: 1,
format: VertexFormat.float32x2,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(4) member: vec3<f32>,
@location(7) member_1: vec4<f32>,
@location(2) member_2: vec4<f32>,
@location(3) member_3: vec4<f32>,
@location(5) member_4: vec4<f32>,
@location(1) member_5: vec4<f32>,
@location(0) member_6: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_zenith: vec4<f32>;
var<private> zenith_1: vec4<f32>;
var<private> v_horizon: vec4<f32>;
var<private> horizon_1: vec4<f32>;
var<private> v_nadir: vec4<f32>;
var<private> nadir_1: vec4<f32>;
var<private> v_sun: vec4<f32>;
var<private> sun_1: vec4<f32>;
var<private> v_glow: vec4<f32>;
var<private> glow_1: vec4<f32>;
var<private> v_disc: vec4<f32>;
var<private> disc_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e20 = corner_ray_1;
v_ray = _e20;
let _e21 = zenith_1;
v_zenith = _e21;
let _e22 = horizon_1;
v_horizon = _e22;
let _e23 = nadir_1;
v_nadir = _e23;
let _e24 = sun_1;
v_sun = _e24;
let _e25 = glow_1;
v_glow = _e25;
let _e26 = disc_1;
v_disc = _e26;
let _e27 = position_1;
unnamed.gl_Position = vec4<f32>(_e27.x, _e27.y, 0.999999f, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) zenith: vec4<f32>, @location(3) horizon: vec4<f32>, @location(4) nadir: vec4<f32>, @location(5) sun: vec4<f32>, @location(6) glow: vec4<f32>, @location(7) disc: vec4<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
zenith_1 = zenith;
horizon_1 = horizon;
nadir_1 = nadir;
sun_1 = sun;
glow_1 = glow;
disc_1 = disc;
position_1 = position;
main_1();
let _e25 = v_ray;
let _e26 = v_zenith;
let _e27 = v_horizon;
let _e28 = v_nadir;
let _e29 = v_sun;
let _e30 = v_glow;
let _e31 = v_disc;
let _e32 = unnamed.gl_Position;
return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31, _e32);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'zenith',
location: 2,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'horizon',
location: 3,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'nadir',
location: 4,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'sun',
location: 5,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'glow',
location: 6,
format: VertexFormat.float32x4,
),
WebGpuAttribute(
name: 'disc',
location: 7,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'SkyCubeVertex': WebGpuStage(
wgsl: r'''
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(4) member: vec3<f32>,
@location(6) member_1: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_tint: vec4<f32>;
var<private> tint_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;
fn main_1() {
let _e10 = corner_ray_1;
v_ray = _e10;
let _e11 = tint_1;
v_tint = _e11;
let _e12 = position_1;
unnamed.gl_Position = vec4<f32>(_e12.x, _e12.y, 0.999999f, 1f);
return;
}
@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) tint: vec4<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
corner_ray_1 = corner_ray;
tint_1 = tint;
position_1 = position;
main_1();
let _e10 = v_ray;
let _e11 = v_tint;
let _e12 = unnamed.gl_Position;
return VertexOutput(_e10, _e11, _e12);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x2,
),
WebGpuAttribute(
name: 'corner_ray',
location: 1,
format: VertexFormat.float32x3,
),
WebGpuAttribute(
name: 'tint',
location: 2,
format: VertexFormat.float32x4,
),
],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'VertexTextureProbeVertex': WebGpuStage(
wgsl: r'''
struct ProbeInfo {
at: vec4<f32>,
}
struct gl_PerVertex {
@builtin(position) gl_Position: vec4<f32>,
gl_PointSize: f32,
gl_ClipDistance: array<f32, 1>,
gl_CullDistance: array<f32, 1>,
}
struct VertexOutput {
@location(0) member: vec4<f32>,
@builtin(position) gl_Position: vec4<f32>,
}
var<private> v_sampled: vec4<f32>;
@group(0) @binding(1)
var probe_texture_tex: texture_2d<f32>;
@group(0) @binding(2)
var probe_texture_smp: sampler;
@group(0) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;
fn main_1() {
let _e11 = probe_info.at;
let _e13 = textureSampleLevel(probe_texture_tex, probe_texture_smp, _e11.xy, 0f);
v_sampled = _e13;
let _e14 = position_1;
unnamed.gl_Position = vec4<f32>(_e14.x, _e14.y, _e14.z, 1f);
return;
}
@vertex
fn main(@location(0) position: vec3<f32>) -> VertexOutput {
position_1 = position;
main_1();
let _e5 = v_sampled;
let _e6 = unnamed.gl_Position;
return VertexOutput(_e5, _e6);
}
''',
attributes: <WebGpuAttribute>[
WebGpuAttribute(
name: 'position',
location: 0,
format: VertexFormat.float32x3,
),
],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ProbeInfo',
group: 0,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'at', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'probe_texture',
group: 0,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
},
fragment: <String, WebGpuStage>{
'Unlit': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e52 = (*n)[0u];
let _e55 = (*n)[1u];
let _e59 = (*n)[2u];
let _e62 = (*n);
(*n) = (_e62 / vec3(((abs(_e52) + abs(_e55)) + abs(_e59))));
let _e65 = (*n);
e = _e65.xy;
let _e68 = (*n)[2u];
if (_e68 < 0f) {
let _e70 = (*n);
let _e76 = (*n)[0u];
let _e80 = (*n)[1u];
e = ((vec2(1f) - abs(_e70.yx)) * vec2<f32>(select(-1f, 1f, (_e76 >= 0f)), select(-1f, 1f, (_e80 >= 0f))));
}
let _e85 = e;
return ((_e85 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e49 = v_world_position_1;
let _e51 = fog_info.eye;
let _e55 = fog_info.forward;
return dot((_e49 - _e51.xyz), _e55.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e51 = g_debug_surface_on;
if _e51 {
let _e52 = g_debug_surface;
let _e53 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e52.x, _e52.y, _e52.z, _e53);
return;
}
let _e58 = v_normal_1;
param = normalize(_e58);
let _e60 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e61 = (*roughness);
let _e63 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e60.x, _e60.y, clamp(_e61, 0f, 1f), _e63);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e49 = v_world_position_1;
let _e51 = fog_info.eye;
return distance(_e49, _e51.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e54 = fog_info.fog[3u];
density = _e54;
let _e55 = density;
if (_e55 <= 0f) {
let _e57 = (*color);
return _e57;
}
let _e58 = EyeDistance_u0028_();
d = _e58;
let _e60 = fog_info.fog;
let _e62 = (*color);
let _e63 = density;
let _e65 = d;
return mix(_e60.xyz, _e62, vec3(clamp(exp((-(_e63) * _e65)), 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 _e54 = (*linearColor);
param_1 = _e54;
let _e55 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e56 = (*alpha);
frag_color = vec4<f32>(_e55.x, _e55.y, _e55.z, _e56);
let _e61 = (*roughness_1);
param_2 = _e61;
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 _e54 = (*linearColor_1);
param_3 = _e54;
let _e55 = (*alpha_1);
param_4 = _e55;
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 _e50 = (*srgb);
let _e53 = (*srgb);
let _e58 = (*srgb);
return mix((_e50 / vec3(12.92f)), pow(((_e53 + 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), _e58));
}
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 phi_289_: bool;
let _e54 = v_texcoord_1;
let _e55 = textureSample(base_color_texture_tex, base_color_texture_smp, _e54);
texel = _e55;
let _e56 = texel;
param_6 = _e56.xyz;
let _e58 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e60 = frag_info.base_color;
param_7 = _e60.xyz;
let _e62 = SrgbToLinear_u0028_vf3_u003b((¶m_7));
let _e64 = v_color_1;
s.albedo = ((_e58 * _e62) * _e64.xyz);
let _e69 = texel[3u];
let _e72 = frag_info.base_color[3u];
let _e75 = v_color_1[3u];
s.alpha = ((_e69 * _e72) * _e75);
let _e80 = frag_info.material2_[0u];
cutoff = _e80;
let _e81 = cutoff;
let _e82 = (_e81 >= 0f);
phi_289_ = _e82;
if _e82 {
let _e84 = s.alpha;
let _e85 = cutoff;
phi_289_ = (_e84 < _e85);
}
let _e88 = phi_289_;
if _e88 {
discard;
}
let _e89 = v_normal_1;
s.n = normalize(_e89);
let _e93 = frag_info.camera_position;
let _e95 = v_world_position_1;
s.v = normalize((_e93.xyz - _e95));
let _e100 = s.n;
let _e102 = s.v;
s.n_dot_v = max(dot(_e100, _e102), 0.0001f);
let _e108 = frag_info.material[0u];
s.metallic = clamp(_e108, 0f, 1f);
let _e113 = frag_info.material[1u];
s.roughness = clamp(_e113, 0.02f, 1f);
let _e117 = frag_info.ambient_ground;
let _e120 = frag_info.ambient_sky;
let _e124 = s.n[1u];
let _e131 = frag_info.material[2u];
s.ambient = (mix(_e117.xyz, _e120.xyz, vec3(((_e124 * 0.5f) + 0.5f))) * _e131);
let _e136 = frag_info.frame_params[0u];
s.exposure = max(_e136, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e141 = s;
return _e141;
}
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 _e52 = ReadSurface_u0028_();
s_1 = _e52;
let _e54 = s_1.albedo;
param_8 = _e54;
let _e56 = s_1.alpha;
param_9 = _e56;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e14 = frag_surface;
let _e15 = frag_color;
return FragmentOutput(_e14, _e15);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Xray': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
var<private> v_color_1: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e47 = v_world_position_1;
let _e49 = fog_info.eye;
return distance(_e47, _e49.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e52 = fog_info.fog[3u];
density = _e52;
let _e53 = density;
if (_e53 <= 0f) {
let _e55 = (*color);
return _e55;
}
let _e56 = EyeDistance_u0028_();
d = _e56;
let _e58 = fog_info.fog;
let _e60 = (*color);
let _e61 = density;
let _e63 = d;
return mix(_e58.xyz, _e60, vec3(clamp(exp((-(_e61) * _e63)), 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 _e52 = (*linearColor);
param = _e52;
let _e53 = ApplyFog_u0028_vf3_u003b((¶m));
let _e54 = (*alpha);
frag_color = vec4<f32>(_e53.x, _e53.y, _e53.z, _e54);
let _e59 = (*roughness_1);
param_1 = _e59;
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 _e52 = (*linearColor_1);
param_2 = _e52;
let _e53 = (*alpha_1);
param_3 = _e53;
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 _e48 = (*srgb);
let _e51 = (*srgb);
let _e56 = (*srgb);
return mix((_e48 / vec3(12.92f)), pow(((_e51 + 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), _e56));
}
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 phi_201_: bool;
let _e52 = v_texcoord_1;
let _e53 = textureSample(base_color_texture_tex, base_color_texture_smp, _e52);
texel = _e53;
let _e54 = texel;
param_5 = _e54.xyz;
let _e56 = SrgbToLinear_u0028_vf3_u003b((¶m_5));
let _e58 = frag_info.base_color;
param_6 = _e58.xyz;
let _e60 = SrgbToLinear_u0028_vf3_u003b((¶m_6));
let _e62 = v_color_1;
s.albedo = ((_e56 * _e60) * _e62.xyz);
let _e67 = texel[3u];
let _e70 = frag_info.base_color[3u];
let _e73 = v_color_1[3u];
s.alpha = ((_e67 * _e70) * _e73);
let _e78 = frag_info.material2_[0u];
cutoff = _e78;
let _e79 = cutoff;
let _e80 = (_e79 >= 0f);
phi_201_ = _e80;
if _e80 {
let _e82 = s.alpha;
let _e83 = cutoff;
phi_201_ = (_e82 < _e83);
}
let _e86 = phi_201_;
if _e86 {
discard;
}
let _e87 = v_normal_1;
s.n = normalize(_e87);
let _e91 = frag_info.camera_position;
let _e93 = v_world_position_1;
s.v = normalize((_e91.xyz - _e93));
let _e98 = s.n;
let _e100 = s.v;
s.n_dot_v = max(dot(_e98, _e100), 0.0001f);
let _e106 = frag_info.material[0u];
s.metallic = clamp(_e106, 0f, 1f);
let _e111 = frag_info.material[1u];
s.roughness = clamp(_e111, 0.02f, 1f);
let _e115 = frag_info.ambient_ground;
let _e118 = frag_info.ambient_sky;
let _e122 = s.n[1u];
let _e129 = frag_info.material[2u];
s.ambient = (mix(_e115.xyz, _e118.xyz, vec3(((_e122 * 0.5f) + 0.5f))) * _e129);
let _e134 = frag_info.frame_params[0u];
s.exposure = max(_e134, 0f);
s.occlusion = 1f;
s.emissive = vec3<f32>(0f, 0f, 0f);
let _e139 = s;
return _e139;
}
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 _e50 = ReadSurface_u0028_();
s_1 = _e50;
let _e52 = s_1.albedo;
param_7 = _e52;
let _e54 = s_1.alpha;
param_8 = _e54;
WriteSurface_u0028_vf3_u003b_f1_u003b((¶m_7), (¶m_8));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_normal: vec3<f32>, @location(3) v_tangent: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
v_normal_1 = v_normal;
v_tangent_1 = v_tangent;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e13 = frag_color;
return _e13;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 2,
samplerBinding: 3,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Lambert': WebGpuStage(
wgsl: r'''
struct Surface {
albedo: vec3<f32>,
alpha: f32,
n: vec3<f32>,
v: vec3<f32>,
n_dot_v: f32,
metallic: f32,
roughness: f32,
occlusion: f32,
emissive: vec3<f32>,
ambient: vec3<f32>,
exposure: f32,
}
struct LightSample {
l: vec3<f32>,
h: vec3<f32>,
radiance: vec3<f32>,
n_dot_l: f32,
n_dot_h: f32,
v_dot_h: f32,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
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(2)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(17)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var point_shadow_texture_smp: sampler;
@group(1) @binding(15)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(7)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(13)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var occlusion_texture_smp: sampler;
@group(1) @binding(5)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var emissive_texture_smp: sampler;
@group(1) @binding(11)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(19)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var shadow_texture_smp: sampler;
@group(1) @binding(9)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var metallic_roughness_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e119 = (*n)[0u];
let _e122 = (*n)[1u];
let _e126 = (*n)[2u];
let _e129 = (*n);
(*n) = (_e129 / vec3(((abs(_e119) + abs(_e122)) + abs(_e126))));
let _e132 = (*n);
e = _e132.xy;
let _e135 = (*n)[2u];
if (_e135 < 0f) {
let _e137 = (*n);
let _e143 = (*n)[0u];
let _e147 = (*n)[1u];
e = ((vec2(1f) - abs(_e137.yx)) * vec2<f32>(select(-1f, 1f, (_e143 >= 0f)), select(-1f, 1f, (_e147 >= 0f))));
}
let _e152 = e;
return ((_e152 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e116 = v_world_position_1;
let _e118 = fog_info.eye;
let _e122 = fog_info.forward;
return dot((_e116 - _e118.xyz), _e122.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e118 = g_debug_surface_on;
if _e118 {
let _e119 = g_debug_surface;
let _e120 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e119.x, _e119.y, _e119.z, _e120);
return;
}
let _e125 = v_normal_1;
param = normalize(_e125);
let _e127 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e128 = (*roughness);
let _e130 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e127.x, _e127.y, clamp(_e128, 0f, 1f), _e130);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e116 = v_world_position_1;
let _e118 = fog_info.eye;
return distance(_e116, _e118.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e121 = fog_info.fog[3u];
density = _e121;
let _e122 = density;
if (_e122 <= 0f) {
let _e124 = (*color);
return _e124;
}
let _e125 = EyeDistance_u0028_();
d = _e125;
let _e127 = fog_info.fog;
let _e129 = (*color);
let _e130 = density;
let _e132 = d;
return mix(_e127.xyz, _e129, vec3(clamp(exp((-(_e130) * _e132)), 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 _e121 = (*linearColor);
param_1 = _e121;
let _e122 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e123 = (*alpha);
frag_color = vec4<f32>(_e122.x, _e122.y, _e122.z, _e123);
let _e128 = (*roughness_1);
param_2 = _e128;
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 _e119 = (*s).albedo;
return _e119;
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e117 = (*i);
if (_e117 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e119 = (*i);
if (_e119 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e121 = (*i);
if (_e121 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e123 = (*i);
if (_e123 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e125 = (*i);
if (_e125 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e127 = (*i);
if (_e127 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e129 = (*i);
if (_e129 == 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 _e122 = (*i_1);
param_3 = _e122;
let _e123 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e123;
let _e125 = p[0u];
let _e126 = (*ca);
let _e129 = p[1u];
let _e130 = (*sa);
let _e134 = p[0u];
let _e135 = (*sa);
let _e138 = p[1u];
let _e139 = (*ca);
let _e143 = (*radius);
return (vec2<f32>(((_e125 * _e126) - (_e129 * _e130)), ((_e134 * _e135) + (_e138 * _e139))) * _e143);
}
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 _e125 = point_shadow.params[0u];
inset = _e125;
let _e126 = (*uv);
let _e127 = (*offset);
let _e129 = inset;
let _e130 = inset;
local = clamp((_e126 + _e127), vec2(_e129), vec2((1f - _e130)));
let _e135 = local;
let _e136 = (*tile);
atlas = ((_e135 + _e136) * vec2<f32>(0.16666667f, 0.16666667f));
let _e141 = point_shadow.params3_[0u];
if (_e141 > 0.5f) {
let _e144 = atlas[1u];
atlas[1u] = (1f - _e144);
}
let _e147 = atlas;
let _e148 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e147, 0f);
let _e150 = atlas;
let _e151 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e150, 0f);
let _e154 = (*range);
return (min(_e148.x, _e151.x) * _e154);
}
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 _e126 = (*uv_1);
param_4 = _e126;
let _e127 = (*offset_1);
param_5 = _e127;
let _e128 = (*tile_1);
param_6 = _e128;
let _e129 = (*range_1);
param_7 = _e129;
let _e130 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e130;
let _e131 = stored;
let _e132 = (*range_1);
if (_e131 >= (_e132 * 0.999f)) {
return 1f;
}
let _e135 = (*receiver);
let _e136 = stored;
return select(1f, 0f, (_e135 > _e136));
}
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 _e147 = point_shadow.params2_[1u];
lightRadius = _e147;
let _e150 = point_shadow.params2_[0u];
minRadius = _e150;
let _e153 = point_shadow.params2_[2u];
maxRadius = _e153;
let _e154 = lightRadius;
if (_e154 <= 0f) {
let _e156 = (*uv_2);
param_8 = _e156;
param_9 = vec2<f32>(0f, 0f);
let _e157 = (*tile_2);
param_10 = _e157;
let _e158 = (*range_2);
param_11 = _e158;
let _e159 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e159;
let _e160 = minRadius;
return _e160;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e161 = i_2;
if (_e161 < 8i) {
let _e163 = i_2;
param_12 = _e163;
let _e164 = (*ca_1);
param_13 = _e164;
let _e165 = (*sa_1);
param_14 = _e165;
let _e166 = maxRadius;
param_15 = _e166;
let _e167 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e168 = (*uv_2);
param_16 = _e168;
param_17 = _e167;
let _e169 = (*tile_2);
param_18 = _e169;
let _e170 = (*range_2);
param_19 = _e170;
let _e171 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e171;
let _e172 = stored_1;
let _e173 = (*range_2);
if (_e172 >= (_e173 * 0.999f)) {
continue;
}
let _e176 = stored_1;
let _e177 = (*receiver_1);
if (_e176 >= _e177) {
continue;
}
let _e179 = stored_1;
let _e180 = sum;
sum = (_e180 + _e179);
let _e182 = count;
count = (_e182 + 1f);
continue;
} else {
break;
}
continuing {
let _e184 = i_2;
i_2 = (_e184 + 1i);
}
}
let _e186 = count;
if (_e186 < 0.5f) {
return -1f;
}
let _e188 = sum;
let _e189 = count;
blocker = max((_e188 / _e189), 0.0001f);
let _e192 = blocker;
(*blockerOut) = _e192;
let _e193 = lightRadius;
let _e194 = (*receiver_1);
let _e195 = blocker;
let _e199 = blocker;
world = ((_e193 * max((_e194 - _e195), 0f)) / _e199);
let _e201 = world;
let _e202 = (*receiver_1);
let _e204 = (*tanHalf);
let _e207 = minRadius;
let _e208 = maxRadius;
return clamp((_e201 / ((2f * _e202) * _e204)), _e207, _e208);
}
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_1002_: bool;
var phi_1064_: bool;
let _e169 = (*lightIndex);
let _e173 = point_shadow.slots[_e169][0u];
slot = i32((_e173 + 0.5f));
let _e176 = (*lightIndex);
let _e180 = point_shadow.slots[_e176][0u];
if (_e180 < 0f) {
return 1f;
}
let _e184 = point_shadow.params[2u];
strength = _e184;
let _e185 = strength;
if (_e185 <= 0f) {
return 1f;
}
let _e187 = slot;
let _e190 = point_shadow.lights[_e187];
let _e192 = (*world_1);
toLight = (_e190.xyz - _e192);
let _e194 = toLight;
toLightLength = max(length(_e194), 0.000001f);
let _e197 = (*normal);
let _e198 = toLight;
let _e199 = toLightLength;
nDotL = max(dot(_e197, (_e198 / vec3(_e199))), 0.15f);
let _e204 = nDotL;
let _e205 = nDotL;
let _e210 = nDotL;
let _e211 = nDotL;
slope = min((sqrt(max((1f - (_e204 * _e205)), 0f)) / (_e210 * _e211)), 8f);
let _e215 = toLightLength;
let _e217 = (*lightIndex);
let _e221 = point_shadow.slots[_e217][2u];
let _e226 = point_shadow.params3_[1u];
texel = (((2f * _e215) * max(_e221, 0.0001f)) * _e226);
let _e228 = (*world_1);
let _e229 = (*normal);
let _e230 = texel;
let _e234 = point_shadow.params[3u];
let _e236 = slope;
origin = (_e228 + (((_e229 * _e230) * _e234) * (1f + _e236)));
let _e240 = origin;
let _e241 = slot;
let _e244 = point_shadow.lights[_e241];
toFragment = (_e240 - _e244.xyz);
let _e247 = toFragment;
distance_ = length(_e247);
let _e249 = slot;
let _e253 = point_shadow.lights[_e249][3u];
range_3 = max(_e253, 0.0001f);
let _e255 = distance_;
let _e256 = range_3;
if (_e255 >= _e256) {
return 1f;
}
face = 0i;
let _e258 = (*lightIndex);
let _e262 = point_shadow.slots[_e258][1u];
if (_e262 < 0.5f) {
let _e264 = toFragment;
a = abs(_e264);
let _e267 = a[0u];
let _e269 = a[1u];
let _e270 = (_e267 >= _e269);
phi_1002_ = _e270;
if _e270 {
let _e272 = a[0u];
let _e274 = a[2u];
phi_1002_ = (_e272 >= _e274);
}
let _e277 = phi_1002_;
if _e277 {
let _e279 = toFragment[0u];
face = select(1i, 0i, (_e279 > 0f));
} else {
let _e283 = a[1u];
let _e285 = a[2u];
if (_e283 >= _e285) {
let _e288 = toFragment[1u];
face = select(3i, 2i, (_e288 > 0f));
} else {
let _e292 = toFragment[2u];
face = select(5i, 4i, (_e292 > 0f));
}
}
}
let _e295 = slot;
let _e297 = face;
let _e301 = point_shadow.faces[((_e295 * 6i) + _e297)];
let _e302 = origin;
clip = (_e301 * vec4<f32>(_e302.x, _e302.y, _e302.z, 1f));
let _e309 = clip[3u];
if (_e309 <= 0f) {
return 1f;
}
let _e311 = clip;
let _e314 = clip[3u];
ndc = (_e311.xy / vec2(_e314));
let _e318 = ndc[0u];
let _e320 = (abs(_e318) > 1f);
phi_1064_ = _e320;
if !(_e320) {
let _e323 = ndc[1u];
phi_1064_ = (abs(_e323) > 1f);
}
let _e327 = phi_1064_;
if _e327 {
return 1f;
}
let _e329 = ndc[0u];
let _e333 = ndc[1u];
uv_3 = vec2<f32>(((_e329 * 0.5f) + 0.5f), (0.5f - (_e333 * 0.5f)));
let _e337 = face;
let _e339 = slot;
tile_3 = vec2<f32>(f32(_e337), f32(_e339));
let _e342 = distance_;
let _e345 = point_shadow.params[1u];
receiver_2 = (_e342 - _e345);
let _e347 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e347.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e353 = noise;
angle = (_e353 * 6.2831855f);
let _e355 = angle;
ca_2 = cos(_e355);
let _e357 = angle;
sa_2 = sin(_e357);
let _e359 = (*lightIndex);
let _e363 = point_shadow.slots[_e359][2u];
tanHalf_1 = max(_e363, 0.0001f);
blocker_1 = -1f;
let _e365 = uv_3;
param_20 = _e365;
let _e366 = tile_3;
param_21 = _e366;
let _e367 = range_3;
param_22 = _e367;
let _e368 = receiver_2;
param_23 = _e368;
let _e369 = ca_2;
param_24 = _e369;
let _e370 = sa_2;
param_25 = _e370;
let _e371 = tanHalf_1;
param_26 = _e371;
let _e372 = 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 _e373 = param_27;
blocker_1 = _e373;
radius_1 = _e372;
let _e376 = point_shadow.params2_[3u];
if (_e376 > 0.5f) {
g_debug_surface_on = true;
let _e378 = radius_1;
if (_e378 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e380 = radius_1;
let _e383 = point_shadow.params2_[2u];
let _e387 = blocker_1;
let _e388 = range_3;
local_1 = vec3<f32>(clamp((_e380 / max(_e383, 0.000001f)), 0f, 1f), clamp((_e387 / _e388), 0f, 1f), 0f);
}
let _e392 = local_1;
g_debug_surface = _e392;
}
let _e393 = radius_1;
if (_e393 < 0f) {
return 1f;
}
let _e395 = uv_3;
param_28 = _e395;
param_29 = vec2<f32>(0f, 0f);
let _e396 = tile_3;
param_30 = _e396;
let _e397 = range_3;
param_31 = _e397;
let _e398 = receiver_2;
param_32 = _e398;
let _e399 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e399;
let _e400 = radius_1;
if (_e400 > 0f) {
i_3 = 0i;
loop {
let _e402 = i_3;
if (_e402 < 8i) {
let _e404 = i_3;
param_33 = _e404;
let _e405 = ca_2;
param_34 = _e405;
let _e406 = sa_2;
param_35 = _e406;
let _e407 = radius_1;
param_36 = _e407;
let _e408 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e409 = uv_3;
param_37 = _e409;
param_38 = _e408;
let _e410 = tile_3;
param_39 = _e410;
let _e411 = range_3;
param_40 = _e411;
let _e412 = receiver_2;
param_41 = _e412;
let _e413 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e414 = lit;
lit = (_e414 + _e413);
continue;
} else {
break;
}
continuing {
let _e416 = i_3;
i_3 = (_e416 + 1i);
}
}
let _e418 = lit;
lit = (_e418 * 0.11111111f);
}
let _e420 = lit;
let _e421 = strength;
return mix(1f, _e420, clamp(_e421, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var phi_1480_: bool;
var phi_1491_: bool;
var phi_1581_: bool;
var phi_1588_: bool;
var phi_1595_: bool;
let _e143 = frag_info.shadow_params[3u];
strength_1 = _e143;
let _e144 = strength_1;
if (_e144 <= 0f) {
return 1f;
}
let _e146 = (*lightIndex_1);
let _e149 = frag_info.frame_params[2u];
if (_e146 != i32((_e149 + 0.5f))) {
return 1f;
}
let _e153 = v_world_position_1;
let _e155 = (*s_1).n;
let _e158 = frag_info.shadow_params[2u];
origin_1 = (_e153 + (_e155 * _e158));
let _e163 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e163 + 0.5f));
let _e166 = v_world_position_1;
let _e168 = frag_info.camera_position;
viewDistance = length((_e166 - _e168.xyz));
cascade = 0i;
let _e172 = cascadeCount;
let _e173 = (_e172 > 1i);
phi_1480_ = _e173;
if _e173 {
let _e174 = viewDistance;
let _e177 = frag_info.shadow_cascades[0u];
phi_1480_ = (_e174 > _e177);
}
let _e180 = phi_1480_;
if _e180 {
cascade = 1i;
}
let _e181 = cascadeCount;
let _e182 = (_e181 > 2i);
phi_1491_ = _e182;
if _e182 {
let _e183 = viewDistance;
let _e186 = frag_info.shadow_cascades[1u];
phi_1491_ = (_e183 > _e186);
}
let _e189 = phi_1491_;
if _e189 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e190 = attempt;
if (_e190 < 3i) {
let _e192 = cascade;
let _e193 = attempt;
which = (_e192 + _e193);
let _e195 = which;
let _e196 = cascadeCount;
if (_e195 >= _e196) {
break;
}
let _e198 = which;
if (_e198 == 0i) {
let _e201 = frag_info.shadow_matrix;
local_2 = _e201;
} else {
let _e202 = which;
if (_e202 == 1i) {
let _e205 = frag_info.shadow_matrix_far;
local_3 = _e205;
} else {
let _e207 = frag_info.shadow_matrix_farthest;
local_3 = _e207;
}
let _e208 = local_3;
local_2 = _e208;
}
let _e209 = local_2;
matrix = _e209;
let _e210 = matrix;
let _e211 = origin_1;
lightSpace = (_e210 * vec4<f32>(_e211.x, _e211.y, _e211.z, 1f));
let _e218 = lightSpace[3u];
if (_e218 <= 0f) {
continue;
}
let _e220 = lightSpace;
let _e223 = lightSpace[3u];
candidate = (_e220.xyz / vec3(_e223));
let _e227 = candidate[0u];
let _e231 = candidate[1u];
inTile = vec2<f32>(((_e227 * 0.5f) + 0.5f), (0.5f - (_e231 * 0.5f)));
let _e236 = inTile[0u];
let _e237 = (_e236 < 0f);
phi_1581_ = _e237;
if !(_e237) {
let _e240 = inTile[0u];
phi_1581_ = (_e240 > 1f);
}
let _e243 = phi_1581_;
phi_1588_ = _e243;
if !(_e243) {
let _e246 = inTile[1u];
phi_1588_ = (_e246 < 0f);
}
let _e249 = phi_1588_;
phi_1595_ = _e249;
if !(_e249) {
let _e252 = inTile[1u];
phi_1595_ = (_e252 > 1f);
}
let _e255 = phi_1595_;
if _e255 {
continue;
}
let _e257 = candidate[2u];
if (_e257 > 1f) {
continue;
}
let _e260 = inTile[0u];
let _e261 = which;
let _e264 = cascadeCount;
let _e268 = inTile[1u];
uv_4 = vec2<f32>(((_e260 + f32(_e261)) / f32(_e264)), _e268);
let _e270 = candidate;
projected = _e270;
let _e271 = which;
cascade = _e271;
found = true;
break;
} else {
break;
}
continuing {
let _e272 = attempt;
attempt = (_e272 + 1i);
}
}
let _e274 = found;
if !(_e274) {
return 1f;
}
let _e278 = frag_info.shadow_params[1u];
bias = _e278;
let _e281 = frag_info.shadow_params[0u];
let _e284 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e281, _e284);
lit_1 = 0f;
y = -1i;
loop {
let _e286 = y;
if (_e286 <= 1i) {
x = -1i;
loop {
let _e288 = x;
if (_e288 <= 1i) {
let _e290 = uv_4;
let _e291 = x;
let _e293 = y;
let _e296 = texel_1;
let _e299 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e290 + (vec2<f32>(f32(_e291), f32(_e293)) * _e296)), 0f);
occluder = _e299.x;
let _e302 = projected[2u];
let _e303 = bias;
let _e305 = occluder;
let _e308 = lit_1;
lit_1 = (_e308 + select(1f, 0f, ((_e302 - _e303) > _e305)));
continue;
} else {
break;
}
continuing {
let _e310 = x;
x = (_e310 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e312 = y;
y = (_e312 + 1i);
}
}
let _e314 = lit_1;
lit_1 = (_e314 * 0.11111111f);
let _e316 = lit_1;
let _e317 = strength_1;
return mix(1f, _e316, clamp(_e317, 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 _e122 = (*s_2);
param_42 = _e122;
let _e123 = (*light_2);
param_43 = _e123;
let _e124 = (*index);
param_44 = _e124;
let _e125 = 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 _e125;
}
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 _e121 = (*distance_1);
let _e122 = (*distance_1);
attenuation = (1f / max((_e121 * _e122), 0.0001f));
let _e126 = (*range_4);
if (_e126 > 0f) {
let _e128 = (*distance_1);
let _e129 = (*range_4);
ratio = (_e128 / _e129);
let _e131 = ratio;
let _e132 = ratio;
let _e134 = ratio;
let _e136 = ratio;
window = clamp((1f - (((_e131 * _e132) * _e134) * _e136)), 0f, 1f);
let _e140 = window;
let _e141 = window;
let _e143 = attenuation;
attenuation = (_e143 * (_e140 * _e141));
}
let _e145 = attenuation;
return _e145;
}
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_1: 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 type_33: f32;
var aim: vec3<f32>;
var attenuation_1: f32;
var light_3: LightSample;
var toLight_1: vec3<f32>;
var distance_2: f32;
var param_45: f32;
var param_46: f32;
var cosAngle: f32;
let _e131 = (*index_1);
let _e134 = frag_info.light_position[_e131];
position = _e134;
let _e135 = (*index_1);
let _e138 = frag_info.light_color[_e135];
color_1 = _e138;
let _e139 = (*index_1);
let _e142 = frag_info.light_direction[_e139];
direction = _e142;
let _e143 = (*index_1);
let _e146 = frag_info.light_cone[_e143];
cone = _e146;
let _e148 = position[3u];
type_33 = _e148;
let _e149 = direction;
aim = normalize(_e149.xyz);
attenuation_1 = 1f;
let _e152 = type_33;
if (_e152 < 0.5f) {
let _e154 = aim;
light_3.l = -(_e154);
} else {
let _e157 = position;
let _e159 = v_world_position_1;
toLight_1 = (_e157.xyz - _e159);
let _e161 = toLight_1;
distance_2 = length(_e161);
let _e163 = distance_2;
if (_e163 < 0.000001f) {
let _e166 = (*s_3).n;
light_3.l = _e166;
let _e169 = (*s_3).n;
light_3.h = _e169;
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 _e175 = light_3;
return _e175;
}
let _e176 = toLight_1;
let _e177 = distance_2;
light_3.l = (_e176 / vec3(_e177));
let _e181 = distance_2;
param_45 = _e181;
let _e183 = direction[3u];
param_46 = _e183;
let _e184 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_45), (¶m_46));
attenuation_1 = _e184;
let _e185 = type_33;
if (_e185 > 1.5f) {
let _e187 = aim;
let _e189 = light_3.l;
cosAngle = dot(_e187, -(_e189));
let _e192 = cosAngle;
let _e194 = cone[1u];
let _e197 = cone[0u];
let _e199 = cone[1u];
let _e203 = attenuation_1;
attenuation_1 = (_e203 * clamp(((_e192 - _e194) / (_e197 - _e199)), 0f, 1f));
}
}
let _e206 = light_3.l;
let _e208 = (*s_3).v;
light_3.h = normalize((_e206 + _e208));
let _e213 = (*s_3).n;
let _e215 = light_3.l;
light_3.n_dot_l = max(dot(_e213, _e215), 0f);
let _e220 = (*s_3).n;
let _e222 = light_3.h;
light_3.n_dot_h = max(dot(_e220, _e222), 0f);
let _e227 = (*s_3).v;
let _e229 = light_3.h;
light_3.v_dot_h = max(dot(_e227, _e229), 0f);
let _e233 = color_1;
let _e236 = color_1[3u];
let _e238 = attenuation_1;
light_3.radiance = ((_e233.xyz * _e236) * _e238);
let _e241 = light_3;
return _e241;
}
fn LightCount_u0028_() -> i32 {
let _e118 = frag_info.frame_params[1u];
return clamp(i32((_e118 + 0.5f)), 0i, 8i);
}
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: vec3<f32>;
var count_1: i32;
var i_4: i32;
var light_4: LightSample;
var param_47: i32;
var param_48: Surface;
var visibility: f32;
var param_49: Surface;
var param_50: LightSample;
var param_51: i32;
var param_52: vec3<f32>;
var param_53: vec3<f32>;
var param_54: i32;
var param_55: Surface;
var param_56: LightSample;
total = vec3<f32>(0f, 0f, 0f);
let _e132 = LightCount_u0028_();
count_1 = _e132;
i_4 = 0i;
loop {
let _e133 = i_4;
if (_e133 < 8i) {
let _e135 = i_4;
let _e136 = count_1;
if (_e135 >= _e136) {
break;
}
let _e138 = i_4;
param_47 = _e138;
let _e139 = (*s_4);
param_48 = _e139;
let _e140 = 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_47), (¶m_48));
light_4 = _e140;
let _e142 = light_4.n_dot_l;
if (_e142 <= 0f) {
continue;
}
let _e144 = (*s_4);
param_49 = _e144;
let _e145 = light_4;
param_50 = _e145;
let _e146 = i_4;
param_51 = _e146;
let _e147 = 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_49), (¶m_50), (¶m_51));
let _e148 = v_world_position_1;
param_52 = _e148;
let _e150 = (*s_4).n;
param_53 = _e150;
let _e151 = i_4;
param_54 = _e151;
let _e152 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_52), (¶m_53), (¶m_54));
visibility = (_e147 * _e152);
let _e154 = visibility;
if (_e154 <= 0f) {
continue;
}
let _e156 = (*s_4);
param_55 = _e156;
let _e157 = light_4;
param_56 = _e157;
let _e158 = 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_55), (¶m_56));
let _e160 = light_4.radiance;
let _e163 = light_4.n_dot_l;
let _e165 = visibility;
let _e167 = total;
total = (_e167 + (((_e158 * _e160) * _e163) * _e165));
continue;
} else {
break;
}
continuing {
let _e169 = i_4;
i_4 = (_e169 + 1i);
}
}
let _e171 = total;
return _e171;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e117 = v_lightmap_uv_1;
let _e118 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e117);
texel_2 = _e118;
let _e119 = texel_2;
let _e122 = texel_2[3u];
return ((_e119.xyz * _e122) * 8f);
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e117 = (*srgb);
let _e120 = (*srgb);
let _e125 = (*srgb);
return mix((_e117 / vec3(12.92f)), pow(((_e120 + 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), _e125));
}
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_57: vec3<f32>;
let _e119 = v_texcoord_1;
let _e120 = textureSample(emissive_texture_tex, emissive_texture_smp, _e119);
param_57 = _e120.xyz;
let _e122 = SrgbToLinear_u0028_vf3_u003b((¶m_57));
emissive = _e122;
let _e123 = emissive;
let _e125 = frag_info.emissive;
let _e130 = frag_info.material2_[3u];
(*s_5).emissive = ((_e123 * _e125.xyz) * _e130);
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 _e118 = v_texcoord_1;
let _e119 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e118);
occlusion = _e119.x;
let _e121 = occlusion;
let _e124 = frag_info.material2_[2u];
(*s_6).occlusion = mix(1f, _e121, clamp(_e124, 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: vec3<f32>;
var b: vec3<f32>;
var sampled: vec3<f32>;
let _e121 = v_texcoord_1;
let _e122 = textureSample(normal_texture_tex, normal_texture_smp, _e121);
sampledTexel = _e122;
let _e123 = v_tangent_1;
t = _e123.xyz;
let _e125 = t;
let _e127 = (*s_7).n;
let _e129 = (*s_7).n;
let _e130 = t;
t = (_e125 - (_e127 * dot(_e129, _e130)));
let _e134 = t;
let _e135 = t;
if (dot(_e134, _e135) < 0.000000000001f) {
return;
}
let _e138 = t;
t = normalize(_e138);
let _e141 = (*s_7).n;
let _e142 = t;
let _e145 = v_tangent_1[3u];
b = (cross(_e141, _e142) * _e145);
let _e147 = sampledTexel;
sampled = ((_e147.xyz * 2f) - vec3(1f));
let _e154 = frag_info.material2_[1u];
let _e155 = sampled;
let _e157 = (_e155.xy * _e154);
sampled[0u] = _e157.x;
sampled[1u] = _e157.y;
let _e162 = t;
let _e164 = sampled[0u];
let _e166 = b;
let _e168 = sampled[1u];
let _e172 = (*s_7).n;
let _e174 = sampled[2u];
(*s_7).n = normalize((((_e162 * _e164) + (_e166 * _e168)) + (_e172 * _e174)));
let _e180 = (*s_7).n;
let _e182 = (*s_7).v;
(*s_7).n_dot_v = max(dot(_e180, _e182), 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_58: Surface;
var param_59: Surface;
var param_60: Surface;
let _e120 = (*s_8);
param_58 = _e120;
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_58));
let _e121 = param_58;
(*s_8) = _e121;
let _e122 = (*s_8);
param_59 = _e122;
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_59));
let _e123 = param_59;
(*s_8) = _e123;
let _e124 = (*s_8);
param_60 = _e124;
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_60));
let _e125 = param_60;
(*s_8) = _e125;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_9: Surface;
var param_61: vec3<f32>;
var param_62: vec3<f32>;
var cutoff: f32;
var phi_373_: bool;
let _e121 = v_texcoord_1;
let _e122 = textureSample(base_color_texture_tex, base_color_texture_smp, _e121);
texel_3 = _e122;
let _e123 = texel_3;
param_61 = _e123.xyz;
let _e125 = SrgbToLinear_u0028_vf3_u003b((¶m_61));
let _e127 = frag_info.base_color;
param_62 = _e127.xyz;
let _e129 = SrgbToLinear_u0028_vf3_u003b((¶m_62));
let _e131 = v_color_1;
s_9.albedo = ((_e125 * _e129) * _e131.xyz);
let _e136 = texel_3[3u];
let _e139 = frag_info.base_color[3u];
let _e142 = v_color_1[3u];
s_9.alpha = ((_e136 * _e139) * _e142);
let _e147 = frag_info.material2_[0u];
cutoff = _e147;
let _e148 = cutoff;
let _e149 = (_e148 >= 0f);
phi_373_ = _e149;
if _e149 {
let _e151 = s_9.alpha;
let _e152 = cutoff;
phi_373_ = (_e151 < _e152);
}
let _e155 = phi_373_;
if _e155 {
discard;
}
let _e156 = v_normal_1;
s_9.n = normalize(_e156);
let _e160 = frag_info.camera_position;
let _e162 = v_world_position_1;
s_9.v = normalize((_e160.xyz - _e162));
let _e167 = s_9.n;
let _e169 = s_9.v;
s_9.n_dot_v = max(dot(_e167, _e169), 0.0001f);
let _e175 = frag_info.material[0u];
s_9.metallic = clamp(_e175, 0f, 1f);
let _e180 = frag_info.material[1u];
s_9.roughness = clamp(_e180, 0.02f, 1f);
let _e184 = frag_info.ambient_ground;
let _e187 = frag_info.ambient_sky;
let _e191 = s_9.n[1u];
let _e198 = frag_info.material[2u];
s_9.ambient = (mix(_e184.xyz, _e187.xyz, vec3(((_e191 * 0.5f) + 0.5f))) * _e198);
let _e203 = frag_info.frame_params[0u];
s_9.exposure = max(_e203, 0f);
s_9.occlusion = 1f;
s_9.emissive = vec3<f32>(0f, 0f, 0f);
let _e208 = s_9;
return _e208;
}
fn main_1() {
var s_10: Surface;
var param_63: Surface;
var ambient: vec3<f32>;
var param_64: Surface;
var param_65: vec3<f32>;
var param_66: f32;
var param_67: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e123 = ReadSurface_u0028_();
s_10 = _e123;
let _e124 = s_10;
param_63 = _e124;
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_63));
let _e125 = param_63;
s_10 = _e125;
let _e127 = s_10.albedo;
let _e129 = s_10.ambient;
let _e130 = SampleLightmap_u0028_();
let _e134 = s_10.occlusion;
ambient = ((_e127 * (_e129 + _e130)) * _e134);
let _e136 = s_10;
param_64 = _e136;
let _e137 = 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_64));
let _e139 = s_10.occlusion;
let _e141 = ambient;
let _e144 = s_10.emissive;
param_65 = (((_e137 * _e139) + _e141) + _e144);
let _e147 = s_10.alpha;
param_66 = _e147;
let _e149 = s_10.roughness;
param_67 = _e149;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_65), (¶m_66), (¶m_67));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 2,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
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 FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
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(2)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(17)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var point_shadow_texture_smp: sampler;
@group(1) @binding(15)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(7)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(9)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(13)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var occlusion_texture_smp: sampler;
@group(1) @binding(5)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var emissive_texture_smp: sampler;
@group(1) @binding(11)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(19)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var shadow_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e121 = (*n)[0u];
let _e124 = (*n)[1u];
let _e128 = (*n)[2u];
let _e131 = (*n);
(*n) = (_e131 / vec3(((abs(_e121) + abs(_e124)) + abs(_e128))));
let _e134 = (*n);
e = _e134.xy;
let _e137 = (*n)[2u];
if (_e137 < 0f) {
let _e139 = (*n);
let _e145 = (*n)[0u];
let _e149 = (*n)[1u];
e = ((vec2(1f) - abs(_e139.yx)) * vec2<f32>(select(-1f, 1f, (_e145 >= 0f)), select(-1f, 1f, (_e149 >= 0f))));
}
let _e154 = e;
return ((_e154 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e118 = v_world_position_1;
let _e120 = fog_info.eye;
let _e124 = fog_info.forward;
return dot((_e118 - _e120.xyz), _e124.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e120 = g_debug_surface_on;
if _e120 {
let _e121 = g_debug_surface;
let _e122 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e121.x, _e121.y, _e121.z, _e122);
return;
}
let _e127 = v_normal_1;
param = normalize(_e127);
let _e129 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e130 = (*roughness);
let _e132 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e129.x, _e129.y, clamp(_e130, 0f, 1f), _e132);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e118 = v_world_position_1;
let _e120 = fog_info.eye;
return distance(_e118, _e120.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e123 = fog_info.fog[3u];
density = _e123;
let _e124 = density;
if (_e124 <= 0f) {
let _e126 = (*color);
return _e126;
}
let _e127 = EyeDistance_u0028_();
d = _e127;
let _e129 = fog_info.fog;
let _e131 = (*color);
let _e132 = density;
let _e134 = d;
return mix(_e129.xyz, _e131, vec3(clamp(exp((-(_e132) * _e134)), 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 _e123 = (*linearColor);
param_1 = _e123;
let _e124 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e125 = (*alpha);
frag_color = vec4<f32>(_e124.x, _e124.y, _e124.z, _e125);
let _e130 = (*roughness_1);
param_2 = _e130;
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 _e123 = (*s).roughness;
shininess = mix(256f, 4f, _e123);
let _e126 = (*light).n_dot_h;
let _e127 = shininess;
let _e131 = frag_info.material[3u];
specular = (pow(_e126, _e127) * _e131);
let _e134 = (*s).albedo;
let _e135 = specular;
return (_e134 + vec3(_e135));
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e119 = (*i);
if (_e119 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e121 = (*i);
if (_e121 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e123 = (*i);
if (_e123 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e125 = (*i);
if (_e125 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e127 = (*i);
if (_e127 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e129 = (*i);
if (_e129 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e131 = (*i);
if (_e131 == 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 _e124 = (*i_1);
param_3 = _e124;
let _e125 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e125;
let _e127 = p[0u];
let _e128 = (*ca);
let _e131 = p[1u];
let _e132 = (*sa);
let _e136 = p[0u];
let _e137 = (*sa);
let _e140 = p[1u];
let _e141 = (*ca);
let _e145 = (*radius);
return (vec2<f32>(((_e127 * _e128) - (_e131 * _e132)), ((_e136 * _e137) + (_e140 * _e141))) * _e145);
}
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 _e127 = point_shadow.params[0u];
inset = _e127;
let _e128 = (*uv);
let _e129 = (*offset);
let _e131 = inset;
let _e132 = inset;
local = clamp((_e128 + _e129), vec2(_e131), vec2((1f - _e132)));
let _e137 = local;
let _e138 = (*tile);
atlas = ((_e137 + _e138) * vec2<f32>(0.16666667f, 0.16666667f));
let _e143 = point_shadow.params3_[0u];
if (_e143 > 0.5f) {
let _e146 = atlas[1u];
atlas[1u] = (1f - _e146);
}
let _e149 = atlas;
let _e150 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e149, 0f);
let _e152 = atlas;
let _e153 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e152, 0f);
let _e156 = (*range);
return (min(_e150.x, _e153.x) * _e156);
}
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 _e128 = (*uv_1);
param_4 = _e128;
let _e129 = (*offset_1);
param_5 = _e129;
let _e130 = (*tile_1);
param_6 = _e130;
let _e131 = (*range_1);
param_7 = _e131;
let _e132 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e132;
let _e133 = stored;
let _e134 = (*range_1);
if (_e133 >= (_e134 * 0.999f)) {
return 1f;
}
let _e137 = (*receiver);
let _e138 = stored;
return select(1f, 0f, (_e137 > _e138));
}
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 _e149 = point_shadow.params2_[1u];
lightRadius = _e149;
let _e152 = point_shadow.params2_[0u];
minRadius = _e152;
let _e155 = point_shadow.params2_[2u];
maxRadius = _e155;
let _e156 = lightRadius;
if (_e156 <= 0f) {
let _e158 = (*uv_2);
param_8 = _e158;
param_9 = vec2<f32>(0f, 0f);
let _e159 = (*tile_2);
param_10 = _e159;
let _e160 = (*range_2);
param_11 = _e160;
let _e161 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e161;
let _e162 = minRadius;
return _e162;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e163 = i_2;
if (_e163 < 8i) {
let _e165 = i_2;
param_12 = _e165;
let _e166 = (*ca_1);
param_13 = _e166;
let _e167 = (*sa_1);
param_14 = _e167;
let _e168 = maxRadius;
param_15 = _e168;
let _e169 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e170 = (*uv_2);
param_16 = _e170;
param_17 = _e169;
let _e171 = (*tile_2);
param_18 = _e171;
let _e172 = (*range_2);
param_19 = _e172;
let _e173 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e173;
let _e174 = stored_1;
let _e175 = (*range_2);
if (_e174 >= (_e175 * 0.999f)) {
continue;
}
let _e178 = stored_1;
let _e179 = (*receiver_1);
if (_e178 >= _e179) {
continue;
}
let _e181 = stored_1;
let _e182 = sum;
sum = (_e182 + _e181);
let _e184 = count;
count = (_e184 + 1f);
continue;
} else {
break;
}
continuing {
let _e186 = i_2;
i_2 = (_e186 + 1i);
}
}
let _e188 = count;
if (_e188 < 0.5f) {
return -1f;
}
let _e190 = sum;
let _e191 = count;
blocker = max((_e190 / _e191), 0.0001f);
let _e194 = blocker;
(*blockerOut) = _e194;
let _e195 = lightRadius;
let _e196 = (*receiver_1);
let _e197 = blocker;
let _e201 = blocker;
world = ((_e195 * max((_e196 - _e197), 0f)) / _e201);
let _e203 = world;
let _e204 = (*receiver_1);
let _e206 = (*tanHalf);
let _e209 = minRadius;
let _e210 = maxRadius;
return clamp((_e203 / ((2f * _e204) * _e206)), _e209, _e210);
}
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_1005_: bool;
var phi_1067_: bool;
let _e171 = (*lightIndex);
let _e175 = point_shadow.slots[_e171][0u];
slot = i32((_e175 + 0.5f));
let _e178 = (*lightIndex);
let _e182 = point_shadow.slots[_e178][0u];
if (_e182 < 0f) {
return 1f;
}
let _e186 = point_shadow.params[2u];
strength = _e186;
let _e187 = strength;
if (_e187 <= 0f) {
return 1f;
}
let _e189 = slot;
let _e192 = point_shadow.lights[_e189];
let _e194 = (*world_1);
toLight = (_e192.xyz - _e194);
let _e196 = toLight;
toLightLength = max(length(_e196), 0.000001f);
let _e199 = (*normal);
let _e200 = toLight;
let _e201 = toLightLength;
nDotL = max(dot(_e199, (_e200 / vec3(_e201))), 0.15f);
let _e206 = nDotL;
let _e207 = nDotL;
let _e212 = nDotL;
let _e213 = nDotL;
slope = min((sqrt(max((1f - (_e206 * _e207)), 0f)) / (_e212 * _e213)), 8f);
let _e217 = toLightLength;
let _e219 = (*lightIndex);
let _e223 = point_shadow.slots[_e219][2u];
let _e228 = point_shadow.params3_[1u];
texel = (((2f * _e217) * max(_e223, 0.0001f)) * _e228);
let _e230 = (*world_1);
let _e231 = (*normal);
let _e232 = texel;
let _e236 = point_shadow.params[3u];
let _e238 = slope;
origin = (_e230 + (((_e231 * _e232) * _e236) * (1f + _e238)));
let _e242 = origin;
let _e243 = slot;
let _e246 = point_shadow.lights[_e243];
toFragment = (_e242 - _e246.xyz);
let _e249 = toFragment;
distance_ = length(_e249);
let _e251 = slot;
let _e255 = point_shadow.lights[_e251][3u];
range_3 = max(_e255, 0.0001f);
let _e257 = distance_;
let _e258 = range_3;
if (_e257 >= _e258) {
return 1f;
}
face = 0i;
let _e260 = (*lightIndex);
let _e264 = point_shadow.slots[_e260][1u];
if (_e264 < 0.5f) {
let _e266 = toFragment;
a = abs(_e266);
let _e269 = a[0u];
let _e271 = a[1u];
let _e272 = (_e269 >= _e271);
phi_1005_ = _e272;
if _e272 {
let _e274 = a[0u];
let _e276 = a[2u];
phi_1005_ = (_e274 >= _e276);
}
let _e279 = phi_1005_;
if _e279 {
let _e281 = toFragment[0u];
face = select(1i, 0i, (_e281 > 0f));
} else {
let _e285 = a[1u];
let _e287 = a[2u];
if (_e285 >= _e287) {
let _e290 = toFragment[1u];
face = select(3i, 2i, (_e290 > 0f));
} else {
let _e294 = toFragment[2u];
face = select(5i, 4i, (_e294 > 0f));
}
}
}
let _e297 = slot;
let _e299 = face;
let _e303 = point_shadow.faces[((_e297 * 6i) + _e299)];
let _e304 = origin;
clip = (_e303 * vec4<f32>(_e304.x, _e304.y, _e304.z, 1f));
let _e311 = clip[3u];
if (_e311 <= 0f) {
return 1f;
}
let _e313 = clip;
let _e316 = clip[3u];
ndc = (_e313.xy / vec2(_e316));
let _e320 = ndc[0u];
let _e322 = (abs(_e320) > 1f);
phi_1067_ = _e322;
if !(_e322) {
let _e325 = ndc[1u];
phi_1067_ = (abs(_e325) > 1f);
}
let _e329 = phi_1067_;
if _e329 {
return 1f;
}
let _e331 = ndc[0u];
let _e335 = ndc[1u];
uv_3 = vec2<f32>(((_e331 * 0.5f) + 0.5f), (0.5f - (_e335 * 0.5f)));
let _e339 = face;
let _e341 = slot;
tile_3 = vec2<f32>(f32(_e339), f32(_e341));
let _e344 = distance_;
let _e347 = point_shadow.params[1u];
receiver_2 = (_e344 - _e347);
let _e349 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e349.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e355 = noise;
angle = (_e355 * 6.2831855f);
let _e357 = angle;
ca_2 = cos(_e357);
let _e359 = angle;
sa_2 = sin(_e359);
let _e361 = (*lightIndex);
let _e365 = point_shadow.slots[_e361][2u];
tanHalf_1 = max(_e365, 0.0001f);
blocker_1 = -1f;
let _e367 = uv_3;
param_20 = _e367;
let _e368 = tile_3;
param_21 = _e368;
let _e369 = range_3;
param_22 = _e369;
let _e370 = receiver_2;
param_23 = _e370;
let _e371 = ca_2;
param_24 = _e371;
let _e372 = sa_2;
param_25 = _e372;
let _e373 = tanHalf_1;
param_26 = _e373;
let _e374 = 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 _e375 = param_27;
blocker_1 = _e375;
radius_1 = _e374;
let _e378 = point_shadow.params2_[3u];
if (_e378 > 0.5f) {
g_debug_surface_on = true;
let _e380 = radius_1;
if (_e380 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e382 = radius_1;
let _e385 = point_shadow.params2_[2u];
let _e389 = blocker_1;
let _e390 = range_3;
local_1 = vec3<f32>(clamp((_e382 / max(_e385, 0.000001f)), 0f, 1f), clamp((_e389 / _e390), 0f, 1f), 0f);
}
let _e394 = local_1;
g_debug_surface = _e394;
}
let _e395 = radius_1;
if (_e395 < 0f) {
return 1f;
}
let _e397 = uv_3;
param_28 = _e397;
param_29 = vec2<f32>(0f, 0f);
let _e398 = tile_3;
param_30 = _e398;
let _e399 = range_3;
param_31 = _e399;
let _e400 = receiver_2;
param_32 = _e400;
let _e401 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e401;
let _e402 = radius_1;
if (_e402 > 0f) {
i_3 = 0i;
loop {
let _e404 = i_3;
if (_e404 < 8i) {
let _e406 = i_3;
param_33 = _e406;
let _e407 = ca_2;
param_34 = _e407;
let _e408 = sa_2;
param_35 = _e408;
let _e409 = radius_1;
param_36 = _e409;
let _e410 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e411 = uv_3;
param_37 = _e411;
param_38 = _e410;
let _e412 = tile_3;
param_39 = _e412;
let _e413 = range_3;
param_40 = _e413;
let _e414 = receiver_2;
param_41 = _e414;
let _e415 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e416 = lit;
lit = (_e416 + _e415);
continue;
} else {
break;
}
continuing {
let _e418 = i_3;
i_3 = (_e418 + 1i);
}
}
let _e420 = lit;
lit = (_e420 * 0.11111111f);
}
let _e422 = lit;
let _e423 = strength;
return mix(1f, _e422, clamp(_e423, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var phi_1506_: bool;
var phi_1517_: bool;
var phi_1607_: bool;
var phi_1614_: bool;
var phi_1621_: bool;
let _e145 = frag_info.shadow_params[3u];
strength_1 = _e145;
let _e146 = strength_1;
if (_e146 <= 0f) {
return 1f;
}
let _e148 = (*lightIndex_1);
let _e151 = frag_info.frame_params[2u];
if (_e148 != i32((_e151 + 0.5f))) {
return 1f;
}
let _e155 = v_world_position_1;
let _e157 = (*s_1).n;
let _e160 = frag_info.shadow_params[2u];
origin_1 = (_e155 + (_e157 * _e160));
let _e165 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e165 + 0.5f));
let _e168 = v_world_position_1;
let _e170 = frag_info.camera_position;
viewDistance = length((_e168 - _e170.xyz));
cascade = 0i;
let _e174 = cascadeCount;
let _e175 = (_e174 > 1i);
phi_1506_ = _e175;
if _e175 {
let _e176 = viewDistance;
let _e179 = frag_info.shadow_cascades[0u];
phi_1506_ = (_e176 > _e179);
}
let _e182 = phi_1506_;
if _e182 {
cascade = 1i;
}
let _e183 = cascadeCount;
let _e184 = (_e183 > 2i);
phi_1517_ = _e184;
if _e184 {
let _e185 = viewDistance;
let _e188 = frag_info.shadow_cascades[1u];
phi_1517_ = (_e185 > _e188);
}
let _e191 = phi_1517_;
if _e191 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e192 = attempt;
if (_e192 < 3i) {
let _e194 = cascade;
let _e195 = attempt;
which = (_e194 + _e195);
let _e197 = which;
let _e198 = cascadeCount;
if (_e197 >= _e198) {
break;
}
let _e200 = which;
if (_e200 == 0i) {
let _e203 = frag_info.shadow_matrix;
local_2 = _e203;
} else {
let _e204 = which;
if (_e204 == 1i) {
let _e207 = frag_info.shadow_matrix_far;
local_3 = _e207;
} else {
let _e209 = frag_info.shadow_matrix_farthest;
local_3 = _e209;
}
let _e210 = local_3;
local_2 = _e210;
}
let _e211 = local_2;
matrix = _e211;
let _e212 = matrix;
let _e213 = origin_1;
lightSpace = (_e212 * vec4<f32>(_e213.x, _e213.y, _e213.z, 1f));
let _e220 = lightSpace[3u];
if (_e220 <= 0f) {
continue;
}
let _e222 = lightSpace;
let _e225 = lightSpace[3u];
candidate = (_e222.xyz / vec3(_e225));
let _e229 = candidate[0u];
let _e233 = candidate[1u];
inTile = vec2<f32>(((_e229 * 0.5f) + 0.5f), (0.5f - (_e233 * 0.5f)));
let _e238 = inTile[0u];
let _e239 = (_e238 < 0f);
phi_1607_ = _e239;
if !(_e239) {
let _e242 = inTile[0u];
phi_1607_ = (_e242 > 1f);
}
let _e245 = phi_1607_;
phi_1614_ = _e245;
if !(_e245) {
let _e248 = inTile[1u];
phi_1614_ = (_e248 < 0f);
}
let _e251 = phi_1614_;
phi_1621_ = _e251;
if !(_e251) {
let _e254 = inTile[1u];
phi_1621_ = (_e254 > 1f);
}
let _e257 = phi_1621_;
if _e257 {
continue;
}
let _e259 = candidate[2u];
if (_e259 > 1f) {
continue;
}
let _e262 = inTile[0u];
let _e263 = which;
let _e266 = cascadeCount;
let _e270 = inTile[1u];
uv_4 = vec2<f32>(((_e262 + f32(_e263)) / f32(_e266)), _e270);
let _e272 = candidate;
projected = _e272;
let _e273 = which;
cascade = _e273;
found = true;
break;
} else {
break;
}
continuing {
let _e274 = attempt;
attempt = (_e274 + 1i);
}
}
let _e276 = found;
if !(_e276) {
return 1f;
}
let _e280 = frag_info.shadow_params[1u];
bias = _e280;
let _e283 = frag_info.shadow_params[0u];
let _e286 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e283, _e286);
lit_1 = 0f;
y = -1i;
loop {
let _e288 = y;
if (_e288 <= 1i) {
x = -1i;
loop {
let _e290 = x;
if (_e290 <= 1i) {
let _e292 = uv_4;
let _e293 = x;
let _e295 = y;
let _e298 = texel_1;
let _e301 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e292 + (vec2<f32>(f32(_e293), f32(_e295)) * _e298)), 0f);
occluder = _e301.x;
let _e304 = projected[2u];
let _e305 = bias;
let _e307 = occluder;
let _e310 = lit_1;
lit_1 = (_e310 + select(1f, 0f, ((_e304 - _e305) > _e307)));
continue;
} else {
break;
}
continuing {
let _e312 = x;
x = (_e312 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e314 = y;
y = (_e314 + 1i);
}
}
let _e316 = lit_1;
lit_1 = (_e316 * 0.11111111f);
let _e318 = lit_1;
let _e319 = strength_1;
return mix(1f, _e318, clamp(_e319, 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 _e124 = (*s_2);
param_42 = _e124;
let _e125 = (*light_2);
param_43 = _e125;
let _e126 = (*index);
param_44 = _e126;
let _e127 = 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 _e127;
}
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 _e123 = (*distance_1);
let _e124 = (*distance_1);
attenuation = (1f / max((_e123 * _e124), 0.0001f));
let _e128 = (*range_4);
if (_e128 > 0f) {
let _e130 = (*distance_1);
let _e131 = (*range_4);
ratio = (_e130 / _e131);
let _e133 = ratio;
let _e134 = ratio;
let _e136 = ratio;
let _e138 = ratio;
window = clamp((1f - (((_e133 * _e134) * _e136) * _e138)), 0f, 1f);
let _e142 = window;
let _e143 = window;
let _e145 = attenuation;
attenuation = (_e145 * (_e142 * _e143));
}
let _e147 = attenuation;
return _e147;
}
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_1: 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 type_33: f32;
var aim: vec3<f32>;
var attenuation_1: f32;
var light_3: LightSample;
var toLight_1: vec3<f32>;
var distance_2: f32;
var param_45: f32;
var param_46: f32;
var cosAngle: f32;
let _e133 = (*index_1);
let _e136 = frag_info.light_position[_e133];
position = _e136;
let _e137 = (*index_1);
let _e140 = frag_info.light_color[_e137];
color_1 = _e140;
let _e141 = (*index_1);
let _e144 = frag_info.light_direction[_e141];
direction = _e144;
let _e145 = (*index_1);
let _e148 = frag_info.light_cone[_e145];
cone = _e148;
let _e150 = position[3u];
type_33 = _e150;
let _e151 = direction;
aim = normalize(_e151.xyz);
attenuation_1 = 1f;
let _e154 = type_33;
if (_e154 < 0.5f) {
let _e156 = aim;
light_3.l = -(_e156);
} else {
let _e159 = position;
let _e161 = v_world_position_1;
toLight_1 = (_e159.xyz - _e161);
let _e163 = toLight_1;
distance_2 = length(_e163);
let _e165 = distance_2;
if (_e165 < 0.000001f) {
let _e168 = (*s_3).n;
light_3.l = _e168;
let _e171 = (*s_3).n;
light_3.h = _e171;
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 _e177 = light_3;
return _e177;
}
let _e178 = toLight_1;
let _e179 = distance_2;
light_3.l = (_e178 / vec3(_e179));
let _e183 = distance_2;
param_45 = _e183;
let _e185 = direction[3u];
param_46 = _e185;
let _e186 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_45), (¶m_46));
attenuation_1 = _e186;
let _e187 = type_33;
if (_e187 > 1.5f) {
let _e189 = aim;
let _e191 = light_3.l;
cosAngle = dot(_e189, -(_e191));
let _e194 = cosAngle;
let _e196 = cone[1u];
let _e199 = cone[0u];
let _e201 = cone[1u];
let _e205 = attenuation_1;
attenuation_1 = (_e205 * clamp(((_e194 - _e196) / (_e199 - _e201)), 0f, 1f));
}
}
let _e208 = light_3.l;
let _e210 = (*s_3).v;
light_3.h = normalize((_e208 + _e210));
let _e215 = (*s_3).n;
let _e217 = light_3.l;
light_3.n_dot_l = max(dot(_e215, _e217), 0f);
let _e222 = (*s_3).n;
let _e224 = light_3.h;
light_3.n_dot_h = max(dot(_e222, _e224), 0f);
let _e229 = (*s_3).v;
let _e231 = light_3.h;
light_3.v_dot_h = max(dot(_e229, _e231), 0f);
let _e235 = color_1;
let _e238 = color_1[3u];
let _e240 = attenuation_1;
light_3.radiance = ((_e235.xyz * _e238) * _e240);
let _e243 = light_3;
return _e243;
}
fn LightCount_u0028_() -> i32 {
let _e120 = frag_info.frame_params[1u];
return clamp(i32((_e120 + 0.5f)), 0i, 8i);
}
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: vec3<f32>;
var count_1: i32;
var i_4: i32;
var light_4: LightSample;
var param_47: i32;
var param_48: Surface;
var visibility: f32;
var param_49: Surface;
var param_50: LightSample;
var param_51: i32;
var param_52: vec3<f32>;
var param_53: vec3<f32>;
var param_54: i32;
var param_55: Surface;
var param_56: LightSample;
total = vec3<f32>(0f, 0f, 0f);
let _e134 = LightCount_u0028_();
count_1 = _e134;
i_4 = 0i;
loop {
let _e135 = i_4;
if (_e135 < 8i) {
let _e137 = i_4;
let _e138 = count_1;
if (_e137 >= _e138) {
break;
}
let _e140 = i_4;
param_47 = _e140;
let _e141 = (*s_4);
param_48 = _e141;
let _e142 = 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_47), (¶m_48));
light_4 = _e142;
let _e144 = light_4.n_dot_l;
if (_e144 <= 0f) {
continue;
}
let _e146 = (*s_4);
param_49 = _e146;
let _e147 = light_4;
param_50 = _e147;
let _e148 = i_4;
param_51 = _e148;
let _e149 = 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_49), (¶m_50), (¶m_51));
let _e150 = v_world_position_1;
param_52 = _e150;
let _e152 = (*s_4).n;
param_53 = _e152;
let _e153 = i_4;
param_54 = _e153;
let _e154 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_52), (¶m_53), (¶m_54));
visibility = (_e149 * _e154);
let _e156 = visibility;
if (_e156 <= 0f) {
continue;
}
let _e158 = (*s_4);
param_55 = _e158;
let _e159 = light_4;
param_56 = _e159;
let _e160 = 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_55), (¶m_56));
let _e162 = light_4.radiance;
let _e165 = light_4.n_dot_l;
let _e167 = visibility;
let _e169 = total;
total = (_e169 + (((_e160 * _e162) * _e165) * _e167));
continue;
} else {
break;
}
continuing {
let _e171 = i_4;
i_4 = (_e171 + 1i);
}
}
let _e173 = total;
return _e173;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e119 = v_lightmap_uv_1;
let _e120 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e119);
texel_2 = _e120;
let _e121 = texel_2;
let _e124 = texel_2[3u];
return ((_e121.xyz * _e124) * 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 _e120 = v_texcoord_1;
let _e121 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e120);
orm = _e121.xyz;
let _e124 = (*s_5).metallic;
let _e126 = orm[2u];
(*s_5).metallic = clamp((_e124 * _e126), 0f, 1f);
let _e131 = (*s_5).roughness;
let _e133 = orm[1u];
(*s_5).roughness = clamp((_e131 * _e133), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e119 = (*srgb);
let _e122 = (*srgb);
let _e127 = (*srgb);
return mix((_e119 / vec3(12.92f)), pow(((_e122 + 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), _e127));
}
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_57: vec3<f32>;
let _e121 = v_texcoord_1;
let _e122 = textureSample(emissive_texture_tex, emissive_texture_smp, _e121);
param_57 = _e122.xyz;
let _e124 = SrgbToLinear_u0028_vf3_u003b((¶m_57));
emissive = _e124;
let _e125 = emissive;
let _e127 = frag_info.emissive;
let _e132 = frag_info.material2_[3u];
(*s_6).emissive = ((_e125 * _e127.xyz) * _e132);
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 _e120 = v_texcoord_1;
let _e121 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e120);
occlusion = _e121.x;
let _e123 = occlusion;
let _e126 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e123, clamp(_e126, 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: vec3<f32>;
var b: vec3<f32>;
var sampled: vec3<f32>;
let _e123 = v_texcoord_1;
let _e124 = textureSample(normal_texture_tex, normal_texture_smp, _e123);
sampledTexel = _e124;
let _e125 = v_tangent_1;
t = _e125.xyz;
let _e127 = t;
let _e129 = (*s_8).n;
let _e131 = (*s_8).n;
let _e132 = t;
t = (_e127 - (_e129 * dot(_e131, _e132)));
let _e136 = t;
let _e137 = t;
if (dot(_e136, _e137) < 0.000000000001f) {
return;
}
let _e140 = t;
t = normalize(_e140);
let _e143 = (*s_8).n;
let _e144 = t;
let _e147 = v_tangent_1[3u];
b = (cross(_e143, _e144) * _e147);
let _e149 = sampledTexel;
sampled = ((_e149.xyz * 2f) - vec3(1f));
let _e156 = frag_info.material2_[1u];
let _e157 = sampled;
let _e159 = (_e157.xy * _e156);
sampled[0u] = _e159.x;
sampled[1u] = _e159.y;
let _e164 = t;
let _e166 = sampled[0u];
let _e168 = b;
let _e170 = sampled[1u];
let _e174 = (*s_8).n;
let _e176 = sampled[2u];
(*s_8).n = normalize((((_e164 * _e166) + (_e168 * _e170)) + (_e174 * _e176)));
let _e182 = (*s_8).n;
let _e184 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e182, _e184), 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_58: Surface;
var param_59: Surface;
var param_60: Surface;
let _e122 = (*s_9);
param_58 = _e122;
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_58));
let _e123 = param_58;
(*s_9) = _e123;
let _e124 = (*s_9);
param_59 = _e124;
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_59));
let _e125 = param_59;
(*s_9) = _e125;
let _e126 = (*s_9);
param_60 = _e126;
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_60));
let _e127 = param_60;
(*s_9) = _e127;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_61: vec3<f32>;
var param_62: vec3<f32>;
var cutoff: f32;
var phi_376_: bool;
let _e123 = v_texcoord_1;
let _e124 = textureSample(base_color_texture_tex, base_color_texture_smp, _e123);
texel_3 = _e124;
let _e125 = texel_3;
param_61 = _e125.xyz;
let _e127 = SrgbToLinear_u0028_vf3_u003b((¶m_61));
let _e129 = frag_info.base_color;
param_62 = _e129.xyz;
let _e131 = SrgbToLinear_u0028_vf3_u003b((¶m_62));
let _e133 = v_color_1;
s_10.albedo = ((_e127 * _e131) * _e133.xyz);
let _e138 = texel_3[3u];
let _e141 = frag_info.base_color[3u];
let _e144 = v_color_1[3u];
s_10.alpha = ((_e138 * _e141) * _e144);
let _e149 = frag_info.material2_[0u];
cutoff = _e149;
let _e150 = cutoff;
let _e151 = (_e150 >= 0f);
phi_376_ = _e151;
if _e151 {
let _e153 = s_10.alpha;
let _e154 = cutoff;
phi_376_ = (_e153 < _e154);
}
let _e157 = phi_376_;
if _e157 {
discard;
}
let _e158 = v_normal_1;
s_10.n = normalize(_e158);
let _e162 = frag_info.camera_position;
let _e164 = v_world_position_1;
s_10.v = normalize((_e162.xyz - _e164));
let _e169 = s_10.n;
let _e171 = s_10.v;
s_10.n_dot_v = max(dot(_e169, _e171), 0.0001f);
let _e177 = frag_info.material[0u];
s_10.metallic = clamp(_e177, 0f, 1f);
let _e182 = frag_info.material[1u];
s_10.roughness = clamp(_e182, 0.02f, 1f);
let _e186 = frag_info.ambient_ground;
let _e189 = frag_info.ambient_sky;
let _e193 = s_10.n[1u];
let _e200 = frag_info.material[2u];
s_10.ambient = (mix(_e186.xyz, _e189.xyz, vec3(((_e193 * 0.5f) + 0.5f))) * _e200);
let _e205 = frag_info.frame_params[0u];
s_10.exposure = max(_e205, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e210 = s_10;
return _e210;
}
fn main_1() {
var s_11: Surface;
var param_63: Surface;
var param_64: Surface;
var ambient: vec3<f32>;
var param_65: Surface;
var param_66: vec3<f32>;
var param_67: f32;
var param_68: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e126 = ReadSurface_u0028_();
s_11 = _e126;
let _e127 = s_11;
param_63 = _e127;
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_63));
let _e128 = param_63;
s_11 = _e128;
let _e129 = s_11;
param_64 = _e129;
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_64));
let _e130 = param_64;
s_11 = _e130;
let _e132 = s_11.albedo;
let _e134 = s_11.ambient;
let _e135 = SampleLightmap_u0028_();
let _e139 = s_11.occlusion;
ambient = ((_e132 * (_e134 + _e135)) * _e139);
let _e141 = s_11;
param_65 = _e141;
let _e142 = 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_65));
let _e144 = s_11.occlusion;
let _e146 = ambient;
let _e149 = s_11.emissive;
param_66 = (((_e142 * _e144) + _e146) + _e149);
let _e152 = s_11.alpha;
param_67 = _e152;
let _e154 = s_11.roughness;
param_68 = _e154;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_66), (¶m_67), (¶m_68));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 2,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
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 FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
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(2)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(19)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var point_shadow_texture_smp: sampler;
@group(1) @binding(17)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(9)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(11)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(15)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var occlusion_texture_smp: sampler;
@group(1) @binding(5)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var emissive_texture_smp: sampler;
@group(1) @binding(13)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(21)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var shadow_texture_smp: sampler;
@group(1) @binding(7)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(8)
var environment_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e138 = (*n)[0u];
let _e141 = (*n)[1u];
let _e145 = (*n)[2u];
let _e148 = (*n);
(*n) = (_e148 / vec3(((abs(_e138) + abs(_e141)) + abs(_e145))));
let _e151 = (*n);
e = _e151.xy;
let _e154 = (*n)[2u];
if (_e154 < 0f) {
let _e156 = (*n);
let _e162 = (*n)[0u];
let _e166 = (*n)[1u];
e = ((vec2(1f) - abs(_e156.yx)) * vec2<f32>(select(-1f, 1f, (_e162 >= 0f)), select(-1f, 1f, (_e166 >= 0f))));
}
let _e171 = e;
return ((_e171 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e135 = v_world_position_1;
let _e137 = fog_info.eye;
let _e141 = fog_info.forward;
return dot((_e135 - _e137.xyz), _e141.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e137 = g_debug_surface_on;
if _e137 {
let _e138 = g_debug_surface;
let _e139 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e138.x, _e138.y, _e138.z, _e139);
return;
}
let _e144 = v_normal_1;
param = normalize(_e144);
let _e146 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e147 = (*roughness);
let _e149 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e146.x, _e146.y, clamp(_e147, 0f, 1f), _e149);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e135 = v_world_position_1;
let _e137 = fog_info.eye;
return distance(_e135, _e137.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e140 = fog_info.fog[3u];
density = _e140;
let _e141 = density;
if (_e141 <= 0f) {
let _e143 = (*color);
return _e143;
}
let _e144 = EyeDistance_u0028_();
d = _e144;
let _e146 = fog_info.fog;
let _e148 = (*color);
let _e149 = density;
let _e151 = d;
return mix(_e146.xyz, _e148, vec3(clamp(exp((-(_e149) * _e151)), 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 _e140 = (*linearColor);
param_1 = _e140;
let _e141 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e142 = (*alpha);
frag_color = vec4<f32>(_e141.x, _e141.y, _e141.z, _e142);
let _e147 = (*roughness_1);
param_2 = _e147;
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 _e138 = (*v_dot_h);
f = pow((1f - _e138), 5f);
let _e141 = (*f0_);
let _e142 = (*f0_);
let _e144 = f;
return (_e141 + ((vec3<f32>(1f, 1f, 1f) - _e142) * _e144));
}
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 _e141 = (*alpha_1);
let _e142 = (*alpha_1);
a2_ = (_e141 * _e142);
let _e144 = (*n_dot_l);
let _e145 = (*n_dot_v);
let _e146 = (*n_dot_v);
let _e148 = a2_;
let _e151 = a2_;
lambda_v = (_e144 * sqrt((((_e145 * _e146) * (1f - _e148)) + _e151)));
let _e155 = (*n_dot_v);
let _e156 = (*n_dot_l);
let _e157 = (*n_dot_l);
let _e159 = a2_;
let _e162 = a2_;
lambda_l = (_e155 * sqrt((((_e156 * _e157) * (1f - _e159)) + _e162)));
let _e166 = lambda_v;
let _e167 = lambda_l;
return (0.5f / max((_e166 + _e167), 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 _e139 = (*n_dot_h);
let _e140 = (*alpha_2);
a = (_e139 * _e140);
let _e142 = (*alpha_2);
let _e143 = (*n_dot_h);
let _e144 = (*n_dot_h);
let _e147 = a;
let _e148 = a;
k = (_e142 / max(((1f - (_e143 * _e144)) + (_e147 * _e148)), 0.000001f));
let _e153 = k;
let _e154 = k;
return ((_e153 * _e154) * 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 _e153 = (*s).roughness;
let _e155 = (*s).roughness;
alpha_3 = (_e153 * _e155);
let _e158 = (*s).albedo;
let _e160 = (*s).metallic;
f0_1 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e158, vec3(_e160));
let _e164 = (*s).albedo;
let _e166 = (*s).metallic;
diffuseColor = (_e164 * (1f - _e166));
let _e170 = (*light).n_dot_h;
param_3 = _e170;
let _e171 = alpha_3;
param_4 = _e171;
let _e172 = D_GGX_u0028_f1_u003b_f1_u003b((¶m_3), (¶m_4));
d_1 = _e172;
let _e174 = (*s).n_dot_v;
param_5 = _e174;
let _e176 = (*light).n_dot_l;
param_6 = _e176;
let _e177 = alpha_3;
param_7 = _e177;
let _e178 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((¶m_5), (¶m_6), (¶m_7));
vis = _e178;
let _e179 = f0_1;
param_8 = _e179;
let _e181 = (*light).v_dot_h;
param_9 = _e181;
let _e182 = F_Schlick_u0028_vf3_u003b_f1_u003b((¶m_8), (¶m_9));
f_1 = _e182;
let _e183 = d_1;
let _e184 = vis;
let _e186 = f_1;
let _e190 = frag_info.material[3u];
specular = ((_e186 * (_e183 * _e184)) * _e190);
let _e192 = diffuseColor;
let _e193 = f_1;
diffuse = ((_e192 * (vec3<f32>(1f, 1f, 1f) - _e193)) / vec3(3.1415927f));
let _e198 = diffuse;
let _e199 = specular;
return ((_e198 + _e199) * 3.1415927f);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e136 = (*i);
if (_e136 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e138 = (*i);
if (_e138 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e140 = (*i);
if (_e140 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e142 = (*i);
if (_e142 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e144 = (*i);
if (_e144 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e146 = (*i);
if (_e146 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e148 = (*i);
if (_e148 == 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 _e141 = (*i_1);
param_10 = _e141;
let _e142 = PointShadowDiskTap_u0028_i1_u003b((¶m_10));
p = _e142;
let _e144 = p[0u];
let _e145 = (*ca);
let _e148 = p[1u];
let _e149 = (*sa);
let _e153 = p[0u];
let _e154 = (*sa);
let _e157 = p[1u];
let _e158 = (*ca);
let _e162 = (*radius);
return (vec2<f32>(((_e144 * _e145) - (_e148 * _e149)), ((_e153 * _e154) + (_e157 * _e158))) * _e162);
}
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 _e144 = point_shadow.params[0u];
inset = _e144;
let _e145 = (*uv);
let _e146 = (*offset);
let _e148 = inset;
let _e149 = inset;
local = clamp((_e145 + _e146), vec2(_e148), vec2((1f - _e149)));
let _e154 = local;
let _e155 = (*tile);
atlas = ((_e154 + _e155) * vec2<f32>(0.16666667f, 0.16666667f));
let _e160 = point_shadow.params3_[0u];
if (_e160 > 0.5f) {
let _e163 = atlas[1u];
atlas[1u] = (1f - _e163);
}
let _e166 = atlas;
let _e167 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e166, 0f);
let _e169 = atlas;
let _e170 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e169, 0f);
let _e173 = (*range);
return (min(_e167.x, _e170.x) * _e173);
}
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 _e145 = (*uv_1);
param_11 = _e145;
let _e146 = (*offset_1);
param_12 = _e146;
let _e147 = (*tile_1);
param_13 = _e147;
let _e148 = (*range_1);
param_14 = _e148;
let _e149 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_11), (¶m_12), (¶m_13), (¶m_14));
stored = _e149;
let _e150 = stored;
let _e151 = (*range_1);
if (_e150 >= (_e151 * 0.999f)) {
return 1f;
}
let _e154 = (*receiver);
let _e155 = stored;
return select(1f, 0f, (_e154 > _e155));
}
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 _e166 = point_shadow.params2_[1u];
lightRadius = _e166;
let _e169 = point_shadow.params2_[0u];
minRadius = _e169;
let _e172 = point_shadow.params2_[2u];
maxRadius = _e172;
let _e173 = lightRadius;
if (_e173 <= 0f) {
let _e175 = (*uv_2);
param_15 = _e175;
param_16 = vec2<f32>(0f, 0f);
let _e176 = (*tile_2);
param_17 = _e176;
let _e177 = (*range_2);
param_18 = _e177;
let _e178 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_15), (¶m_16), (¶m_17), (¶m_18));
(*blockerOut) = _e178;
let _e179 = minRadius;
return _e179;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e180 = i_2;
if (_e180 < 8i) {
let _e182 = i_2;
param_19 = _e182;
let _e183 = (*ca_1);
param_20 = _e183;
let _e184 = (*sa_1);
param_21 = _e184;
let _e185 = maxRadius;
param_22 = _e185;
let _e186 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_19), (¶m_20), (¶m_21), (¶m_22));
let _e187 = (*uv_2);
param_23 = _e187;
param_24 = _e186;
let _e188 = (*tile_2);
param_25 = _e188;
let _e189 = (*range_2);
param_26 = _e189;
let _e190 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_23), (¶m_24), (¶m_25), (¶m_26));
stored_1 = _e190;
let _e191 = stored_1;
let _e192 = (*range_2);
if (_e191 >= (_e192 * 0.999f)) {
continue;
}
let _e195 = stored_1;
let _e196 = (*receiver_1);
if (_e195 >= _e196) {
continue;
}
let _e198 = stored_1;
let _e199 = sum;
sum = (_e199 + _e198);
let _e201 = count;
count = (_e201 + 1f);
continue;
} else {
break;
}
continuing {
let _e203 = i_2;
i_2 = (_e203 + 1i);
}
}
let _e205 = count;
if (_e205 < 0.5f) {
return -1f;
}
let _e207 = sum;
let _e208 = count;
blocker = max((_e207 / _e208), 0.0001f);
let _e211 = blocker;
(*blockerOut) = _e211;
let _e212 = lightRadius;
let _e213 = (*receiver_1);
let _e214 = blocker;
let _e218 = blocker;
world = ((_e212 * max((_e213 - _e214), 0f)) / _e218);
let _e220 = world;
let _e221 = (*receiver_1);
let _e223 = (*tanHalf);
let _e226 = minRadius;
let _e227 = maxRadius;
return clamp((_e220 / ((2f * _e221) * _e223)), _e226, _e227);
}
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_1025_: bool;
var phi_1087_: bool;
let _e188 = (*lightIndex);
let _e192 = point_shadow.slots[_e188][0u];
slot = i32((_e192 + 0.5f));
let _e195 = (*lightIndex);
let _e199 = point_shadow.slots[_e195][0u];
if (_e199 < 0f) {
return 1f;
}
let _e203 = point_shadow.params[2u];
strength = _e203;
let _e204 = strength;
if (_e204 <= 0f) {
return 1f;
}
let _e206 = slot;
let _e209 = point_shadow.lights[_e206];
let _e211 = (*world_1);
toLight = (_e209.xyz - _e211);
let _e213 = toLight;
toLightLength = max(length(_e213), 0.000001f);
let _e216 = (*normal);
let _e217 = toLight;
let _e218 = toLightLength;
nDotL = max(dot(_e216, (_e217 / vec3(_e218))), 0.15f);
let _e223 = nDotL;
let _e224 = nDotL;
let _e229 = nDotL;
let _e230 = nDotL;
slope = min((sqrt(max((1f - (_e223 * _e224)), 0f)) / (_e229 * _e230)), 8f);
let _e234 = toLightLength;
let _e236 = (*lightIndex);
let _e240 = point_shadow.slots[_e236][2u];
let _e245 = point_shadow.params3_[1u];
texel = (((2f * _e234) * max(_e240, 0.0001f)) * _e245);
let _e247 = (*world_1);
let _e248 = (*normal);
let _e249 = texel;
let _e253 = point_shadow.params[3u];
let _e255 = slope;
origin = (_e247 + (((_e248 * _e249) * _e253) * (1f + _e255)));
let _e259 = origin;
let _e260 = slot;
let _e263 = point_shadow.lights[_e260];
toFragment = (_e259 - _e263.xyz);
let _e266 = toFragment;
distance_ = length(_e266);
let _e268 = slot;
let _e272 = point_shadow.lights[_e268][3u];
range_3 = max(_e272, 0.0001f);
let _e274 = distance_;
let _e275 = range_3;
if (_e274 >= _e275) {
return 1f;
}
face = 0i;
let _e277 = (*lightIndex);
let _e281 = point_shadow.slots[_e277][1u];
if (_e281 < 0.5f) {
let _e283 = toFragment;
a_1 = abs(_e283);
let _e286 = a_1[0u];
let _e288 = a_1[1u];
let _e289 = (_e286 >= _e288);
phi_1025_ = _e289;
if _e289 {
let _e291 = a_1[0u];
let _e293 = a_1[2u];
phi_1025_ = (_e291 >= _e293);
}
let _e296 = phi_1025_;
if _e296 {
let _e298 = toFragment[0u];
face = select(1i, 0i, (_e298 > 0f));
} else {
let _e302 = a_1[1u];
let _e304 = a_1[2u];
if (_e302 >= _e304) {
let _e307 = toFragment[1u];
face = select(3i, 2i, (_e307 > 0f));
} else {
let _e311 = toFragment[2u];
face = select(5i, 4i, (_e311 > 0f));
}
}
}
let _e314 = slot;
let _e316 = face;
let _e320 = point_shadow.faces[((_e314 * 6i) + _e316)];
let _e321 = origin;
clip = (_e320 * vec4<f32>(_e321.x, _e321.y, _e321.z, 1f));
let _e328 = clip[3u];
if (_e328 <= 0f) {
return 1f;
}
let _e330 = clip;
let _e333 = clip[3u];
ndc = (_e330.xy / vec2(_e333));
let _e337 = ndc[0u];
let _e339 = (abs(_e337) > 1f);
phi_1087_ = _e339;
if !(_e339) {
let _e342 = ndc[1u];
phi_1087_ = (abs(_e342) > 1f);
}
let _e346 = phi_1087_;
if _e346 {
return 1f;
}
let _e348 = ndc[0u];
let _e352 = ndc[1u];
uv_3 = vec2<f32>(((_e348 * 0.5f) + 0.5f), (0.5f - (_e352 * 0.5f)));
let _e356 = face;
let _e358 = slot;
tile_3 = vec2<f32>(f32(_e356), f32(_e358));
let _e361 = distance_;
let _e364 = point_shadow.params[1u];
receiver_2 = (_e361 - _e364);
let _e366 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e366.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e372 = noise;
angle = (_e372 * 6.2831855f);
let _e374 = angle;
ca_2 = cos(_e374);
let _e376 = angle;
sa_2 = sin(_e376);
let _e378 = (*lightIndex);
let _e382 = point_shadow.slots[_e378][2u];
tanHalf_1 = max(_e382, 0.0001f);
blocker_1 = -1f;
let _e384 = uv_3;
param_27 = _e384;
let _e385 = tile_3;
param_28 = _e385;
let _e386 = range_3;
param_29 = _e386;
let _e387 = receiver_2;
param_30 = _e387;
let _e388 = ca_2;
param_31 = _e388;
let _e389 = sa_2;
param_32 = _e389;
let _e390 = tanHalf_1;
param_33 = _e390;
let _e391 = 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 _e392 = param_34;
blocker_1 = _e392;
radius_1 = _e391;
let _e395 = point_shadow.params2_[3u];
if (_e395 > 0.5f) {
g_debug_surface_on = true;
let _e397 = radius_1;
if (_e397 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e399 = radius_1;
let _e402 = point_shadow.params2_[2u];
let _e406 = blocker_1;
let _e407 = range_3;
local_1 = vec3<f32>(clamp((_e399 / max(_e402, 0.000001f)), 0f, 1f), clamp((_e406 / _e407), 0f, 1f), 0f);
}
let _e411 = local_1;
g_debug_surface = _e411;
}
let _e412 = radius_1;
if (_e412 < 0f) {
return 1f;
}
let _e414 = uv_3;
param_35 = _e414;
param_36 = vec2<f32>(0f, 0f);
let _e415 = tile_3;
param_37 = _e415;
let _e416 = range_3;
param_38 = _e416;
let _e417 = receiver_2;
param_39 = _e417;
let _e418 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_35), (¶m_36), (¶m_37), (¶m_38), (¶m_39));
lit = _e418;
let _e419 = radius_1;
if (_e419 > 0f) {
i_3 = 0i;
loop {
let _e421 = i_3;
if (_e421 < 8i) {
let _e423 = i_3;
param_40 = _e423;
let _e424 = ca_2;
param_41 = _e424;
let _e425 = sa_2;
param_42 = _e425;
let _e426 = radius_1;
param_43 = _e426;
let _e427 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_40), (¶m_41), (¶m_42), (¶m_43));
let _e428 = uv_3;
param_44 = _e428;
param_45 = _e427;
let _e429 = tile_3;
param_46 = _e429;
let _e430 = range_3;
param_47 = _e430;
let _e431 = receiver_2;
param_48 = _e431;
let _e432 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_44), (¶m_45), (¶m_46), (¶m_47), (¶m_48));
let _e433 = lit;
lit = (_e433 + _e432);
continue;
} else {
break;
}
continuing {
let _e435 = i_3;
i_3 = (_e435 + 1i);
}
}
let _e437 = lit;
lit = (_e437 * 0.11111111f);
}
let _e439 = lit;
let _e440 = strength;
return mix(1f, _e439, clamp(_e440, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var phi_1526_: bool;
var phi_1537_: bool;
var phi_1627_: bool;
var phi_1634_: bool;
var phi_1641_: bool;
let _e162 = frag_info.shadow_params[3u];
strength_1 = _e162;
let _e163 = strength_1;
if (_e163 <= 0f) {
return 1f;
}
let _e165 = (*lightIndex_1);
let _e168 = frag_info.frame_params[2u];
if (_e165 != i32((_e168 + 0.5f))) {
return 1f;
}
let _e172 = v_world_position_1;
let _e174 = (*s_1).n;
let _e177 = frag_info.shadow_params[2u];
origin_1 = (_e172 + (_e174 * _e177));
let _e182 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e182 + 0.5f));
let _e185 = v_world_position_1;
let _e187 = frag_info.camera_position;
viewDistance = length((_e185 - _e187.xyz));
cascade = 0i;
let _e191 = cascadeCount;
let _e192 = (_e191 > 1i);
phi_1526_ = _e192;
if _e192 {
let _e193 = viewDistance;
let _e196 = frag_info.shadow_cascades[0u];
phi_1526_ = (_e193 > _e196);
}
let _e199 = phi_1526_;
if _e199 {
cascade = 1i;
}
let _e200 = cascadeCount;
let _e201 = (_e200 > 2i);
phi_1537_ = _e201;
if _e201 {
let _e202 = viewDistance;
let _e205 = frag_info.shadow_cascades[1u];
phi_1537_ = (_e202 > _e205);
}
let _e208 = phi_1537_;
if _e208 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e209 = attempt;
if (_e209 < 3i) {
let _e211 = cascade;
let _e212 = attempt;
which = (_e211 + _e212);
let _e214 = which;
let _e215 = cascadeCount;
if (_e214 >= _e215) {
break;
}
let _e217 = which;
if (_e217 == 0i) {
let _e220 = frag_info.shadow_matrix;
local_2 = _e220;
} else {
let _e221 = which;
if (_e221 == 1i) {
let _e224 = frag_info.shadow_matrix_far;
local_3 = _e224;
} else {
let _e226 = frag_info.shadow_matrix_farthest;
local_3 = _e226;
}
let _e227 = local_3;
local_2 = _e227;
}
let _e228 = local_2;
matrix = _e228;
let _e229 = matrix;
let _e230 = origin_1;
lightSpace = (_e229 * vec4<f32>(_e230.x, _e230.y, _e230.z, 1f));
let _e237 = lightSpace[3u];
if (_e237 <= 0f) {
continue;
}
let _e239 = lightSpace;
let _e242 = lightSpace[3u];
candidate = (_e239.xyz / vec3(_e242));
let _e246 = candidate[0u];
let _e250 = candidate[1u];
inTile = vec2<f32>(((_e246 * 0.5f) + 0.5f), (0.5f - (_e250 * 0.5f)));
let _e255 = inTile[0u];
let _e256 = (_e255 < 0f);
phi_1627_ = _e256;
if !(_e256) {
let _e259 = inTile[0u];
phi_1627_ = (_e259 > 1f);
}
let _e262 = phi_1627_;
phi_1634_ = _e262;
if !(_e262) {
let _e265 = inTile[1u];
phi_1634_ = (_e265 < 0f);
}
let _e268 = phi_1634_;
phi_1641_ = _e268;
if !(_e268) {
let _e271 = inTile[1u];
phi_1641_ = (_e271 > 1f);
}
let _e274 = phi_1641_;
if _e274 {
continue;
}
let _e276 = candidate[2u];
if (_e276 > 1f) {
continue;
}
let _e279 = inTile[0u];
let _e280 = which;
let _e283 = cascadeCount;
let _e287 = inTile[1u];
uv_4 = vec2<f32>(((_e279 + f32(_e280)) / f32(_e283)), _e287);
let _e289 = candidate;
projected = _e289;
let _e290 = which;
cascade = _e290;
found = true;
break;
} else {
break;
}
continuing {
let _e291 = attempt;
attempt = (_e291 + 1i);
}
}
let _e293 = found;
if !(_e293) {
return 1f;
}
let _e297 = frag_info.shadow_params[1u];
bias = _e297;
let _e300 = frag_info.shadow_params[0u];
let _e303 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e300, _e303);
lit_1 = 0f;
y = -1i;
loop {
let _e305 = y;
if (_e305 <= 1i) {
x = -1i;
loop {
let _e307 = x;
if (_e307 <= 1i) {
let _e309 = uv_4;
let _e310 = x;
let _e312 = y;
let _e315 = texel_1;
let _e318 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e309 + (vec2<f32>(f32(_e310), f32(_e312)) * _e315)), 0f);
occluder = _e318.x;
let _e321 = projected[2u];
let _e322 = bias;
let _e324 = occluder;
let _e327 = lit_1;
lit_1 = (_e327 + select(1f, 0f, ((_e321 - _e322) > _e324)));
continue;
} else {
break;
}
continuing {
let _e329 = x;
x = (_e329 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e331 = y;
y = (_e331 + 1i);
}
}
let _e333 = lit_1;
lit_1 = (_e333 * 0.11111111f);
let _e335 = lit_1;
let _e336 = strength_1;
return mix(1f, _e335, clamp(_e336, 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 _e141 = (*s_2);
param_49 = _e141;
let _e142 = (*light_2);
param_50 = _e142;
let _e143 = (*index);
param_51 = _e143;
let _e144 = 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 _e144;
}
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 _e140 = (*distance_1);
let _e141 = (*distance_1);
attenuation = (1f / max((_e140 * _e141), 0.0001f));
let _e145 = (*range_4);
if (_e145 > 0f) {
let _e147 = (*distance_1);
let _e148 = (*range_4);
ratio = (_e147 / _e148);
let _e150 = ratio;
let _e151 = ratio;
let _e153 = ratio;
let _e155 = ratio;
window = clamp((1f - (((_e150 * _e151) * _e153) * _e155)), 0f, 1f);
let _e159 = window;
let _e160 = window;
let _e162 = attenuation;
attenuation = (_e162 * (_e159 * _e160));
}
let _e164 = attenuation;
return _e164;
}
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_1: 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 type_34: f32;
var aim: vec3<f32>;
var attenuation_1: f32;
var light_3: LightSample;
var toLight_1: vec3<f32>;
var distance_2: f32;
var param_52: f32;
var param_53: f32;
var cosAngle: f32;
let _e150 = (*index_1);
let _e153 = frag_info.light_position[_e150];
position = _e153;
let _e154 = (*index_1);
let _e157 = frag_info.light_color[_e154];
color_1 = _e157;
let _e158 = (*index_1);
let _e161 = frag_info.light_direction[_e158];
direction = _e161;
let _e162 = (*index_1);
let _e165 = frag_info.light_cone[_e162];
cone = _e165;
let _e167 = position[3u];
type_34 = _e167;
let _e168 = direction;
aim = normalize(_e168.xyz);
attenuation_1 = 1f;
let _e171 = type_34;
if (_e171 < 0.5f) {
let _e173 = aim;
light_3.l = -(_e173);
} else {
let _e176 = position;
let _e178 = v_world_position_1;
toLight_1 = (_e176.xyz - _e178);
let _e180 = toLight_1;
distance_2 = length(_e180);
let _e182 = distance_2;
if (_e182 < 0.000001f) {
let _e185 = (*s_3).n;
light_3.l = _e185;
let _e188 = (*s_3).n;
light_3.h = _e188;
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 _e194 = light_3;
return _e194;
}
let _e195 = toLight_1;
let _e196 = distance_2;
light_3.l = (_e195 / vec3(_e196));
let _e200 = distance_2;
param_52 = _e200;
let _e202 = direction[3u];
param_53 = _e202;
let _e203 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_52), (¶m_53));
attenuation_1 = _e203;
let _e204 = type_34;
if (_e204 > 1.5f) {
let _e206 = aim;
let _e208 = light_3.l;
cosAngle = dot(_e206, -(_e208));
let _e211 = cosAngle;
let _e213 = cone[1u];
let _e216 = cone[0u];
let _e218 = cone[1u];
let _e222 = attenuation_1;
attenuation_1 = (_e222 * clamp(((_e211 - _e213) / (_e216 - _e218)), 0f, 1f));
}
}
let _e225 = light_3.l;
let _e227 = (*s_3).v;
light_3.h = normalize((_e225 + _e227));
let _e232 = (*s_3).n;
let _e234 = light_3.l;
light_3.n_dot_l = max(dot(_e232, _e234), 0f);
let _e239 = (*s_3).n;
let _e241 = light_3.h;
light_3.n_dot_h = max(dot(_e239, _e241), 0f);
let _e246 = (*s_3).v;
let _e248 = light_3.h;
light_3.v_dot_h = max(dot(_e246, _e248), 0f);
let _e252 = color_1;
let _e255 = color_1[3u];
let _e257 = attenuation_1;
light_3.radiance = ((_e252.xyz * _e255) * _e257);
let _e260 = light_3;
return _e260;
}
fn LightCount_u0028_() -> i32 {
let _e137 = frag_info.frame_params[1u];
return clamp(i32((_e137 + 0.5f)), 0i, 8i);
}
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: vec3<f32>;
var count_1: i32;
var i_4: i32;
var light_4: LightSample;
var param_54: i32;
var param_55: Surface;
var visibility: f32;
var param_56: Surface;
var param_57: LightSample;
var param_58: i32;
var param_59: vec3<f32>;
var param_60: vec3<f32>;
var param_61: i32;
var param_62: Surface;
var param_63: LightSample;
total = vec3<f32>(0f, 0f, 0f);
let _e151 = LightCount_u0028_();
count_1 = _e151;
i_4 = 0i;
loop {
let _e152 = i_4;
if (_e152 < 8i) {
let _e154 = i_4;
let _e155 = count_1;
if (_e154 >= _e155) {
break;
}
let _e157 = i_4;
param_54 = _e157;
let _e158 = (*s_4);
param_55 = _e158;
let _e159 = 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_54), (¶m_55));
light_4 = _e159;
let _e161 = light_4.n_dot_l;
if (_e161 <= 0f) {
continue;
}
let _e163 = (*s_4);
param_56 = _e163;
let _e164 = light_4;
param_57 = _e164;
let _e165 = i_4;
param_58 = _e165;
let _e166 = 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_56), (¶m_57), (¶m_58));
let _e167 = v_world_position_1;
param_59 = _e167;
let _e169 = (*s_4).n;
param_60 = _e169;
let _e170 = i_4;
param_61 = _e170;
let _e171 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_59), (¶m_60), (¶m_61));
visibility = (_e166 * _e171);
let _e173 = visibility;
if (_e173 <= 0f) {
continue;
}
let _e175 = (*s_4);
param_62 = _e175;
let _e176 = light_4;
param_63 = _e176;
let _e177 = 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_62), (¶m_63));
let _e179 = light_4.radiance;
let _e182 = light_4.n_dot_l;
let _e184 = visibility;
let _e186 = total;
total = (_e186 + (((_e177 * _e179) * _e182) * _e184));
continue;
} else {
break;
}
continuing {
let _e188 = i_4;
i_4 = (_e188 + 1i);
}
}
let _e190 = total;
return _e190;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e136 = v_lightmap_uv_1;
let _e137 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e136);
texel_2 = _e137;
let _e138 = texel_2;
let _e141 = texel_2[3u];
return ((_e138.xyz * _e141) * 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 _e139 = (*roughness_2);
r = ((vec4<f32>(-1f, -0.0275f, -0.572f, 0.022f) * _e139) + vec4<f32>(1f, 0.0425f, 1.04f, -0.04f));
let _e143 = r[0u];
let _e145 = r[0u];
let _e147 = (*n_dot_v_1);
let _e152 = r[0u];
let _e155 = r[1u];
a004_ = ((min((_e143 * _e145), exp2((-9.28f * _e147))) * _e152) + _e155);
let _e157 = a004_;
let _e159 = r;
return ((vec2<f32>(-1.04f, 1.04f) * _e157) + _e159.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 _e137 = v_texcoord_1;
let _e138 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e137);
orm = _e138.xyz;
let _e141 = (*s_5).metallic;
let _e143 = orm[2u];
(*s_5).metallic = clamp((_e141 * _e143), 0f, 1f);
let _e148 = (*s_5).roughness;
let _e150 = orm[1u];
(*s_5).roughness = clamp((_e148 * _e150), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e136 = (*srgb);
let _e139 = (*srgb);
let _e144 = (*srgb);
return mix((_e136 / vec3(12.92f)), pow(((_e139 + 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), _e144));
}
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_64: vec3<f32>;
let _e138 = v_texcoord_1;
let _e139 = textureSample(emissive_texture_tex, emissive_texture_smp, _e138);
param_64 = _e139.xyz;
let _e141 = SrgbToLinear_u0028_vf3_u003b((¶m_64));
emissive = _e141;
let _e142 = emissive;
let _e144 = frag_info.emissive;
let _e149 = frag_info.material2_[3u];
(*s_6).emissive = ((_e142 * _e144.xyz) * _e149);
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 _e137 = v_texcoord_1;
let _e138 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e137);
occlusion = _e138.x;
let _e140 = occlusion;
let _e143 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e140, clamp(_e143, 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: vec3<f32>;
var b: vec3<f32>;
var sampled: vec3<f32>;
let _e140 = v_texcoord_1;
let _e141 = textureSample(normal_texture_tex, normal_texture_smp, _e140);
sampledTexel = _e141;
let _e142 = v_tangent_1;
t = _e142.xyz;
let _e144 = t;
let _e146 = (*s_8).n;
let _e148 = (*s_8).n;
let _e149 = t;
t = (_e144 - (_e146 * dot(_e148, _e149)));
let _e153 = t;
let _e154 = t;
if (dot(_e153, _e154) < 0.000000000001f) {
return;
}
let _e157 = t;
t = normalize(_e157);
let _e160 = (*s_8).n;
let _e161 = t;
let _e164 = v_tangent_1[3u];
b = (cross(_e160, _e161) * _e164);
let _e166 = sampledTexel;
sampled = ((_e166.xyz * 2f) - vec3(1f));
let _e173 = frag_info.material2_[1u];
let _e174 = sampled;
let _e176 = (_e174.xy * _e173);
sampled[0u] = _e176.x;
sampled[1u] = _e176.y;
let _e181 = t;
let _e183 = sampled[0u];
let _e185 = b;
let _e187 = sampled[1u];
let _e191 = (*s_8).n;
let _e193 = sampled[2u];
(*s_8).n = normalize((((_e181 * _e183) + (_e185 * _e187)) + (_e191 * _e193)));
let _e199 = (*s_8).n;
let _e201 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e199, _e201), 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_65: Surface;
var param_66: Surface;
var param_67: Surface;
let _e139 = (*s_9);
param_65 = _e139;
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_65));
let _e140 = param_65;
(*s_9) = _e140;
let _e141 = (*s_9);
param_66 = _e141;
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_66));
let _e142 = param_66;
(*s_9) = _e142;
let _e143 = (*s_9);
param_67 = _e143;
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_67));
let _e144 = param_67;
(*s_9) = _e144;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_68: vec3<f32>;
var param_69: vec3<f32>;
var cutoff: f32;
var phi_396_: bool;
let _e140 = v_texcoord_1;
let _e141 = textureSample(base_color_texture_tex, base_color_texture_smp, _e140);
texel_3 = _e141;
let _e142 = texel_3;
param_68 = _e142.xyz;
let _e144 = SrgbToLinear_u0028_vf3_u003b((¶m_68));
let _e146 = frag_info.base_color;
param_69 = _e146.xyz;
let _e148 = SrgbToLinear_u0028_vf3_u003b((¶m_69));
let _e150 = v_color_1;
s_10.albedo = ((_e144 * _e148) * _e150.xyz);
let _e155 = texel_3[3u];
let _e158 = frag_info.base_color[3u];
let _e161 = v_color_1[3u];
s_10.alpha = ((_e155 * _e158) * _e161);
let _e166 = frag_info.material2_[0u];
cutoff = _e166;
let _e167 = cutoff;
let _e168 = (_e167 >= 0f);
phi_396_ = _e168;
if _e168 {
let _e170 = s_10.alpha;
let _e171 = cutoff;
phi_396_ = (_e170 < _e171);
}
let _e174 = phi_396_;
if _e174 {
discard;
}
let _e175 = v_normal_1;
s_10.n = normalize(_e175);
let _e179 = frag_info.camera_position;
let _e181 = v_world_position_1;
s_10.v = normalize((_e179.xyz - _e181));
let _e186 = s_10.n;
let _e188 = s_10.v;
s_10.n_dot_v = max(dot(_e186, _e188), 0.0001f);
let _e194 = frag_info.material[0u];
s_10.metallic = clamp(_e194, 0f, 1f);
let _e199 = frag_info.material[1u];
s_10.roughness = clamp(_e199, 0.02f, 1f);
let _e203 = frag_info.ambient_ground;
let _e206 = frag_info.ambient_sky;
let _e210 = s_10.n[1u];
let _e217 = frag_info.material[2u];
s_10.ambient = (mix(_e203.xyz, _e206.xyz, vec3(((_e210 * 0.5f) + 0.5f))) * _e217);
let _e222 = frag_info.frame_params[0u];
s_10.exposure = max(_e222, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e227 = s_10;
return _e227;
}
fn main_1() {
var s_11: Surface;
var param_70: Surface;
var param_71: 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_72: f32;
var param_73: f32;
var param_74: Surface;
var param_75: vec3<f32>;
var param_76: f32;
var param_77: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e153 = ReadSurface_u0028_();
s_11 = _e153;
let _e154 = s_11;
param_70 = _e154;
ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_70));
let _e155 = param_70;
s_11 = _e155;
let _e156 = s_11;
param_71 = _e156;
ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((¶m_71));
let _e157 = param_71;
s_11 = _e157;
let _e159 = s_11.metallic;
metallic = clamp(_e159, 0f, 1f);
let _e162 = s_11.albedo;
let _e163 = metallic;
diffuseColor_1 = (_e162 * (1f - _e163));
let _e166 = diffuseColor_1;
let _e168 = s_11.ambient;
let _e171 = s_11.occlusion;
ambient = ((_e166 * _e168) * _e171);
let _e175 = frag_info.frame_params[3u];
levels = _e175;
let _e176 = levels;
if (_e176 > 0f) {
let _e179 = s_11.albedo;
let _e180 = metallic;
f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e179, vec3(_e180));
let _e184 = s_11.v;
let _e187 = s_11.n;
reflected = reflect(-(_e184), _e187);
let _e190 = s_11.n;
let _e191 = levels;
let _e192 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e190, _e191);
irradiance = _e192.xyz;
let _e194 = reflected;
let _e196 = s_11.roughness;
let _e197 = levels;
let _e199 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e194, (_e196 * _e197));
prefiltered = _e199.xyz;
let _e202 = s_11.roughness;
param_72 = _e202;
let _e204 = s_11.n_dot_v;
param_73 = _e204;
let _e205 = EnvBrdfApprox_u0028_f1_u003b_f1_u003b((¶m_72), (¶m_73));
ab = _e205;
let _e206 = diffuseColor_1;
let _e207 = irradiance;
let _e209 = prefiltered;
let _e210 = f0_2;
let _e212 = ab[0u];
let _e215 = ab[1u];
let _e222 = frag_info.material[2u];
let _e225 = s_11.occlusion;
ambient = ((((_e206 * _e207) + (_e209 * ((_e210 * _e212) + vec3(_e215)))) * _e222) * _e225);
}
let _e227 = diffuseColor_1;
let _e228 = SampleLightmap_u0028_();
let _e231 = s_11.occlusion;
let _e233 = ambient;
ambient = (_e233 + ((_e227 * _e228) * _e231));
let _e235 = s_11;
param_74 = _e235;
let _e236 = 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_74));
let _e238 = s_11.occlusion;
let _e240 = ambient;
let _e243 = s_11.emissive;
param_75 = (((_e236 * _e238) + _e240) + _e243);
let _e246 = s_11.alpha;
param_76 = _e246;
let _e248 = s_11.roughness;
param_77 = _e248;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_75), (¶m_76), (¶m_77));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 2,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'environment_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.cube,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 21,
samplerBinding: 22,
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 FragInfo {
light_position: array<vec4<f32>, 8>,
light_color: array<vec4<f32>, 8>,
light_direction: array<vec4<f32>, 8>,
light_cone: array<vec4<f32>, 8>,
base_color: vec4<f32>,
emissive: vec4<f32>,
camera_position: vec4<f32>,
material: vec4<f32>,
material2_: vec4<f32>,
frame_params: vec4<f32>,
shadow_params: vec4<f32>,
shadow_matrix: mat4x4<f32>,
shadow_matrix_far: mat4x4<f32>,
shadow_matrix_farthest: mat4x4<f32>,
shadow_cascades: vec4<f32>,
ambient_sky: vec4<f32>,
ambient_ground: vec4<f32>,
}
struct PointShadow {
faces: array<mat4x4<f32>, 36>,
lights: array<vec4<f32>, 6>,
slots: array<vec4<f32>, 8>,
params: vec4<f32>,
params2_: vec4<f32>,
params3_: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
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(2)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(17)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var point_shadow_texture_smp: sampler;
@group(1) @binding(15)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var point_shadow_static_texture_smp: sampler;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(7)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(9)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(13)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var occlusion_texture_smp: sampler;
@group(1) @binding(5)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var emissive_texture_smp: sampler;
@group(1) @binding(11)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(19)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var shadow_texture_smp: sampler;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e124 = (*n)[0u];
let _e127 = (*n)[1u];
let _e131 = (*n)[2u];
let _e134 = (*n);
(*n) = (_e134 / vec3(((abs(_e124) + abs(_e127)) + abs(_e131))));
let _e137 = (*n);
e = _e137.xy;
let _e140 = (*n)[2u];
if (_e140 < 0f) {
let _e142 = (*n);
let _e148 = (*n)[0u];
let _e152 = (*n)[1u];
e = ((vec2(1f) - abs(_e142.yx)) * vec2<f32>(select(-1f, 1f, (_e148 >= 0f)), select(-1f, 1f, (_e152 >= 0f))));
}
let _e157 = e;
return ((_e157 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e121 = v_world_position_1;
let _e123 = fog_info.eye;
let _e127 = fog_info.forward;
return dot((_e121 - _e123.xyz), _e127.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e123 = g_debug_surface_on;
if _e123 {
let _e124 = g_debug_surface;
let _e125 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e124.x, _e124.y, _e124.z, _e125);
return;
}
let _e130 = v_normal_1;
param = normalize(_e130);
let _e132 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e133 = (*roughness);
let _e135 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e132.x, _e132.y, clamp(_e133, 0f, 1f), _e135);
return;
}
fn EyeDistance_u0028_() -> f32 {
let _e121 = v_world_position_1;
let _e123 = fog_info.eye;
return distance(_e121, _e123.xyz);
}
fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
var density: f32;
var d: f32;
let _e126 = fog_info.fog[3u];
density = _e126;
let _e127 = density;
if (_e127 <= 0f) {
let _e129 = (*color);
return _e129;
}
let _e130 = EyeDistance_u0028_();
d = _e130;
let _e132 = fog_info.fog;
let _e134 = (*color);
let _e135 = density;
let _e137 = d;
return mix(_e132.xyz, _e134, vec3(clamp(exp((-(_e135) * _e137)), 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 _e126 = (*linearColor);
param_1 = _e126;
let _e127 = ApplyFog_u0028_vf3_u003b((¶m_1));
let _e128 = (*alpha);
frag_color = vec4<f32>(_e127.x, _e127.y, _e127.z, _e128);
let _e133 = (*roughness_1);
param_2 = _e133;
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 _e128 = (*s).roughness;
bands = mix(5f, 2f, _e128);
let _e131 = (*light).n_dot_l;
let _e132 = bands;
let _e135 = bands;
quantized = (floor((_e131 * _e132)) / _e135);
let _e138 = (*light).n_dot_l;
let _e139 = bands;
fraction = fract((_e138 * _e139));
let _e142 = fraction;
let _e144 = bands;
let _e146 = quantized;
quantized = (_e146 + (smoothstep(0.85f, 1f, _e142) / _e144));
let _e148 = quantized;
let _e150 = (*light).n_dot_l;
ramp = (_e148 / max(_e150, 0.001f));
let _e154 = (*s).albedo;
let _e155 = ramp;
return (_e154 * _e155);
}
fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
let _e122 = (*i);
if (_e122 == 0i) {
return vec2<f32>(-0.94201624f, -0.39906216f);
}
let _e124 = (*i);
if (_e124 == 1i) {
return vec2<f32>(0.9455861f, -0.76890725f);
}
let _e126 = (*i);
if (_e126 == 2i) {
return vec2<f32>(-0.0941841f, -0.9293887f);
}
let _e128 = (*i);
if (_e128 == 3i) {
return vec2<f32>(0.34495938f, 0.2938776f);
}
let _e130 = (*i);
if (_e130 == 4i) {
return vec2<f32>(-0.9158858f, 0.45771432f);
}
let _e132 = (*i);
if (_e132 == 5i) {
return vec2<f32>(-0.8154423f, -0.87912464f);
}
let _e134 = (*i);
if (_e134 == 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 _e127 = (*i_1);
param_3 = _e127;
let _e128 = PointShadowDiskTap_u0028_i1_u003b((¶m_3));
p = _e128;
let _e130 = p[0u];
let _e131 = (*ca);
let _e134 = p[1u];
let _e135 = (*sa);
let _e139 = p[0u];
let _e140 = (*sa);
let _e143 = p[1u];
let _e144 = (*ca);
let _e148 = (*radius);
return (vec2<f32>(((_e130 * _e131) - (_e134 * _e135)), ((_e139 * _e140) + (_e143 * _e144))) * _e148);
}
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 _e130 = point_shadow.params[0u];
inset = _e130;
let _e131 = (*uv);
let _e132 = (*offset);
let _e134 = inset;
let _e135 = inset;
local = clamp((_e131 + _e132), vec2(_e134), vec2((1f - _e135)));
let _e140 = local;
let _e141 = (*tile);
atlas = ((_e140 + _e141) * vec2<f32>(0.16666667f, 0.16666667f));
let _e146 = point_shadow.params3_[0u];
if (_e146 > 0.5f) {
let _e149 = atlas[1u];
atlas[1u] = (1f - _e149);
}
let _e152 = atlas;
let _e153 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e152, 0f);
let _e155 = atlas;
let _e156 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e155, 0f);
let _e159 = (*range);
return (min(_e153.x, _e156.x) * _e159);
}
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 _e131 = (*uv_1);
param_4 = _e131;
let _e132 = (*offset_1);
param_5 = _e132;
let _e133 = (*tile_1);
param_6 = _e133;
let _e134 = (*range_1);
param_7 = _e134;
let _e135 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_4), (¶m_5), (¶m_6), (¶m_7));
stored = _e135;
let _e136 = stored;
let _e137 = (*range_1);
if (_e136 >= (_e137 * 0.999f)) {
return 1f;
}
let _e140 = (*receiver);
let _e141 = stored;
return select(1f, 0f, (_e140 > _e141));
}
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 _e152 = point_shadow.params2_[1u];
lightRadius = _e152;
let _e155 = point_shadow.params2_[0u];
minRadius = _e155;
let _e158 = point_shadow.params2_[2u];
maxRadius = _e158;
let _e159 = lightRadius;
if (_e159 <= 0f) {
let _e161 = (*uv_2);
param_8 = _e161;
param_9 = vec2<f32>(0f, 0f);
let _e162 = (*tile_2);
param_10 = _e162;
let _e163 = (*range_2);
param_11 = _e163;
let _e164 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_8), (¶m_9), (¶m_10), (¶m_11));
(*blockerOut) = _e164;
let _e165 = minRadius;
return _e165;
}
sum = 0f;
count = 0f;
i_2 = 0i;
loop {
let _e166 = i_2;
if (_e166 < 8i) {
let _e168 = i_2;
param_12 = _e168;
let _e169 = (*ca_1);
param_13 = _e169;
let _e170 = (*sa_1);
param_14 = _e170;
let _e171 = maxRadius;
param_15 = _e171;
let _e172 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_12), (¶m_13), (¶m_14), (¶m_15));
let _e173 = (*uv_2);
param_16 = _e173;
param_17 = _e172;
let _e174 = (*tile_2);
param_18 = _e174;
let _e175 = (*range_2);
param_19 = _e175;
let _e176 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((¶m_16), (¶m_17), (¶m_18), (¶m_19));
stored_1 = _e176;
let _e177 = stored_1;
let _e178 = (*range_2);
if (_e177 >= (_e178 * 0.999f)) {
continue;
}
let _e181 = stored_1;
let _e182 = (*receiver_1);
if (_e181 >= _e182) {
continue;
}
let _e184 = stored_1;
let _e185 = sum;
sum = (_e185 + _e184);
let _e187 = count;
count = (_e187 + 1f);
continue;
} else {
break;
}
continuing {
let _e189 = i_2;
i_2 = (_e189 + 1i);
}
}
let _e191 = count;
if (_e191 < 0.5f) {
return -1f;
}
let _e193 = sum;
let _e194 = count;
blocker = max((_e193 / _e194), 0.0001f);
let _e197 = blocker;
(*blockerOut) = _e197;
let _e198 = lightRadius;
let _e199 = (*receiver_1);
let _e200 = blocker;
let _e204 = blocker;
world = ((_e198 * max((_e199 - _e200), 0f)) / _e204);
let _e206 = world;
let _e207 = (*receiver_1);
let _e209 = (*tanHalf);
let _e212 = minRadius;
let _e213 = maxRadius;
return clamp((_e206 / ((2f * _e207) * _e209)), _e212, _e213);
}
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_1005_: bool;
var phi_1067_: bool;
let _e174 = (*lightIndex);
let _e178 = point_shadow.slots[_e174][0u];
slot = i32((_e178 + 0.5f));
let _e181 = (*lightIndex);
let _e185 = point_shadow.slots[_e181][0u];
if (_e185 < 0f) {
return 1f;
}
let _e189 = point_shadow.params[2u];
strength = _e189;
let _e190 = strength;
if (_e190 <= 0f) {
return 1f;
}
let _e192 = slot;
let _e195 = point_shadow.lights[_e192];
let _e197 = (*world_1);
toLight = (_e195.xyz - _e197);
let _e199 = toLight;
toLightLength = max(length(_e199), 0.000001f);
let _e202 = (*normal);
let _e203 = toLight;
let _e204 = toLightLength;
nDotL = max(dot(_e202, (_e203 / vec3(_e204))), 0.15f);
let _e209 = nDotL;
let _e210 = nDotL;
let _e215 = nDotL;
let _e216 = nDotL;
slope = min((sqrt(max((1f - (_e209 * _e210)), 0f)) / (_e215 * _e216)), 8f);
let _e220 = toLightLength;
let _e222 = (*lightIndex);
let _e226 = point_shadow.slots[_e222][2u];
let _e231 = point_shadow.params3_[1u];
texel = (((2f * _e220) * max(_e226, 0.0001f)) * _e231);
let _e233 = (*world_1);
let _e234 = (*normal);
let _e235 = texel;
let _e239 = point_shadow.params[3u];
let _e241 = slope;
origin = (_e233 + (((_e234 * _e235) * _e239) * (1f + _e241)));
let _e245 = origin;
let _e246 = slot;
let _e249 = point_shadow.lights[_e246];
toFragment = (_e245 - _e249.xyz);
let _e252 = toFragment;
distance_ = length(_e252);
let _e254 = slot;
let _e258 = point_shadow.lights[_e254][3u];
range_3 = max(_e258, 0.0001f);
let _e260 = distance_;
let _e261 = range_3;
if (_e260 >= _e261) {
return 1f;
}
face = 0i;
let _e263 = (*lightIndex);
let _e267 = point_shadow.slots[_e263][1u];
if (_e267 < 0.5f) {
let _e269 = toFragment;
a = abs(_e269);
let _e272 = a[0u];
let _e274 = a[1u];
let _e275 = (_e272 >= _e274);
phi_1005_ = _e275;
if _e275 {
let _e277 = a[0u];
let _e279 = a[2u];
phi_1005_ = (_e277 >= _e279);
}
let _e282 = phi_1005_;
if _e282 {
let _e284 = toFragment[0u];
face = select(1i, 0i, (_e284 > 0f));
} else {
let _e288 = a[1u];
let _e290 = a[2u];
if (_e288 >= _e290) {
let _e293 = toFragment[1u];
face = select(3i, 2i, (_e293 > 0f));
} else {
let _e297 = toFragment[2u];
face = select(5i, 4i, (_e297 > 0f));
}
}
}
let _e300 = slot;
let _e302 = face;
let _e306 = point_shadow.faces[((_e300 * 6i) + _e302)];
let _e307 = origin;
clip = (_e306 * vec4<f32>(_e307.x, _e307.y, _e307.z, 1f));
let _e314 = clip[3u];
if (_e314 <= 0f) {
return 1f;
}
let _e316 = clip;
let _e319 = clip[3u];
ndc = (_e316.xy / vec2(_e319));
let _e323 = ndc[0u];
let _e325 = (abs(_e323) > 1f);
phi_1067_ = _e325;
if !(_e325) {
let _e328 = ndc[1u];
phi_1067_ = (abs(_e328) > 1f);
}
let _e332 = phi_1067_;
if _e332 {
return 1f;
}
let _e334 = ndc[0u];
let _e338 = ndc[1u];
uv_3 = vec2<f32>(((_e334 * 0.5f) + 0.5f), (0.5f - (_e338 * 0.5f)));
let _e342 = face;
let _e344 = slot;
tile_3 = vec2<f32>(f32(_e342), f32(_e344));
let _e347 = distance_;
let _e350 = point_shadow.params[1u];
receiver_2 = (_e347 - _e350);
let _e352 = gl_FragCoord_1;
noise = fract((52.982918f * fract(dot(_e352.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
let _e358 = noise;
angle = (_e358 * 6.2831855f);
let _e360 = angle;
ca_2 = cos(_e360);
let _e362 = angle;
sa_2 = sin(_e362);
let _e364 = (*lightIndex);
let _e368 = point_shadow.slots[_e364][2u];
tanHalf_1 = max(_e368, 0.0001f);
blocker_1 = -1f;
let _e370 = uv_3;
param_20 = _e370;
let _e371 = tile_3;
param_21 = _e371;
let _e372 = range_3;
param_22 = _e372;
let _e373 = receiver_2;
param_23 = _e373;
let _e374 = ca_2;
param_24 = _e374;
let _e375 = sa_2;
param_25 = _e375;
let _e376 = tanHalf_1;
param_26 = _e376;
let _e377 = 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 _e378 = param_27;
blocker_1 = _e378;
radius_1 = _e377;
let _e381 = point_shadow.params2_[3u];
if (_e381 > 0.5f) {
g_debug_surface_on = true;
let _e383 = radius_1;
if (_e383 < 0f) {
local_1 = vec3<f32>(0f, 0f, 1f);
} else {
let _e385 = radius_1;
let _e388 = point_shadow.params2_[2u];
let _e392 = blocker_1;
let _e393 = range_3;
local_1 = vec3<f32>(clamp((_e385 / max(_e388, 0.000001f)), 0f, 1f), clamp((_e392 / _e393), 0f, 1f), 0f);
}
let _e397 = local_1;
g_debug_surface = _e397;
}
let _e398 = radius_1;
if (_e398 < 0f) {
return 1f;
}
let _e400 = uv_3;
param_28 = _e400;
param_29 = vec2<f32>(0f, 0f);
let _e401 = tile_3;
param_30 = _e401;
let _e402 = range_3;
param_31 = _e402;
let _e403 = receiver_2;
param_32 = _e403;
let _e404 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_28), (¶m_29), (¶m_30), (¶m_31), (¶m_32));
lit = _e404;
let _e405 = radius_1;
if (_e405 > 0f) {
i_3 = 0i;
loop {
let _e407 = i_3;
if (_e407 < 8i) {
let _e409 = i_3;
param_33 = _e409;
let _e410 = ca_2;
param_34 = _e410;
let _e411 = sa_2;
param_35 = _e411;
let _e412 = radius_1;
param_36 = _e412;
let _e413 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((¶m_33), (¶m_34), (¶m_35), (¶m_36));
let _e414 = uv_3;
param_37 = _e414;
param_38 = _e413;
let _e415 = tile_3;
param_39 = _e415;
let _e416 = range_3;
param_40 = _e416;
let _e417 = receiver_2;
param_41 = _e417;
let _e418 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((¶m_37), (¶m_38), (¶m_39), (¶m_40), (¶m_41));
let _e419 = lit;
lit = (_e419 + _e418);
continue;
} else {
break;
}
continuing {
let _e421 = i_3;
i_3 = (_e421 + 1i);
}
}
let _e423 = lit;
lit = (_e423 * 0.11111111f);
}
let _e425 = lit;
let _e426 = strength;
return mix(1f, _e425, clamp(_e426, 0f, 1f));
}
fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f11_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
var strength_1: f32;
var origin_1: vec3<f32>;
var cascadeCount: i32;
var viewDistance: f32;
var cascade: i32;
var uv_4: vec2<f32>;
var projected: vec3<f32>;
var found: bool;
var attempt: i32;
var which: i32;
var matrix: mat4x4<f32>;
var local_2: mat4x4<f32>;
var local_3: mat4x4<f32>;
var lightSpace: vec4<f32>;
var candidate: vec3<f32>;
var inTile: vec2<f32>;
var bias: f32;
var texel_1: vec2<f32>;
var lit_1: f32;
var y: i32;
var x: i32;
var occluder: f32;
var phi_1506_: bool;
var phi_1517_: bool;
var phi_1607_: bool;
var phi_1614_: bool;
var phi_1621_: bool;
let _e148 = frag_info.shadow_params[3u];
strength_1 = _e148;
let _e149 = strength_1;
if (_e149 <= 0f) {
return 1f;
}
let _e151 = (*lightIndex_1);
let _e154 = frag_info.frame_params[2u];
if (_e151 != i32((_e154 + 0.5f))) {
return 1f;
}
let _e158 = v_world_position_1;
let _e160 = (*s_1).n;
let _e163 = frag_info.shadow_params[2u];
origin_1 = (_e158 + (_e160 * _e163));
let _e168 = frag_info.shadow_cascades[2u];
cascadeCount = i32((_e168 + 0.5f));
let _e171 = v_world_position_1;
let _e173 = frag_info.camera_position;
viewDistance = length((_e171 - _e173.xyz));
cascade = 0i;
let _e177 = cascadeCount;
let _e178 = (_e177 > 1i);
phi_1506_ = _e178;
if _e178 {
let _e179 = viewDistance;
let _e182 = frag_info.shadow_cascades[0u];
phi_1506_ = (_e179 > _e182);
}
let _e185 = phi_1506_;
if _e185 {
cascade = 1i;
}
let _e186 = cascadeCount;
let _e187 = (_e186 > 2i);
phi_1517_ = _e187;
if _e187 {
let _e188 = viewDistance;
let _e191 = frag_info.shadow_cascades[1u];
phi_1517_ = (_e188 > _e191);
}
let _e194 = phi_1517_;
if _e194 {
cascade = 2i;
}
uv_4 = vec2<f32>(0f, 0f);
projected = vec3<f32>(0f, 0f, 0f);
found = false;
attempt = 0i;
loop {
let _e195 = attempt;
if (_e195 < 3i) {
let _e197 = cascade;
let _e198 = attempt;
which = (_e197 + _e198);
let _e200 = which;
let _e201 = cascadeCount;
if (_e200 >= _e201) {
break;
}
let _e203 = which;
if (_e203 == 0i) {
let _e206 = frag_info.shadow_matrix;
local_2 = _e206;
} else {
let _e207 = which;
if (_e207 == 1i) {
let _e210 = frag_info.shadow_matrix_far;
local_3 = _e210;
} else {
let _e212 = frag_info.shadow_matrix_farthest;
local_3 = _e212;
}
let _e213 = local_3;
local_2 = _e213;
}
let _e214 = local_2;
matrix = _e214;
let _e215 = matrix;
let _e216 = origin_1;
lightSpace = (_e215 * vec4<f32>(_e216.x, _e216.y, _e216.z, 1f));
let _e223 = lightSpace[3u];
if (_e223 <= 0f) {
continue;
}
let _e225 = lightSpace;
let _e228 = lightSpace[3u];
candidate = (_e225.xyz / vec3(_e228));
let _e232 = candidate[0u];
let _e236 = candidate[1u];
inTile = vec2<f32>(((_e232 * 0.5f) + 0.5f), (0.5f - (_e236 * 0.5f)));
let _e241 = inTile[0u];
let _e242 = (_e241 < 0f);
phi_1607_ = _e242;
if !(_e242) {
let _e245 = inTile[0u];
phi_1607_ = (_e245 > 1f);
}
let _e248 = phi_1607_;
phi_1614_ = _e248;
if !(_e248) {
let _e251 = inTile[1u];
phi_1614_ = (_e251 < 0f);
}
let _e254 = phi_1614_;
phi_1621_ = _e254;
if !(_e254) {
let _e257 = inTile[1u];
phi_1621_ = (_e257 > 1f);
}
let _e260 = phi_1621_;
if _e260 {
continue;
}
let _e262 = candidate[2u];
if (_e262 > 1f) {
continue;
}
let _e265 = inTile[0u];
let _e266 = which;
let _e269 = cascadeCount;
let _e273 = inTile[1u];
uv_4 = vec2<f32>(((_e265 + f32(_e266)) / f32(_e269)), _e273);
let _e275 = candidate;
projected = _e275;
let _e276 = which;
cascade = _e276;
found = true;
break;
} else {
break;
}
continuing {
let _e277 = attempt;
attempt = (_e277 + 1i);
}
}
let _e279 = found;
if !(_e279) {
return 1f;
}
let _e283 = frag_info.shadow_params[1u];
bias = _e283;
let _e286 = frag_info.shadow_params[0u];
let _e289 = frag_info.shadow_cascades[3u];
texel_1 = vec2<f32>(_e286, _e289);
lit_1 = 0f;
y = -1i;
loop {
let _e291 = y;
if (_e291 <= 1i) {
x = -1i;
loop {
let _e293 = x;
if (_e293 <= 1i) {
let _e295 = uv_4;
let _e296 = x;
let _e298 = y;
let _e301 = texel_1;
let _e304 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, (_e295 + (vec2<f32>(f32(_e296), f32(_e298)) * _e301)), 0f);
occluder = _e304.x;
let _e307 = projected[2u];
let _e308 = bias;
let _e310 = occluder;
let _e313 = lit_1;
lit_1 = (_e313 + select(1f, 0f, ((_e307 - _e308) > _e310)));
continue;
} else {
break;
}
continuing {
let _e315 = x;
x = (_e315 + 1i);
}
}
continue;
} else {
break;
}
continuing {
let _e317 = y;
y = (_e317 + 1i);
}
}
let _e319 = lit_1;
lit_1 = (_e319 * 0.11111111f);
let _e321 = lit_1;
let _e322 = strength_1;
return mix(1f, _e321, clamp(_e322, 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 _e127 = (*s_2);
param_42 = _e127;
let _e128 = (*light_2);
param_43 = _e128;
let _e129 = (*index);
param_44 = _e129;
let _e130 = 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 _e130;
}
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 _e126 = (*distance_1);
let _e127 = (*distance_1);
attenuation = (1f / max((_e126 * _e127), 0.0001f));
let _e131 = (*range_4);
if (_e131 > 0f) {
let _e133 = (*distance_1);
let _e134 = (*range_4);
ratio = (_e133 / _e134);
let _e136 = ratio;
let _e137 = ratio;
let _e139 = ratio;
let _e141 = ratio;
window = clamp((1f - (((_e136 * _e137) * _e139) * _e141)), 0f, 1f);
let _e145 = window;
let _e146 = window;
let _e148 = attenuation;
attenuation = (_e148 * (_e145 * _e146));
}
let _e150 = attenuation;
return _e150;
}
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_1: 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 type_33: f32;
var aim: vec3<f32>;
var attenuation_1: f32;
var light_3: LightSample;
var toLight_1: vec3<f32>;
var distance_2: f32;
var param_45: f32;
var param_46: f32;
var cosAngle: f32;
let _e136 = (*index_1);
let _e139 = frag_info.light_position[_e136];
position = _e139;
let _e140 = (*index_1);
let _e143 = frag_info.light_color[_e140];
color_1 = _e143;
let _e144 = (*index_1);
let _e147 = frag_info.light_direction[_e144];
direction = _e147;
let _e148 = (*index_1);
let _e151 = frag_info.light_cone[_e148];
cone = _e151;
let _e153 = position[3u];
type_33 = _e153;
let _e154 = direction;
aim = normalize(_e154.xyz);
attenuation_1 = 1f;
let _e157 = type_33;
if (_e157 < 0.5f) {
let _e159 = aim;
light_3.l = -(_e159);
} else {
let _e162 = position;
let _e164 = v_world_position_1;
toLight_1 = (_e162.xyz - _e164);
let _e166 = toLight_1;
distance_2 = length(_e166);
let _e168 = distance_2;
if (_e168 < 0.000001f) {
let _e171 = (*s_3).n;
light_3.l = _e171;
let _e174 = (*s_3).n;
light_3.h = _e174;
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 _e180 = light_3;
return _e180;
}
let _e181 = toLight_1;
let _e182 = distance_2;
light_3.l = (_e181 / vec3(_e182));
let _e186 = distance_2;
param_45 = _e186;
let _e188 = direction[3u];
param_46 = _e188;
let _e189 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((¶m_45), (¶m_46));
attenuation_1 = _e189;
let _e190 = type_33;
if (_e190 > 1.5f) {
let _e192 = aim;
let _e194 = light_3.l;
cosAngle = dot(_e192, -(_e194));
let _e197 = cosAngle;
let _e199 = cone[1u];
let _e202 = cone[0u];
let _e204 = cone[1u];
let _e208 = attenuation_1;
attenuation_1 = (_e208 * clamp(((_e197 - _e199) / (_e202 - _e204)), 0f, 1f));
}
}
let _e211 = light_3.l;
let _e213 = (*s_3).v;
light_3.h = normalize((_e211 + _e213));
let _e218 = (*s_3).n;
let _e220 = light_3.l;
light_3.n_dot_l = max(dot(_e218, _e220), 0f);
let _e225 = (*s_3).n;
let _e227 = light_3.h;
light_3.n_dot_h = max(dot(_e225, _e227), 0f);
let _e232 = (*s_3).v;
let _e234 = light_3.h;
light_3.v_dot_h = max(dot(_e232, _e234), 0f);
let _e238 = color_1;
let _e241 = color_1[3u];
let _e243 = attenuation_1;
light_3.radiance = ((_e238.xyz * _e241) * _e243);
let _e246 = light_3;
return _e246;
}
fn LightCount_u0028_() -> i32 {
let _e123 = frag_info.frame_params[1u];
return clamp(i32((_e123 + 0.5f)), 0i, 8i);
}
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: vec3<f32>;
var count_1: i32;
var i_4: i32;
var light_4: LightSample;
var param_47: i32;
var param_48: Surface;
var visibility: f32;
var param_49: Surface;
var param_50: LightSample;
var param_51: i32;
var param_52: vec3<f32>;
var param_53: vec3<f32>;
var param_54: i32;
var param_55: Surface;
var param_56: LightSample;
total = vec3<f32>(0f, 0f, 0f);
let _e137 = LightCount_u0028_();
count_1 = _e137;
i_4 = 0i;
loop {
let _e138 = i_4;
if (_e138 < 8i) {
let _e140 = i_4;
let _e141 = count_1;
if (_e140 >= _e141) {
break;
}
let _e143 = i_4;
param_47 = _e143;
let _e144 = (*s_4);
param_48 = _e144;
let _e145 = 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_47), (¶m_48));
light_4 = _e145;
let _e147 = light_4.n_dot_l;
if (_e147 <= 0f) {
continue;
}
let _e149 = (*s_4);
param_49 = _e149;
let _e150 = light_4;
param_50 = _e150;
let _e151 = i_4;
param_51 = _e151;
let _e152 = 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_49), (¶m_50), (¶m_51));
let _e153 = v_world_position_1;
param_52 = _e153;
let _e155 = (*s_4).n;
param_53 = _e155;
let _e156 = i_4;
param_54 = _e156;
let _e157 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((¶m_52), (¶m_53), (¶m_54));
visibility = (_e152 * _e157);
let _e159 = visibility;
if (_e159 <= 0f) {
continue;
}
let _e161 = (*s_4);
param_55 = _e161;
let _e162 = light_4;
param_56 = _e162;
let _e163 = 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_55), (¶m_56));
let _e165 = light_4.radiance;
let _e168 = light_4.n_dot_l;
let _e170 = visibility;
let _e172 = total;
total = (_e172 + (((_e163 * _e165) * _e168) * _e170));
continue;
} else {
break;
}
continuing {
let _e174 = i_4;
i_4 = (_e174 + 1i);
}
}
let _e176 = total;
return _e176;
}
fn SampleLightmap_u0028_() -> vec3<f32> {
var texel_2: vec4<f32>;
let _e122 = v_lightmap_uv_1;
let _e123 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e122);
texel_2 = _e123;
let _e124 = texel_2;
let _e127 = texel_2[3u];
return ((_e124.xyz * _e127) * 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 _e123 = v_texcoord_1;
let _e124 = textureSample(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e123);
orm = _e124.xyz;
let _e127 = (*s_5).metallic;
let _e129 = orm[2u];
(*s_5).metallic = clamp((_e127 * _e129), 0f, 1f);
let _e134 = (*s_5).roughness;
let _e136 = orm[1u];
(*s_5).roughness = clamp((_e134 * _e136), 0.02f, 1f);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e122 = (*srgb);
let _e125 = (*srgb);
let _e130 = (*srgb);
return mix((_e122 / vec3(12.92f)), pow(((_e125 + 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), _e130));
}
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_57: vec3<f32>;
let _e124 = v_texcoord_1;
let _e125 = textureSample(emissive_texture_tex, emissive_texture_smp, _e124);
param_57 = _e125.xyz;
let _e127 = SrgbToLinear_u0028_vf3_u003b((¶m_57));
emissive = _e127;
let _e128 = emissive;
let _e130 = frag_info.emissive;
let _e135 = frag_info.material2_[3u];
(*s_6).emissive = ((_e128 * _e130.xyz) * _e135);
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 _e123 = v_texcoord_1;
let _e124 = textureSample(occlusion_texture_tex, occlusion_texture_smp, _e123);
occlusion = _e124.x;
let _e126 = occlusion;
let _e129 = frag_info.material2_[2u];
(*s_7).occlusion = mix(1f, _e126, clamp(_e129, 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: vec3<f32>;
var b: vec3<f32>;
var sampled: vec3<f32>;
let _e126 = v_texcoord_1;
let _e127 = textureSample(normal_texture_tex, normal_texture_smp, _e126);
sampledTexel = _e127;
let _e128 = v_tangent_1;
t = _e128.xyz;
let _e130 = t;
let _e132 = (*s_8).n;
let _e134 = (*s_8).n;
let _e135 = t;
t = (_e130 - (_e132 * dot(_e134, _e135)));
let _e139 = t;
let _e140 = t;
if (dot(_e139, _e140) < 0.000000000001f) {
return;
}
let _e143 = t;
t = normalize(_e143);
let _e146 = (*s_8).n;
let _e147 = t;
let _e150 = v_tangent_1[3u];
b = (cross(_e146, _e147) * _e150);
let _e152 = sampledTexel;
sampled = ((_e152.xyz * 2f) - vec3(1f));
let _e159 = frag_info.material2_[1u];
let _e160 = sampled;
let _e162 = (_e160.xy * _e159);
sampled[0u] = _e162.x;
sampled[1u] = _e162.y;
let _e167 = t;
let _e169 = sampled[0u];
let _e171 = b;
let _e173 = sampled[1u];
let _e177 = (*s_8).n;
let _e179 = sampled[2u];
(*s_8).n = normalize((((_e167 * _e169) + (_e171 * _e173)) + (_e177 * _e179)));
let _e185 = (*s_8).n;
let _e187 = (*s_8).v;
(*s_8).n_dot_v = max(dot(_e185, _e187), 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_58: Surface;
var param_59: Surface;
var param_60: Surface;
let _e125 = (*s_9);
param_58 = _e125;
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_58));
let _e126 = param_58;
(*s_9) = _e126;
let _e127 = (*s_9);
param_59 = _e127;
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_59));
let _e128 = param_59;
(*s_9) = _e128;
let _e129 = (*s_9);
param_60 = _e129;
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_60));
let _e130 = param_60;
(*s_9) = _e130;
return;
}
fn ReadSurface_u0028_() -> Surface {
var texel_3: vec4<f32>;
var s_10: Surface;
var param_61: vec3<f32>;
var param_62: vec3<f32>;
var cutoff: f32;
var phi_376_: bool;
let _e126 = v_texcoord_1;
let _e127 = textureSample(base_color_texture_tex, base_color_texture_smp, _e126);
texel_3 = _e127;
let _e128 = texel_3;
param_61 = _e128.xyz;
let _e130 = SrgbToLinear_u0028_vf3_u003b((¶m_61));
let _e132 = frag_info.base_color;
param_62 = _e132.xyz;
let _e134 = SrgbToLinear_u0028_vf3_u003b((¶m_62));
let _e136 = v_color_1;
s_10.albedo = ((_e130 * _e134) * _e136.xyz);
let _e141 = texel_3[3u];
let _e144 = frag_info.base_color[3u];
let _e147 = v_color_1[3u];
s_10.alpha = ((_e141 * _e144) * _e147);
let _e152 = frag_info.material2_[0u];
cutoff = _e152;
let _e153 = cutoff;
let _e154 = (_e153 >= 0f);
phi_376_ = _e154;
if _e154 {
let _e156 = s_10.alpha;
let _e157 = cutoff;
phi_376_ = (_e156 < _e157);
}
let _e160 = phi_376_;
if _e160 {
discard;
}
let _e161 = v_normal_1;
s_10.n = normalize(_e161);
let _e165 = frag_info.camera_position;
let _e167 = v_world_position_1;
s_10.v = normalize((_e165.xyz - _e167));
let _e172 = s_10.n;
let _e174 = s_10.v;
s_10.n_dot_v = max(dot(_e172, _e174), 0.0001f);
let _e180 = frag_info.material[0u];
s_10.metallic = clamp(_e180, 0f, 1f);
let _e185 = frag_info.material[1u];
s_10.roughness = clamp(_e185, 0.02f, 1f);
let _e189 = frag_info.ambient_ground;
let _e192 = frag_info.ambient_sky;
let _e196 = s_10.n[1u];
let _e203 = frag_info.material[2u];
s_10.ambient = (mix(_e189.xyz, _e192.xyz, vec3(((_e196 * 0.5f) + 0.5f))) * _e203);
let _e208 = frag_info.frame_params[0u];
s_10.exposure = max(_e208, 0f);
s_10.occlusion = 1f;
s_10.emissive = vec3<f32>(0f, 0f, 0f);
let _e213 = s_10;
return _e213;
}
fn main_1() {
var s_11: Surface;
var param_63: Surface;
var param_64: Surface;
var rim: f32;
var ambient: vec3<f32>;
var param_65: Surface;
var param_66: vec3<f32>;
var param_67: f32;
var param_68: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e130 = ReadSurface_u0028_();
s_11 = _e130;
let _e131 = s_11;
param_63 = _e131;
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_63));
let _e132 = param_63;
s_11 = _e132;
let _e133 = s_11;
param_64 = _e133;
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_64));
let _e134 = param_64;
s_11 = _e134;
let _e136 = s_11.n_dot_v;
let _e141 = frag_info.material[3u];
rim = (pow((1f - _e136), 3f) * _e141);
let _e144 = s_11.albedo;
let _e146 = s_11.ambient;
let _e147 = SampleLightmap_u0028_();
let _e151 = s_11.occlusion;
ambient = ((_e144 * (_e146 + _e147)) * _e151);
let _e153 = s_11;
param_65 = _e153;
let _e154 = 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_65));
let _e156 = s_11.occlusion;
let _e158 = ambient;
let _e160 = rim;
let _e165 = s_11.emissive;
param_66 = ((((_e154 * _e156) + _e158) + vec3((_e160 * 0.35f))) + _e165);
let _e168 = s_11.alpha;
param_67 = _e168;
let _e170 = s_11.roughness;
param_68 = _e170;
WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((¶m_66), (¶m_67), (¶m_68));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>, @location(3) v_tangent: vec4<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_color_1 = v_color;
gl_FragCoord_1 = gl_FragCoord;
v_lightmap_uv_1 = v_lightmap_uv;
v_tangent_1 = v_tangent;
main_1();
let _e16 = frag_surface;
let _e17 = frag_color;
return FragmentOutput(_e16, _e17);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'FragInfo',
group: 1,
binding: 1,
sizeInBytes: 864,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'light_position',
offsetInBytes: 0,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_color',
offsetInBytes: 128,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_direction',
offsetInBytes: 256,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'light_cone',
offsetInBytes: 384,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'base_color',
offsetInBytes: 512,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'emissive',
offsetInBytes: 528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera_position',
offsetInBytes: 544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material',
offsetInBytes: 560,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'material2',
offsetInBytes: 576,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'frame_params',
offsetInBytes: 592,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_params',
offsetInBytes: 608,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'shadow_matrix',
offsetInBytes: 624,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_far',
offsetInBytes: 688,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_matrix_farthest',
offsetInBytes: 752,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'shadow_cascades',
offsetInBytes: 816,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_sky',
offsetInBytes: 832,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'ambient_ground',
offsetInBytes: 848,
sizeInBytes: 16,
),
],
),
WebGpuBlock(
name: 'PointShadow',
group: 1,
binding: 2,
sizeInBytes: 2576,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'faces',
offsetInBytes: 0,
sizeInBytes: 2304,
),
WebGpuBlockMember(
name: 'lights',
offsetInBytes: 2304,
sizeInBytes: 96,
),
WebGpuBlockMember(
name: 'slots',
offsetInBytes: 2400,
sizeInBytes: 128,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 2528,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params2',
offsetInBytes: 2544,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params3',
offsetInBytes: 2560,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'base_color_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'emissive_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'lightmap_texture',
group: 1,
textureBinding: 7,
samplerBinding: 8,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'metallic_roughness_texture',
group: 1,
textureBinding: 9,
samplerBinding: 10,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'normal_texture',
group: 1,
textureBinding: 11,
samplerBinding: 12,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'occlusion_texture',
group: 1,
textureBinding: 13,
samplerBinding: 14,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_static_texture',
group: 1,
textureBinding: 15,
samplerBinding: 16,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'point_shadow_texture',
group: 1,
textureBinding: 17,
samplerBinding: 18,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'shadow_texture',
group: 1,
textureBinding: 19,
samplerBinding: 20,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Normals': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
struct FragmentOutput {
@location(1) member: vec4<f32>,
@location(0) member_1: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;
fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
var e: vec2<f32>;
let _e35 = (*n)[0u];
let _e38 = (*n)[1u];
let _e42 = (*n)[2u];
let _e45 = (*n);
(*n) = (_e45 / vec3(((abs(_e35) + abs(_e38)) + abs(_e42))));
let _e48 = (*n);
e = _e48.xy;
let _e51 = (*n)[2u];
if (_e51 < 0f) {
let _e53 = (*n);
let _e59 = (*n)[0u];
let _e63 = (*n)[1u];
e = ((vec2(1f) - abs(_e53.yx)) * vec2<f32>(select(-1f, 1f, (_e59 >= 0f)), select(-1f, 1f, (_e63 >= 0f))));
}
let _e68 = e;
return ((_e68 * 0.5f) + vec2(0.5f));
}
fn ViewDepth_u0028_() -> f32 {
let _e32 = v_world_position_1;
let _e34 = fog_info.eye;
let _e38 = fog_info.forward;
return dot((_e32 - _e34.xyz), _e38.xyz);
}
fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
var param: vec3<f32>;
let _e34 = g_debug_surface_on;
if _e34 {
let _e35 = g_debug_surface;
let _e36 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e35.x, _e35.y, _e35.z, _e36);
return;
}
let _e41 = v_normal_1;
param = normalize(_e41);
let _e43 = EncodeOctahedral_u0028_vf3_u003b((¶m));
let _e44 = (*roughness);
let _e46 = ViewDepth_u0028_();
frag_surface = vec4<f32>(_e43.x, _e43.y, clamp(_e44, 0f, 1f), _e46);
return;
}
fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e33 = (*srgb);
let _e36 = (*srgb);
let _e41 = (*srgb);
return mix((_e33 / vec3(12.92f)), pow(((_e36 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e41));
}
fn WriteDisplayColor_u0028_vf3_u003b_f1_u003b(displayColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>) {
var param_1: vec3<f32>;
var param_2: f32;
let _e36 = (*displayColor);
param_1 = _e36;
let _e37 = SrgbToLinear_u0028_vf3_u003b((¶m_1));
let _e38 = (*alpha);
frag_color = vec4<f32>(_e37.x, _e37.y, _e37.z, _e38);
param_2 = 1f;
WriteSurfaceGeometry_u0028_f1_u003b((¶m_2));
return;
}
fn main_1() {
var n_1: vec3<f32>;
var param_3: vec3<f32>;
var param_4: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e35 = v_normal_1;
n_1 = normalize(_e35);
let _e37 = n_1;
param_3 = ((_e37 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
param_4 = 1f;
WriteDisplayColor_u0028_vf3_u003b_f1_u003b((¶m_3), (¶m_4));
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(4) v_texcoord: vec2<f32>, @location(3) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(1) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_texcoord_1 = v_texcoord;
v_tangent_1 = v_tangent;
v_color_1 = v_color;
v_lightmap_uv_1 = v_lightmap_uv;
main_1();
let _e14 = frag_surface;
let _e15 = frag_color;
return FragmentOutput(_e14, _e15);
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 48,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 32,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[],
),
'DebugLine': WebGpuStage(
wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_line_color_1: vec4<f32>;
fn main_1() {
let _e2 = v_line_color_1;
frag_color = _e2;
return;
}
@fragment
fn main(@location(0) v_line_color: vec4<f32>) -> @location(0) vec4<f32> {
v_line_color_1 = v_line_color;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[],
samplers: <WebGpuSampler>[],
),
'BloomThreshold': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn Luminance_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e25 = (*color);
return dot(_e25, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn main_1() {
var texel: vec2<f32>;
var sum: vec3<f32>;
var color_1: vec3<f32>;
var threshold: f32;
var knee: f32;
var brightness: f32;
var param: vec3<f32>;
var soft: f32;
var contribution: f32;
let _e34 = bloom_info.params;
texel = _e34.xy;
let _e36 = v_uv_1;
let _e37 = texel;
let _e40 = textureSample(source_texture_tex, source_texture_smp, (_e36 + (_e37 * vec2<f32>(-0.5f, -0.5f))));
let _e42 = v_uv_1;
let _e43 = texel;
let _e46 = textureSample(source_texture_tex, source_texture_smp, (_e42 + (_e43 * vec2<f32>(0.5f, -0.5f))));
let _e49 = v_uv_1;
let _e50 = texel;
let _e53 = textureSample(source_texture_tex, source_texture_smp, (_e49 + (_e50 * vec2<f32>(-0.5f, 0.5f))));
let _e56 = v_uv_1;
let _e57 = texel;
let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (_e57 * vec2<f32>(0.5f, 0.5f))));
sum = (((_e40.xyz + _e46.xyz) + _e53.xyz) + _e60.xyz);
let _e63 = sum;
color_1 = (_e63 * 0.25f);
let _e67 = bloom_info.params[2u];
threshold = _e67;
let _e70 = bloom_info.params[3u];
knee = max(_e70, 0.0001f);
let _e72 = color_1;
param = _e72;
let _e73 = Luminance_u0028_vf3_u003b((¶m));
brightness = _e73;
let _e74 = brightness;
let _e75 = threshold;
let _e77 = knee;
let _e79 = knee;
soft = clamp(((_e74 - _e75) + _e77), 0f, (2f * _e79));
let _e82 = soft;
let _e83 = soft;
let _e85 = knee;
soft = ((_e82 * _e83) / (4f * _e85));
let _e88 = soft;
let _e89 = brightness;
let _e90 = threshold;
let _e93 = brightness;
contribution = (max(_e88, (_e89 - _e90)) / max(_e93, 0.0001f));
let _e96 = color_1;
let _e97 = contribution;
let _e98 = (_e96 * _e97);
frag_color = vec4<f32>(_e98.x, _e98.y, _e98.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BloomDownsample': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var t: vec2<f32>;
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var d: vec3<f32>;
var e: vec3<f32>;
var f: vec3<f32>;
var g: vec3<f32>;
var h: vec3<f32>;
var i: vec3<f32>;
var j: vec3<f32>;
var k: vec3<f32>;
var l: vec3<f32>;
var m: vec3<f32>;
var result: vec3<f32>;
let _e42 = bloom_info.params;
t = _e42.xy;
let _e44 = v_uv_1;
let _e45 = t;
let _e48 = textureSample(source_texture_tex, source_texture_smp, (_e44 + (vec2<f32>(-2f, 2f) * _e45)));
a = _e48.xyz;
let _e50 = v_uv_1;
let _e51 = t;
let _e54 = textureSample(source_texture_tex, source_texture_smp, (_e50 + (vec2<f32>(0f, 2f) * _e51)));
b = _e54.xyz;
let _e56 = v_uv_1;
let _e57 = t;
let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (vec2<f32>(2f, 2f) * _e57)));
c = _e60.xyz;
let _e62 = v_uv_1;
let _e63 = t;
let _e66 = textureSample(source_texture_tex, source_texture_smp, (_e62 + (vec2<f32>(-2f, 0f) * _e63)));
d = _e66.xyz;
let _e68 = v_uv_1;
let _e69 = textureSample(source_texture_tex, source_texture_smp, _e68);
e = _e69.xyz;
let _e71 = v_uv_1;
let _e72 = t;
let _e75 = textureSample(source_texture_tex, source_texture_smp, (_e71 + (vec2<f32>(2f, 0f) * _e72)));
f = _e75.xyz;
let _e77 = v_uv_1;
let _e78 = t;
let _e81 = textureSample(source_texture_tex, source_texture_smp, (_e77 + (vec2<f32>(-2f, -2f) * _e78)));
g = _e81.xyz;
let _e83 = v_uv_1;
let _e84 = t;
let _e87 = textureSample(source_texture_tex, source_texture_smp, (_e83 + (vec2<f32>(0f, -2f) * _e84)));
h = _e87.xyz;
let _e89 = v_uv_1;
let _e90 = t;
let _e93 = textureSample(source_texture_tex, source_texture_smp, (_e89 + (vec2<f32>(2f, -2f) * _e90)));
i = _e93.xyz;
let _e95 = v_uv_1;
let _e96 = t;
let _e99 = textureSample(source_texture_tex, source_texture_smp, (_e95 + (vec2<f32>(-1f, 1f) * _e96)));
j = _e99.xyz;
let _e101 = v_uv_1;
let _e102 = t;
let _e105 = textureSample(source_texture_tex, source_texture_smp, (_e101 + (vec2<f32>(1f, 1f) * _e102)));
k = _e105.xyz;
let _e107 = v_uv_1;
let _e108 = t;
let _e111 = textureSample(source_texture_tex, source_texture_smp, (_e107 + (vec2<f32>(-1f, -1f) * _e108)));
l = _e111.xyz;
let _e113 = v_uv_1;
let _e114 = t;
let _e117 = textureSample(source_texture_tex, source_texture_smp, (_e113 + (vec2<f32>(1f, -1f) * _e114)));
m = _e117.xyz;
let _e119 = j;
let _e120 = k;
let _e122 = l;
let _e124 = m;
result = (((((_e119 + _e120) + _e122) + _e124) * 0.5f) * 0.25f);
let _e128 = a;
let _e129 = b;
let _e131 = d;
let _e133 = e;
let _e137 = result;
result = (_e137 + (((((_e128 + _e129) + _e131) + _e133) * 0.125f) * 0.25f));
let _e139 = b;
let _e140 = c;
let _e142 = e;
let _e144 = f;
let _e148 = result;
result = (_e148 + (((((_e139 + _e140) + _e142) + _e144) * 0.125f) * 0.25f));
let _e150 = d;
let _e151 = e;
let _e153 = g;
let _e155 = h;
let _e159 = result;
result = (_e159 + (((((_e150 + _e151) + _e153) + _e155) * 0.125f) * 0.25f));
let _e161 = e;
let _e162 = f;
let _e164 = h;
let _e166 = i;
let _e170 = result;
result = (_e170 + (((((_e161 + _e162) + _e164) + _e166) * 0.125f) * 0.25f));
let _e172 = result;
frag_color = vec4<f32>(_e172.x, _e172.y, _e172.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'BloomUpsample': WebGpuStage(
wgsl: r'''
struct BloomInfo {
params: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn main_1() {
var t: vec2<f32>;
var a: vec3<f32>;
var b: vec3<f32>;
var c: vec3<f32>;
var d: vec3<f32>;
var e: vec3<f32>;
var f: vec3<f32>;
var g: vec3<f32>;
var h: vec3<f32>;
var i: vec3<f32>;
var result: vec3<f32>;
let _e33 = bloom_info.params;
let _e37 = bloom_info.params[2u];
t = (_e33.xy * max(_e37, 0f));
let _e40 = v_uv_1;
let _e41 = t;
let _e44 = textureSample(source_texture_tex, source_texture_smp, (_e40 + (vec2<f32>(-1f, 1f) * _e41)));
a = _e44.xyz;
let _e46 = v_uv_1;
let _e47 = t;
let _e50 = textureSample(source_texture_tex, source_texture_smp, (_e46 + (vec2<f32>(0f, 1f) * _e47)));
b = _e50.xyz;
let _e52 = v_uv_1;
let _e53 = t;
let _e56 = textureSample(source_texture_tex, source_texture_smp, (_e52 + (vec2<f32>(1f, 1f) * _e53)));
c = _e56.xyz;
let _e58 = v_uv_1;
let _e59 = t;
let _e62 = textureSample(source_texture_tex, source_texture_smp, (_e58 + (vec2<f32>(-1f, 0f) * _e59)));
d = _e62.xyz;
let _e64 = v_uv_1;
let _e65 = textureSample(source_texture_tex, source_texture_smp, _e64);
e = _e65.xyz;
let _e67 = v_uv_1;
let _e68 = t;
let _e71 = textureSample(source_texture_tex, source_texture_smp, (_e67 + (vec2<f32>(1f, 0f) * _e68)));
f = _e71.xyz;
let _e73 = v_uv_1;
let _e74 = t;
let _e77 = textureSample(source_texture_tex, source_texture_smp, (_e73 + (vec2<f32>(-1f, -1f) * _e74)));
g = _e77.xyz;
let _e79 = v_uv_1;
let _e80 = t;
let _e83 = textureSample(source_texture_tex, source_texture_smp, (_e79 + (vec2<f32>(0f, -1f) * _e80)));
h = _e83.xyz;
let _e85 = v_uv_1;
let _e86 = t;
let _e89 = textureSample(source_texture_tex, source_texture_smp, (_e85 + (vec2<f32>(1f, -1f) * _e86)));
i = _e89.xyz;
let _e91 = e;
let _e93 = b;
let _e94 = d;
let _e96 = f;
let _e98 = h;
let _e102 = a;
let _e103 = c;
let _e105 = g;
let _e107 = i;
result = (((_e91 * 4f) + ((((_e93 + _e94) + _e96) + _e98) * 2f)) + (((_e102 + _e103) + _e105) + _e107));
let _e110 = result;
let _e111 = (_e110 * 0.0625f);
frag_color = vec4<f32>(_e111.x, _e111.y, _e111.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'BloomInfo',
group: 1,
binding: 0,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'params',
offsetInBytes: 0,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'source_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Composite': WebGpuStage(
wgsl: r'''
struct CompositeInfo {
params: vec4<f32>,
ao_texel: vec4<f32>,
look: vec4<f32>,
look_more: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> composite_info: CompositeInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(5)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
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;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
let _e52 = (*linear);
let _e54 = (*linear);
let _e59 = (*linear);
return mix((_e52 * 12.92f), ((pow(max(_e54, 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), _e59));
}
fn Hash_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
let _e52 = (*at);
return fract((sin(dot(_e52, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}
fn Luma_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
let _e52 = (*color);
return dot(_e52, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}
fn TonemapNeutral_u0028_vf3_u003b(color_1: 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 _e59 = (*color_1)[0u];
let _e61 = (*color_1)[1u];
let _e63 = (*color_1)[2u];
minChannel = min(_e59, min(_e61, _e63));
let _e66 = minChannel;
if (_e66 < 0.08f) {
let _e68 = minChannel;
let _e69 = minChannel;
let _e71 = minChannel;
local = (_e68 - ((6.25f * _e69) * _e71));
} else {
local = 0.04f;
}
let _e74 = local;
offset = _e74;
let _e75 = offset;
let _e76 = (*color_1);
(*color_1) = (_e76 - vec3(_e75));
let _e80 = (*color_1)[0u];
let _e82 = (*color_1)[1u];
let _e84 = (*color_1)[2u];
peak = max(_e80, max(_e82, _e84));
let _e87 = peak;
if (_e87 < 0.76f) {
let _e89 = (*color_1);
return _e89;
}
let _e90 = peak;
newPeak = (1f - (0.0576f / ((_e90 + 0.24f) - 0.76f)));
let _e95 = newPeak;
let _e96 = peak;
let _e98 = (*color_1);
(*color_1) = (_e98 * (_e95 / _e96));
let _e100 = peak;
let _e101 = newPeak;
desaturate = (1f - (1f / ((0.15f * (_e100 - _e101)) + 1f)));
let _e107 = (*color_1);
let _e108 = newPeak;
let _e110 = desaturate;
return mix(_e107, vec3(_e108), vec3(_e110));
}
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 color_2: vec3<f32>;
var param: vec3<f32>;
var contrast: f32;
var saturation: f32;
var temperature: f32;
var param_1: vec3<f32>;
var vignette: f32;
var fromCentre_1: vec2<f32>;
var aspect: f32;
var radius: f32;
var grain: f32;
var param_2: vec2<f32>;
var param_3: vec3<f32>;
let _e73 = composite_info.look[3u];
dispersion = _e73;
let _e74 = dispersion;
if (_e74 > 0f) {
let _e76 = v_uv_1;
fromCentre = (_e76 - vec2<f32>(0.5f, 0.5f));
let _e78 = fromCentre;
let _e79 = dispersion;
step_uv = (_e78 * _e79);
let _e81 = v_uv_1;
let _e82 = textureSample(scene_texture_tex, scene_texture_smp, _e81);
scene = _e82;
let _e83 = v_uv_1;
let _e84 = step_uv;
let _e86 = textureSample(scene_texture_tex, scene_texture_smp, (_e83 + _e84));
scene[0u] = _e86.x;
let _e89 = v_uv_1;
let _e90 = step_uv;
let _e92 = textureSample(scene_texture_tex, scene_texture_smp, (_e89 - _e90));
scene[2u] = _e92.z;
} else {
let _e95 = v_uv_1;
let _e96 = textureSample(scene_texture_tex, scene_texture_smp, _e95);
scene = _e96;
}
let _e97 = v_uv_1;
let _e98 = textureSample(bloom_texture_tex, bloom_texture_smp, _e97);
bloom = _e98.xyz;
let _e101 = composite_info.ao_texel;
half_texel = (_e101.xy * 0.5f);
let _e104 = v_uv_1;
let _e106 = half_texel[0u];
let _e108 = half_texel[1u];
let _e111 = textureSample(ao_texture_tex, ao_texture_smp, (_e104 + vec2<f32>(_e106, _e108)));
let _e113 = v_uv_1;
let _e115 = half_texel[0u];
let _e118 = half_texel[1u];
let _e121 = textureSample(ao_texture_tex, ao_texture_smp, (_e113 + vec2<f32>(-(_e115), _e118)));
let _e124 = v_uv_1;
let _e126 = half_texel[0u];
let _e128 = half_texel[1u];
let _e132 = textureSample(ao_texture_tex, ao_texture_smp, (_e124 + vec2<f32>(_e126, -(_e128))));
let _e135 = v_uv_1;
let _e137 = half_texel[0u];
let _e140 = half_texel[1u];
let _e144 = textureSample(ao_texture_tex, ao_texture_smp, (_e135 + vec2<f32>(-(_e137), -(_e140))));
ao = (0.25f * (((_e111.x + _e121.x) + _e132.x) + _e144.x));
let _e148 = ao;
let _e151 = composite_info.params[3u];
ao = mix(1f, _e148, clamp(_e151, 0f, 1f));
let _e154 = scene;
let _e156 = ao;
let _e158 = bloom;
let _e161 = composite_info.params[1u];
color_2 = ((_e154.xyz * _e156) + (_e158 * _e161));
let _e166 = composite_info.params[0u];
let _e168 = color_2;
color_2 = (_e168 * max(_e166, 0f));
let _e172 = composite_info.params[2u];
if (_e172 > 0.5f) {
let _e174 = color_2;
param = _e174;
let _e175 = TonemapNeutral_u0028_vf3_u003b((¶m));
color_2 = _e175;
}
let _e178 = composite_info.look[0u];
contrast = _e178;
let _e181 = composite_info.look[1u];
saturation = _e181;
let _e184 = composite_info.look[2u];
temperature = _e184;
let _e185 = color_2;
let _e187 = contrast;
color_2 = (((_e185 - vec3<f32>(0.5f, 0.5f, 0.5f)) * _e187) + vec3<f32>(0.5f, 0.5f, 0.5f));
let _e190 = color_2;
param_1 = _e190;
let _e191 = Luma_u0028_vf3_u003b((¶m_1));
let _e193 = color_2;
let _e194 = saturation;
color_2 = mix(vec3(_e191), _e193, vec3(_e194));
let _e197 = temperature;
let _e200 = temperature;
let _e204 = color_2;
color_2 = (_e204 * vec3<f32>((1f + (_e197 * 0.1f)), 1f, (1f - (_e200 * 0.1f))));
let _e208 = composite_info.look_more[0u];
vignette = _e208;
let _e209 = vignette;
if (_e209 > 0f) {
let _e211 = v_uv_1;
fromCentre_1 = (_e211 - vec2<f32>(0.5f, 0.5f));
let _e215 = composite_info.look_more[3u];
aspect = max(_e215, 0.0001f);
let _e217 = aspect;
let _e220 = composite_info.look_more[1u];
let _e223 = fromCentre_1[0u];
fromCentre_1[0u] = (_e223 * mix(1f, _e217, _e220));
let _e226 = fromCentre_1;
radius = (length(_e226) * 1.4142135f);
let _e229 = vignette;
let _e231 = radius;
let _e234 = color_2;
color_2 = (_e234 * mix(1f, (1f - _e229), clamp(_e231, 0f, 1f)));
}
let _e238 = composite_info.look_more[2u];
grain = _e238;
let _e239 = grain;
if (_e239 > 0f) {
let _e241 = gl_FragCoord_1;
param_2 = _e241.xy;
let _e243 = Hash_u0028_vf2_u003b((¶m_2));
let _e245 = grain;
let _e248 = color_2;
color_2 = (_e248 + vec3(((_e243 - 0.5f) * _e245)));
}
let _e250 = color_2;
param_3 = max(_e250, vec3<f32>(0f, 0f, 0f));
let _e252 = LinearToSrgb_u0028_vf3_u003b((¶m_3));
let _e254 = scene[3u];
frag_color = vec4<f32>(_e252.x, _e252.y, _e252.z, _e254);
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: 64,
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,
),
],
),
],
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: 'scene_texture',
group: 1,
textureBinding: 5,
samplerBinding: 6,
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'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
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>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
fn main_1() {
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e18 = gl_FragCoord_1[2u];
frag_color = vec4<f32>(_e18, 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>[
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>[],
),
'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,
),
],
),
'ParticleMesh': WebGpuStage(
wgsl: r'''
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;
fn main_1() {
var to_eye: vec3<f32>;
var distance_to_eye: f32;
var n: vec3<f32>;
var facing: f32;
var local: f32;
var intensity: f32;
var fogged: f32;
let _e19 = fog_info.eye;
let _e21 = v_world_position_1;
to_eye = (_e19.xyz - _e21);
let _e23 = to_eye;
distance_to_eye = length(_e23);
let _e25 = v_normal_1;
n = normalize(_e25);
let _e27 = distance_to_eye;
if (_e27 > 0f) {
let _e29 = n;
let _e30 = to_eye;
let _e31 = distance_to_eye;
local = abs(dot(_e29, (_e30 / vec3(_e31))));
} else {
local = 1f;
}
let _e36 = local;
facing = _e36;
let _e37 = facing;
intensity = mix(0.35f, 1f, _e37);
fogged = 1f;
let _e41 = fog_info.fog[3u];
if (_e41 > 0f) {
let _e45 = fog_info.fog[3u];
let _e47 = distance_to_eye;
fogged = clamp(exp((-(_e45) * _e47)), 0f, 1f);
}
let _e51 = v_color_1;
let _e54 = v_color_1[3u];
let _e56 = intensity;
let _e58 = fogged;
let _e59 = (((_e51.xyz * _e54) * _e56) * _e58);
frag_color = vec4<f32>(_e59.x, _e59.y, _e59.z, 1f);
return;
}
@fragment
fn main(@location(6) v_world_position: vec3<f32>, @location(2) v_normal: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
v_world_position_1 = v_world_position;
v_normal_1 = v_normal;
v_color_1 = v_color;
main_1();
let _e7 = frag_color;
return _e7;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'FogInfo',
group: 1,
binding: 0,
sizeInBytes: 32,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'Reflections': WebGpuStage(
wgsl: r'''
struct ReflectionInfo {
view_projection: mat4x4<f32>,
inverse_view_projection: mat4x4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> reflection_info: ReflectionInfo;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e31 = (*at);
let _e33 = reflection_info.camera;
let _e37 = reflection_info.forward;
return dot((_e31 - _e33.xyz), _e37.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e32 = (*ndc)[0u];
let _e36 = (*ndc)[1u];
return vec2<f32>(((_e32 * 0.5f) + 0.5f), (0.5f - (_e36 * 0.5f)));
}
fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, origin: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>) {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
let _e37 = (*uv)[0u];
let _e41 = (*uv)[1u];
xy = vec2<f32>(((_e37 * 2f) - 1f), (1f - (_e41 * 2f)));
let _e46 = reflection_info.inverse_view_projection;
let _e47 = xy;
nearH = (_e46 * vec4<f32>(_e47.x, _e47.y, 0f, 1f));
let _e53 = reflection_info.inverse_view_projection;
let _e54 = xy;
farH = (_e53 * vec4<f32>(_e54.x, _e54.y, 1f, 1f));
let _e59 = nearH;
let _e62 = nearH[3u];
(*origin) = (_e59.xyz / vec3(_e62));
let _e65 = farH;
let _e68 = farH[3u];
let _e71 = (*origin);
(*along) = normalize(((_e65.xyz / vec3(_e68)) - _e71));
return;
}
fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var origin_1: vec3<f32>;
var along_1: vec3<f32>;
var param: vec2<f32>;
var param_1: vec3<f32>;
var param_2: vec3<f32>;
var axis: vec3<f32>;
let _e38 = (*uv_1);
param = _e38;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m), (¶m_1), (¶m_2));
let _e39 = param_1;
origin_1 = _e39;
let _e40 = param_2;
along_1 = _e40;
let _e42 = reflection_info.forward;
axis = _e42.xyz;
let _e44 = origin_1;
let _e45 = along_1;
let _e46 = (*depth);
let _e47 = origin_1;
let _e49 = reflection_info.camera;
let _e52 = axis;
let _e55 = along_1;
let _e56 = axis;
return (_e44 + (_e45 * ((_e46 - dot((_e47 - _e49.xyz), _e52)) / dot(_e55, _e56))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e35 = (*e);
(*e) = ((_e35 * 2f) - vec2(1f));
let _e39 = (*e);
let _e41 = (*e)[0u];
let _e45 = (*e)[1u];
n = vec3<f32>(_e39.x, _e39.y, ((1f - abs(_e41)) - abs(_e45)));
let _e52 = n[2u];
t = max(-(_e52), 0f);
let _e56 = n[0u];
if (_e56 >= 0f) {
let _e58 = t;
local = -(_e58);
} else {
let _e60 = t;
local = _e60;
}
let _e61 = local;
let _e63 = n[0u];
n[0u] = (_e63 + _e61);
let _e67 = n[1u];
if (_e67 >= 0f) {
let _e69 = t;
local_1 = -(_e69);
} else {
let _e71 = t;
local_1 = _e71;
}
let _e72 = local_1;
let _e74 = n[1u];
n[1u] = (_e74 + _e72);
let _e77 = n;
return normalize(_e77);
}
fn main_1() {
var surface: vec4<f32>;
var scene: vec3<f32>;
var debugOnly: bool;
var background: vec3<f32>;
var normal: vec3<f32>;
var param_3: vec2<f32>;
var roughness: f32;
var polish: f32;
var position: vec3<f32>;
var param_4: vec2<f32>;
var param_5: f32;
var rayOrigin: vec3<f32>;
var viewRay: vec3<f32>;
var param_6: vec2<f32>;
var param_7: vec3<f32>;
var param_8: vec3<f32>;
var toEye: vec3<f32>;
var facing: f32;
var ray: vec3<f32>;
var steps: i32;
var stride: f32;
var thickness: f32;
var intensity: f32;
var march: vec3<f32>;
var hitColor: vec3<f32>;
var hit: f32;
var travelled: f32;
var i: i32;
var clip: vec4<f32>;
var ndc_1: vec3<f32>;
var uv_2: vec2<f32>;
var param_9: vec2<f32>;
var sceneDepth: f32;
var marchDepth: f32;
var param_10: vec3<f32>;
var seen: vec3<f32>;
var param_11: vec2<f32>;
var param_12: f32;
var behind: f32;
var edge: vec2<f32>;
var border: f32;
var fresnel: f32;
var reflection: vec3<f32>;
var local_2: vec3<f32>;
var phi_403_: bool;
var phi_410_: bool;
var phi_417_: bool;
let _e74 = v_uv_1;
let _e75 = textureSample(surface_texture_tex, surface_texture_smp, _e74);
surface = _e75;
let _e76 = v_uv_1;
let _e77 = textureSample(scene_texture_tex, scene_texture_smp, _e76);
scene = _e77.xyz;
let _e81 = reflection_info.screen[3u];
debugOnly = (_e81 > 0.5f);
let _e83 = debugOnly;
let _e84 = scene;
background = select(_e84, vec3<f32>(0f, 0f, 0f), vec3(_e83));
let _e88 = surface[3u];
if (_e88 <= 0f) {
let _e90 = background;
frag_color = vec4<f32>(_e90.x, _e90.y, _e90.z, 1f);
return;
}
let _e95 = surface;
param_3 = _e95.xy;
let _e97 = DecodeOctahedral_u0028_vf2_u003b((¶m_3));
normal = _e97;
let _e99 = surface[2u];
roughness = _e99;
let _e100 = roughness;
polish = (1f - smoothstep(0.18f, 0.45f, _e100));
let _e103 = polish;
if (_e103 <= 0f) {
let _e105 = background;
frag_color = vec4<f32>(_e105.x, _e105.y, _e105.z, 1f);
return;
}
let _e110 = v_uv_1;
param_4 = _e110;
let _e112 = surface[3u];
param_5 = _e112;
let _e113 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_4), (¶m_5));
position = _e113;
let _e114 = v_uv_1;
param_6 = _e114;
PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((¶m_6), (¶m_7), (¶m_8));
let _e115 = param_7;
rayOrigin = _e115;
let _e116 = param_8;
viewRay = _e116;
let _e117 = viewRay;
toEye = -(_e117);
let _e119 = normal;
let _e120 = toEye;
facing = dot(_e119, _e120);
let _e122 = facing;
if (_e122 <= 0.05f) {
let _e124 = background;
frag_color = vec4<f32>(_e124.x, _e124.y, _e124.z, 1f);
return;
}
let _e129 = toEye;
let _e131 = normal;
ray = reflect(-(_e129), _e131);
let _e135 = reflection_info.params[0u];
steps = i32(_e135);
let _e139 = reflection_info.params[1u];
stride = _e139;
let _e142 = reflection_info.params[2u];
thickness = _e142;
let _e145 = reflection_info.params[3u];
intensity = _e145;
let _e146 = position;
let _e147 = normal;
let _e150 = ray;
let _e151 = stride;
march = ((_e146 + (_e147 * 0.02f)) + (_e150 * _e151));
hitColor = vec3<f32>(0f, 0f, 0f);
hit = 0f;
let _e154 = stride;
travelled = _e154;
i = 0i;
loop {
let _e155 = i;
if (_e155 < 64i) {
let _e157 = i;
let _e158 = steps;
if (_e157 >= _e158) {
break;
}
let _e161 = reflection_info.view_projection;
let _e162 = march;
clip = (_e161 * vec4<f32>(_e162.x, _e162.y, _e162.z, 1f));
let _e169 = clip[3u];
if (_e169 <= 0f) {
break;
}
let _e171 = clip;
let _e174 = clip[3u];
ndc_1 = (_e171.xyz / vec3(_e174));
let _e177 = ndc_1;
param_9 = _e177.xy;
let _e179 = UvFromNdc_u0028_vf2_u003b((¶m_9));
uv_2 = _e179;
let _e181 = uv_2[0u];
let _e182 = (_e181 < 0f);
phi_403_ = _e182;
if !(_e182) {
let _e185 = uv_2[0u];
phi_403_ = (_e185 > 1f);
}
let _e188 = phi_403_;
phi_410_ = _e188;
if !(_e188) {
let _e191 = uv_2[1u];
phi_410_ = (_e191 < 0f);
}
let _e194 = phi_410_;
phi_417_ = _e194;
if !(_e194) {
let _e197 = uv_2[1u];
phi_417_ = (_e197 > 1f);
}
let _e200 = phi_417_;
if _e200 {
break;
}
let _e201 = uv_2;
let _e202 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e201, 0f);
sceneDepth = _e202.w;
let _e204 = march;
param_10 = _e204;
let _e205 = DepthOf_u0028_vf3_u003b((¶m_10));
marchDepth = _e205;
let _e206 = sceneDepth;
let _e208 = marchDepth;
let _e209 = sceneDepth;
if ((_e206 > 0f) && (_e208 > _e209)) {
let _e212 = uv_2;
param_11 = _e212;
let _e213 = sceneDepth;
param_12 = _e213;
let _e214 = WorldAt_u0028_vf2_u003b_f1_u003b((¶m_11), (¶m_12));
seen = _e214;
let _e215 = march;
let _e216 = seen;
behind = distance(_e215, _e216);
let _e218 = behind;
let _e219 = thickness;
if (_e218 < _e219) {
let _e221 = uv_2;
let _e222 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e221, 0f);
hitColor = _e222.xyz;
let _e224 = uv_2;
edge = abs(((_e224 * 2f) - vec2(1f)));
let _e230 = edge[0u];
let _e232 = edge[1u];
border = (1f - max(_e230, _e232));
let _e235 = border;
hit = smoothstep(0f, 0.15f, _e235);
break;
}
}
let _e237 = ray;
let _e238 = stride;
let _e240 = march;
march = (_e240 + (_e237 * _e238));
let _e242 = stride;
let _e243 = travelled;
travelled = (_e243 + _e242);
continue;
} else {
break;
}
continuing {
let _e245 = i;
i = (_e245 + 1i);
}
}
let _e247 = facing;
fresnel = pow((1f - _e247), 4f);
let _e250 = hitColor;
let _e251 = hit;
let _e253 = intensity;
let _e255 = polish;
let _e257 = fresnel;
reflection = ((((_e250 * _e251) * _e253) * _e255) * (0.15f + (0.85f * _e257)));
let _e261 = debugOnly;
if _e261 {
let _e262 = reflection;
local_2 = _e262;
} else {
let _e263 = scene;
let _e264 = reflection;
local_2 = (_e263 + _e264);
}
let _e266 = local_2;
frag_color = vec4<f32>(_e266.x, _e266.y, _e266.z, 1f);
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'ReflectionInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'scene_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 3,
samplerBinding: 4,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'Ssao': WebGpuStage(
wgsl: r'''
struct SsaoInfo {
inverse_view_projection: mat4x4<f32>,
view_projection: mat4x4<f32>,
params: vec4<f32>,
screen: vec4<f32>,
camera: vec4<f32>,
forward: vec4<f32>,
}
@group(1) @binding(0)
var<uniform> ssao_info: SsaoInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
let _e82 = (*at);
let _e84 = ssao_info.camera;
let _e88 = ssao_info.forward;
return dot((_e82 - _e84.xyz), _e88.xyz);
}
fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
let _e83 = (*ndc)[0u];
let _e87 = (*ndc)[1u];
return vec2<f32>(((_e83 * 0.5f) + 0.5f), (0.5f - (_e87 * 0.5f)));
}
fn KernelTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec3<f32> {
let _e82 = (*i);
if (_e82 == 0i) {
return vec3<f32>(0.5381f, 0.1856f, 0.4319f);
}
let _e84 = (*i);
if (_e84 == 1i) {
return vec3<f32>(0.1379f, 0.2486f, 0.443f);
}
let _e86 = (*i);
if (_e86 == 2i) {
return vec3<f32>(0.3371f, 0.5679f, 0.0057f);
}
let _e88 = (*i);
if (_e88 == 3i) {
return vec3<f32>(-0.6999f, -0.0451f, 0.0019f);
}
let _e90 = (*i);
if (_e90 == 4i) {
return vec3<f32>(0.0689f, -0.1598f, -0.8547f);
}
let _e92 = (*i);
if (_e92 == 5i) {
return vec3<f32>(0.056f, 0.0069f, -0.1843f);
}
let _e94 = (*i);
if (_e94 == 6i) {
return vec3<f32>(-0.0146f, 0.1402f, 0.0762f);
}
let _e96 = (*i);
if (_e96 == 7i) {
return vec3<f32>(0.01f, -0.1924f, -0.0344f);
}
let _e98 = (*i);
if (_e98 == 8i) {
return vec3<f32>(-0.3577f, -0.5301f, -0.4358f);
}
let _e100 = (*i);
if (_e100 == 9i) {
return vec3<f32>(-0.3169f, 0.1063f, 0.0158f);
}
let _e102 = (*i);
if (_e102 == 10i) {
return vec3<f32>(0.0103f, -0.5869f, 0.0046f);
}
return vec3<f32>(-0.0897f, -0.494f, 0.3287f);
}
fn Rotation_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec2<f32> {
var pixel: vec2<f32>;
var oddX: bool;
var oddY: bool;
let _e85 = (*uv);
let _e87 = ssao_info.screen;
pixel = floor((_e85 / _e87.xy));
let _e92 = pixel[0u];
oddX = ((_e92 - (floor((_e92 / 2f)) * 2f)) >= 1f);
let _e99 = pixel[1u];
oddY = ((_e99 - (floor((_e99 / 2f)) * 2f)) >= 1f);
let _e105 = oddX;
let _e106 = oddY;
if (_e105 && _e106) {
return vec2<f32>(-0.7071f, -0.7071f);
}
let _e108 = oddX;
if _e108 {
return vec2<f32>(0.7071f, -0.7071f);
}
let _e109 = oddY;
if _e109 {
return vec2<f32>(-0.7071f, 0.7071f);
}
return vec2<f32>(1f, 0f);
}
fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
var xy: vec2<f32>;
var nearH: vec4<f32>;
var farH: vec4<f32>;
var origin: vec3<f32>;
var along: vec3<f32>;
var axis: vec3<f32>;
let _e90 = (*uv_1)[0u];
let _e94 = (*uv_1)[1u];
xy = vec2<f32>(((_e90 * 2f) - 1f), (1f - (_e94 * 2f)));
let _e99 = ssao_info.inverse_view_projection;
let _e100 = xy;
nearH = (_e99 * vec4<f32>(_e100.x, _e100.y, 0f, 1f));
let _e106 = ssao_info.inverse_view_projection;
let _e107 = xy;
farH = (_e106 * vec4<f32>(_e107.x, _e107.y, 1f, 1f));
let _e112 = nearH;
let _e115 = nearH[3u];
origin = (_e112.xyz / vec3(_e115));
let _e118 = farH;
let _e121 = farH[3u];
let _e124 = origin;
along = normalize(((_e118.xyz / vec3(_e121)) - _e124));
let _e128 = ssao_info.forward;
axis = _e128.xyz;
let _e130 = origin;
let _e131 = along;
let _e132 = (*depth);
let _e133 = origin;
let _e135 = ssao_info.camera;
let _e138 = axis;
let _e141 = along;
let _e142 = axis;
return (_e130 + (_e131 * ((_e132 - dot((_e133 - _e135.xyz), _e138)) / dot(_e141, _e142))));
}
fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
var n: vec3<f32>;
var t: f32;
var local: f32;
var local_1: f32;
let _e86 = (*e);
(*e) = ((_e86 * 2f) - vec2(1f));
let _e90 = (*e);
let _e92 = (*e)[0u];
let _e96 = (*e)[1u];
n = vec3<f32>(_e90.x, _e90.y, ((1f - abs(_e92)) - abs(_e96)));
let _e103 = n[2u];
t = max(-(_e103), 0f);
let _e107 = n[0u];
if (_e107 >= 0f) {
let _e109 = t;
local = -(_e109);
} else {
let _e111 = t;
local = _e111;
}
let _e112 = local;
let _e114 = n[0u];
n[0u] = (_e114 + _e112);
let _e118 = n[1u];
if (_e118 >= 0f) {
let _e120 = t;
local_1 = -(_e120);
} else {
let _e122 = t;
local_1 = _e122;
}
let _e123 = local_1;
let _e125 = n[1u];
n[1u] = (_e125 + _e123);
let _e128 = n;
return normalize(_e128);
}
fn main_1() {
var surface: vec4<f32>;
var normal: vec3<f32>;
var param: vec2<f32>;
var radius: f32;
var samples: i32;
var origin_1: vec3<f32>;
var param_1: vec2<f32>;
var param_2: f32;
var rot: vec2<f32>;
var param_3: vec2<f32>;
var occluded: f32;
var i_1: i32;
var tap: vec3<f32>;
var param_4: i32;
var spun: vec3<f32>;
var at_1: vec3<f32>;
var clip: vec4<f32>;
var ndc_1: vec3<f32>;
var uv_2: vec2<f32>;
var param_5: vec2<f32>;
var there: vec4<f32>;
var param_6: vec3<f32>;
var seen: vec3<f32>;
var param_7: vec2<f32>;
var param_8: f32;
var phi_506_: bool;
let _e106 = v_uv_1;
let _e107 = textureSample(surface_texture_tex, surface_texture_smp, _e106);
surface = _e107;
let _e109 = surface[3u];
if (_e109 <= 0f) {
frag_color = vec4<f32>(1f, 1f, 1f, 1f);
return;
}
let _e111 = surface;
param = _e111.xy;
let _e113 = DecodeOctahedral_u0028_vf2_u003b((¶m));
normal = _e113;
let _e116 = ssao_info.params[0u];
radius = max(_e116, 0.0001f);
let _e120 = ssao_info.params[1u];
samples = clamp(i32((_e120 + 0.5f)), 1i, 12i);
let _e124 = v_uv_1;
param_1 = _e124;
let _e126 = surface[3u];
param_2 = _e126;
let _e127 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_1), (¶m_2));
let _e128 = normal;
let _e131 = ssao_info.params[3u];
origin_1 = (_e127 + (_e128 * _e131));
let _e134 = v_uv_1;
param_3 = _e134;
let _e135 = Rotation_u0028_vf2_u003b((¶m_3));
rot = _e135;
occluded = 0f;
i_1 = 0i;
loop {
let _e136 = i_1;
if (_e136 < 12i) {
let _e138 = i_1;
let _e139 = samples;
if (_e138 >= _e139) {
break;
}
let _e141 = i_1;
param_4 = _e141;
let _e142 = KernelTap_u0028_i1_u003b((¶m_4));
tap = _e142;
let _e144 = tap[0u];
let _e146 = rot[0u];
let _e149 = tap[1u];
let _e151 = rot[1u];
let _e155 = tap[0u];
let _e157 = rot[1u];
let _e160 = tap[1u];
let _e162 = rot[0u];
let _e166 = tap[2u];
spun = vec3<f32>(((_e144 * _e146) - (_e149 * _e151)), ((_e155 * _e157) + (_e160 * _e162)), _e166);
let _e168 = spun;
let _e169 = normal;
if (dot(_e168, _e169) < 0f) {
let _e172 = spun;
spun = -(_e172);
}
let _e174 = origin_1;
let _e175 = spun;
let _e176 = radius;
at_1 = (_e174 + (_e175 * _e176));
let _e180 = ssao_info.view_projection;
let _e181 = at_1;
clip = (_e180 * vec4<f32>(_e181.x, _e181.y, _e181.z, 1f));
let _e188 = clip[3u];
if (_e188 <= 0f) {
continue;
}
let _e190 = clip;
let _e193 = clip[3u];
ndc_1 = (_e190.xyz / vec3(_e193));
let _e197 = ndc_1[0u];
let _e199 = (abs(_e197) > 1f);
phi_506_ = _e199;
if !(_e199) {
let _e202 = ndc_1[1u];
phi_506_ = (abs(_e202) > 1f);
}
let _e206 = phi_506_;
if _e206 {
continue;
}
let _e207 = ndc_1;
param_5 = _e207.xy;
let _e209 = UvFromNdc_u0028_vf2_u003b((¶m_5));
uv_2 = _e209;
let _e210 = uv_2;
let _e211 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e210, 0f);
there = _e211;
let _e213 = there[3u];
if (_e213 <= 0f) {
continue;
}
let _e216 = there[3u];
let _e217 = at_1;
param_6 = _e217;
let _e218 = DepthOf_u0028_vf3_u003b((¶m_6));
if (_e216 >= _e218) {
continue;
}
let _e220 = uv_2;
param_7 = _e220;
let _e222 = there[3u];
param_8 = _e222;
let _e223 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((¶m_7), (¶m_8));
seen = _e223;
let _e224 = radius;
let _e225 = seen;
let _e226 = origin_1;
let _e231 = occluded;
occluded = (_e231 + smoothstep(0f, 1f, (_e224 / max(distance(_e225, _e226), 0.0001f))));
continue;
} else {
break;
}
continuing {
let _e233 = i_1;
i_1 = (_e233 + 1i);
}
}
let _e235 = occluded;
let _e236 = samples;
frag_color = vec4(clamp((1f - (_e235 / f32(_e236))), 0f, 1f));
return;
}
@fragment
fn main(@location(5) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
v_uv_1 = v_uv;
main_1();
let _e3 = frag_color;
return _e3;
}
''',
attributes: <WebGpuAttribute>[],
blocks: <WebGpuBlock>[
WebGpuBlock(
name: 'SsaoInfo',
group: 1,
binding: 0,
sizeInBytes: 192,
members: <WebGpuBlockMember>[
WebGpuBlockMember(
name: 'inverse_view_projection',
offsetInBytes: 0,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'view_projection',
offsetInBytes: 64,
sizeInBytes: 64,
),
WebGpuBlockMember(
name: 'params',
offsetInBytes: 128,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'screen',
offsetInBytes: 144,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'camera',
offsetInBytes: 160,
sizeInBytes: 16,
),
WebGpuBlockMember(
name: 'forward',
offsetInBytes: 176,
sizeInBytes: 16,
),
],
),
],
samplers: <WebGpuSampler>[
WebGpuSampler(
name: 'surface_texture',
group: 1,
textureBinding: 1,
samplerBinding: 2,
dimension: WebGpuTextureDimension.twoDimensional,
),
],
),
'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>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@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_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>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
fn main_1() {
var range: f32;
var distance_: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e23 = shadow_light.light[3u];
range = max(_e23, 0.0001f);
let _e25 = v_world_position_1;
let _e27 = shadow_light.light;
distance_ = length((_e25 - _e27.xyz));
let _e31 = distance_;
let _e32 = range;
frag_color = vec4<f32>(clamp((_e31 / _e32), 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: '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: 'ShadowLight',
group: 1,
binding: 1,
sizeInBytes: 16,
members: <WebGpuBlockMember>[
WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
],
),
],
samplers: <WebGpuSampler>[],
),
'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>,
}
struct FogInfo {
fog: vec4<f32>,
eye: vec4<f32>,
forward: vec4<f32>,
}
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
@group(1) @binding(1)
var<uniform> id_info: IdInfo;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> 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>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
fn main_1() {
var cutoff: f32;
var alpha: f32;
g_debug_surface = vec3<f32>(0f, 0f, 0f);
g_debug_surface_on = false;
let _e27 = id_info.mask[0u];
cutoff = _e27;
let _e28 = cutoff;
if (_e28 >= 0f) {
let _e30 = v_texcoord_1;
let _e31 = textureSample(base_color_texture_tex, base_color_texture_smp, _e30);
let _e35 = id_info.mask[1u];
let _e38 = v_color_1[3u];
alpha = ((_e31.w * _e35) * _e38);
let _e40 = alpha;
let _e41 = cutoff;
if (_e40 < _e41) {
discard;
}
}
let _e44 = id_info.id;
let _e45 = _e44.xyz;
frag_color = vec4<f32>(_e45.x, _e45.y, _e45.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: '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: 'IdInfo',
group: 1,
binding: 1,
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: 2,
samplerBinding: 3,
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>[],
),
},
);