webGpuEngineShaders top-level property

WebGpuSectionStages webGpuEngineShaders

Every shader the engine asks for, in WGSL, beside the reflection a GPUShaderModule cannot be asked for.

Public, and promised with the rest: WebGpuDevice.open takes the stages it compiles, and uses these when it is given none.

Implementation

final WebGpuSectionStages webGpuEngineShaders = WebGpuSectionStages(
  vertex: <String, WebGpuStage>{
    'MeshVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(7) member: vec3<f32>,
    @location(3) member_1: vec3<f32>,
    @location(5) member_2: vec2<f32>,
    @location(4) member_3: vec4<f32>,
    @location(0) member_4: vec4<f32>,
    @location(2) member_5: vec2<f32>,
    @location(1) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(2)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(3)
var morph_texture_smp: sampler;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> v_instance: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn MorphWidth_u0028_() -> i32 {
    let _e36 = morph_info.morph_params[1u];
    return i32(((1f / _e36) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e34 = gl_VertexIndex_1;
    return _e34;
}

fn MorphBand_u0028_() -> f32 {
    let _e34 = F3dVertexIndex_u0028_();
    let _e35 = MorphWidth_u0028_();
    return f32((_e34 / _e35));
}

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 bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e46 = morph_info.morph_params[3u];
    bands = max(_e46, 1f);
    let _e48 = (*t);
    let _e51 = bands;
    let _e53 = MorphBand_u0028_();
    let _e56 = (*rowStep);
    row = ((((f32((_e48 * 3i)) * _e51) + _e53) + 0.5f) * _e56);
    let _e58 = (*rowStep);
    let _e59 = bands;
    streamStep = (_e58 * _e59);
    let _e61 = (*column);
    let _e62 = row;
    let _e64 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e61, _e62), 0f);
    let _e66 = (*weight);
    let _e68 = (*position_1);
    (*position_1) = (_e68 + (_e64.xyz * _e66));
    let _e70 = (*column);
    let _e71 = row;
    let _e72 = streamStep;
    let _e75 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e70, (_e71 + _e72)), 0f);
    let _e77 = (*weight);
    let _e79 = (*normal_1);
    (*normal_1) = (_e79 + (_e75.xyz * _e77));
    let _e81 = (*column);
    let _e82 = row;
    let _e83 = streamStep;
    let _e87 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e81, (_e82 + (_e83 * 2f))), 0f);
    let _e89 = (*weight);
    let _e91 = (*tangent_1);
    let _e93 = (_e91.xyz + (_e87.xyz * _e89));
    (*tangent_1)[0u] = _e93.x;
    (*tangent_1)[1u] = _e93.y;
    (*tangent_1)[2u] = _e93.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e34 = F3dVertexIndex_u0028_();
    let _e35 = MorphWidth_u0028_();
    let _e47 = morph_info.morph_params[1u];
    return ((f32((_e34 - (i32(floor((f32(_e34) / f32(_e35)))) * _e35))) + 0.5f) * _e47);
}

fn MorphCount_u0028_() -> i32 {
    let _e36 = morph_info.morph_params[0u];
    return i32((_e36 + 0.5f));
}

fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var i: i32;
    var weight_1: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e49 = MorphCount_u0028_();
    count = _e49;
    let _e50 = count;
    if (_e50 <= 0i) {
        return;
    }
    let _e52 = MorphColumn_u0028_();
    column_1 = _e52;
    let _e55 = morph_info.morph_params[2u];
    rowStep_1 = _e55;
    i = 0i;
    loop {
        let _e56 = i;
        if (_e56 < 8i) {
            let _e58 = i;
            let _e59 = count;
            if (_e58 >= _e59) {
                break;
            }
            let _e61 = i;
            let _e63 = i;
            let _e74 = morph_info.morph_weights[(_e61 / 4i)][(_e63 - (i32(floor((f32(_e63) / f32(4i)))) * 4i))];
            weight_1 = _e74;
            let _e75 = weight_1;
            if (_e75 == 0f) {
                continue;
            }
            let _e77 = i;
            param = _e77;
            let _e78 = weight_1;
            param_1 = _e78;
            let _e79 = column_1;
            param_2 = _e79;
            let _e80 = rowStep_1;
            param_3 = _e80;
            let _e81 = (*position_2);
            param_4 = _e81;
            let _e82 = (*normal_2);
            param_5 = _e82;
            let _e83 = (*tangent_2);
            param_6 = _e83;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e84 = param_4;
            (*position_2) = _e84;
            let _e85 = param_5;
            (*normal_2) = _e85;
            let _e86 = param_6;
            (*tangent_2) = _e86;
            continue;
        } else {
            break;
        }
        continuing {
            let _e87 = i;
            i = (_e87 + 1i);
        }
    }
    return;
}

fn main_1() {
    var morphed_position: vec3<f32>;
    var morphed_normal: vec3<f32>;
    var morphed_tangent: vec4<f32>;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var param_9: vec4<f32>;
    var world: vec4<f32>;
    var mirrored: bool;
    var local: f32;

    let _e43 = position_3;
    morphed_position = _e43;
    let _e44 = normal_3;
    morphed_normal = _e44;
    let _e45 = tangent_3;
    morphed_tangent = _e45;
    let _e46 = morphed_position;
    param_7 = _e46;
    let _e47 = morphed_normal;
    param_8 = _e47;
    let _e48 = morphed_tangent;
    param_9 = _e48;
    ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((&param_7), (&param_8), (&param_9));
    let _e49 = param_7;
    morphed_position = _e49;
    let _e50 = param_8;
    morphed_normal = _e50;
    let _e51 = param_9;
    morphed_tangent = _e51;
    let _e53 = frame_info.model;
    let _e54 = morphed_position;
    world = (_e53 * vec4<f32>(_e54.x, _e54.y, _e54.z, 1f));
    let _e60 = world;
    v_world_position = _e60.xyz;
    let _e63 = frame_info.normal_matrix;
    let _e71 = morphed_normal;
    v_normal = (mat3x3<f32>(_e63[0].xyz, _e63[1].xyz, _e63[2].xyz) * _e71);
    let _e73 = texcoord_1;
    v_texcoord = _e73;
    let _e75 = frame_info.model;
    mirrored = (determinant(mat3x3<f32>(_e75[0].xyz, _e75[1].xyz, _e75[2].xyz)) < 0f);
    let _e86 = frame_info.model;
    let _e94 = morphed_tangent;
    let _e96 = (mat3x3<f32>(_e86[0].xyz, _e86[1].xyz, _e86[2].xyz) * _e94.xyz);
    let _e97 = mirrored;
    if _e97 {
        let _e99 = morphed_tangent[3u];
        local = -(_e99);
    } else {
        let _e102 = morphed_tangent[3u];
        local = _e102;
    }
    let _e103 = local;
    v_tangent = vec4<f32>(_e96.x, _e96.y, _e96.z, _e103);
    let _e108 = color_1;
    v_color = _e108;
    v_lightmap_uv = vec2<f32>(0f, 0f);
    v_instance = vec4<f32>(0f, 0f, 0f, 0f);
    let _e110 = frame_info.mvp;
    let _e111 = morphed_position;
    unnamed.gl_Position = (_e110 * vec4<f32>(_e111.x, _e111.y, _e111.z, 1f));
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    position_3 = position;
    normal_3 = normal;
    tangent_3 = tangent;
    texcoord_1 = texcoord;
    color_1 = color;
    main_1();
    let _e22 = v_world_position;
    let _e23 = v_normal;
    let _e24 = v_texcoord;
    let _e25 = v_tangent;
    let _e26 = v_color;
    let _e27 = v_lightmap_uv;
    let _e28 = v_instance;
    let _e29 = unnamed.gl_Position;
    return VertexOutput(_e22, _e23, _e24, _e25, _e26, _e27, _e28, _e29);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'tangent',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 4,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'DebugLineVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct LineInfo {
    view_projection: mat4x4<f32>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_line_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> line_info: LineInfo;
var<private> position_1: vec3<f32>;

fn main_1() {
    let _e8 = color_1;
    v_line_color = _e8;
    let _e10 = line_info.view_projection;
    let _e11 = position_1;
    unnamed.gl_Position = (_e10 * vec4<f32>(_e11.x, _e11.y, _e11.z, 1f));
    return;
}

@vertex
fn main(@location(1) color: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
    color_1 = color;
    position_1 = position;
    main_1();
    let _e7 = v_line_color;
    let _e8 = unnamed.gl_Position;
    return VertexOutput(_e7, _e8);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 1,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'LineInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'FullscreenVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(6) member: vec2<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;

fn main_1() {
    let _e8 = texcoord_1;
    v_uv = _e8;
    let _e9 = position_1;
    unnamed.gl_Position = vec4<f32>(_e9.x, _e9.y, 0f, 1f);
    return;
}

@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
    texcoord_1 = texcoord;
    position_1 = position;
    main_1();
    let _e7 = v_uv;
    let _e8 = unnamed.gl_Position;
    return VertexOutput(_e7, _e8);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 1,
          format: VertexFormat.float32x2,
        ),
      ],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'MeshSkinnedVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct SkinInfo {
    joint_matrices: array<mat4x4<f32>, 64>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(7) member: vec3<f32>,
    @location(3) member_1: vec3<f32>,
    @location(4) member_2: vec4<f32>,
    @location(5) member_3: vec2<f32>,
    @location(0) member_4: vec4<f32>,
    @location(2) member_5: vec2<f32>,
    @location(1) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(3)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_texture_smp: sampler;
var<private> weights_1: vec4<f32>;
@group(0) @binding(2)
var<uniform> skin_info: SkinInfo;
var<private> joints_1: vec4<f32>;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> v_instance: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn MorphWidth_u0028_() -> i32 {
    let _e43 = morph_info.morph_params[1u];
    return i32(((1f / _e43) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e41 = gl_VertexIndex_1;
    return _e41;
}

fn MorphBand_u0028_() -> f32 {
    let _e41 = F3dVertexIndex_u0028_();
    let _e42 = MorphWidth_u0028_();
    return f32((_e41 / _e42));
}

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 bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e53 = morph_info.morph_params[3u];
    bands = max(_e53, 1f);
    let _e55 = (*t);
    let _e58 = bands;
    let _e60 = MorphBand_u0028_();
    let _e63 = (*rowStep);
    row = ((((f32((_e55 * 3i)) * _e58) + _e60) + 0.5f) * _e63);
    let _e65 = (*rowStep);
    let _e66 = bands;
    streamStep = (_e65 * _e66);
    let _e68 = (*column);
    let _e69 = row;
    let _e71 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e68, _e69), 0f);
    let _e73 = (*weight);
    let _e75 = (*position_1);
    (*position_1) = (_e75 + (_e71.xyz * _e73));
    let _e77 = (*column);
    let _e78 = row;
    let _e79 = streamStep;
    let _e82 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e77, (_e78 + _e79)), 0f);
    let _e84 = (*weight);
    let _e86 = (*normal_1);
    (*normal_1) = (_e86 + (_e82.xyz * _e84));
    let _e88 = (*column);
    let _e89 = row;
    let _e90 = streamStep;
    let _e94 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e88, (_e89 + (_e90 * 2f))), 0f);
    let _e96 = (*weight);
    let _e98 = (*tangent_1);
    let _e100 = (_e98.xyz + (_e94.xyz * _e96));
    (*tangent_1)[0u] = _e100.x;
    (*tangent_1)[1u] = _e100.y;
    (*tangent_1)[2u] = _e100.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e41 = F3dVertexIndex_u0028_();
    let _e42 = MorphWidth_u0028_();
    let _e54 = morph_info.morph_params[1u];
    return ((f32((_e41 - (i32(floor((f32(_e41) / f32(_e42)))) * _e42))) + 0.5f) * _e54);
}

fn MorphCount_u0028_() -> i32 {
    let _e43 = morph_info.morph_params[0u];
    return i32((_e43 + 0.5f));
}

fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var i: i32;
    var weight_1: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e56 = MorphCount_u0028_();
    count = _e56;
    let _e57 = count;
    if (_e57 <= 0i) {
        return;
    }
    let _e59 = MorphColumn_u0028_();
    column_1 = _e59;
    let _e62 = morph_info.morph_params[2u];
    rowStep_1 = _e62;
    i = 0i;
    loop {
        let _e63 = i;
        if (_e63 < 8i) {
            let _e65 = i;
            let _e66 = count;
            if (_e65 >= _e66) {
                break;
            }
            let _e68 = i;
            let _e70 = i;
            let _e81 = morph_info.morph_weights[(_e68 / 4i)][(_e70 - (i32(floor((f32(_e70) / f32(4i)))) * 4i))];
            weight_1 = _e81;
            let _e82 = weight_1;
            if (_e82 == 0f) {
                continue;
            }
            let _e84 = i;
            param = _e84;
            let _e85 = weight_1;
            param_1 = _e85;
            let _e86 = column_1;
            param_2 = _e86;
            let _e87 = rowStep_1;
            param_3 = _e87;
            let _e88 = (*position_2);
            param_4 = _e88;
            let _e89 = (*normal_2);
            param_5 = _e89;
            let _e90 = (*tangent_2);
            param_6 = _e90;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e91 = param_4;
            (*position_2) = _e91;
            let _e92 = param_5;
            (*normal_2) = _e92;
            let _e93 = param_6;
            (*tangent_2) = _e93;
            continue;
        } else {
            break;
        }
        continuing {
            let _e94 = i;
            i = (_e94 + 1i);
        }
    }
    return;
}

fn JointIndex_u0028_f1_u003b(joint: ptr<function, f32>) -> i32 {
    let _e42 = (*joint);
    return clamp(i32(_e42), 0i, 63i);
}

fn SkinMatrix_u0028_() -> mat4x4<f32> {
    var total: f32;
    var w: vec4<f32>;
    var local: vec4<f32>;
    var param_7: f32;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;

    let _e49 = weights_1[0u];
    let _e51 = weights_1[1u];
    let _e54 = weights_1[2u];
    let _e57 = weights_1[3u];
    total = (((_e49 + _e51) + _e54) + _e57);
    let _e59 = total;
    if (_e59 > 0.00001f) {
        let _e61 = weights_1;
        let _e62 = total;
        local = (_e61 / vec4(_e62));
    } else {
        local = vec4<f32>(1f, 0f, 0f, 0f);
    }
    let _e65 = local;
    w = _e65;
    let _e67 = w[0u];
    let _e69 = joints_1[0u];
    param_7 = _e69;
    let _e70 = JointIndex_u0028_f1_u003b((&param_7));
    let _e73 = skin_info.joint_matrices[_e70];
    let _e74 = (_e73 * _e67);
    let _e76 = w[1u];
    let _e78 = joints_1[1u];
    param_8 = _e78;
    let _e79 = JointIndex_u0028_f1_u003b((&param_8));
    let _e82 = skin_info.joint_matrices[_e79];
    let _e83 = (_e82 * _e76);
    let _e96 = mat4x4<f32>((_e74[0] + _e83[0]), (_e74[1] + _e83[1]), (_e74[2] + _e83[2]), (_e74[3] + _e83[3]));
    let _e98 = w[2u];
    let _e100 = joints_1[2u];
    param_9 = _e100;
    let _e101 = JointIndex_u0028_f1_u003b((&param_9));
    let _e104 = skin_info.joint_matrices[_e101];
    let _e105 = (_e104 * _e98);
    let _e118 = mat4x4<f32>((_e96[0] + _e105[0]), (_e96[1] + _e105[1]), (_e96[2] + _e105[2]), (_e96[3] + _e105[3]));
    let _e120 = w[3u];
    let _e122 = joints_1[3u];
    param_10 = _e122;
    let _e123 = JointIndex_u0028_f1_u003b((&param_10));
    let _e126 = skin_info.joint_matrices[_e123];
    let _e127 = (_e126 * _e120);
    return mat4x4<f32>((_e118[0] + _e127[0]), (_e118[1] + _e127[1]), (_e118[2] + _e127[2]), (_e118[3] + _e127[3]));
}

fn main_1() {
    var skin: mat4x4<f32>;
    var morphed_position: vec3<f32>;
    var morphed_normal: vec3<f32>;
    var morphed_tangent: vec4<f32>;
    var param_11: vec3<f32>;
    var param_12: vec3<f32>;
    var param_13: vec4<f32>;
    var skinnedModel: mat4x4<f32>;
    var world: vec4<f32>;
    var skinRotation: mat3x3<f32>;
    var mirrored: bool;
    var local_1: f32;

    let _e53 = SkinMatrix_u0028_();
    skin = _e53;
    let _e54 = position_3;
    morphed_position = _e54;
    let _e55 = normal_3;
    morphed_normal = _e55;
    let _e56 = tangent_3;
    morphed_tangent = _e56;
    let _e57 = morphed_position;
    param_11 = _e57;
    let _e58 = morphed_normal;
    param_12 = _e58;
    let _e59 = morphed_tangent;
    param_13 = _e59;
    ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((&param_11), (&param_12), (&param_13));
    let _e60 = param_11;
    morphed_position = _e60;
    let _e61 = param_12;
    morphed_normal = _e61;
    let _e62 = param_13;
    morphed_tangent = _e62;
    let _e64 = frame_info.model;
    let _e65 = skin;
    skinnedModel = (_e64 * _e65);
    let _e67 = skinnedModel;
    let _e68 = morphed_position;
    world = (_e67 * vec4<f32>(_e68.x, _e68.y, _e68.z, 1f));
    let _e74 = world;
    v_world_position = _e74.xyz;
    let _e76 = skin;
    skinRotation = mat3x3<f32>(_e76[0].xyz, _e76[1].xyz, _e76[2].xyz);
    let _e85 = frame_info.normal_matrix;
    let _e93 = skinRotation;
    let _e94 = morphed_normal;
    v_normal = (mat3x3<f32>(_e85[0].xyz, _e85[1].xyz, _e85[2].xyz) * (_e93 * _e94));
    let _e98 = frame_info.model;
    let _e108 = skinRotation;
    mirrored = ((determinant(mat3x3<f32>(_e98[0].xyz, _e98[1].xyz, _e98[2].xyz)) < 0f) != (determinant(_e108) < 0f));
    let _e113 = frame_info.model;
    let _e121 = skinRotation;
    let _e122 = morphed_tangent;
    let _e125 = (mat3x3<f32>(_e113[0].xyz, _e113[1].xyz, _e113[2].xyz) * (_e121 * _e122.xyz));
    let _e126 = mirrored;
    if _e126 {
        let _e128 = morphed_tangent[3u];
        local_1 = -(_e128);
    } else {
        let _e131 = morphed_tangent[3u];
        local_1 = _e131;
    }
    let _e132 = local_1;
    v_tangent = vec4<f32>(_e125.x, _e125.y, _e125.z, _e132);
    let _e137 = texcoord_1;
    v_texcoord = _e137;
    let _e138 = color_1;
    v_color = _e138;
    v_lightmap_uv = vec2<f32>(0f, 0f);
    v_instance = vec4<f32>(0f, 0f, 0f, 0f);
    let _e140 = frame_info.mvp;
    let _e141 = skin;
    let _e142 = morphed_position;
    unnamed.gl_Position = (_e140 * (_e141 * vec4<f32>(_e142.x, _e142.y, _e142.z, 1f)));
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(6) weights: vec4<f32>, @location(5) joints: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    weights_1 = weights;
    joints_1 = joints;
    position_3 = position;
    normal_3 = normal;
    tangent_3 = tangent;
    texcoord_1 = texcoord;
    color_1 = color;
    main_1();
    let _e26 = v_world_position;
    let _e27 = v_normal;
    let _e28 = v_tangent;
    let _e29 = v_texcoord;
    let _e30 = v_color;
    let _e31 = v_lightmap_uv;
    let _e32 = v_instance;
    let _e33 = unnamed.gl_Position;
    return VertexOutput(_e26, _e27, _e28, _e29, _e30, _e31, _e32, _e33);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'tangent',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 4,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'joints',
          location: 5,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'weights',
          location: 6,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SkinInfo',
          group: 0,
          binding: 2,
          sizeInBytes: 4096,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'joint_matrices',
              offsetInBytes: 0,
              sizeInBytes: 4096,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'MeshInstancedVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct MorphInstanceInfo {
    instance_params: vec4<f32>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(7) member: vec3<f32>,
    @location(3) member_1: vec3<f32>,
    @location(5) member_2: vec2<f32>,
    @location(4) member_3: vec4<f32>,
    @location(0) member_4: vec4<f32>,
    @location(2) member_5: vec2<f32>,
    @location(1) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(5)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(6)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> morph_instance_info: MorphInstanceInfo;
@group(0) @binding(3)
var morph_instance_weights_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_instance_weights_smp: sampler;
var<private> gl_InstanceIndex_1: i32;
var<private> i_row0_1: vec4<f32>;
var<private> i_row1_1: vec4<f32>;
var<private> i_row2_1: vec4<f32>;
var<private> position_4: vec3<f32>;
var<private> normal_4: vec3<f32>;
var<private> tangent_4: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> v_instance: vec4<f32>;
var<private> i_data_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn MorphWidth_u0028_() -> i32 {
    let _e44 = morph_info.morph_params[1u];
    return i32(((1f / _e44) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e42 = gl_VertexIndex_1;
    return _e42;
}

fn MorphBand_u0028_() -> f32 {
    let _e42 = F3dVertexIndex_u0028_();
    let _e43 = MorphWidth_u0028_();
    return f32((_e42 / _e43));
}

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 bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e54 = morph_info.morph_params[3u];
    bands = max(_e54, 1f);
    let _e56 = (*t);
    let _e59 = bands;
    let _e61 = MorphBand_u0028_();
    let _e64 = (*rowStep);
    row = ((((f32((_e56 * 3i)) * _e59) + _e61) + 0.5f) * _e64);
    let _e66 = (*rowStep);
    let _e67 = bands;
    streamStep = (_e66 * _e67);
    let _e69 = (*column);
    let _e70 = row;
    let _e72 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e69, _e70), 0f);
    let _e74 = (*weight);
    let _e76 = (*position_1);
    (*position_1) = (_e76 + (_e72.xyz * _e74));
    let _e78 = (*column);
    let _e79 = row;
    let _e80 = streamStep;
    let _e83 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e78, (_e79 + _e80)), 0f);
    let _e85 = (*weight);
    let _e87 = (*normal_1);
    (*normal_1) = (_e87 + (_e83.xyz * _e85));
    let _e89 = (*column);
    let _e90 = row;
    let _e91 = streamStep;
    let _e95 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e89, (_e90 + (_e91 * 2f))), 0f);
    let _e97 = (*weight);
    let _e99 = (*tangent_1);
    let _e101 = (_e99.xyz + (_e95.xyz * _e97));
    (*tangent_1)[0u] = _e101.x;
    (*tangent_1)[1u] = _e101.y;
    (*tangent_1)[2u] = _e101.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e42 = F3dVertexIndex_u0028_();
    let _e43 = MorphWidth_u0028_();
    let _e55 = morph_info.morph_params[1u];
    return ((f32((_e42 - (i32(floor((f32(_e42) / f32(_e43)))) * _e43))) + 0.5f) * _e55);
}

fn MorphCount_u0028_() -> i32 {
    let _e44 = morph_info.morph_params[0u];
    return i32((_e44 + 0.5f));
}

fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var i: i32;
    var weight_1: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e57 = MorphCount_u0028_();
    count = _e57;
    let _e58 = count;
    if (_e58 <= 0i) {
        return;
    }
    let _e60 = MorphColumn_u0028_();
    column_1 = _e60;
    let _e63 = morph_info.morph_params[2u];
    rowStep_1 = _e63;
    i = 0i;
    loop {
        let _e64 = i;
        if (_e64 < 8i) {
            let _e66 = i;
            let _e67 = count;
            if (_e66 >= _e67) {
                break;
            }
            let _e69 = i;
            let _e71 = i;
            let _e82 = morph_info.morph_weights[(_e69 / 4i)][(_e71 - (i32(floor((f32(_e71) / f32(4i)))) * 4i))];
            weight_1 = _e82;
            let _e83 = weight_1;
            if (_e83 == 0f) {
                continue;
            }
            let _e85 = i;
            param = _e85;
            let _e86 = weight_1;
            param_1 = _e86;
            let _e87 = column_1;
            param_2 = _e87;
            let _e88 = rowStep_1;
            param_3 = _e88;
            let _e89 = (*position_2);
            param_4 = _e89;
            let _e90 = (*normal_2);
            param_5 = _e90;
            let _e91 = (*tangent_2);
            param_6 = _e91;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e92 = param_4;
            (*position_2) = _e92;
            let _e93 = param_5;
            (*normal_2) = _e93;
            let _e94 = param_6;
            (*tangent_2) = _e94;
            continue;
        } else {
            break;
        }
        continuing {
            let _e95 = i;
            i = (_e95 + 1i);
        }
    }
    return;
}

fn ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(instance: ptr<function, i32>, position_3: ptr<function, vec3<f32>>, normal_3: ptr<function, vec3<f32>>, tangent_3: ptr<function, vec4<f32>>) {
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var param_9: vec4<f32>;
    var count_1: i32;
    var deltaColumn: f32;
    var deltaRowStep: f32;
    var row_1: f32;
    var i_1: i32;
    var column_2: f32;
    var weight_2: f32;
    var param_10: i32;
    var param_11: f32;
    var param_12: f32;
    var param_13: f32;
    var param_14: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: vec4<f32>;

    let _e65 = morph_instance_info.instance_params[0u];
    if (_e65 < 0.5f) {
        let _e67 = (*position_3);
        param_7 = _e67;
        let _e68 = (*normal_3);
        param_8 = _e68;
        let _e69 = (*tangent_3);
        param_9 = _e69;
        ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((&param_7), (&param_8), (&param_9));
        let _e70 = param_7;
        (*position_3) = _e70;
        let _e71 = param_8;
        (*normal_3) = _e71;
        let _e72 = param_9;
        (*tangent_3) = _e72;
        return;
    }
    let _e73 = MorphCount_u0028_();
    count_1 = _e73;
    let _e74 = count_1;
    if (_e74 <= 0i) {
        return;
    }
    let _e76 = MorphColumn_u0028_();
    deltaColumn = _e76;
    let _e79 = morph_info.morph_params[2u];
    deltaRowStep = _e79;
    let _e80 = (*instance);
    let _e85 = morph_instance_info.instance_params[2u];
    row_1 = ((f32(_e80) + 0.5f) * _e85);
    i_1 = 0i;
    loop {
        let _e87 = i_1;
        if (_e87 < 8i) {
            let _e89 = i_1;
            let _e90 = count_1;
            if (_e89 >= _e90) {
                break;
            }
            let _e92 = i_1;
            let _e98 = morph_instance_info.instance_params[1u];
            column_2 = ((f32((_e92 / 4i)) + 0.5f) * _e98);
            let _e100 = column_2;
            let _e101 = row_1;
            let _e103 = textureSampleLevel(morph_instance_weights_tex, morph_instance_weights_smp, vec2<f32>(_e100, _e101), 0f);
            let _e104 = i_1;
            let _e111 = (_e104 - (i32(floor((f32(_e104) / f32(4i)))) * 4i));
            weight_2 = select(select(select(_e103[0i], _e103[1i], (1i == _e111)), _e103[2i], (2i == _e111)), _e103[3i], (3i == _e111));
            let _e126 = weight_2;
            if (_e126 == 0f) {
                continue;
            }
            let _e128 = i_1;
            param_10 = _e128;
            let _e129 = weight_2;
            param_11 = _e129;
            let _e130 = deltaColumn;
            param_12 = _e130;
            let _e131 = deltaRowStep;
            param_13 = _e131;
            let _e132 = (*position_3);
            param_14 = _e132;
            let _e133 = (*normal_3);
            param_15 = _e133;
            let _e134 = (*tangent_3);
            param_16 = _e134;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param_10), (&param_11), (&param_12), (&param_13), (&param_14), (&param_15), (&param_16));
            let _e135 = param_14;
            (*position_3) = _e135;
            let _e136 = param_15;
            (*normal_3) = _e136;
            let _e137 = param_16;
            (*tangent_3) = _e137;
            continue;
        } else {
            break;
        }
        continuing {
            let _e138 = i_1;
            i_1 = (_e138 + 1i);
        }
    }
    return;
}

fn F3dInstanceIndex_u0028_() -> i32 {
    let _e42 = gl_InstanceIndex_1;
    return _e42;
}

fn main_1() {
    var instance_1: mat4x4<f32>;
    var morphed_position: vec3<f32>;
    var morphed_normal: vec3<f32>;
    var morphed_tangent: vec4<f32>;
    var param_17: i32;
    var param_18: vec3<f32>;
    var param_19: vec3<f32>;
    var param_20: vec4<f32>;
    var local: vec4<f32>;
    var world: vec4<f32>;
    var rotation: mat3x3<f32>;
    var mirrored: bool;
    var local_1: f32;

    let _e56 = i_row0_1[0u];
    let _e58 = i_row1_1[0u];
    let _e60 = i_row2_1[0u];
    let _e61 = vec4<f32>(_e56, _e58, _e60, 0f);
    let _e63 = i_row0_1[1u];
    let _e65 = i_row1_1[1u];
    let _e67 = i_row2_1[1u];
    let _e68 = vec4<f32>(_e63, _e65, _e67, 0f);
    let _e70 = i_row0_1[2u];
    let _e72 = i_row1_1[2u];
    let _e74 = i_row2_1[2u];
    let _e75 = vec4<f32>(_e70, _e72, _e74, 0f);
    let _e77 = i_row0_1[3u];
    let _e79 = i_row1_1[3u];
    let _e81 = i_row2_1[3u];
    let _e82 = vec4<f32>(_e77, _e79, _e81, 1f);
    instance_1 = mat4x4<f32>(vec4<f32>(_e61.x, _e61.y, _e61.z, _e61.w), vec4<f32>(_e68.x, _e68.y, _e68.z, _e68.w), vec4<f32>(_e75.x, _e75.y, _e75.z, _e75.w), vec4<f32>(_e82.x, _e82.y, _e82.z, _e82.w));
    let _e104 = position_4;
    morphed_position = _e104;
    let _e105 = normal_4;
    morphed_normal = _e105;
    let _e106 = tangent_4;
    morphed_tangent = _e106;
    let _e107 = F3dInstanceIndex_u0028_();
    param_17 = _e107;
    let _e108 = morphed_position;
    param_18 = _e108;
    let _e109 = morphed_normal;
    param_19 = _e109;
    let _e110 = morphed_tangent;
    param_20 = _e110;
    ApplyMorphInstanced_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param_17), (&param_18), (&param_19), (&param_20));
    let _e111 = param_18;
    morphed_position = _e111;
    let _e112 = param_19;
    morphed_normal = _e112;
    let _e113 = param_20;
    morphed_tangent = _e113;
    let _e114 = instance_1;
    let _e115 = morphed_position;
    local = (_e114 * vec4<f32>(_e115.x, _e115.y, _e115.z, 1f));
    let _e122 = frame_info.model;
    let _e123 = local;
    world = (_e122 * _e123);
    let _e125 = world;
    v_world_position = _e125.xyz;
    let _e127 = instance_1;
    rotation = mat3x3<f32>(_e127[0].xyz, _e127[1].xyz, _e127[2].xyz);
    let _e136 = frame_info.normal_matrix;
    let _e144 = rotation;
    let _e145 = morphed_normal;
    v_normal = (mat3x3<f32>(_e136[0].xyz, _e136[1].xyz, _e136[2].xyz) * normalize((_e144 * _e145)));
    let _e149 = texcoord_1;
    v_texcoord = _e149;
    let _e151 = frame_info.model;
    let _e161 = rotation;
    mirrored = ((determinant(mat3x3<f32>(_e151[0].xyz, _e151[1].xyz, _e151[2].xyz)) < 0f) != (determinant(_e161) < 0f));
    let _e166 = frame_info.model;
    let _e174 = rotation;
    let _e175 = morphed_tangent;
    let _e178 = (mat3x3<f32>(_e166[0].xyz, _e166[1].xyz, _e166[2].xyz) * (_e174 * _e175.xyz));
    let _e179 = mirrored;
    if _e179 {
        let _e181 = morphed_tangent[3u];
        local_1 = -(_e181);
    } else {
        let _e184 = morphed_tangent[3u];
        local_1 = _e184;
    }
    let _e185 = local_1;
    v_tangent = vec4<f32>(_e178.x, _e178.y, _e178.z, _e185);
    let _e190 = color_1;
    let _e191 = i_color_1;
    v_color = (_e190 * _e191);
    v_lightmap_uv = vec2<f32>(0f, 0f);
    let _e193 = i_data_1;
    v_instance = _e193;
    let _e195 = frame_info.mvp;
    let _e196 = local;
    unnamed.gl_Position = (_e195 * _e196);
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @builtin(instance_index) gl_InstanceIndex: u32, @location(5) i_row0_: vec4<f32>, @location(6) i_row1_: vec4<f32>, @location(7) i_row2_: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>, @location(8) i_color: vec4<f32>, @location(9) i_data: vec4<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    gl_InstanceIndex_1 = i32(gl_InstanceIndex);
    i_row0_1 = i_row0_;
    i_row1_1 = i_row1_;
    i_row2_1 = i_row2_;
    position_4 = position;
    normal_4 = normal;
    tangent_4 = tangent;
    texcoord_1 = texcoord;
    color_1 = color;
    i_color_1 = i_color;
    i_data_1 = i_data;
    main_1();
    let _e35 = v_world_position;
    let _e36 = v_normal;
    let _e37 = v_texcoord;
    let _e38 = v_tangent;
    let _e39 = v_color;
    let _e40 = v_lightmap_uv;
    let _e41 = v_instance;
    let _e42 = unnamed.gl_Position;
    return VertexOutput(_e35, _e36, _e37, _e38, _e39, _e40, _e41, _e42);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'tangent',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 4,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_row0',
          location: 5,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_row1',
          location: 6,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_row2',
          location: 7,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_color',
          location: 8,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_data',
          location: 9,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInstanceInfo',
          group: 0,
          binding: 2,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'instance_params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_instance_weights',
          group: 0,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'MeshLightmappedVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(7) member: vec3<f32>,
    @location(3) member_1: vec3<f32>,
    @location(5) member_2: vec2<f32>,
    @location(4) member_3: vec4<f32>,
    @location(0) member_4: vec4<f32>,
    @location(2) member_5: vec2<f32>,
    @location(1) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(2)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(3)
var morph_texture_smp: sampler;
var<private> position_3: vec3<f32>;
var<private> normal_3: vec3<f32>;
var<private> tangent_3: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> color_1: vec4<f32>;
var<private> v_instance: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn MorphWidth_u0028_() -> i32 {
    let _e36 = morph_info.morph_params[1u];
    return i32(((1f / _e36) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e34 = gl_VertexIndex_1;
    return _e34;
}

fn MorphBand_u0028_() -> f32 {
    let _e34 = F3dVertexIndex_u0028_();
    let _e35 = MorphWidth_u0028_();
    return f32((_e34 / _e35));
}

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 bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e46 = morph_info.morph_params[3u];
    bands = max(_e46, 1f);
    let _e48 = (*t);
    let _e51 = bands;
    let _e53 = MorphBand_u0028_();
    let _e56 = (*rowStep);
    row = ((((f32((_e48 * 3i)) * _e51) + _e53) + 0.5f) * _e56);
    let _e58 = (*rowStep);
    let _e59 = bands;
    streamStep = (_e58 * _e59);
    let _e61 = (*column);
    let _e62 = row;
    let _e64 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e61, _e62), 0f);
    let _e66 = (*weight);
    let _e68 = (*position_1);
    (*position_1) = (_e68 + (_e64.xyz * _e66));
    let _e70 = (*column);
    let _e71 = row;
    let _e72 = streamStep;
    let _e75 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e70, (_e71 + _e72)), 0f);
    let _e77 = (*weight);
    let _e79 = (*normal_1);
    (*normal_1) = (_e79 + (_e75.xyz * _e77));
    let _e81 = (*column);
    let _e82 = row;
    let _e83 = streamStep;
    let _e87 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e81, (_e82 + (_e83 * 2f))), 0f);
    let _e89 = (*weight);
    let _e91 = (*tangent_1);
    let _e93 = (_e91.xyz + (_e87.xyz * _e89));
    (*tangent_1)[0u] = _e93.x;
    (*tangent_1)[1u] = _e93.y;
    (*tangent_1)[2u] = _e93.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e34 = F3dVertexIndex_u0028_();
    let _e35 = MorphWidth_u0028_();
    let _e47 = morph_info.morph_params[1u];
    return ((f32((_e34 - (i32(floor((f32(_e34) / f32(_e35)))) * _e35))) + 0.5f) * _e47);
}

fn MorphCount_u0028_() -> i32 {
    let _e36 = morph_info.morph_params[0u];
    return i32((_e36 + 0.5f));
}

fn ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, normal_2: ptr<function, vec3<f32>>, tangent_2: ptr<function, vec4<f32>>) {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var i: i32;
    var weight_1: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e49 = MorphCount_u0028_();
    count = _e49;
    let _e50 = count;
    if (_e50 <= 0i) {
        return;
    }
    let _e52 = MorphColumn_u0028_();
    column_1 = _e52;
    let _e55 = morph_info.morph_params[2u];
    rowStep_1 = _e55;
    i = 0i;
    loop {
        let _e56 = i;
        if (_e56 < 8i) {
            let _e58 = i;
            let _e59 = count;
            if (_e58 >= _e59) {
                break;
            }
            let _e61 = i;
            let _e63 = i;
            let _e74 = morph_info.morph_weights[(_e61 / 4i)][(_e63 - (i32(floor((f32(_e63) / f32(4i)))) * 4i))];
            weight_1 = _e74;
            let _e75 = weight_1;
            if (_e75 == 0f) {
                continue;
            }
            let _e77 = i;
            param = _e77;
            let _e78 = weight_1;
            param_1 = _e78;
            let _e79 = column_1;
            param_2 = _e79;
            let _e80 = rowStep_1;
            param_3 = _e80;
            let _e81 = (*position_2);
            param_4 = _e81;
            let _e82 = (*normal_2);
            param_5 = _e82;
            let _e83 = (*tangent_2);
            param_6 = _e83;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e84 = param_4;
            (*position_2) = _e84;
            let _e85 = param_5;
            (*normal_2) = _e85;
            let _e86 = param_6;
            (*tangent_2) = _e86;
            continue;
        } else {
            break;
        }
        continuing {
            let _e87 = i;
            i = (_e87 + 1i);
        }
    }
    return;
}

fn main_1() {
    var morphed_position: vec3<f32>;
    var morphed_normal: vec3<f32>;
    var morphed_tangent: vec4<f32>;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var param_9: vec4<f32>;
    var world: vec4<f32>;
    var mirrored: bool;
    var local: f32;

    let _e43 = position_3;
    morphed_position = _e43;
    let _e44 = normal_3;
    morphed_normal = _e44;
    let _e45 = tangent_3;
    morphed_tangent = _e45;
    let _e46 = morphed_position;
    param_7 = _e46;
    let _e47 = morphed_normal;
    param_8 = _e47;
    let _e48 = morphed_tangent;
    param_9 = _e48;
    ApplyMorph_u0028_vf3_u003b_vf3_u003b_vf4_u003b((&param_7), (&param_8), (&param_9));
    let _e49 = param_7;
    morphed_position = _e49;
    let _e50 = param_8;
    morphed_normal = _e50;
    let _e51 = param_9;
    morphed_tangent = _e51;
    let _e53 = frame_info.model;
    let _e54 = morphed_position;
    world = (_e53 * vec4<f32>(_e54.x, _e54.y, _e54.z, 1f));
    let _e60 = world;
    v_world_position = _e60.xyz;
    let _e63 = frame_info.normal_matrix;
    let _e71 = morphed_normal;
    v_normal = (mat3x3<f32>(_e63[0].xyz, _e63[1].xyz, _e63[2].xyz) * _e71);
    let _e73 = texcoord_1;
    v_texcoord = _e73;
    let _e75 = frame_info.model;
    mirrored = (determinant(mat3x3<f32>(_e75[0].xyz, _e75[1].xyz, _e75[2].xyz)) < 0f);
    let _e86 = frame_info.model;
    let _e94 = morphed_tangent;
    let _e96 = (mat3x3<f32>(_e86[0].xyz, _e86[1].xyz, _e86[2].xyz) * _e94.xyz);
    let _e97 = mirrored;
    if _e97 {
        let _e99 = morphed_tangent[3u];
        local = -(_e99);
    } else {
        let _e102 = morphed_tangent[3u];
        local = _e102;
    }
    let _e103 = local;
    v_tangent = vec4<f32>(_e96.x, _e96.y, _e96.z, _e103);
    v_color = vec4<f32>(1f, 1f, 1f, 1f);
    let _e108 = color_1;
    v_lightmap_uv = _e108.xy;
    v_instance = vec4<f32>(0f, 0f, 0f, 0f);
    let _e111 = frame_info.mvp;
    let _e112 = morphed_position;
    unnamed.gl_Position = (_e111 * vec4<f32>(_e112.x, _e112.y, _e112.z, 1f));
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(3) tangent: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    position_3 = position;
    normal_3 = normal;
    tangent_3 = tangent;
    texcoord_1 = texcoord;
    color_1 = color;
    main_1();
    let _e22 = v_world_position;
    let _e23 = v_normal;
    let _e24 = v_texcoord;
    let _e25 = v_tangent;
    let _e26 = v_color;
    let _e27 = v_lightmap_uv;
    let _e28 = v_instance;
    let _e29 = unnamed.gl_Position;
    return VertexOutput(_e22, _e23, _e24, _e25, _e26, _e27, _e28, _e29);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'tangent',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 4,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VelocityVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct PrevFrameInfo {
    current_mvp: mat4x4<f32>,
    previous_mvp: mat4x4<f32>,
    previous_morph_weights: array<vec4<f32>, 2>,
    camera: vec4<f32>,
    forward: vec4<f32>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @location(1) member_1: f32,
    @location(2) member_2: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(3)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> prev_info: PrevFrameInfo;
var<private> position_3: vec3<f32>;
var<private> v_current: vec4<f32>;
var<private> v_depth: f32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_previous: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn DepthAlongAxis_u0028_vf4_u003b(world: ptr<function, vec4<f32>>) -> f32 {
    let _e28 = (*world);
    let _e31 = prev_info.camera;
    let _e35 = prev_info.forward;
    return dot((_e28.xyz - _e31.xyz), _e35.xyz);
}

fn MorphWidth_u0028_() -> i32 {
    let _e29 = morph_info.morph_params[1u];
    return i32(((1f / _e29) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e27 = gl_VertexIndex_1;
    return _e27;
}

fn MorphBand_u0028_() -> f32 {
    let _e27 = F3dVertexIndex_u0028_();
    let _e28 = MorphWidth_u0028_();
    return f32((_e27 / _e28));
}

fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, tangent: ptr<function, vec4<f32>>) {
    var bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e39 = morph_info.morph_params[3u];
    bands = max(_e39, 1f);
    let _e41 = (*t);
    let _e44 = bands;
    let _e46 = MorphBand_u0028_();
    let _e49 = (*rowStep);
    row = ((((f32((_e41 * 3i)) * _e44) + _e46) + 0.5f) * _e49);
    let _e51 = (*rowStep);
    let _e52 = bands;
    streamStep = (_e51 * _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 = streamStep;
    let _e68 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e63, (_e64 + _e65)), 0f);
    let _e70 = (*weight);
    let _e72 = (*normal);
    (*normal) = (_e72 + (_e68.xyz * _e70));
    let _e74 = (*column);
    let _e75 = row;
    let _e76 = streamStep;
    let _e80 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e74, (_e75 + (_e76 * 2f))), 0f);
    let _e82 = (*weight);
    let _e84 = (*tangent);
    let _e86 = (_e84.xyz + (_e80.xyz * _e82));
    (*tangent)[0u] = _e86.x;
    (*tangent)[1u] = _e86.y;
    (*tangent)[2u] = _e86.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e27 = F3dVertexIndex_u0028_();
    let _e28 = MorphWidth_u0028_();
    let _e40 = morph_info.morph_params[1u];
    return ((f32((_e27 - (i32(floor((f32(_e27) / f32(_e28)))) * _e28))) + 0.5f) * _e40);
}

fn MorphCount_u0028_() -> i32 {
    let _e29 = morph_info.morph_params[0u];
    return i32((_e29 + 0.5f));
}

fn MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, w0_: ptr<function, vec4<f32>>, w1_: ptr<function, vec4<f32>>) -> vec3<f32> {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var normal_1: vec3<f32>;
    var tangent_1: vec4<f32>;
    var i: i32;
    var weight_1: f32;
    var local: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e45 = MorphCount_u0028_();
    count = _e45;
    let _e46 = count;
    if (_e46 <= 0i) {
        let _e48 = (*position_2);
        return _e48;
    }
    let _e49 = MorphColumn_u0028_();
    column_1 = _e49;
    let _e52 = morph_info.morph_params[2u];
    rowStep_1 = _e52;
    normal_1 = vec3<f32>(0f, 0f, 0f);
    tangent_1 = vec4<f32>(0f, 0f, 0f, 0f);
    i = 0i;
    loop {
        let _e53 = i;
        if (_e53 < 8i) {
            let _e55 = i;
            let _e56 = count;
            if (_e55 >= _e56) {
                break;
            }
            let _e58 = i;
            if (_e58 < 4i) {
                let _e60 = i;
                let _e62 = (*w0_)[_e60];
                local = _e62;
            } else {
                let _e63 = i;
                let _e66 = (*w1_)[(_e63 - 4i)];
                local = _e66;
            }
            let _e67 = local;
            weight_1 = _e67;
            let _e68 = weight_1;
            if (_e68 == 0f) {
                continue;
            }
            let _e70 = i;
            param = _e70;
            let _e71 = weight_1;
            param_1 = _e71;
            let _e72 = column_1;
            param_2 = _e72;
            let _e73 = rowStep_1;
            param_3 = _e73;
            let _e74 = (*position_2);
            param_4 = _e74;
            let _e75 = normal_1;
            param_5 = _e75;
            let _e76 = tangent_1;
            param_6 = _e76;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e77 = param_4;
            (*position_2) = _e77;
            let _e78 = param_5;
            normal_1 = _e78;
            let _e79 = param_6;
            tangent_1 = _e79;
            continue;
        } else {
            break;
        }
        continuing {
            let _e80 = i;
            i = (_e80 + 1i);
        }
    }
    let _e82 = (*position_2);
    return _e82;
}

fn main_1() {
    var now: vec3<f32>;
    var param_7: vec3<f32>;
    var param_8: vec4<f32>;
    var param_9: vec4<f32>;
    var then: vec3<f32>;
    var param_10: vec3<f32>;
    var param_11: vec4<f32>;
    var param_12: vec4<f32>;
    var param_13: vec4<f32>;

    let _e36 = position_3;
    param_7 = _e36;
    let _e39 = morph_info.morph_weights[0i];
    param_8 = _e39;
    let _e42 = morph_info.morph_weights[1i];
    param_9 = _e42;
    let _e43 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((&param_7), (&param_8), (&param_9));
    now = _e43;
    let _e44 = position_3;
    param_10 = _e44;
    let _e47 = prev_info.previous_morph_weights[0i];
    param_11 = _e47;
    let _e50 = prev_info.previous_morph_weights[1i];
    param_12 = _e50;
    let _e51 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((&param_10), (&param_11), (&param_12));
    then = _e51;
    let _e53 = prev_info.current_mvp;
    let _e54 = now;
    v_current = (_e53 * vec4<f32>(_e54.x, _e54.y, _e54.z, 1f));
    let _e61 = frame_info.model;
    let _e62 = now;
    param_13 = (_e61 * vec4<f32>(_e62.x, _e62.y, _e62.z, 1f));
    let _e68 = DepthAlongAxis_u0028_vf4_u003b((&param_13));
    v_depth = _e68;
    let _e70 = prev_info.previous_mvp;
    let _e71 = then;
    v_previous = (_e70 * vec4<f32>(_e71.x, _e71.y, _e71.z, 1f));
    let _e78 = frame_info.mvp;
    let _e79 = now;
    unnamed.gl_Position = (_e78 * vec4<f32>(_e79.x, _e79.y, _e79.z, 1f));
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    position_3 = position;
    main_1();
    let _e10 = v_current;
    let _e11 = v_depth;
    let _e12 = v_previous;
    let _e13 = unnamed.gl_Position;
    return VertexOutput(_e10, _e11, _e12, _e13);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PrevFrameInfo',
          group: 0,
          binding: 2,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'current_mvp',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_mvp',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_morph_weights',
              offsetInBytes: 128,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 160,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 176,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VelocitySkinnedVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct PrevFrameInfo {
    current_mvp: mat4x4<f32>,
    previous_mvp: mat4x4<f32>,
    previous_morph_weights: array<vec4<f32>, 2>,
    camera: vec4<f32>,
    forward: vec4<f32>,
}

struct SkinInfo {
    joint_matrices: array<mat4x4<f32>, 64>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @location(1) member_1: f32,
    @location(2) member_2: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(4)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(5)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> prev_info: PrevFrameInfo;
@group(0) @binding(6)
var prev_joint_texture_tex: texture_2d<f32>;
@group(0) @binding(7)
var prev_joint_texture_smp: sampler;
var<private> weights_1: vec4<f32>;
var<private> joints_1: vec4<f32>;
@group(0) @binding(3)
var<uniform> skin_info: SkinInfo;
var<private> position_3: vec3<f32>;
var<private> v_current: vec4<f32>;
var<private> v_depth: f32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_previous: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn DepthAlongAxis_u0028_vf4_u003b(world: ptr<function, vec4<f32>>) -> f32 {
    let _e42 = (*world);
    let _e45 = prev_info.camera;
    let _e49 = prev_info.forward;
    return dot((_e42.xyz - _e45.xyz), _e49.xyz);
}

fn MorphWidth_u0028_() -> i32 {
    let _e43 = morph_info.morph_params[1u];
    return i32(((1f / _e43) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e41 = gl_VertexIndex_1;
    return _e41;
}

fn MorphBand_u0028_() -> f32 {
    let _e41 = F3dVertexIndex_u0028_();
    let _e42 = MorphWidth_u0028_();
    return f32((_e41 / _e42));
}

fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, tangent: ptr<function, vec4<f32>>) {
    var bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e53 = morph_info.morph_params[3u];
    bands = max(_e53, 1f);
    let _e55 = (*t);
    let _e58 = bands;
    let _e60 = MorphBand_u0028_();
    let _e63 = (*rowStep);
    row = ((((f32((_e55 * 3i)) * _e58) + _e60) + 0.5f) * _e63);
    let _e65 = (*rowStep);
    let _e66 = bands;
    streamStep = (_e65 * _e66);
    let _e68 = (*column);
    let _e69 = row;
    let _e71 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e68, _e69), 0f);
    let _e73 = (*weight);
    let _e75 = (*position_1);
    (*position_1) = (_e75 + (_e71.xyz * _e73));
    let _e77 = (*column);
    let _e78 = row;
    let _e79 = streamStep;
    let _e82 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e77, (_e78 + _e79)), 0f);
    let _e84 = (*weight);
    let _e86 = (*normal);
    (*normal) = (_e86 + (_e82.xyz * _e84));
    let _e88 = (*column);
    let _e89 = row;
    let _e90 = streamStep;
    let _e94 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e88, (_e89 + (_e90 * 2f))), 0f);
    let _e96 = (*weight);
    let _e98 = (*tangent);
    let _e100 = (_e98.xyz + (_e94.xyz * _e96));
    (*tangent)[0u] = _e100.x;
    (*tangent)[1u] = _e100.y;
    (*tangent)[2u] = _e100.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e41 = F3dVertexIndex_u0028_();
    let _e42 = MorphWidth_u0028_();
    let _e54 = morph_info.morph_params[1u];
    return ((f32((_e41 - (i32(floor((f32(_e41) / f32(_e42)))) * _e42))) + 0.5f) * _e54);
}

fn MorphCount_u0028_() -> i32 {
    let _e43 = morph_info.morph_params[0u];
    return i32((_e43 + 0.5f));
}

fn MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, w0_: ptr<function, vec4<f32>>, w1_: ptr<function, vec4<f32>>) -> vec3<f32> {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var normal_1: vec3<f32>;
    var tangent_1: vec4<f32>;
    var i: i32;
    var weight_1: f32;
    var local: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e59 = MorphCount_u0028_();
    count = _e59;
    let _e60 = count;
    if (_e60 <= 0i) {
        let _e62 = (*position_2);
        return _e62;
    }
    let _e63 = MorphColumn_u0028_();
    column_1 = _e63;
    let _e66 = morph_info.morph_params[2u];
    rowStep_1 = _e66;
    normal_1 = vec3<f32>(0f, 0f, 0f);
    tangent_1 = vec4<f32>(0f, 0f, 0f, 0f);
    i = 0i;
    loop {
        let _e67 = i;
        if (_e67 < 8i) {
            let _e69 = i;
            let _e70 = count;
            if (_e69 >= _e70) {
                break;
            }
            let _e72 = i;
            if (_e72 < 4i) {
                let _e74 = i;
                let _e76 = (*w0_)[_e74];
                local = _e76;
            } else {
                let _e77 = i;
                let _e80 = (*w1_)[(_e77 - 4i)];
                local = _e80;
            }
            let _e81 = local;
            weight_1 = _e81;
            let _e82 = weight_1;
            if (_e82 == 0f) {
                continue;
            }
            let _e84 = i;
            param = _e84;
            let _e85 = weight_1;
            param_1 = _e85;
            let _e86 = column_1;
            param_2 = _e86;
            let _e87 = rowStep_1;
            param_3 = _e87;
            let _e88 = (*position_2);
            param_4 = _e88;
            let _e89 = normal_1;
            param_5 = _e89;
            let _e90 = tangent_1;
            param_6 = _e90;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e91 = param_4;
            (*position_2) = _e91;
            let _e92 = param_5;
            normal_1 = _e92;
            let _e93 = param_6;
            tangent_1 = _e93;
            continue;
        } else {
            break;
        }
        continuing {
            let _e94 = i;
            i = (_e94 + 1i);
        }
    }
    let _e96 = (*position_2);
    return _e96;
}

fn PrevJoint_u0028_f1_u003b(joint: ptr<function, f32>) -> mat4x4<f32> {
    var v: f32;

    let _e43 = (*joint);
    v = ((_e43 + 0.5f) / 64f);
    let _e46 = v;
    let _e48 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.125f, _e46), 0f);
    let _e49 = v;
    let _e51 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.375f, _e49), 0f);
    let _e52 = v;
    let _e54 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.625f, _e52), 0f);
    let _e55 = v;
    let _e57 = textureSampleLevel(prev_joint_texture_tex, prev_joint_texture_smp, vec2<f32>(0.875f, _e55), 0f);
    return mat4x4<f32>(vec4<f32>(_e48.x, _e48.y, _e48.z, _e48.w), vec4<f32>(_e51.x, _e51.y, _e51.z, _e51.w), vec4<f32>(_e54.x, _e54.y, _e54.z, _e54.w), vec4<f32>(_e57.x, _e57.y, _e57.z, _e57.w));
}

fn JointIndex_u0028_f1_u003b(joint_1: ptr<function, f32>) -> i32 {
    let _e42 = (*joint_1);
    return clamp(i32(_e42), 0i, 63i);
}

fn BlendWeights_u0028_() -> vec4<f32> {
    var total: f32;
    var local_1: vec4<f32>;

    let _e44 = weights_1[0u];
    let _e46 = weights_1[1u];
    let _e49 = weights_1[2u];
    let _e52 = weights_1[3u];
    total = (((_e44 + _e46) + _e49) + _e52);
    let _e54 = total;
    if (_e54 > 0.00001f) {
        let _e56 = weights_1;
        let _e57 = total;
        local_1 = (_e56 / vec4(_e57));
    } else {
        local_1 = vec4<f32>(1f, 0f, 0f, 0f);
    }
    let _e60 = local_1;
    return _e60;
}

fn main_1() {
    var w: vec4<f32>;
    var j: vec4<i32>;
    var param_7: f32;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;
    var skin: mat4x4<f32>;
    var prevSkin: mat4x4<f32>;
    var param_11: f32;
    var param_12: f32;
    var param_13: f32;
    var param_14: f32;
    var now: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: vec4<f32>;
    var param_17: vec4<f32>;
    var then: vec3<f32>;
    var param_18: vec3<f32>;
    var param_19: vec4<f32>;
    var param_20: vec4<f32>;
    var posed: vec4<f32>;
    var param_21: vec4<f32>;

    let _e63 = BlendWeights_u0028_();
    w = _e63;
    let _e65 = joints_1[0u];
    param_7 = _e65;
    let _e66 = JointIndex_u0028_f1_u003b((&param_7));
    let _e68 = joints_1[1u];
    param_8 = _e68;
    let _e69 = JointIndex_u0028_f1_u003b((&param_8));
    let _e71 = joints_1[2u];
    param_9 = _e71;
    let _e72 = JointIndex_u0028_f1_u003b((&param_9));
    let _e74 = joints_1[3u];
    param_10 = _e74;
    let _e75 = JointIndex_u0028_f1_u003b((&param_10));
    j = vec4<i32>(_e66, _e69, _e72, _e75);
    let _e78 = w[0u];
    let _e80 = j[0u];
    let _e83 = skin_info.joint_matrices[_e80];
    let _e84 = (_e83 * _e78);
    let _e86 = w[1u];
    let _e88 = j[1u];
    let _e91 = skin_info.joint_matrices[_e88];
    let _e92 = (_e91 * _e86);
    let _e105 = mat4x4<f32>((_e84[0] + _e92[0]), (_e84[1] + _e92[1]), (_e84[2] + _e92[2]), (_e84[3] + _e92[3]));
    let _e107 = w[2u];
    let _e109 = j[2u];
    let _e112 = skin_info.joint_matrices[_e109];
    let _e113 = (_e112 * _e107);
    let _e126 = mat4x4<f32>((_e105[0] + _e113[0]), (_e105[1] + _e113[1]), (_e105[2] + _e113[2]), (_e105[3] + _e113[3]));
    let _e128 = w[3u];
    let _e130 = j[3u];
    let _e133 = skin_info.joint_matrices[_e130];
    let _e134 = (_e133 * _e128);
    skin = mat4x4<f32>((_e126[0] + _e134[0]), (_e126[1] + _e134[1]), (_e126[2] + _e134[2]), (_e126[3] + _e134[3]));
    let _e149 = w[0u];
    let _e151 = j[0u];
    param_11 = f32(_e151);
    let _e153 = PrevJoint_u0028_f1_u003b((&param_11));
    let _e154 = (_e153 * _e149);
    let _e156 = w[1u];
    let _e158 = j[1u];
    param_12 = f32(_e158);
    let _e160 = PrevJoint_u0028_f1_u003b((&param_12));
    let _e161 = (_e160 * _e156);
    let _e174 = mat4x4<f32>((_e154[0] + _e161[0]), (_e154[1] + _e161[1]), (_e154[2] + _e161[2]), (_e154[3] + _e161[3]));
    let _e176 = w[2u];
    let _e178 = j[2u];
    param_13 = f32(_e178);
    let _e180 = PrevJoint_u0028_f1_u003b((&param_13));
    let _e181 = (_e180 * _e176);
    let _e194 = mat4x4<f32>((_e174[0] + _e181[0]), (_e174[1] + _e181[1]), (_e174[2] + _e181[2]), (_e174[3] + _e181[3]));
    let _e196 = w[3u];
    let _e198 = j[3u];
    param_14 = f32(_e198);
    let _e200 = PrevJoint_u0028_f1_u003b((&param_14));
    let _e201 = (_e200 * _e196);
    prevSkin = mat4x4<f32>((_e194[0] + _e201[0]), (_e194[1] + _e201[1]), (_e194[2] + _e201[2]), (_e194[3] + _e201[3]));
    let _e215 = position_3;
    param_15 = _e215;
    let _e218 = morph_info.morph_weights[0i];
    param_16 = _e218;
    let _e221 = morph_info.morph_weights[1i];
    param_17 = _e221;
    let _e222 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((&param_15), (&param_16), (&param_17));
    now = _e222;
    let _e223 = position_3;
    param_18 = _e223;
    let _e226 = prev_info.previous_morph_weights[0i];
    param_19 = _e226;
    let _e229 = prev_info.previous_morph_weights[1i];
    param_20 = _e229;
    let _e230 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((&param_18), (&param_19), (&param_20));
    then = _e230;
    let _e231 = skin;
    let _e232 = now;
    posed = (_e231 * vec4<f32>(_e232.x, _e232.y, _e232.z, 1f));
    let _e239 = prev_info.current_mvp;
    let _e240 = posed;
    v_current = (_e239 * _e240);
    let _e243 = frame_info.model;
    let _e244 = posed;
    param_21 = (_e243 * _e244);
    let _e246 = DepthAlongAxis_u0028_vf4_u003b((&param_21));
    v_depth = _e246;
    let _e248 = prev_info.previous_mvp;
    let _e249 = prevSkin;
    let _e250 = then;
    v_previous = (_e248 * (_e249 * vec4<f32>(_e250.x, _e250.y, _e250.z, 1f)));
    let _e258 = frame_info.mvp;
    let _e259 = posed;
    unnamed.gl_Position = (_e258 * _e259);
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(2) weights: vec4<f32>, @location(1) joints: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    weights_1 = weights;
    joints_1 = joints;
    position_3 = position;
    main_1();
    let _e14 = v_current;
    let _e15 = v_depth;
    let _e16 = v_previous;
    let _e17 = unnamed.gl_Position;
    return VertexOutput(_e14, _e15, _e16, _e17);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'joints',
          location: 1,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'weights',
          location: 2,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PrevFrameInfo',
          group: 0,
          binding: 2,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'current_mvp',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_mvp',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_morph_weights',
              offsetInBytes: 128,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 160,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 176,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SkinInfo',
          group: 0,
          binding: 3,
          sizeInBytes: 4096,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'joint_matrices',
              offsetInBytes: 0,
              sizeInBytes: 4096,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'prev_joint_texture',
          group: 0,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VelocityInstancedVertex': WebGpuStage(
      wgsl: r'''
struct MorphInfo {
    morph_weights: array<vec4<f32>, 2>,
    morph_params: vec4<f32>,
}

struct PrevFrameInfo {
    current_mvp: mat4x4<f32>,
    previous_mvp: mat4x4<f32>,
    previous_morph_weights: array<vec4<f32>, 2>,
    camera: vec4<f32>,
    forward: vec4<f32>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @location(1) member_1: f32,
    @location(2) member_2: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_VertexIndex_1: i32;
@group(0) @binding(1)
var<uniform> morph_info: MorphInfo;
@group(0) @binding(3)
var morph_texture_tex: texture_2d<f32>;
@group(0) @binding(4)
var morph_texture_smp: sampler;
@group(0) @binding(2)
var<uniform> prev_info: PrevFrameInfo;
var<private> position_3: vec3<f32>;
var<private> i_row0_1: vec4<f32>;
var<private> i_row1_1: vec4<f32>;
var<private> i_row2_1: vec4<f32>;
var<private> i_prev_row0_1: vec4<f32>;
var<private> i_prev_row1_1: vec4<f32>;
var<private> i_prev_row2_1: vec4<f32>;
var<private> v_current: vec4<f32>;
var<private> v_depth: f32;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> v_previous: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn DepthAlongAxis_u0028_vf4_u003b(world: ptr<function, vec4<f32>>) -> f32 {
    let _e34 = (*world);
    let _e37 = prev_info.camera;
    let _e41 = prev_info.forward;
    return dot((_e34.xyz - _e37.xyz), _e41.xyz);
}

fn Affine_u0028_vf4_u003b_vf4_u003b_vf4_u003b(row0_: ptr<function, vec4<f32>>, row1_: ptr<function, vec4<f32>>, row2_: ptr<function, vec4<f32>>) -> mat4x4<f32> {
    let _e37 = (*row0_)[0u];
    let _e39 = (*row1_)[0u];
    let _e41 = (*row2_)[0u];
    let _e42 = vec4<f32>(_e37, _e39, _e41, 0f);
    let _e44 = (*row0_)[1u];
    let _e46 = (*row1_)[1u];
    let _e48 = (*row2_)[1u];
    let _e49 = vec4<f32>(_e44, _e46, _e48, 0f);
    let _e51 = (*row0_)[2u];
    let _e53 = (*row1_)[2u];
    let _e55 = (*row2_)[2u];
    let _e56 = vec4<f32>(_e51, _e53, _e55, 0f);
    let _e58 = (*row0_)[3u];
    let _e60 = (*row1_)[3u];
    let _e62 = (*row2_)[3u];
    let _e63 = vec4<f32>(_e58, _e60, _e62, 1f);
    return mat4x4<f32>(vec4<f32>(_e42.x, _e42.y, _e42.z, _e42.w), vec4<f32>(_e49.x, _e49.y, _e49.z, _e49.w), vec4<f32>(_e56.x, _e56.y, _e56.z, _e56.w), vec4<f32>(_e63.x, _e63.y, _e63.z, _e63.w));
}

fn MorphWidth_u0028_() -> i32 {
    let _e35 = morph_info.morph_params[1u];
    return i32(((1f / _e35) + 0.5f));
}

fn F3dVertexIndex_u0028_() -> i32 {
    let _e33 = gl_VertexIndex_1;
    return _e33;
}

fn MorphBand_u0028_() -> f32 {
    let _e33 = F3dVertexIndex_u0028_();
    let _e34 = MorphWidth_u0028_();
    return f32((_e33 / _e34));
}

fn AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b(t: ptr<function, i32>, weight: ptr<function, f32>, column: ptr<function, f32>, rowStep: ptr<function, f32>, position_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, tangent: ptr<function, vec4<f32>>) {
    var bands: f32;
    var row: f32;
    var streamStep: f32;

    let _e45 = morph_info.morph_params[3u];
    bands = max(_e45, 1f);
    let _e47 = (*t);
    let _e50 = bands;
    let _e52 = MorphBand_u0028_();
    let _e55 = (*rowStep);
    row = ((((f32((_e47 * 3i)) * _e50) + _e52) + 0.5f) * _e55);
    let _e57 = (*rowStep);
    let _e58 = bands;
    streamStep = (_e57 * _e58);
    let _e60 = (*column);
    let _e61 = row;
    let _e63 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e60, _e61), 0f);
    let _e65 = (*weight);
    let _e67 = (*position_1);
    (*position_1) = (_e67 + (_e63.xyz * _e65));
    let _e69 = (*column);
    let _e70 = row;
    let _e71 = streamStep;
    let _e74 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e69, (_e70 + _e71)), 0f);
    let _e76 = (*weight);
    let _e78 = (*normal);
    (*normal) = (_e78 + (_e74.xyz * _e76));
    let _e80 = (*column);
    let _e81 = row;
    let _e82 = streamStep;
    let _e86 = textureSampleLevel(morph_texture_tex, morph_texture_smp, vec2<f32>(_e80, (_e81 + (_e82 * 2f))), 0f);
    let _e88 = (*weight);
    let _e90 = (*tangent);
    let _e92 = (_e90.xyz + (_e86.xyz * _e88));
    (*tangent)[0u] = _e92.x;
    (*tangent)[1u] = _e92.y;
    (*tangent)[2u] = _e92.z;
    return;
}

fn MorphColumn_u0028_() -> f32 {
    let _e33 = F3dVertexIndex_u0028_();
    let _e34 = MorphWidth_u0028_();
    let _e46 = morph_info.morph_params[1u];
    return ((f32((_e33 - (i32(floor((f32(_e33) / f32(_e34)))) * _e34))) + 0.5f) * _e46);
}

fn MorphCount_u0028_() -> i32 {
    let _e35 = morph_info.morph_params[0u];
    return i32((_e35 + 0.5f));
}

fn MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b(position_2: ptr<function, vec3<f32>>, w0_: ptr<function, vec4<f32>>, w1_: ptr<function, vec4<f32>>) -> vec3<f32> {
    var count: i32;
    var column_1: f32;
    var rowStep_1: f32;
    var normal_1: vec3<f32>;
    var tangent_1: vec4<f32>;
    var i: i32;
    var weight_1: f32;
    var local: f32;
    var param: i32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec4<f32>;

    let _e51 = MorphCount_u0028_();
    count = _e51;
    let _e52 = count;
    if (_e52 <= 0i) {
        let _e54 = (*position_2);
        return _e54;
    }
    let _e55 = MorphColumn_u0028_();
    column_1 = _e55;
    let _e58 = morph_info.morph_params[2u];
    rowStep_1 = _e58;
    normal_1 = vec3<f32>(0f, 0f, 0f);
    tangent_1 = vec4<f32>(0f, 0f, 0f, 0f);
    i = 0i;
    loop {
        let _e59 = i;
        if (_e59 < 8i) {
            let _e61 = i;
            let _e62 = count;
            if (_e61 >= _e62) {
                break;
            }
            let _e64 = i;
            if (_e64 < 4i) {
                let _e66 = i;
                let _e68 = (*w0_)[_e66];
                local = _e68;
            } else {
                let _e69 = i;
                let _e72 = (*w1_)[(_e69 - 4i)];
                local = _e72;
            }
            let _e73 = local;
            weight_1 = _e73;
            let _e74 = weight_1;
            if (_e74 == 0f) {
                continue;
            }
            let _e76 = i;
            param = _e76;
            let _e77 = weight_1;
            param_1 = _e77;
            let _e78 = column_1;
            param_2 = _e78;
            let _e79 = rowStep_1;
            param_3 = _e79;
            let _e80 = (*position_2);
            param_4 = _e80;
            let _e81 = normal_1;
            param_5 = _e81;
            let _e82 = tangent_1;
            param_6 = _e82;
            AddMorphTargetAt_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b_vf3_u003b_vf3_u003b_vf4_u003b((&param), (&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
            let _e83 = param_4;
            (*position_2) = _e83;
            let _e84 = param_5;
            normal_1 = _e84;
            let _e85 = param_6;
            tangent_1 = _e85;
            continue;
        } else {
            break;
        }
        continuing {
            let _e86 = i;
            i = (_e86 + 1i);
        }
    }
    let _e88 = (*position_2);
    return _e88;
}

fn main_1() {
    var now: vec3<f32>;
    var param_7: vec3<f32>;
    var param_8: vec4<f32>;
    var param_9: vec4<f32>;
    var then: vec3<f32>;
    var param_10: vec3<f32>;
    var param_11: vec4<f32>;
    var param_12: vec4<f32>;
    var local_1: vec4<f32>;
    var param_13: vec4<f32>;
    var param_14: vec4<f32>;
    var param_15: vec4<f32>;
    var before: vec4<f32>;
    var param_16: vec4<f32>;
    var param_17: vec4<f32>;
    var param_18: vec4<f32>;
    var param_19: vec4<f32>;

    let _e50 = position_3;
    param_7 = _e50;
    let _e53 = morph_info.morph_weights[0i];
    param_8 = _e53;
    let _e56 = morph_info.morph_weights[1i];
    param_9 = _e56;
    let _e57 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((&param_7), (&param_8), (&param_9));
    now = _e57;
    let _e58 = position_3;
    param_10 = _e58;
    let _e61 = prev_info.previous_morph_weights[0i];
    param_11 = _e61;
    let _e64 = prev_info.previous_morph_weights[1i];
    param_12 = _e64;
    let _e65 = MorphPositionWith_u0028_vf3_u003b_vf4_u003b_vf4_u003b((&param_10), (&param_11), (&param_12));
    then = _e65;
    let _e66 = i_row0_1;
    param_13 = _e66;
    let _e67 = i_row1_1;
    param_14 = _e67;
    let _e68 = i_row2_1;
    param_15 = _e68;
    let _e69 = Affine_u0028_vf4_u003b_vf4_u003b_vf4_u003b((&param_13), (&param_14), (&param_15));
    let _e70 = now;
    local_1 = (_e69 * vec4<f32>(_e70.x, _e70.y, _e70.z, 1f));
    let _e76 = i_prev_row0_1;
    param_16 = _e76;
    let _e77 = i_prev_row1_1;
    param_17 = _e77;
    let _e78 = i_prev_row2_1;
    param_18 = _e78;
    let _e79 = Affine_u0028_vf4_u003b_vf4_u003b_vf4_u003b((&param_16), (&param_17), (&param_18));
    let _e80 = then;
    before = (_e79 * vec4<f32>(_e80.x, _e80.y, _e80.z, 1f));
    let _e87 = prev_info.current_mvp;
    let _e88 = local_1;
    v_current = (_e87 * _e88);
    let _e91 = frame_info.model;
    let _e92 = local_1;
    param_19 = (_e91 * _e92);
    let _e94 = DepthAlongAxis_u0028_vf4_u003b((&param_19));
    v_depth = _e94;
    let _e96 = prev_info.previous_mvp;
    let _e97 = before;
    v_previous = (_e96 * _e97);
    let _e100 = frame_info.mvp;
    let _e101 = local_1;
    unnamed.gl_Position = (_e100 * _e101);
    return;
}

@vertex
fn main(@builtin(vertex_index) gl_VertexIndex: u32, @location(0) position: vec3<f32>, @location(1) i_row0_: vec4<f32>, @location(2) i_row1_: vec4<f32>, @location(3) i_row2_: vec4<f32>, @location(4) i_prev_row0_: vec4<f32>, @location(5) i_prev_row1_: vec4<f32>, @location(6) i_prev_row2_: vec4<f32>) -> VertexOutput {
    gl_VertexIndex_1 = i32(gl_VertexIndex);
    position_3 = position;
    i_row0_1 = i_row0_;
    i_row1_1 = i_row1_;
    i_row2_1 = i_row2_;
    i_prev_row0_1 = i_prev_row0_;
    i_prev_row1_1 = i_prev_row1_;
    i_prev_row2_1 = i_prev_row2_;
    main_1();
    let _e22 = v_current;
    let _e23 = v_depth;
    let _e24 = v_previous;
    let _e25 = unnamed.gl_Position;
    return VertexOutput(_e22, _e23, _e24, _e25);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'i_row0',
          location: 1,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_row1',
          location: 2,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_row2',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_prev_row0',
          location: 4,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_prev_row1',
          location: 5,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_prev_row2',
          location: 6,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MorphInfo',
          group: 0,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'morph_weights',
              offsetInBytes: 0,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'morph_params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PrevFrameInfo',
          group: 0,
          binding: 2,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'current_mvp',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_mvp',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_morph_weights',
              offsetInBytes: 128,
              sizeInBytes: 32,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 160,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 176,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'morph_texture',
          group: 0,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PolylineVertex': WebGpuStage(
      wgsl: r'''
struct MaterialParams {
    viewport: vec4<f32>,
}

struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @builtin(position) gl_Position: vec4<f32>,
    @location(7) member: vec3<f32>,
    @location(3) member_1: vec3<f32>,
    @location(5) member_2: vec2<f32>,
    @location(4) member_3: vec4<f32>,
    @location(0) member_4: vec4<f32>,
    @location(2) member_5: vec2<f32>,
    @location(1) member_6: vec4<f32>,
}

@group(0) @binding(1)
var<uniform> params: MaterialParams;
var<private> tangent_1: vec4<f32>;
@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> position_1: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> v_instance: vec4<f32>;

fn ToPixels_u0028_vf4_u003b_vf2_u003b(clip: ptr<function, vec4<f32>>, viewport: ptr<function, vec2<f32>>) -> vec2<f32> {
    let _e34 = (*clip);
    let _e37 = (*clip)[3u];
    let _e40 = (*viewport);
    return (((_e34.xy / vec2(_e37)) * _e40) * 0.5f);
}

fn InFront_u0028_vf4_u003b_vf4_u003b(from_: ptr<function, vec4<f32>>, to: ptr<function, vec4<f32>>) -> vec4<f32> {
    var t: f32;

    let _e36 = (*from_)[3u];
    if (_e36 >= 0.0001f) {
        let _e38 = (*from_);
        return _e38;
    }
    let _e40 = (*from_)[3u];
    let _e43 = (*to)[3u];
    let _e45 = (*from_)[3u];
    t = ((0.0001f - _e40) / (_e43 - _e45));
    let _e48 = (*from_);
    let _e49 = (*to);
    let _e50 = t;
    return mix(_e48, _e49, vec4(clamp(_e50, 0f, 1f)));
}

fn main_1() {
    var viewport_1: vec2<f32>;
    var halfWidth: f32;
    var side: f32;
    var here: vec4<f32>;
    var before: vec4<f32>;
    var after: vec4<f32>;
    var local: vec4<f32>;
    var param: vec4<f32>;
    var param_1: vec4<f32>;
    var param_2: vec4<f32>;
    var param_3: vec4<f32>;
    var param_4: vec4<f32>;
    var param_5: vec4<f32>;
    var param_6: vec4<f32>;
    var param_7: vec4<f32>;
    var dir: vec2<f32>;
    var param_8: vec4<f32>;
    var param_9: vec2<f32>;
    var param_10: vec4<f32>;
    var param_11: vec2<f32>;
    var dirLength: f32;
    var segmentNormal: vec2<f32>;
    var local_1: vec2<f32>;
    var offset: vec2<f32>;

    let _e57 = params.viewport;
    viewport_1 = _e57.xy;
    let _e60 = tangent_1[3u];
    halfWidth = abs(_e60);
    let _e63 = tangent_1[3u];
    side = select(1f, -1f, (_e63 < 0f));
    let _e67 = frame_info.mvp;
    let _e68 = position_1;
    here = (_e67 * vec4<f32>(_e68.x, _e68.y, _e68.z, 1f));
    let _e75 = frame_info.mvp;
    let _e76 = normal_1;
    before = (_e75 * vec4<f32>(_e76.x, _e76.y, _e76.z, 1f));
    let _e83 = frame_info.mvp;
    let _e84 = tangent_1;
    let _e85 = _e84.xyz;
    after = (_e83 * vec4<f32>(_e85.x, _e85.y, _e85.z, 1f));
    let _e92 = here[3u];
    if (_e92 < 0.0001f) {
        let _e95 = after[3u];
        if (_e95 >= 0.0001f) {
            let _e97 = here;
            param = _e97;
            let _e98 = after;
            param_1 = _e98;
            let _e99 = InFront_u0028_vf4_u003b_vf4_u003b((&param), (&param_1));
            local = _e99;
        } else {
            let _e100 = here;
            param_2 = _e100;
            let _e101 = before;
            param_3 = _e101;
            let _e102 = InFront_u0028_vf4_u003b_vf4_u003b((&param_2), (&param_3));
            local = _e102;
        }
        let _e103 = local;
        here = _e103;
    }
    let _e104 = before;
    param_4 = _e104;
    let _e105 = here;
    param_5 = _e105;
    let _e106 = InFront_u0028_vf4_u003b_vf4_u003b((&param_4), (&param_5));
    before = _e106;
    let _e107 = after;
    param_6 = _e107;
    let _e108 = here;
    param_7 = _e108;
    let _e109 = InFront_u0028_vf4_u003b_vf4_u003b((&param_6), (&param_7));
    after = _e109;
    let _e110 = after;
    param_8 = _e110;
    let _e111 = viewport_1;
    param_9 = _e111;
    let _e112 = ToPixels_u0028_vf4_u003b_vf2_u003b((&param_8), (&param_9));
    let _e113 = before;
    param_10 = _e113;
    let _e114 = viewport_1;
    param_11 = _e114;
    let _e115 = ToPixels_u0028_vf4_u003b_vf2_u003b((&param_10), (&param_11));
    dir = (_e112 - _e115);
    let _e117 = dir;
    dirLength = length(_e117);
    let _e119 = dirLength;
    if (_e119 > 0.000000001f) {
        let _e122 = dir[1u];
        let _e125 = dir[0u];
        let _e127 = dirLength;
        local_1 = (vec2<f32>(-(_e122), _e125) / vec2(_e127));
    } else {
        local_1 = vec2<f32>(1f, 0f);
    }
    let _e130 = local_1;
    segmentNormal = _e130;
    let _e131 = segmentNormal;
    let _e132 = halfWidth;
    let _e134 = side;
    offset = ((_e131 * _e132) * _e134);
    let _e136 = here;
    let _e138 = offset;
    let _e139 = viewport_1;
    let _e143 = here[3u];
    let _e145 = (_e136.xy + ((_e138 / (_e139 * 0.5f)) * _e143));
    let _e146 = here;
    let _e147 = _e146.zw;
    unnamed.gl_Position = vec4<f32>(_e145.x, _e145.y, _e147.x, _e147.y);
    let _e155 = frame_info.model;
    let _e156 = position_1;
    v_world_position = (_e155 * vec4<f32>(_e156.x, _e156.y, _e156.z, 1f)).xyz;
    let _e164 = frame_info.normal_matrix;
    v_normal = normalize((mat3x3<f32>(_e164[0].xyz, _e164[1].xyz, _e164[2].xyz) * vec3<f32>(0f, 1f, 0f)));
    let _e174 = texcoord_1;
    v_texcoord = _e174;
    v_tangent = vec4<f32>(1f, 0f, 0f, 1f);
    let _e175 = color_1;
    v_color = _e175;
    v_lightmap_uv = vec2<f32>(0f, 0f);
    v_instance = vec4<f32>(0f, 0f, 0f, 0f);
    return;
}

@vertex
fn main(@location(3) tangent: vec4<f32>, @location(0) position: vec3<f32>, @location(1) normal: vec3<f32>, @location(2) texcoord: vec2<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
    tangent_1 = tangent;
    position_1 = position;
    normal_1 = normal;
    texcoord_1 = texcoord;
    color_1 = color;
    main_1();
    let _e19 = unnamed.gl_Position;
    let _e20 = v_world_position;
    let _e21 = v_normal;
    let _e22 = v_texcoord;
    let _e23 = v_tangent;
    let _e24 = v_color;
    let _e25 = v_lightmap_uv;
    let _e26 = v_instance;
    return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25, _e26);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'tangent',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 4,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MaterialParams',
          group: 0,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'viewport',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'ParticleVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct ParticleInfo {
    view_projection: mat4x4<f32>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @location(6) member_1: vec2<f32>,
    @location(7) member_2: vec3<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> v_world_position: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_info: ParticleInfo;

fn main_1() {
    let _e11 = color_1;
    v_color = _e11;
    let _e12 = texcoord_1;
    v_uv = _e12;
    let _e13 = position_1;
    v_world_position = _e13;
    let _e15 = particle_info.view_projection;
    let _e16 = position_1;
    unnamed.gl_Position = (_e15 * vec4<f32>(_e16.x, _e16.y, _e16.z, 1f));
    return;
}

@vertex
fn main(@location(1) color: vec4<f32>, @location(2) texcoord: vec2<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
    color_1 = color;
    texcoord_1 = texcoord;
    position_1 = position;
    main_1();
    let _e11 = v_color;
    let _e12 = v_uv;
    let _e13 = v_world_position;
    let _e14 = unnamed.gl_Position;
    return VertexOutput(_e11, _e12, _e13, _e14);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 1,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ParticleInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'ParticleMeshVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct ParticleMeshInfo {
    view_projection: mat4x4<f32>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @location(7) member_1: vec3<f32>,
    @location(3) member_2: vec3<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> i_position_1: vec3<f32>;
var<private> position_1: vec3<f32>;
var<private> i_scale_1: f32;
var<private> v_color: vec4<f32>;
var<private> i_color_1: vec4<f32>;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> normal_1: vec3<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
@group(0) @binding(0)
var<uniform> particle_mesh_info: ParticleMeshInfo;

fn main_1() {
    var world: vec3<f32>;

    let _e14 = i_position_1;
    let _e15 = position_1;
    let _e16 = i_scale_1;
    world = (_e14 + (_e15 * _e16));
    let _e19 = i_color_1;
    v_color = _e19;
    let _e20 = world;
    v_world_position = _e20;
    let _e21 = normal_1;
    v_normal = _e21;
    let _e23 = particle_mesh_info.view_projection;
    let _e24 = world;
    unnamed.gl_Position = (_e23 * vec4<f32>(_e24.x, _e24.y, _e24.z, 1f));
    return;
}

@vertex
fn main(@location(2) i_position: vec3<f32>, @location(0) position: vec3<f32>, @location(4) i_scale: f32, @location(3) i_color: vec4<f32>, @location(1) normal: vec3<f32>) -> VertexOutput {
    i_position_1 = i_position;
    position_1 = position;
    i_scale_1 = i_scale;
    i_color_1 = i_color;
    normal_1 = normal;
    main_1();
    let _e15 = v_color;
    let _e16 = v_world_position;
    let _e17 = v_normal;
    let _e18 = unnamed.gl_Position;
    return VertexOutput(_e15, _e16, _e17, _e18);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'i_position',
          location: 2,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'i_color',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'i_scale',
          location: 4,
          format: VertexFormat.float32,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ParticleMeshInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'CausticPhotonVertex': WebGpuStage(
      wgsl: r'''
struct CausticInfo {
    map_to_world: mat4x4<f32>,
    world_to_map: mat4x4<f32>,
    world_to_tile: mat4x4<f32>,
    world_to_clip: mat4x4<f32>,
    grid: vec4<f32>,
    light: vec4<f32>,
    optics: vec4<f32>,
    tint: vec4<f32>,
    attenuation: vec4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(6) member: vec2<f32>,
    @location(0) member_1: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> gl_InstanceIndex_1: i32;
@group(0) @binding(5)
var caustic_front_tex: texture_2d<f32>;
@group(0) @binding(6)
var caustic_front_smp: sampler;
@group(0) @binding(0)
var<uniform> caustic_info: CausticInfo;
@group(0) @binding(1)
var caustic_back_tex: texture_2d<f32>;
@group(0) @binding(2)
var caustic_back_smp: sampler;
@group(0) @binding(3)
var caustic_depth_tex: texture_2d<f32>;
@group(0) @binding(4)
var caustic_depth_smp: sampler;
var<private> v_uv: vec2<f32>;
var<private> corner_1: vec2<f32>;
var<private> v_color: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b(a: ptr<function, vec2<f32>>, fallback: ptr<function, vec2<f32>>, least: ptr<function, f32>) -> vec2<f32> {
    var size: f32;
    var local: vec2<f32>;

    let _e51 = (*a);
    size = length(_e51);
    let _e53 = size;
    if (_e53 < 0.000000001f) {
        let _e55 = (*fallback);
        let _e57 = (*least);
        return (normalize(_e55) * _e57);
    }
    let _e59 = size;
    let _e60 = (*least);
    if (_e59 < _e60) {
        let _e62 = (*a);
        let _e63 = (*least);
        let _e64 = size;
        local = (_e62 * (_e63 / _e64));
    } else {
        let _e67 = (*a);
        local = _e67;
    }
    let _e68 = local;
    return _e68;
}

fn Schlick_u0028_f1_u003b_f1_u003b(f0_: ptr<function, f32>, cosine: ptr<function, f32>) -> f32 {
    var c: f32;

    let _e49 = (*cosine);
    c = clamp((1f - _e49), 0f, 1f);
    let _e52 = (*f0_);
    let _e53 = (*f0_);
    let _e55 = c;
    let _e57 = c;
    let _e59 = c;
    let _e61 = c;
    let _e63 = c;
    return (_e52 + ((((((1f - _e53) * _e55) * _e57) * _e59) * _e61) * _e63));
}

fn MapUv_u0028_vf4_u003b(p: ptr<function, vec4<f32>>) -> vec2<f32> {
    let _e48 = (*p)[0u];
    let _e52 = (*p)[1u];
    return vec2<f32>(((_e48 * 0.5f) + 0.5f), (0.5f - (_e52 * 0.5f)));
}

fn Follow_u0028_vf2_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, energy: ptr<function, vec3<f32>>) -> vec4<f32> {
    var front: vec4<f32>;
    var ndc: vec2<f32>;
    var entry: vec3<f32>;
    var range: f32;
    var l: vec3<f32>;
    var n1_: vec3<f32>;
    var index: f32;
    var inside: vec3<f32>;
    var back: vec4<f32>;
    var across: f32;
    var exit: vec3<f32>;
    var there: vec4<f32>;
    var param: vec4<f32>;
    var n2_: vec3<f32>;
    var local_1: vec3<f32>;
    var out_ray: vec3<f32>;
    var f0_1: f32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: f32;
    var fading: f32;
    var p_1: vec3<f32>;
    var down: f32;
    var k: i32;
    var q: vec4<f32>;
    var receiver: f32;
    var param_5: vec4<f32>;
    var advance: f32;
    var landed: vec4<f32>;
    var under: f32;
    var param_6: vec4<f32>;
    var clip: vec4<f32>;
    var phi_109_: bool;

    (*energy) = vec3<f32>(0f, 0f, 0f);
    let _e81 = (*uv);
    let _e82 = textureSampleLevel(caustic_front_tex, caustic_front_smp, _e81, 0f);
    front = _e82;
    let _e84 = front[3u];
    let _e85 = (_e84 >= 1f);
    phi_109_ = _e85;
    if !(_e85) {
        let _e87 = front;
        let _e89 = front;
        phi_109_ = (dot(_e87.xyz, _e89.xyz) < 0.25f);
    }
    let _e94 = phi_109_;
    if _e94 {
        return vec4<f32>(0f, 0f, 0f, 0f);
    }
    let _e96 = (*uv)[0u];
    let _e100 = (*uv)[1u];
    ndc = vec2<f32>(((_e96 * 2f) - 1f), ((0.5f - _e100) * 2f));
    let _e105 = caustic_info.map_to_world;
    let _e106 = ndc;
    let _e108 = front[3u];
    entry = (_e105 * vec4<f32>(_e106.x, _e106.y, _e108, 1f)).xyz;
    let _e115 = caustic_info.map_to_world;
    range = length((_e115 * vec4<f32>(0f, 0f, 1f, 0f)).xyz);
    let _e120 = caustic_info.light;
    l = normalize(_e120.xyz);
    let _e123 = front;
    n1_ = normalize(_e123.xyz);
    let _e126 = n1_;
    let _e127 = l;
    if (dot(_e126, _e127) > 0f) {
        let _e130 = n1_;
        n1_ = -(_e130);
    }
    let _e134 = caustic_info.optics[0u];
    index = max(_e134, 1f);
    let _e136 = l;
    let _e137 = n1_;
    let _e138 = index;
    inside = refract(_e136, _e137, (1f / _e138));
    let _e141 = (*uv);
    let _e142 = textureSampleLevel(caustic_back_tex, caustic_back_smp, _e141, 0f);
    back = _e142;
    let _e144 = back[3u];
    let _e146 = front[3u];
    if (_e144 <= _e146) {
        return vec4<f32>(0f, 0f, 0f, 0f);
    }
    let _e149 = back[3u];
    let _e151 = front[3u];
    let _e153 = range;
    across = ((_e149 - _e151) * _e153);
    let _e155 = entry;
    let _e156 = inside;
    let _e157 = across;
    let _e158 = inside;
    let _e159 = l;
    exit = (_e155 + (_e156 * (_e157 / max(dot(_e158, _e159), 0.2f))));
    let _e166 = caustic_info.world_to_map;
    let _e167 = exit;
    param = (_e166 * vec4<f32>(_e167.x, _e167.y, _e167.z, 1f));
    let _e173 = MapUv_u0028_vf4_u003b((&param));
    let _e177 = textureSampleLevel(caustic_back_tex, caustic_back_smp, clamp(_e173, vec2(0f), vec2(1f)), 0f);
    there = _e177;
    let _e178 = there;
    let _e180 = there;
    if (dot(_e178.xyz, _e180.xyz) > 0.25f) {
        let _e184 = there;
        local_1 = normalize(_e184.xyz);
    } else {
        let _e187 = back;
        local_1 = normalize(_e187.xyz);
    }
    let _e190 = local_1;
    n2_ = _e190;
    let _e191 = n2_;
    let _e192 = inside;
    if (dot(_e191, _e192) < 0f) {
        let _e195 = n2_;
        n2_ = -(_e195);
    }
    let _e197 = inside;
    let _e198 = n2_;
    let _e200 = index;
    out_ray = refract(_e197, -(_e198), _e200);
    let _e202 = out_ray;
    let _e203 = out_ray;
    if (dot(_e202, _e203) < 0.000001f) {
        return vec4<f32>(0f, 0f, 0f, 0f);
    }
    let _e206 = out_ray;
    out_ray = normalize(_e206);
    let _e208 = out_ray;
    let _e209 = l;
    if (dot(_e208, _e209) < 0.3f) {
        return vec4<f32>(0f, 0f, 0f, 0f);
    }
    let _e214 = caustic_info.optics[1u];
    f0_1 = _e214;
    let _e216 = caustic_info.tint;
    let _e218 = l;
    let _e219 = n1_;
    let _e222 = f0_1;
    param_1 = _e222;
    param_2 = abs(dot(_e218, _e219));
    let _e223 = Schlick_u0028_f1_u003b_f1_u003b((&param_1), (&param_2));
    let _e226 = out_ray;
    let _e227 = n2_;
    let _e230 = f0_1;
    param_3 = _e230;
    param_4 = abs(dot(_e226, _e227));
    let _e231 = Schlick_u0028_f1_u003b_f1_u003b((&param_3), (&param_4));
    (*energy) = ((_e216.xyz * (1f - _e223)) * (1f - _e231));
    let _e236 = caustic_info.optics[2u];
    fading = _e236;
    let _e237 = fading;
    if (_e237 > 0f) {
        let _e240 = caustic_info.attenuation;
        let _e243 = exit;
        let _e244 = entry;
        let _e247 = fading;
        let _e251 = (*energy);
        (*energy) = (_e251 * pow(max(_e240.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((length((_e243 - _e244)) / _e247))));
    }
    let _e253 = exit;
    p_1 = _e253;
    let _e254 = out_ray;
    let _e255 = l;
    down = max(dot(_e254, _e255), 0.05f);
    k = 0i;
    loop {
        let _e258 = k;
        if (_e258 < 4i) {
            let _e261 = caustic_info.world_to_tile;
            let _e262 = p_1;
            q = (_e261 * vec4<f32>(_e262.x, _e262.y, _e262.z, 1f));
            let _e268 = q;
            param_5 = _e268;
            let _e269 = MapUv_u0028_vf4_u003b((&param_5));
            let _e273 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e269, vec2(0f), vec2(1f)), 0f);
            receiver = _e273.x;
            let _e275 = receiver;
            let _e277 = q[2u];
            let _e279 = range;
            let _e281 = down;
            advance = (((_e275 - _e277) * _e279) / _e281);
            let _e283 = k;
            if (_e283 == 0i) {
                let _e285 = advance;
                advance = max(_e285, 0f);
            }
            let _e287 = out_ray;
            let _e288 = advance;
            let _e290 = p_1;
            p_1 = (_e290 + (_e287 * _e288));
            continue;
        } else {
            break;
        }
        continuing {
            let _e292 = k;
            k = (_e292 + 1i);
        }
    }
    let _e295 = caustic_info.world_to_tile;
    let _e296 = p_1;
    landed = (_e295 * vec4<f32>(_e296.x, _e296.y, _e296.z, 1f));
    let _e302 = landed;
    param_6 = _e302;
    let _e303 = MapUv_u0028_vf4_u003b((&param_6));
    let _e307 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e303, vec2(0f), vec2(1f)), 0f);
    under = _e307.x;
    let _e309 = under;
    let _e311 = landed[2u];
    let _e314 = range;
    if ((abs((_e309 - _e311)) * _e314) > 0.02f) {
        return vec4<f32>(0f, 0f, 0f, 0f);
    }
    let _e318 = caustic_info.world_to_clip;
    let _e319 = p_1;
    clip = (_e318 * vec4<f32>(_e319.x, _e319.y, _e319.z, 1f));
    let _e325 = clip;
    let _e328 = clip[3u];
    let _e330 = (_e325.xy / vec2(_e328));
    return vec4<f32>(_e330.x, _e330.y, 0f, 1f);
}

fn F3dInstanceIndex_u0028_() -> i32 {
    let _e46 = gl_InstanceIndex_1;
    return _e46;
}

fn main_1() {
    var n: f32;
    var id: f32;
    var column: f32;
    var row: f32;
    var uv_1: vec2<f32>;
    var texel: f32;
    var here: vec4<f32>;
    var energy_1: vec3<f32>;
    var param_7: vec2<f32>;
    var param_8: vec3<f32>;
    var spacing_x: vec2<f32>;
    var spacing_y: vec2<f32>;
    var next_x: vec4<f32>;
    var unused: vec3<f32>;
    var param_9: vec2<f32>;
    var param_10: vec3<f32>;
    var a_1: vec2<f32>;
    var local_2: vec2<f32>;
    var prev_x: vec4<f32>;
    var param_11: vec2<f32>;
    var param_12: vec3<f32>;
    var next_y: vec4<f32>;
    var param_13: vec2<f32>;
    var param_14: vec3<f32>;
    var b: vec2<f32>;
    var local_3: vec2<f32>;
    var prev_y: vec4<f32>;
    var param_15: vec2<f32>;
    var param_16: vec3<f32>;
    var least_1: f32;
    var param_17: vec2<f32>;
    var param_18: vec2<f32>;
    var param_19: f32;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var area: f32;
    var share: f32;
    var phi_660_: bool;

    let _e84 = corner_1;
    v_uv = _e84;
    v_color = vec4<f32>(0f, 0f, 0f, 0f);
    unnamed.gl_Position = vec4<f32>(4f, 4f, 0.5f, 1f);
    let _e88 = caustic_info.grid[0u];
    n = _e88;
    let _e89 = F3dInstanceIndex_u0028_();
    id = f32(_e89);
    let _e91 = id;
    let _e92 = n;
    column = (_e91 - (floor((_e91 / _e92)) * _e92));
    let _e97 = id;
    let _e98 = n;
    row = floor((_e97 / _e98));
    let _e101 = column;
    let _e103 = n;
    let _e105 = row;
    let _e107 = n;
    uv_1 = vec2<f32>(((_e101 + 0.5f) / _e103), ((_e105 + 0.5f) / _e107));
    let _e110 = n;
    texel = (1f / _e110);
    let _e112 = uv_1;
    param_7 = _e112;
    let _e113 = Follow_u0028_vf2_u003b_vf3_u003b((&param_7), (&param_8));
    let _e114 = param_8;
    energy_1 = _e114;
    here = _e113;
    let _e116 = here[3u];
    if (_e116 < 0.5f) {
        return;
    }
    let _e120 = caustic_info.grid[2u];
    spacing_x = vec2<f32>(_e120, 0f);
    let _e124 = caustic_info.grid[3u];
    spacing_y = vec2<f32>(0f, _e124);
    let _e126 = uv_1;
    let _e127 = texel;
    param_9 = (_e126 + vec2<f32>(_e127, 0f));
    let _e130 = Follow_u0028_vf2_u003b_vf3_u003b((&param_9), (&param_10));
    let _e131 = param_10;
    unused = _e131;
    next_x = _e130;
    let _e133 = next_x[3u];
    if (_e133 > 0.5f) {
        let _e135 = next_x;
        let _e137 = here;
        local_2 = (_e135.xy - _e137.xy);
    } else {
        let _e140 = spacing_x;
        local_2 = _e140;
    }
    let _e141 = local_2;
    a_1 = _e141;
    let _e143 = next_x[3u];
    if (_e143 < 0.5f) {
        let _e145 = uv_1;
        let _e146 = texel;
        param_11 = (_e145 - vec2<f32>(_e146, 0f));
        let _e149 = Follow_u0028_vf2_u003b_vf3_u003b((&param_11), (&param_12));
        let _e150 = param_12;
        unused = _e150;
        prev_x = _e149;
        let _e152 = prev_x[3u];
        if (_e152 > 0.5f) {
            let _e154 = here;
            let _e156 = prev_x;
            a_1 = (_e154.xy - _e156.xy);
        }
    }
    let _e159 = uv_1;
    let _e160 = texel;
    param_13 = (_e159 + vec2<f32>(0f, _e160));
    let _e163 = Follow_u0028_vf2_u003b_vf3_u003b((&param_13), (&param_14));
    let _e164 = param_14;
    unused = _e164;
    next_y = _e163;
    let _e166 = next_y[3u];
    if (_e166 > 0.5f) {
        let _e168 = next_y;
        let _e170 = here;
        local_3 = (_e168.xy - _e170.xy);
    } else {
        let _e173 = spacing_y;
        local_3 = _e173;
    }
    let _e174 = local_3;
    b = _e174;
    let _e176 = next_y[3u];
    if (_e176 < 0.5f) {
        let _e178 = uv_1;
        let _e179 = texel;
        param_15 = (_e178 - vec2<f32>(0f, _e179));
        let _e182 = Follow_u0028_vf2_u003b_vf3_u003b((&param_15), (&param_16));
        let _e183 = param_16;
        unused = _e183;
        prev_y = _e182;
        let _e185 = prev_y[3u];
        if (_e185 > 0.5f) {
            let _e187 = here;
            let _e189 = prev_y;
            b = (_e187.xy - _e189.xy);
        }
    }
    let _e192 = a_1;
    let _e196 = caustic_info.grid[2u];
    let _e198 = (length(_e192) > (16f * _e196));
    phi_660_ = _e198;
    if !(_e198) {
        let _e200 = b;
        let _e204 = caustic_info.grid[3u];
        phi_660_ = (length(_e200) > (16f * _e204));
    }
    let _e208 = phi_660_;
    if _e208 {
        return;
    }
    let _e211 = caustic_info.grid[1u];
    least_1 = _e211;
    let _e212 = a_1;
    param_17 = (_e212 * 1.5f);
    let _e214 = spacing_x;
    param_18 = _e214;
    let _e215 = least_1;
    param_19 = _e215;
    let _e216 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_17), (&param_18), (&param_19));
    a_1 = _e216;
    let _e217 = b;
    param_20 = (_e217 * 1.5f);
    let _e219 = spacing_y;
    param_21 = _e219;
    let _e220 = least_1;
    param_22 = _e220;
    let _e221 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_20), (&param_21), (&param_22));
    b = _e221;
    let _e223 = a_1[0u];
    let _e225 = b[1u];
    let _e228 = a_1[1u];
    let _e230 = b[0u];
    let _e234 = least_1;
    let _e235 = least_1;
    area = max(abs(((_e223 * _e225) - (_e228 * _e230))), (_e234 * _e235));
    let _e238 = here;
    let _e241 = corner_1[0u];
    let _e242 = a_1;
    let _e246 = corner_1[1u];
    let _e247 = b;
    let _e249 = ((_e238.xy + (_e242 * _e241)) + (_e247 * _e246));
    unnamed.gl_Position = vec4<f32>(_e249.x, _e249.y, 0.5f, 1f);
    let _e256 = caustic_info.grid[2u];
    let _e259 = caustic_info.grid[3u];
    share = (_e256 * _e259);
    let _e261 = energy_1;
    let _e262 = share;
    let _e264 = area;
    let _e267 = ((_e261 * _e262) / vec3((1.0471976f * _e264)));
    v_color = vec4<f32>(_e267.x, _e267.y, _e267.z, 0f);
    return;
}

@vertex
fn main(@builtin(instance_index) gl_InstanceIndex: u32, @location(0) corner: vec2<f32>) -> VertexOutput {
    gl_InstanceIndex_1 = i32(gl_InstanceIndex);
    corner_1 = corner;
    main_1();
    let _e9 = v_uv;
    let _e10 = v_color;
    let _e11 = unnamed.gl_Position;
    return VertexOutput(_e9, _e10, _e11);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'corner',
          location: 0,
          format: VertexFormat.float32x2,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'CausticInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'map_to_world',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'world_to_map',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'world_to_tile',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'world_to_clip',
              offsetInBytes: 192,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'grid',
              offsetInBytes: 256,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'light',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'optics',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tint',
              offsetInBytes: 304,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'attenuation',
              offsetInBytes: 320,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'caustic_back',
          group: 0,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'caustic_depth',
          group: 0,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'caustic_front',
          group: 0,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ShadowTileResetVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(6) member: vec2<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_uv: vec2<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec2<f32>;

fn main_1() {
    let _e7 = texcoord_1;
    v_uv = _e7;
    let _e8 = position_1;
    unnamed.gl_Position = vec4<f32>(_e8.x, _e8.y, 1f, 1f);
    return;
}

@vertex
fn main(@location(1) texcoord: vec2<f32>, @location(0) position: vec2<f32>) -> VertexOutput {
    texcoord_1 = texcoord;
    position_1 = position;
    main_1();
    let _e7 = v_uv;
    let _e8 = unnamed.gl_Position;
    return VertexOutput(_e7, _e8);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 1,
          format: VertexFormat.float32x2,
        ),
      ],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'SkyVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(6) member: vec3<f32>,
    @location(11) member_1: vec4<f32>,
    @location(2) member_2: vec4<f32>,
    @location(4) member_3: vec4<f32>,
    @location(9) member_4: vec4<f32>,
    @location(1) member_5: vec4<f32>,
    @location(0) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_zenith: vec4<f32>;
var<private> zenith_1: vec4<f32>;
var<private> v_horizon: vec4<f32>;
var<private> horizon_1: vec4<f32>;
var<private> v_nadir: vec4<f32>;
var<private> nadir_1: vec4<f32>;
var<private> v_sun: vec4<f32>;
var<private> sun_1: vec4<f32>;
var<private> v_glow: vec4<f32>;
var<private> glow_1: vec4<f32>;
var<private> v_disc: vec4<f32>;
var<private> disc_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;

fn main_1() {
    let _e19 = corner_ray_1;
    v_ray = _e19;
    let _e20 = zenith_1;
    v_zenith = _e20;
    let _e21 = horizon_1;
    v_horizon = _e21;
    let _e22 = nadir_1;
    v_nadir = _e22;
    let _e23 = sun_1;
    v_sun = _e23;
    let _e24 = glow_1;
    v_glow = _e24;
    let _e25 = disc_1;
    v_disc = _e25;
    let _e26 = position_1;
    unnamed.gl_Position = vec4<f32>(_e26.x, _e26.y, _e26.z, 1f);
    return;
}

@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) zenith: vec4<f32>, @location(3) horizon: vec4<f32>, @location(4) nadir: vec4<f32>, @location(5) sun: vec4<f32>, @location(6) glow: vec4<f32>, @location(7) disc: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
    corner_ray_1 = corner_ray;
    zenith_1 = zenith;
    horizon_1 = horizon;
    nadir_1 = nadir;
    sun_1 = sun;
    glow_1 = glow;
    disc_1 = disc;
    position_1 = position;
    main_1();
    let _e25 = v_ray;
    let _e26 = v_zenith;
    let _e27 = v_horizon;
    let _e28 = v_nadir;
    let _e29 = v_sun;
    let _e30 = v_glow;
    let _e31 = v_disc;
    let _e32 = unnamed.gl_Position;
    return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31, _e32);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'corner_ray',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'zenith',
          location: 2,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'horizon',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'nadir',
          location: 4,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'sun',
          location: 5,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'glow',
          location: 6,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'disc',
          location: 7,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'SkyCubeVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(6) member: vec3<f32>,
    @location(10) member_1: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_tint: vec4<f32>;
var<private> tint_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;

fn main_1() {
    let _e9 = corner_ray_1;
    v_ray = _e9;
    let _e10 = tint_1;
    v_tint = _e10;
    let _e11 = position_1;
    unnamed.gl_Position = vec4<f32>(_e11.x, _e11.y, _e11.z, 1f);
    return;
}

@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) tint: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
    corner_ray_1 = corner_ray;
    tint_1 = tint;
    position_1 = position;
    main_1();
    let _e10 = v_ray;
    let _e11 = v_tint;
    let _e12 = unnamed.gl_Position;
    return VertexOutput(_e10, _e11, _e12);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'corner_ray',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'tint',
          location: 2,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'SkyPhysicalVertex': WebGpuStage(
      wgsl: r'''
struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(6) member: vec3<f32>,
    @location(7) member_1: vec4<f32>,
    @location(3) member_2: vec4<f32>,
    @location(9) member_3: vec4<f32>,
    @location(5) member_4: vec4<f32>,
    @location(8) member_5: vec4<f32>,
    @location(0) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_ray: vec3<f32>;
var<private> corner_ray_1: vec3<f32>;
var<private> v_rayleigh: vec4<f32>;
var<private> rayleigh_1: vec4<f32>;
var<private> v_mie: vec4<f32>;
var<private> mie_1: vec4<f32>;
var<private> v_sun: vec4<f32>;
var<private> sun_1: vec4<f32>;
var<private> v_planet: vec4<f32>;
var<private> planet_1: vec4<f32>;
var<private> v_stars: vec4<f32>;
var<private> stars_1: vec4<f32>;
var<private> v_disc: vec4<f32>;
var<private> disc_1: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;

fn main_1() {
    let _e19 = corner_ray_1;
    v_ray = _e19;
    let _e20 = rayleigh_1;
    v_rayleigh = _e20;
    let _e21 = mie_1;
    v_mie = _e21;
    let _e22 = sun_1;
    v_sun = _e22;
    let _e23 = planet_1;
    v_planet = _e23;
    let _e24 = stars_1;
    v_stars = _e24;
    let _e25 = disc_1;
    v_disc = _e25;
    let _e26 = position_1;
    unnamed.gl_Position = vec4<f32>(_e26.x, _e26.y, _e26.z, 1f);
    return;
}

@vertex
fn main(@location(1) corner_ray: vec3<f32>, @location(2) rayleigh: vec4<f32>, @location(3) mie: vec4<f32>, @location(4) sun: vec4<f32>, @location(5) planet: vec4<f32>, @location(6) stars: vec4<f32>, @location(7) disc: vec4<f32>, @location(0) position: vec3<f32>) -> VertexOutput {
    corner_ray_1 = corner_ray;
    rayleigh_1 = rayleigh;
    mie_1 = mie;
    sun_1 = sun;
    planet_1 = planet;
    stars_1 = stars;
    disc_1 = disc;
    position_1 = position;
    main_1();
    let _e25 = v_ray;
    let _e26 = v_rayleigh;
    let _e27 = v_mie;
    let _e28 = v_sun;
    let _e29 = v_planet;
    let _e30 = v_stars;
    let _e31 = v_disc;
    let _e32 = unnamed.gl_Position;
    return VertexOutput(_e25, _e26, _e27, _e28, _e29, _e30, _e31, _e32);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'corner_ray',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'rayleigh',
          location: 2,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'mie',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'sun',
          location: 4,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'planet',
          location: 5,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'stars',
          location: 6,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'disc',
          location: 7,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'VertexTextureProbeVertex': WebGpuStage(
      wgsl: r'''
struct ProbeInfo {
    at: vec4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(0) member: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

var<private> v_sampled: vec4<f32>;
@group(0) @binding(1)
var probe_texture_tex: texture_2d<f32>;
@group(0) @binding(2)
var probe_texture_smp: sampler;
@group(0) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());
var<private> position_1: vec3<f32>;

fn main_1() {
    let _e11 = probe_info.at;
    let _e13 = textureSampleLevel(probe_texture_tex, probe_texture_smp, _e11.xy, 0f);
    v_sampled = _e13;
    let _e14 = position_1;
    unnamed.gl_Position = vec4<f32>(_e14.x, _e14.y, _e14.z, 1f);
    return;
}

@vertex
fn main(@location(0) position: vec3<f32>) -> VertexOutput {
    position_1 = position;
    main_1();
    let _e5 = v_sampled;
    let _e6 = unnamed.gl_Position;
    return VertexOutput(_e5, _e6);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ProbeInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'at', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'probe_texture',
          group: 0,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ImpostorVertex': WebGpuStage(
      wgsl: r'''
struct FrameInfo {
    mvp: mat4x4<f32>,
    model: mat4x4<f32>,
    normal_matrix: mat4x4<f32>,
}

struct gl_PerVertex {
    @builtin(position) gl_Position: vec4<f32>,
    gl_PointSize: f32,
    gl_ClipDistance: array<f32, 1>,
    gl_CullDistance: array<f32, 1>,
}

struct VertexOutput {
    @location(7) member: vec3<f32>,
    @location(3) member_1: vec3<f32>,
    @location(4) member_2: vec4<f32>,
    @location(5) member_3: vec2<f32>,
    @location(0) member_4: vec4<f32>,
    @location(2) member_5: vec2<f32>,
    @location(1) member_6: vec4<f32>,
    @builtin(position) gl_Position: vec4<f32>,
}

@group(0) @binding(0)
var<uniform> frame_info: FrameInfo;
var<private> tangent_1: vec4<f32>;
var<private> position_1: vec3<f32>;
var<private> texcoord_1: vec2<f32>;
var<private> normal_1: vec3<f32>;
var<private> v_world_position: vec3<f32>;
var<private> v_normal: vec3<f32>;
var<private> v_tangent: vec4<f32>;
var<private> v_texcoord: vec2<f32>;
var<private> v_color: vec4<f32>;
var<private> color_1: vec4<f32>;
var<private> v_lightmap_uv: vec2<f32>;
var<private> v_instance: vec4<f32>;
var<private> unnamed: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f, array<f32, 1>(), array<f32, 1>());

fn ImpostorRight_u0028_vf3_u003b(d: ptr<function, vec3<f32>>) -> vec3<f32> {
    var up: vec3<f32>;

    let _e34 = (*d)[1u];
    up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e34) > 0.999f)));
    let _e39 = up;
    let _e40 = (*d);
    return normalize(cross(_e39, _e40));
}

fn MvpRow_u0028_i1_u003b(r: ptr<function, i32>) -> vec4<f32> {
    let _e32 = (*r);
    let _e36 = frame_info.mvp[0][_e32];
    let _e37 = (*r);
    let _e41 = frame_info.mvp[1][_e37];
    let _e42 = (*r);
    let _e46 = frame_info.mvp[2][_e42];
    let _e47 = (*r);
    let _e51 = frame_info.mvp[3][_e47];
    return vec4<f32>(_e36, _e41, _e46, _e51);
}

fn main_1() {
    var radius: f32;
    var centre: vec3<f32>;
    var rx: vec4<f32>;
    var param: i32;
    var ry: vec4<f32>;
    var param_1: i32;
    var rz: vec4<f32>;
    var param_2: i32;
    var rw: vec4<f32>;
    var param_3: i32;
    var yw: vec3<f32>;
    var wx: vec3<f32>;
    var xy: vec3<f32>;
    var det: f32;
    var eye: vec3<f32>;
    var toEye: vec3<f32>;
    var local: vec3<f32>;
    var d_1: vec3<f32>;
    var right: vec3<f32>;
    var param_4: vec3<f32>;
    var up_1: vec3<f32>;
    var corner: vec3<f32>;

    let _e54 = tangent_1[3u];
    radius = _e54;
    let _e55 = position_1;
    let _e57 = texcoord_1[0u];
    let _e61 = texcoord_1[1u];
    let _e65 = radius;
    centre = (_e55 - (vec3<f32>(((_e57 * 2f) - 1f), (1f - (_e61 * 2f)), 0f) * _e65));
    param = 0i;
    let _e68 = MvpRow_u0028_i1_u003b((&param));
    rx = _e68;
    param_1 = 1i;
    let _e69 = MvpRow_u0028_i1_u003b((&param_1));
    ry = _e69;
    param_2 = 2i;
    let _e70 = MvpRow_u0028_i1_u003b((&param_2));
    rz = _e70;
    param_3 = 3i;
    let _e71 = MvpRow_u0028_i1_u003b((&param_3));
    rw = _e71;
    let _e72 = ry;
    let _e74 = rw;
    yw = cross(_e72.xyz, _e74.xyz);
    let _e77 = rw;
    let _e79 = rx;
    wx = cross(_e77.xyz, _e79.xyz);
    let _e82 = rx;
    let _e84 = ry;
    xy = cross(_e82.xyz, _e84.xyz);
    let _e87 = rx;
    let _e89 = yw;
    det = dot(_e87.xyz, _e89);
    let _e92 = rx[3u];
    let _e93 = yw;
    let _e96 = ry[3u];
    let _e97 = wx;
    let _e101 = rw[3u];
    let _e102 = xy;
    let _e106 = det;
    let _e109 = det;
    eye = (-((((_e93 * _e92) + (_e97 * _e96)) + (_e102 * _e101))) / vec3(select(1f, _e109, (abs(_e106) > 0.00000000000000000001f))));
    let _e113 = det;
    if (abs(_e113) > 0.00000000000000000001f) {
        let _e116 = eye;
        let _e117 = centre;
        local = (_e116 - _e117);
    } else {
        let _e119 = rz;
        local = -(_e119.xyz);
    }
    let _e122 = local;
    toEye = _e122;
    let _e123 = toEye;
    let _e124 = toEye;
    let _e127 = toEye;
    let _e128 = normal_1;
    d_1 = normalize(select(_e128, _e127, vec3((dot(_e123, _e124) > 0.00000000000000000001f))));
    let _e132 = d_1;
    param_4 = _e132;
    let _e133 = ImpostorRight_u0028_vf3_u003b((&param_4));
    right = _e133;
    let _e134 = d_1;
    let _e135 = right;
    up_1 = cross(_e134, _e135);
    let _e137 = centre;
    let _e138 = right;
    let _e140 = texcoord_1[0u];
    let _e144 = up_1;
    let _e146 = texcoord_1[1u];
    let _e151 = radius;
    corner = (_e137 + (((_e138 * ((_e140 * 2f) - 1f)) + (_e144 * (1f - (_e146 * 2f)))) * _e151));
    let _e155 = frame_info.model;
    let _e156 = corner;
    v_world_position = (_e155 * vec4<f32>(_e156.x, _e156.y, _e156.z, 1f)).xyz;
    let _e164 = frame_info.normal_matrix;
    let _e172 = d_1;
    v_normal = normalize((mat3x3<f32>(_e164[0].xyz, _e164[1].xyz, _e164[2].xyz) * _e172));
    let _e176 = frame_info.model;
    let _e184 = right;
    let _e186 = normalize((mat3x3<f32>(_e176[0].xyz, _e176[1].xyz, _e176[2].xyz) * _e184));
    v_tangent = vec4<f32>(_e186.x, _e186.y, _e186.z, 1f);
    let _e191 = texcoord_1;
    v_texcoord = _e191;
    let _e192 = d_1;
    let _e194 = color_1[3u];
    v_color = vec4<f32>(_e192.x, _e192.y, _e192.z, _e194);
    v_lightmap_uv = vec2<f32>(0f, 0f);
    v_instance = vec4<f32>(0f, 0f, 0f, 0f);
    let _e200 = frame_info.mvp;
    let _e201 = corner;
    unnamed.gl_Position = (_e200 * vec4<f32>(_e201.x, _e201.y, _e201.z, 1f));
    return;
}

@vertex
fn main(@location(3) tangent: vec4<f32>, @location(0) position: vec3<f32>, @location(2) texcoord: vec2<f32>, @location(1) normal: vec3<f32>, @location(4) color: vec4<f32>) -> VertexOutput {
    tangent_1 = tangent;
    position_1 = position;
    texcoord_1 = texcoord;
    normal_1 = normal;
    color_1 = color;
    main_1();
    let _e19 = v_world_position;
    let _e20 = v_normal;
    let _e21 = v_tangent;
    let _e22 = v_texcoord;
    let _e23 = v_color;
    let _e24 = v_lightmap_uv;
    let _e25 = v_instance;
    let _e26 = unnamed.gl_Position;
    return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25, _e26);
}
''',
      attributes: <WebGpuAttribute>[
        WebGpuAttribute(
          name: 'position',
          location: 0,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'normal',
          location: 1,
          format: VertexFormat.float32x3,
        ),
        WebGpuAttribute(
          name: 'texcoord',
          location: 2,
          format: VertexFormat.float32x2,
        ),
        WebGpuAttribute(
          name: 'tangent',
          location: 3,
          format: VertexFormat.float32x4,
        ),
        WebGpuAttribute(
          name: 'color',
          location: 4,
          format: VertexFormat.float32x4,
        ),
      ],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FrameInfo',
          group: 0,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mvp', offsetInBytes: 0, sizeInBytes: 64),
            WebGpuBlockMember(
              name: 'model',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'normal_matrix',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
  },
  fragment: <String, WebGpuStage>{
    'Unlit': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e78 = v_world_position_1;
    let _e80 = fog_info.eye;
    let _e84 = fog_info.forward;
    return dot((_e78 - _e80.xyz), _e84.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e83 = ViewDepth_u0028_();
    z = abs(_e83);
    let _e85 = z;
    near = (_e85 / 5f);
    let _e87 = z;
    far = (_e87 / 200f);
    let _e89 = far;
    let _e90 = far;
    let _e92 = far;
    far3_ = ((_e89 * _e90) * _e92);
    let _e94 = (*alpha);
    let _e95 = near;
    let _e96 = near;
    let _e99 = far3_;
    let _e100 = far3_;
    return (_e94 * clamp((10f / ((0.00001f + (_e95 * _e96)) + (_e99 * _e100))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e87 = fog_info.forward[3u];
    mode = _e87;
    let _e88 = mode;
    if (_e88 > 0.5f) {
        let _e91 = frag_color[3u];
        alpha_1 = _e91;
        let _e92 = alpha_1;
        param = _e92;
        let _e93 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e93;
        let _e94 = frag_color;
        let _e96 = weight;
        let _e97 = (_e94.xyz * _e96);
        let _e98 = alpha_1;
        let _e99 = weight;
        accumulate = vec4<f32>(_e97.x, _e97.y, _e97.z, (_e98 * _e99));
        let _e105 = mode;
        let _e107 = mode;
        revealage = ((_e105 > 1.5f) && (_e107 < 2.5f));
        let _e110 = revealage;
        if _e110 {
            let _e111 = alpha_1;
            local = vec4(_e111);
        } else {
            let _e113 = accumulate;
            local = _e113;
        }
        let _e114 = local;
        frag_color = _e114;
        let _e115 = mode;
        if (_e115 > 2.5f) {
            let _e117 = alpha_1;
            frag_surface = vec4(_e117);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e81 = (*n)[0u];
    let _e84 = (*n)[1u];
    let _e88 = (*n)[2u];
    let _e91 = (*n);
    (*n) = (_e91 / vec3(((abs(_e81) + abs(_e84)) + abs(_e88))));
    let _e94 = (*n);
    e = _e94.xy;
    let _e97 = (*n)[2u];
    if (_e97 < 0f) {
        let _e99 = (*n);
        let _e105 = (*n)[0u];
        let _e109 = (*n)[1u];
        e = ((vec2(1f) - abs(_e99.yx)) * vec2<f32>(select(-1f, 1f, (_e105 >= 0f)), select(-1f, 1f, (_e109 >= 0f))));
    }
    let _e114 = e;
    return ((_e114 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e79 = (*linear);
    let _e81 = (*linear);
    let _e85 = (*linear);
    return mix((_e79 * 12.92f), ((pow(_e81, 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), _e85));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e82 = g_albedo;
    param_1 = clamp(_e82, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e84 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e84.x, _e84.y, _e84.z, 1f);
    let _e89 = g_debug_surface_on;
    if _e89 {
        let _e90 = g_debug_surface;
        let _e91 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e90.x, _e90.y, _e90.z, _e91);
        return;
    }
    let _e96 = v_normal_1;
    geometric = normalize(_e96);
    let _e98 = gl_FrontFacing_1;
    if !(_e98) {
        let _e100 = geometric;
        geometric = -(_e100);
    }
    let _e102 = geometric;
    param_2 = _e102;
    let _e103 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e104 = (*roughness);
    let _e106 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e103.x, _e103.y, clamp(_e104, 0f, 1f), _e106);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e80 = fog_info.projection[0u];
    return (_e80 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e79 = Orthographic_u0028_();
    if _e79 {
        let _e80 = ViewDepth_u0028_();
        local_1 = max(_e80, 0f);
    } else {
        let _e82 = v_world_position_1;
        let _e84 = fog_info.eye;
        local_1 = distance(_e82, _e84.xyz);
    }
    let _e87 = local_1;
    return _e87;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e86 = fog_info.fog[3u];
    density = _e86;
    let _e87 = density;
    if (_e87 <= 0f) {
        let _e89 = (*color);
        return _e89;
    }
    let _e90 = EyeDistance_u0028_();
    d = _e90;
    let _e93 = fog_info.eye[3u];
    falloff = _e93;
    let _e94 = falloff;
    if (_e94 > 0f) {
        let _e96 = falloff;
        let _e98 = v_world_position_1[1u];
        let _e101 = fog_info.eye[1u];
        k = (_e96 * (_e98 - _e101));
        let _e104 = k;
        if (abs(_e104) > 0.001f) {
            let _e107 = k;
            let _e111 = k;
            local_2 = ((1f - exp(-(_e107))) / _e111);
        } else {
            let _e113 = k;
            local_2 = (1f - (0.5f * _e113));
        }
        let _e116 = local_2;
        let _e117 = density;
        density = (_e117 * _e116);
    }
    let _e120 = fog_info.fog;
    let _e122 = (*color);
    let _e123 = density;
    let _e125 = d;
    return mix(_e120.xyz, _e122, vec3(clamp(exp((-(_e123) * _e125)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e84 = g_premultiply;
    let _e85 = (*alpha_2);
    weight_1 = select(1f, _e85, _e84);
    let _e87 = (*linearColor);
    param_3 = _e87;
    let _e88 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e89 = weight_1;
    let _e90 = (_e88 * _e89);
    let _e91 = (*alpha_2);
    let _e92 = g_pass_through;
    frag_color = vec4<f32>(_e90.x, _e90.y, _e90.z, (_e91 * (1f - _e92)));
    let _e99 = (*roughness_1);
    param_4 = _e99;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
    var param_5: vec3<f32>;
    var param_6: f32;
    var param_7: f32;

    let _e83 = (*linearColor_1);
    param_5 = _e83;
    let _e84 = (*alpha_3);
    param_6 = _e84;
    param_7 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_3: vec3<f32>;

    let _e79 = Orthographic_u0028_();
    if _e79 {
        let _e81 = fog_info.forward;
        local_3 = -(_e81.xyz);
    } else {
        let _e85 = fog_info.eye;
        let _e87 = v_world_position_1;
        local_3 = normalize((_e85.xyz - _e87));
    }
    let _e90 = local_3;
    return _e90;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin: vec3<f32>;
    var cell: vec3<f32>;
    var p3_: vec3<f32>;

    let _e84 = (*cutoff);
    key = (-2f - _e84);
    let _e86 = key;
    let _e89 = key;
    let _e91 = floor((_e89 / 128f));
    let _e96 = key;
    origin = vec3<f32>(floor((_e86 / 16384f)), (_e91 - (floor((_e91 / 128f)) * 128f)), (_e96 - (floor((_e96 / 128f)) * 128f)));
    let _e102 = (*scenePosition);
    let _e105 = origin;
    let _e106 = (floor((_e102 * 16f)) + _e105);
    let _e107 = vec3(128f);
    cell = (_e106 - (floor((_e106 / _e107)) * _e107));
    let _e112 = cell;
    p3_ = fract((_e112 * 0.1031f));
    let _e115 = p3_;
    let _e116 = p3_;
    let _e121 = p3_;
    p3_ = (_e121 + vec3(dot(_e115, (_e116.zyx + vec3(31.32f)))));
    let _e125 = p3_[0u];
    let _e127 = p3_[1u];
    let _e130 = p3_[2u];
    return fract(((_e125 + _e127) * _e130));
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e79 = (*srgb);
    let _e82 = (*srgb);
    let _e87 = (*srgb);
    return mix((_e79 / vec3(12.92f)), pow(((_e82 + 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), _e87));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e80 = frag_info.target_origin[1u];
    return _e80;
}

fn ReadSurface_u0028_() -> Surface {
    var texel: vec4<f32>;
    var s: Surface;
    var param_8: vec3<f32>;
    var param_9: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_10: vec3<f32>;
    var param_11: f32;

    let _e86 = v_texcoord_1;
    let _e87 = MaterialLodBias_u0028_();
    let _e88 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e86, _e87);
    texel = _e88;
    let _e89 = texel;
    param_8 = _e89.xyz;
    let _e91 = SrgbToLinear_u0028_vf3_u003b((&param_8));
    let _e93 = frag_info.base_color;
    param_9 = _e93.xyz;
    let _e95 = SrgbToLinear_u0028_vf3_u003b((&param_9));
    let _e97 = v_color_1;
    s.albedo = ((_e91 * _e95) * _e97.xyz);
    let _e102 = texel[3u];
    let _e105 = frag_info.base_color[3u];
    let _e108 = v_color_1[3u];
    s.alpha = ((_e102 * _e105) * _e108);
    let _e112 = s.albedo;
    g_albedo = _e112;
    let _e115 = frag_info.material2_[0u];
    cutoff_1 = _e115;
    let _e116 = cutoff_1;
    if (_e116 > 1f) {
        let _e118 = cutoff_1;
        edge = (_e118 - 1f);
        let _e121 = s.alpha;
        let _e122 = edge;
        let _e125 = s.alpha;
        let _e126 = fwidth(_e125);
        s.alpha = clamp((((_e121 - _e122) / max(_e126, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e132 = cutoff_1;
        if (_e132 >= 0f) {
            let _e135 = s.alpha;
            let _e136 = cutoff_1;
            if (_e135 < _e136) {
                discard;
            }
            s.alpha = 1f;
        } else {
            let _e139 = cutoff_1;
            if (_e139 < -1.5f) {
                let _e142 = s.alpha;
                let _e143 = v_world_position_1;
                param_10 = _e143;
                let _e144 = cutoff_1;
                param_11 = _e144;
                let _e145 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_10), (&param_11));
                if (_e142 < _e145) {
                    discard;
                }
            }
        }
    }
    let _e147 = cutoff_1;
    let _e149 = cutoff_1;
    g_premultiply = ((_e147 < 0f) && (_e149 > -0.75f));
    let _e152 = v_normal_1;
    s.n = normalize(_e152);
    let _e155 = gl_FrontFacing_1;
    if !(_e155) {
        let _e158 = s.n;
        s.n = -(_e158);
    }
    let _e161 = TowardsEye_u0028_();
    s.v = _e161;
    let _e164 = s.n;
    let _e166 = s.v;
    s.n_dot_v = max(dot(_e164, _e166), 0.0001f);
    let _e172 = frag_info.material[0u];
    s.metallic = clamp(_e172, 0f, 1f);
    let _e177 = frag_info.material[1u];
    s.roughness = clamp(_e177, 0.02f, 1f);
    let _e181 = frag_info.ambient_ground;
    let _e184 = frag_info.ambient_sky;
    let _e188 = s.n[1u];
    let _e195 = frag_info.material[2u];
    s.ambient = (mix(_e181.xyz, _e184.xyz, vec3(((_e188 * 0.5f) + 0.5f))) * _e195);
    let _e200 = frag_info.frame_params[0u];
    s.exposure = max(_e200, 0f);
    s.occlusion = 1f;
    s.emissive = vec3<f32>(0f, 0f, 0f);
    let _e205 = s;
    return _e205;
}

fn main_1() {
    var s_1: Surface;
    var param_12: vec3<f32>;
    var param_13: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e81 = ReadSurface_u0028_();
    s_1 = _e81;
    g_albedo = vec3<f32>(0f, 0f, 0f);
    let _e83 = s_1.albedo;
    param_12 = _e83;
    let _e85 = s_1.alpha;
    param_13 = _e85;
    WriteSurface_u0028_vf3_u003b_f1_u003b((&param_12), (&param_13));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e17 = frag_albedo;
    let _e18 = frag_surface;
    let _e19 = frag_color;
    return FragmentOutput(_e17, _e18, _e19);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Xray': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e71 = v_world_position_1;
    let _e73 = fog_info.eye;
    let _e77 = fog_info.forward;
    return dot((_e71 - _e73.xyz), _e77.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e76 = ViewDepth_u0028_();
    z = abs(_e76);
    let _e78 = z;
    near = (_e78 / 5f);
    let _e80 = z;
    far = (_e80 / 200f);
    let _e82 = far;
    let _e83 = far;
    let _e85 = far;
    far3_ = ((_e82 * _e83) * _e85);
    let _e87 = (*alpha);
    let _e88 = near;
    let _e89 = near;
    let _e92 = far3_;
    let _e93 = far3_;
    return (_e87 * clamp((10f / ((0.00001f + (_e88 * _e89)) + (_e92 * _e93))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e80 = fog_info.forward[3u];
    mode = _e80;
    let _e81 = mode;
    if (_e81 > 0.5f) {
        let _e84 = frag_color[3u];
        alpha_1 = _e84;
        let _e85 = alpha_1;
        param = _e85;
        let _e86 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e86;
        let _e87 = frag_color;
        let _e89 = weight;
        let _e90 = (_e87.xyz * _e89);
        let _e91 = alpha_1;
        let _e92 = weight;
        accumulate = vec4<f32>(_e90.x, _e90.y, _e90.z, (_e91 * _e92));
        let _e98 = mode;
        let _e100 = mode;
        revealage = ((_e98 > 1.5f) && (_e100 < 2.5f));
        let _e103 = revealage;
        if _e103 {
            let _e104 = alpha_1;
            local = vec4(_e104);
        } else {
            let _e106 = accumulate;
            local = _e106;
        }
        let _e107 = local;
        frag_color = _e107;
    }
    return;
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e73 = fog_info.projection[0u];
    return (_e73 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e72 = Orthographic_u0028_();
    if _e72 {
        let _e73 = ViewDepth_u0028_();
        local_1 = max(_e73, 0f);
    } else {
        let _e75 = v_world_position_1;
        let _e77 = fog_info.eye;
        local_1 = distance(_e75, _e77.xyz);
    }
    let _e80 = local_1;
    return _e80;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e79 = fog_info.fog[3u];
    density = _e79;
    let _e80 = density;
    if (_e80 <= 0f) {
        let _e82 = (*color);
        return _e82;
    }
    let _e83 = EyeDistance_u0028_();
    d = _e83;
    let _e86 = fog_info.eye[3u];
    falloff = _e86;
    let _e87 = falloff;
    if (_e87 > 0f) {
        let _e89 = falloff;
        let _e91 = v_world_position_1[1u];
        let _e94 = fog_info.eye[1u];
        k = (_e89 * (_e91 - _e94));
        let _e97 = k;
        if (abs(_e97) > 0.001f) {
            let _e100 = k;
            let _e104 = k;
            local_2 = ((1f - exp(-(_e100))) / _e104);
        } else {
            let _e106 = k;
            local_2 = (1f - (0.5f * _e106));
        }
        let _e109 = local_2;
        let _e110 = density;
        density = (_e110 * _e109);
    }
    let _e113 = fog_info.fog;
    let _e115 = (*color);
    let _e116 = density;
    let _e118 = d;
    return mix(_e113.xyz, _e115, vec3(clamp(exp((-(_e116) * _e118)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_1: vec3<f32>;
    var param_2: f32;

    let _e77 = g_premultiply;
    let _e78 = (*alpha_2);
    weight_1 = select(1f, _e78, _e77);
    let _e80 = (*linearColor);
    param_1 = _e80;
    let _e81 = ApplyFog_u0028_vf3_u003b((&param_1));
    let _e82 = weight_1;
    let _e83 = (_e81 * _e82);
    let _e84 = (*alpha_2);
    let _e85 = g_pass_through;
    frag_color = vec4<f32>(_e83.x, _e83.y, _e83.z, (_e84 * (1f - _e85)));
    let _e92 = (*roughness_1);
    param_2 = _e92;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_2));
    WriteWeightedBlended_u0028_();
    return;
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
    var param_3: vec3<f32>;
    var param_4: f32;
    var param_5: f32;

    let _e76 = (*linearColor_1);
    param_3 = _e76;
    let _e77 = (*alpha_3);
    param_4 = _e77;
    param_5 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_3), (&param_4), (&param_5));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_3: vec3<f32>;

    let _e72 = Orthographic_u0028_();
    if _e72 {
        let _e74 = fog_info.forward;
        local_3 = -(_e74.xyz);
    } else {
        let _e78 = fog_info.eye;
        let _e80 = v_world_position_1;
        local_3 = normalize((_e78.xyz - _e80));
    }
    let _e83 = local_3;
    return _e83;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin: vec3<f32>;
    var cell: vec3<f32>;
    var p3_: vec3<f32>;

    let _e77 = (*cutoff);
    key = (-2f - _e77);
    let _e79 = key;
    let _e82 = key;
    let _e84 = floor((_e82 / 128f));
    let _e89 = key;
    origin = vec3<f32>(floor((_e79 / 16384f)), (_e84 - (floor((_e84 / 128f)) * 128f)), (_e89 - (floor((_e89 / 128f)) * 128f)));
    let _e95 = (*scenePosition);
    let _e98 = origin;
    let _e99 = (floor((_e95 * 16f)) + _e98);
    let _e100 = vec3(128f);
    cell = (_e99 - (floor((_e99 / _e100)) * _e100));
    let _e105 = cell;
    p3_ = fract((_e105 * 0.1031f));
    let _e108 = p3_;
    let _e109 = p3_;
    let _e114 = p3_;
    p3_ = (_e114 + vec3(dot(_e108, (_e109.zyx + vec3(31.32f)))));
    let _e118 = p3_[0u];
    let _e120 = p3_[1u];
    let _e123 = p3_[2u];
    return fract(((_e118 + _e120) * _e123));
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e72 = (*srgb);
    let _e75 = (*srgb);
    let _e80 = (*srgb);
    return mix((_e72 / vec3(12.92f)), pow(((_e75 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e80));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e73 = frag_info.target_origin[1u];
    return _e73;
}

fn ReadSurface_u0028_() -> Surface {
    var texel: vec4<f32>;
    var s: Surface;
    var param_6: vec3<f32>;
    var param_7: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_8: vec3<f32>;
    var param_9: f32;

    let _e79 = v_texcoord_1;
    let _e80 = MaterialLodBias_u0028_();
    let _e81 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e79, _e80);
    texel = _e81;
    let _e82 = texel;
    param_6 = _e82.xyz;
    let _e84 = SrgbToLinear_u0028_vf3_u003b((&param_6));
    let _e86 = frag_info.base_color;
    param_7 = _e86.xyz;
    let _e88 = SrgbToLinear_u0028_vf3_u003b((&param_7));
    let _e90 = v_color_1;
    s.albedo = ((_e84 * _e88) * _e90.xyz);
    let _e95 = texel[3u];
    let _e98 = frag_info.base_color[3u];
    let _e101 = v_color_1[3u];
    s.alpha = ((_e95 * _e98) * _e101);
    let _e105 = s.albedo;
    g_albedo = _e105;
    let _e108 = frag_info.material2_[0u];
    cutoff_1 = _e108;
    let _e109 = cutoff_1;
    if (_e109 > 1f) {
        let _e111 = cutoff_1;
        edge = (_e111 - 1f);
        let _e114 = s.alpha;
        let _e115 = edge;
        let _e118 = s.alpha;
        let _e119 = fwidth(_e118);
        s.alpha = clamp((((_e114 - _e115) / max(_e119, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e125 = cutoff_1;
        if (_e125 >= 0f) {
            let _e128 = s.alpha;
            let _e129 = cutoff_1;
            if (_e128 < _e129) {
                discard;
            }
            s.alpha = 1f;
        } else {
            let _e132 = cutoff_1;
            if (_e132 < -1.5f) {
                let _e135 = s.alpha;
                let _e136 = v_world_position_1;
                param_8 = _e136;
                let _e137 = cutoff_1;
                param_9 = _e137;
                let _e138 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_8), (&param_9));
                if (_e135 < _e138) {
                    discard;
                }
            }
        }
    }
    let _e140 = cutoff_1;
    let _e142 = cutoff_1;
    g_premultiply = ((_e140 < 0f) && (_e142 > -0.75f));
    let _e145 = v_normal_1;
    s.n = normalize(_e145);
    let _e148 = gl_FrontFacing_1;
    if !(_e148) {
        let _e151 = s.n;
        s.n = -(_e151);
    }
    let _e154 = TowardsEye_u0028_();
    s.v = _e154;
    let _e157 = s.n;
    let _e159 = s.v;
    s.n_dot_v = max(dot(_e157, _e159), 0.0001f);
    let _e165 = frag_info.material[0u];
    s.metallic = clamp(_e165, 0f, 1f);
    let _e170 = frag_info.material[1u];
    s.roughness = clamp(_e170, 0.02f, 1f);
    let _e174 = frag_info.ambient_ground;
    let _e177 = frag_info.ambient_sky;
    let _e181 = s.n[1u];
    let _e188 = frag_info.material[2u];
    s.ambient = (mix(_e174.xyz, _e177.xyz, vec3(((_e181 * 0.5f) + 0.5f))) * _e188);
    let _e193 = frag_info.frame_params[0u];
    s.exposure = max(_e193, 0f);
    s.occlusion = 1f;
    s.emissive = vec3<f32>(0f, 0f, 0f);
    let _e198 = s;
    return _e198;
}

fn main_1() {
    var s_1: Surface;
    var param_10: vec3<f32>;
    var param_11: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e74 = ReadSurface_u0028_();
    s_1 = _e74;
    let _e76 = s_1.albedo;
    param_10 = _e76;
    let _e78 = s_1.alpha;
    param_11 = _e78;
    WriteSurface_u0028_vf3_u003b_f1_u003b((&param_10), (&param_11));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_world_position_1 = v_world_position;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PlanarReflection': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct PlanarReflectionInfo {
    view: vec4<f32>,
    params: vec4<f32>,
    tint: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> planar_info: PlanarReflectionInfo;
@group(1) @binding(2)
var reflection_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var reflection_texture_smp: sampler;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e33 = v_world_position_1;
    let _e35 = fog_info.eye;
    let _e39 = fog_info.forward;
    return dot((_e33 - _e35.xyz), _e39.xyz);
}

fn Orthographic_u0028_() -> bool {
    let _e35 = fog_info.projection[0u];
    return (_e35 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local: f32;

    let _e34 = Orthographic_u0028_();
    if _e34 {
        let _e35 = ViewDepth_u0028_();
        local = max(_e35, 0f);
    } else {
        let _e37 = v_world_position_1;
        let _e39 = fog_info.eye;
        local = distance(_e37, _e39.xyz);
    }
    let _e42 = local;
    return _e42;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;

    let _e41 = fog_info.fog[3u];
    density = _e41;
    let _e42 = density;
    if (_e42 <= 0f) {
        let _e44 = (*color);
        return _e44;
    }
    let _e45 = EyeDistance_u0028_();
    d = _e45;
    let _e48 = fog_info.eye[3u];
    falloff = _e48;
    let _e49 = falloff;
    if (_e49 > 0f) {
        let _e51 = falloff;
        let _e53 = v_world_position_1[1u];
        let _e56 = fog_info.eye[1u];
        k = (_e51 * (_e53 - _e56));
        let _e59 = k;
        if (abs(_e59) > 0.001f) {
            let _e62 = k;
            let _e66 = k;
            local_1 = ((1f - exp(-(_e62))) / _e66);
        } else {
            let _e68 = k;
            local_1 = (1f - (0.5f * _e68));
        }
        let _e71 = local_1;
        let _e72 = density;
        density = (_e72 * _e71);
    }
    let _e75 = fog_info.fog;
    let _e77 = (*color);
    let _e78 = density;
    let _e80 = d;
    return mix(_e75.xyz, _e77, vec3(clamp(exp((-(_e78) * _e80)), 0f, 1f)));
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_2: vec3<f32>;

    let _e34 = Orthographic_u0028_();
    if _e34 {
        let _e36 = fog_info.forward;
        local_2 = -(_e36.xyz);
    } else {
        let _e40 = fog_info.eye;
        let _e42 = v_world_position_1;
        local_2 = normalize((_e40.xyz - _e42));
    }
    let _e45 = local_2;
    return _e45;
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_3: vec2<f32>;

    let _e35 = (*rows);
    if (_e35 > 0f) {
        let _e38 = gl_FragCoord_1[0u];
        let _e39 = (*rows);
        let _e41 = gl_FragCoord_1[1u];
        local_3 = vec2<f32>(_e38, (_e39 - _e41));
    } else {
        let _e44 = gl_FragCoord_1;
        local_3 = _e44.xy;
    }
    let _e46 = local_3;
    return _e46;
}

fn main_1() {
    var rows_1: f32;
    var pixel: vec2<f32>;
    var param: f32;
    var uv: vec2<f32>;
    var reflected: vec3<f32>;
    var n: vec3<f32>;
    var v: vec3<f32>;
    var cosine: f32;
    var f0_: f32;
    var grazing: f32;
    var grazing2_: f32;
    var fresnel: f32;
    var alpha: f32;
    var param_1: vec3<f32>;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e49 = planar_info.params[2u];
    rows_1 = _e49;
    let _e50 = rows_1;
    param = _e50;
    let _e51 = FragCoordFromTop_u0028_f1_u003b((&param));
    pixel = _e51;
    let _e52 = pixel;
    let _e54 = planar_info.view;
    let _e58 = planar_info.view;
    uv = ((_e52 - _e54.xy) / _e58.zw);
    let _e61 = rows_1;
    if (_e61 > 0f) {
        let _e64 = uv[1u];
        uv[1u] = (1f - _e64);
    }
    let _e67 = uv;
    let _e68 = textureSampleLevel(reflection_texture_tex, reflection_texture_smp, _e67, 0f);
    let _e71 = planar_info.tint;
    reflected = (_e68.xyz * _e71.xyz);
    let _e74 = v_normal_1;
    n = normalize(_e74);
    let _e76 = gl_FrontFacing_1;
    if !(_e76) {
        let _e78 = n;
        n = -(_e78);
    }
    let _e80 = TowardsEye_u0028_();
    v = _e80;
    let _e81 = n;
    let _e82 = v;
    cosine = clamp(dot(_e81, _e82), 0f, 1f);
    let _e87 = planar_info.params[0u];
    f0_ = _e87;
    let _e88 = cosine;
    grazing = (1f - _e88);
    let _e90 = grazing;
    let _e91 = grazing;
    grazing2_ = (_e90 * _e91);
    let _e93 = f0_;
    let _e94 = f0_;
    let _e96 = grazing2_;
    let _e98 = grazing2_;
    let _e100 = grazing;
    fresnel = (_e93 + ((((1f - _e94) * _e96) * _e98) * _e100));
    let _e103 = fresnel;
    let _e106 = planar_info.params[1u];
    alpha = clamp((_e103 * _e106), 0f, 1f);
    let _e109 = reflected;
    param_1 = _e109;
    let _e110 = ApplyFog_u0028_vf3_u003b((&param_1));
    let _e111 = alpha;
    let _e112 = (_e110 * _e111);
    let _e113 = alpha;
    frag_color = vec4<f32>(_e112.x, _e112.y, _e112.z, _e113);
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_world_position_1 = v_world_position;
    gl_FragCoord_1 = gl_FragCoord;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_texcoord_1 = v_texcoord;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e17 = frag_color;
    return _e17;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PlanarReflectionInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'view', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'tint', offsetInBytes: 32, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'reflection_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Lambert': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e180 = v_world_position_1;
    let _e182 = fog_info.eye;
    let _e186 = fog_info.forward;
    return dot((_e180 - _e182.xyz), _e186.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e185 = ViewDepth_u0028_();
    z = abs(_e185);
    let _e187 = z;
    near = (_e187 / 5f);
    let _e189 = z;
    far = (_e189 / 200f);
    let _e191 = far;
    let _e192 = far;
    let _e194 = far;
    far3_ = ((_e191 * _e192) * _e194);
    let _e196 = (*alpha);
    let _e197 = near;
    let _e198 = near;
    let _e201 = far3_;
    let _e202 = far3_;
    return (_e196 * clamp((10f / ((0.00001f + (_e197 * _e198)) + (_e201 * _e202))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e189 = fog_info.forward[3u];
    mode = _e189;
    let _e190 = mode;
    if (_e190 > 0.5f) {
        let _e193 = frag_color[3u];
        alpha_1 = _e193;
        let _e194 = alpha_1;
        param = _e194;
        let _e195 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e195;
        let _e196 = frag_color;
        let _e198 = weight;
        let _e199 = (_e196.xyz * _e198);
        let _e200 = alpha_1;
        let _e201 = weight;
        accumulate = vec4<f32>(_e199.x, _e199.y, _e199.z, (_e200 * _e201));
        let _e207 = mode;
        let _e209 = mode;
        revealage = ((_e207 > 1.5f) && (_e209 < 2.5f));
        let _e212 = revealage;
        if _e212 {
            let _e213 = alpha_1;
            local = vec4(_e213);
        } else {
            let _e215 = accumulate;
            local = _e215;
        }
        let _e216 = local;
        frag_color = _e216;
        let _e217 = mode;
        if (_e217 > 2.5f) {
            let _e219 = alpha_1;
            frag_surface = vec4(_e219);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e183 = (*n)[0u];
    let _e186 = (*n)[1u];
    let _e190 = (*n)[2u];
    let _e193 = (*n);
    (*n) = (_e193 / vec3(((abs(_e183) + abs(_e186)) + abs(_e190))));
    let _e196 = (*n);
    e = _e196.xy;
    let _e199 = (*n)[2u];
    if (_e199 < 0f) {
        let _e201 = (*n);
        let _e207 = (*n)[0u];
        let _e211 = (*n)[1u];
        e = ((vec2(1f) - abs(_e201.yx)) * vec2<f32>(select(-1f, 1f, (_e207 >= 0f)), select(-1f, 1f, (_e211 >= 0f))));
    }
    let _e216 = e;
    return ((_e216 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e181 = (*linear);
    let _e183 = (*linear);
    let _e187 = (*linear);
    return mix((_e181 * 12.92f), ((pow(_e183, 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), _e187));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e184 = g_albedo;
    param_1 = clamp(_e184, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e186 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e186.x, _e186.y, _e186.z, 1f);
    let _e191 = g_debug_surface_on;
    if _e191 {
        let _e192 = g_debug_surface;
        let _e193 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e192.x, _e192.y, _e192.z, _e193);
        return;
    }
    let _e198 = v_normal_1;
    geometric = normalize(_e198);
    let _e200 = gl_FrontFacing_1;
    if !(_e200) {
        let _e202 = geometric;
        geometric = -(_e202);
    }
    let _e204 = geometric;
    param_2 = _e204;
    let _e205 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e206 = (*roughness);
    let _e208 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e205.x, _e205.y, clamp(_e206, 0f, 1f), _e208);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e182 = fog_info.projection[0u];
    return (_e182 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e181 = Orthographic_u0028_();
    if _e181 {
        let _e182 = ViewDepth_u0028_();
        local_1 = max(_e182, 0f);
    } else {
        let _e184 = v_world_position_1;
        let _e186 = fog_info.eye;
        local_1 = distance(_e184, _e186.xyz);
    }
    let _e189 = local_1;
    return _e189;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e188 = fog_info.fog[3u];
    density = _e188;
    let _e189 = density;
    if (_e189 <= 0f) {
        let _e191 = (*color);
        return _e191;
    }
    let _e192 = EyeDistance_u0028_();
    d = _e192;
    let _e195 = fog_info.eye[3u];
    falloff = _e195;
    let _e196 = falloff;
    if (_e196 > 0f) {
        let _e198 = falloff;
        let _e200 = v_world_position_1[1u];
        let _e203 = fog_info.eye[1u];
        k = (_e198 * (_e200 - _e203));
        let _e206 = k;
        if (abs(_e206) > 0.001f) {
            let _e209 = k;
            let _e213 = k;
            local_2 = ((1f - exp(-(_e209))) / _e213);
        } else {
            let _e215 = k;
            local_2 = (1f - (0.5f * _e215));
        }
        let _e218 = local_2;
        let _e219 = density;
        density = (_e219 * _e218);
    }
    let _e222 = fog_info.fog;
    let _e224 = (*color);
    let _e225 = density;
    let _e227 = d;
    return mix(_e222.xyz, _e224, vec3(clamp(exp((-(_e225) * _e227)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e186 = g_premultiply;
    let _e187 = (*alpha_2);
    weight_1 = select(1f, _e187, _e186);
    let _e189 = (*linearColor);
    param_3 = _e189;
    let _e190 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e191 = weight_1;
    let _e192 = (_e190 * _e191);
    let _e193 = (*alpha_2);
    let _e194 = g_pass_through;
    frag_color = vec4<f32>(_e192.x, _e192.y, _e192.z, (_e193 * (1f - _e194)));
    let _e201 = (*roughness_1);
    param_4 = _e201;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_3: f32;

    let _e183 = frag_info.material2_[2u];
    local_3 = floor((_e183 * 0.5f));
    let _e186 = local_3;
    return _e186;
}

fn DirectOcclusion_u0028_struct_u002d_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: ptr<function, Surface>) -> f32 {
    var local_4: f32;
    var local_5: f32;

    let _e183 = OcclusionTarget_u0028_();
    if (_e183 > 1.5f) {
        local_4 = 1f;
    } else {
        let _e186 = (*s).occlusion;
        local_4 = _e186;
    }
    let _e187 = local_4;
    local_5 = _e187;
    let _e188 = local_5;
    return _e188;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    let _e183 = (*s_1).albedo;
    return _e183;
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e181 = (*i);
    if (_e181 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e183 = (*i);
    if (_e183 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e185 = (*i);
    if (_e185 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e187 = (*i);
    if (_e187 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e189 = (*i);
    if (_e189 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e191 = (*i);
    if (_e191 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e193 = (*i);
    if (_e193 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e186 = (*i_1);
    param_5 = _e186;
    let _e187 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e187;
    let _e189 = p[0u];
    let _e190 = (*ca);
    let _e193 = p[1u];
    let _e194 = (*sa);
    let _e198 = p[0u];
    let _e199 = (*sa);
    let _e202 = p[1u];
    let _e203 = (*ca);
    let _e207 = (*radius);
    return (vec2<f32>(((_e189 * _e190) - (_e193 * _e194)), ((_e198 * _e199) + (_e202 * _e203))) * _e207);
}

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_6: vec2<f32>;
    var atlas: vec2<f32>;

    let _e189 = point_shadow.params[0u];
    inset = _e189;
    let _e190 = (*uv);
    let _e191 = (*offset);
    let _e193 = inset;
    let _e194 = inset;
    local_6 = clamp((_e190 + _e191), vec2(_e193), vec2((1f - _e194)));
    let _e199 = local_6;
    let _e200 = (*tile);
    atlas = ((_e199 + _e200) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e205 = point_shadow.params3_[0u];
    if (_e205 > 0.5f) {
        let _e208 = atlas[1u];
        atlas[1u] = (1f - _e208);
    }
    let _e211 = atlas;
    let _e212 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e211, 0f);
    let _e214 = atlas;
    let _e215 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e214, 0f);
    let _e218 = (*range);
    return (min(_e212.x, _e215.x) * _e218);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e190 = (*uv_1);
    param_6 = _e190;
    let _e191 = (*offset_1);
    param_7 = _e191;
    let _e192 = (*tile_1);
    param_8 = _e192;
    let _e193 = (*range_1);
    param_9 = _e193;
    let _e194 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e194;
    let _e195 = stored;
    let _e196 = (*range_1);
    if (_e195 >= (_e196 * 0.999f)) {
        return 1f;
    }
    let _e199 = (*receiver);
    let _e200 = stored;
    return select(1f, 0f, (_e199 > _e200));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e211 = point_shadow.params2_[1u];
    lightRadius = _e211;
    let _e214 = point_shadow.params2_[0u];
    minRadius = _e214;
    let _e217 = point_shadow.params2_[2u];
    maxRadius = _e217;
    let _e218 = lightRadius;
    if (_e218 <= 0f) {
        let _e220 = (*uv_2);
        param_10 = _e220;
        param_11 = vec2<f32>(0f, 0f);
        let _e221 = (*tile_2);
        param_12 = _e221;
        let _e222 = (*range_2);
        param_13 = _e222;
        let _e223 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e223;
        let _e224 = minRadius;
        return _e224;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e225 = i_2;
        if (_e225 < 8i) {
            let _e227 = i_2;
            param_14 = _e227;
            let _e228 = (*ca_1);
            param_15 = _e228;
            let _e229 = (*sa_1);
            param_16 = _e229;
            let _e230 = maxRadius;
            param_17 = _e230;
            let _e231 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e232 = (*uv_2);
            param_18 = _e232;
            param_19 = _e231;
            let _e233 = (*tile_2);
            param_20 = _e233;
            let _e234 = (*range_2);
            param_21 = _e234;
            let _e235 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e235;
            let _e236 = stored_1;
            let _e237 = (*range_2);
            if (_e236 >= (_e237 * 0.999f)) {
                continue;
            }
            let _e240 = stored_1;
            let _e241 = (*receiver_1);
            if (_e240 >= _e241) {
                continue;
            }
            let _e243 = stored_1;
            let _e244 = sum;
            sum = (_e244 + _e243);
            let _e246 = count;
            count = (_e246 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e248 = i_2;
            i_2 = (_e248 + 1i);
        }
    }
    let _e250 = count;
    if (_e250 < 0.5f) {
        return -1f;
    }
    let _e252 = sum;
    let _e253 = count;
    blocker = max((_e252 / _e253), 0.0001f);
    let _e256 = blocker;
    (*blockerOut) = _e256;
    let _e257 = lightRadius;
    let _e258 = (*receiver_1);
    let _e259 = blocker;
    let _e263 = blocker;
    world = ((_e257 * max((_e258 - _e259), 0f)) / _e263);
    let _e265 = world;
    let _e266 = (*receiver_1);
    let _e268 = (*tanHalf);
    let _e271 = minRadius;
    let _e272 = maxRadius;
    return clamp((_e265 / ((2f * _e266) * _e268)), _e271, _e272);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_7: vec2<f32>;

    let _e182 = (*rows);
    if (_e182 > 0f) {
        let _e185 = gl_FragCoord_1[0u];
        let _e186 = (*rows);
        let _e188 = gl_FragCoord_1[1u];
        local_7 = vec2<f32>(_e185, (_e186 - _e188));
    } else {
        let _e191 = gl_FragCoord_1;
        local_7 = _e191.xy;
    }
    let _e193 = local_7;
    return _e193;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_8: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2319_: bool;
    var phi_2380_: bool;

    let _e234 = (*lightIndex);
    let _e238 = point_shadow.slots[_e234][0u];
    slot = i32((_e238 + 0.5f));
    let _e241 = (*lightIndex);
    let _e245 = point_shadow.slots[_e241][0u];
    if (_e245 < 0f) {
        return 1f;
    }
    let _e249 = point_shadow.params[2u];
    strength = _e249;
    let _e250 = strength;
    if (_e250 <= 0f) {
        return 1f;
    }
    let _e252 = slot;
    let _e255 = point_shadow.lights[_e252];
    let _e257 = (*world_1);
    toLight = (_e255.xyz - _e257);
    let _e259 = toLight;
    toLightLength = max(length(_e259), 0.000001f);
    let _e262 = (*normal);
    let _e263 = toLight;
    let _e264 = toLightLength;
    nDotL = max(dot(_e262, (_e263 / vec3(_e264))), 0.15f);
    let _e269 = nDotL;
    let _e270 = nDotL;
    let _e275 = nDotL;
    let _e276 = nDotL;
    slope = min((sqrt(max((1f - (_e269 * _e270)), 0f)) / (_e275 * _e276)), 8f);
    let _e280 = toLightLength;
    let _e282 = (*lightIndex);
    let _e286 = point_shadow.slots[_e282][2u];
    let _e291 = point_shadow.params3_[1u];
    texel = (((2f * _e280) * max(_e286, 0.0001f)) * _e291);
    let _e293 = (*world_1);
    let _e294 = (*normal);
    let _e295 = texel;
    let _e299 = point_shadow.params[3u];
    let _e301 = slope;
    origin = (_e293 + (((_e294 * _e295) * _e299) * (1f + _e301)));
    let _e305 = origin;
    let _e306 = slot;
    let _e309 = point_shadow.lights[_e306];
    toFragment = (_e305 - _e309.xyz);
    let _e312 = toFragment;
    distance_ = length(_e312);
    let _e314 = slot;
    let _e318 = point_shadow.lights[_e314][3u];
    range_3 = max(_e318, 0.0001f);
    let _e320 = distance_;
    let _e321 = range_3;
    if (_e320 >= _e321) {
        return 1f;
    }
    face = 0i;
    let _e323 = (*lightIndex);
    let _e327 = point_shadow.slots[_e323][1u];
    if (_e327 < 0.5f) {
        let _e329 = toFragment;
        a = abs(_e329);
        let _e332 = a[0u];
        let _e334 = a[1u];
        let _e335 = (_e332 >= _e334);
        phi_2319_ = _e335;
        if _e335 {
            let _e337 = a[0u];
            let _e339 = a[2u];
            phi_2319_ = (_e337 >= _e339);
        }
        let _e342 = phi_2319_;
        if _e342 {
            let _e344 = toFragment[0u];
            face = select(1i, 0i, (_e344 > 0f));
        } else {
            let _e348 = a[1u];
            let _e350 = a[2u];
            if (_e348 >= _e350) {
                let _e353 = toFragment[1u];
                face = select(3i, 2i, (_e353 > 0f));
            } else {
                let _e357 = toFragment[2u];
                face = select(5i, 4i, (_e357 > 0f));
            }
        }
    }
    let _e360 = slot;
    let _e362 = face;
    let _e366 = point_shadow.faces[((_e360 * 6i) + _e362)];
    let _e367 = origin;
    clip = (_e366 * vec4<f32>(_e367.x, _e367.y, _e367.z, 1f));
    let _e374 = clip[3u];
    if (_e374 <= 0f) {
        return 1f;
    }
    let _e376 = clip;
    let _e379 = clip[3u];
    ndc = (_e376.xy / vec2(_e379));
    let _e383 = ndc[0u];
    let _e385 = (abs(_e383) > 1f);
    phi_2380_ = _e385;
    if !(_e385) {
        let _e388 = ndc[1u];
        phi_2380_ = (abs(_e388) > 1f);
    }
    let _e392 = phi_2380_;
    if _e392 {
        return 1f;
    }
    let _e394 = ndc[0u];
    let _e398 = ndc[1u];
    uv_3 = vec2<f32>(((_e394 * 0.5f) + 0.5f), (0.5f - (_e398 * 0.5f)));
    let _e402 = face;
    let _e404 = slot;
    tile_3 = vec2<f32>(f32(_e402), f32(_e404));
    let _e407 = distance_;
    let _e410 = point_shadow.params[1u];
    receiver_2 = (_e407 - _e410);
    let _e414 = frag_info.target_origin[0u];
    param_22 = _e414;
    let _e415 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e415, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e420 = noise;
    angle = (_e420 * 6.2831855f);
    let _e422 = angle;
    ca_2 = cos(_e422);
    let _e424 = angle;
    sa_2 = sin(_e424);
    let _e426 = (*lightIndex);
    let _e430 = point_shadow.slots[_e426][2u];
    tanHalf_1 = max(_e430, 0.0001f);
    blocker_1 = -1f;
    let _e432 = uv_3;
    param_23 = _e432;
    let _e433 = tile_3;
    param_24 = _e433;
    let _e434 = range_3;
    param_25 = _e434;
    let _e435 = receiver_2;
    param_26 = _e435;
    let _e436 = ca_2;
    param_27 = _e436;
    let _e437 = sa_2;
    param_28 = _e437;
    let _e438 = tanHalf_1;
    param_29 = _e438;
    let _e439 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e440 = param_30;
    blocker_1 = _e440;
    radius_1 = _e439;
    let _e443 = point_shadow.params2_[3u];
    if (_e443 > 0.5f) {
        g_debug_surface_on = true;
        let _e445 = radius_1;
        if (_e445 < 0f) {
            local_8 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e447 = radius_1;
            let _e450 = point_shadow.params2_[2u];
            let _e454 = blocker_1;
            let _e455 = range_3;
            local_8 = vec3<f32>(clamp((_e447 / max(_e450, 0.000001f)), 0f, 1f), clamp((_e454 / _e455), 0f, 1f), 0f);
        }
        let _e459 = local_8;
        g_debug_surface = _e459;
    }
    let _e460 = radius_1;
    if (_e460 < 0f) {
        return 1f;
    }
    let _e462 = uv_3;
    param_31 = _e462;
    param_32 = vec2<f32>(0f, 0f);
    let _e463 = tile_3;
    param_33 = _e463;
    let _e464 = range_3;
    param_34 = _e464;
    let _e465 = receiver_2;
    param_35 = _e465;
    let _e466 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e466;
    let _e467 = radius_1;
    if (_e467 > 0f) {
        i_3 = 0i;
        loop {
            let _e469 = i_3;
            if (_e469 < 8i) {
                let _e471 = i_3;
                param_36 = _e471;
                let _e472 = ca_2;
                param_37 = _e472;
                let _e473 = sa_2;
                param_38 = _e473;
                let _e474 = radius_1;
                param_39 = _e474;
                let _e475 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e476 = uv_3;
                param_40 = _e476;
                param_41 = _e475;
                let _e477 = tile_3;
                param_42 = _e477;
                let _e478 = range_3;
                param_43 = _e478;
                let _e479 = receiver_2;
                param_44 = _e479;
                let _e480 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e481 = lit;
                lit = (_e481 + _e480);
                continue;
            } else {
                break;
            }
            continuing {
                let _e483 = i_3;
                i_3 = (_e483 + 1i);
            }
        }
        let _e485 = lit;
        lit = (_e485 * 0.11111111f);
    }
    let _e487 = lit;
    let _e488 = strength;
    return mix(1f, _e487, clamp(_e488, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e185 = (*i_4);
    let _e188 = (*n_1);
    r = sqrt(((f32(_e185) + 0.5f) / f32(_e188)));
    let _e192 = (*i_4);
    let _e195 = (*turn);
    theta = ((f32(_e192) * 2.3999631f) + _e195);
    let _e197 = r;
    let _e198 = theta;
    let _e200 = theta;
    return (vec2<f32>(cos(_e198), sin(_e200)) * _e197);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e184 = frag_info.target_origin[0u];
    param_45 = _e184;
    let _e185 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e188 = frag_info.target_origin[3u];
    at = (_e185 + vec2((5.588238f * max(_e188, 0f))));
    let _e193 = at;
    return fract((52.982918f * fract(dot(_e193, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_9: f32;

    let _e183 = (*mode_1);
    if (_e183 > 0.5f) {
        let _e185 = (*stored_2);
        local_9 = (1f - _e185);
    } else {
        let _e187 = (*stored_2);
        local_9 = _e187;
    }
    let _e188 = local_9;
    return _e188;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e189 = (*moments)[1u];
    let _e191 = (*moments)[0u];
    let _e193 = (*moments)[0u];
    let _e196 = (*minVariance);
    variance = max((_e189 - (_e191 * _e193)), _e196);
    let _e198 = (*t);
    let _e200 = (*moments)[0u];
    d_1 = (_e198 - _e200);
    let _e202 = variance;
    let _e203 = variance;
    let _e204 = d_1;
    let _e205 = d_1;
    pMax = (_e202 / (_e203 + (_e204 * _e205)));
    let _e209 = pMax;
    let _e210 = (*bleed);
    let _e212 = (*bleed);
    reduced = clamp(((_e209 - _e210) / max((1f - _e212), 0.0001f)), 0f, 1f);
    let _e217 = (*t);
    let _e219 = (*moments)[0u];
    let _e221 = reduced;
    return select(_e221, 1f, (_e217 <= _e219));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e182 = (*depth);
    d_2 = ((2f * clamp(_e182, 0f, 1f)) - 1f);
    let _e186 = d_2;
    let _e189 = d_2;
    return vec2<f32>(exp((40f * _e186)), -(exp((-5f * _e189))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e196 = (*depth_1);
    param_46 = _e196;
    let _e197 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e197;
    let _e198 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e198);
    let _e201 = scale[0u];
    let _e203 = scale[0u];
    let _e205 = (*moments_1);
    param_47 = _e205.xy;
    let _e208 = warped[0u];
    param_48 = _e208;
    param_49 = (_e201 * _e203);
    let _e209 = (*bleed_1);
    param_50 = _e209;
    let _e210 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e210;
    let _e212 = scale[1u];
    let _e214 = scale[1u];
    let _e216 = (*moments_1);
    param_51 = _e216.zw;
    let _e219 = warped[1u];
    param_52 = _e219;
    param_53 = (_e212 * _e214);
    let _e220 = (*bleed_1);
    param_54 = _e220;
    let _e221 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e221;
    let _e222 = positive;
    let _e223 = negative;
    return min(_e222, _e223);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e182 = (*depth_2);
    stored_3 = max((1f - _e182), 0.000061035156f);
    let _e185 = stored_3;
    return exp2((floor(log2(_e185)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_10: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_11: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_13: f32;
    var local_14: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_3492_: bool;
    var phi_3503_: bool;
    var phi_3664_: bool;
    var phi_3671_: bool;
    var phi_3678_: bool;

    let _e261 = frag_info.shadow_params[3u];
    strength_1 = _e261;
    let _e262 = strength_1;
    if (_e262 <= 0f) {
        return 1f;
    }
    let _e264 = (*lightIndex_1);
    let _e267 = frag_info.frame_params[2u];
    if (_e264 != i32(floor((_e267 + 0.5f)))) {
        return 1f;
    }
    let _e274 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e274 + 0.5f));
    let _e277 = Orthographic_u0028_();
    if _e277 {
        let _e278 = ViewDepth_u0028_();
        local_10 = _e278;
    } else {
        let _e279 = v_world_position_1;
        let _e281 = frag_info.camera_position;
        local_10 = length((_e279 - _e281.xyz));
    }
    let _e285 = local_10;
    viewDistance = _e285;
    cascade = 0i;
    let _e286 = cascadeCount;
    let _e287 = (_e286 > 1i);
    phi_3492_ = _e287;
    if _e287 {
        let _e288 = viewDistance;
        let _e291 = frag_info.shadow_cascades[0u];
        phi_3492_ = (_e288 > _e291);
    }
    let _e294 = phi_3492_;
    if _e294 {
        cascade = 1i;
    }
    let _e295 = cascadeCount;
    let _e296 = (_e295 > 2i);
    phi_3503_ = _e296;
    if _e296 {
        let _e297 = viewDistance;
        let _e300 = frag_info.shadow_cascades[1u];
        phi_3503_ = (_e297 > _e300);
    }
    let _e303 = phi_3503_;
    if _e303 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e304 = attempt;
        if (_e304 < 3i) {
            let _e306 = cascade;
            let _e307 = attempt;
            which = (_e306 + _e307);
            let _e309 = which;
            let _e310 = cascadeCount;
            if (_e309 >= _e310) {
                break;
            }
            let _e312 = which;
            if (_e312 == 0i) {
                let _e315 = frag_info.shadow_matrix;
                local_11 = _e315;
            } else {
                let _e316 = which;
                if (_e316 == 1i) {
                    let _e319 = frag_info.shadow_matrix_far;
                    local_12 = _e319;
                } else {
                    let _e321 = frag_info.shadow_matrix_farthest;
                    local_12 = _e321;
                }
                let _e322 = local_12;
                local_11 = _e322;
            }
            let _e323 = local_11;
            matrix = _e323;
            let _e326 = matrix[0][0u];
            let _e329 = matrix[1][0u];
            let _e332 = matrix[2][0u];
            axisX = vec3<f32>(_e326, _e329, _e332);
            let _e336 = matrix[0][1u];
            let _e339 = matrix[1][1u];
            let _e342 = matrix[2][1u];
            axisY = vec3<f32>(_e336, _e339, _e342);
            let _e344 = axisX;
            rowX = max(length(_e344), 0.000001f);
            let _e347 = axisY;
            rowY = max(length(_e347), 0.000001f);
            let _e352 = frag_info.shadow_cascades[3u];
            let _e354 = rowX;
            texelMetres = ((2f * _e352) / _e354);
            let _e358 = frag_info.shadow_cascades[3u];
            let _e361 = (*s_2).n;
            let _e362 = axisX;
            let _e365 = rowX;
            let _e366 = rowX;
            let _e370 = (*s_2).n;
            let _e371 = axisY;
            let _e374 = rowY;
            let _e375 = rowY;
            reach = ((3f * _e358) * ((abs(dot(_e361, _e362)) / (_e365 * _e366)) + (abs(dot(_e370, _e371)) / (_e374 * _e375))));
            let _e382 = frag_info.shadow_params[2u];
            let _e383 = texelMetres;
            flatOffset = min(_e382, _e383);
            let _e385 = v_world_position_1;
            let _e387 = (*s_2).n;
            let _e388 = flatOffset;
            let _e389 = reach;
            origin_1 = (_e385 + (_e387 * (_e388 + _e389)));
            let _e393 = matrix;
            let _e394 = origin_1;
            lightSpace = (_e393 * vec4<f32>(_e394.x, _e394.y, _e394.z, 1f));
            let _e401 = lightSpace[3u];
            if (_e401 <= 0f) {
                continue;
            }
            let _e403 = lightSpace;
            let _e406 = lightSpace[3u];
            candidate = (_e403.xyz / vec3(_e406));
            let _e410 = candidate[0u];
            let _e414 = candidate[1u];
            inTile = vec2<f32>(((_e410 * 0.5f) + 0.5f), (0.5f - (_e414 * 0.5f)));
            let _e419 = inTile[0u];
            let _e420 = (_e419 < 0f);
            phi_3664_ = _e420;
            if !(_e420) {
                let _e423 = inTile[0u];
                phi_3664_ = (_e423 > 1f);
            }
            let _e426 = phi_3664_;
            phi_3671_ = _e426;
            if !(_e426) {
                let _e429 = inTile[1u];
                phi_3671_ = (_e429 < 0f);
            }
            let _e432 = phi_3671_;
            phi_3678_ = _e432;
            if !(_e432) {
                let _e435 = inTile[1u];
                phi_3678_ = (_e435 > 1f);
            }
            let _e438 = phi_3678_;
            if _e438 {
                continue;
            }
            let _e440 = candidate[2u];
            if (_e440 > 1f) {
                let _e442 = which;
                let _e443 = cascadeCount;
                if (_e442 < (_e443 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e448 = inTile[0u];
            let _e449 = which;
            let _e452 = cascadeCount;
            let _e456 = inTile[1u];
            uv_4 = vec2<f32>(((_e448 + f32(_e449)) / f32(_e452)), _e456);
            let _e458 = candidate;
            projected = _e458;
            let _e459 = which;
            cascade = _e459;
            let _e460 = texelMetres;
            cascadeTexel = _e460;
            let _e463 = matrix[0][2u];
            let _e466 = matrix[1][2u];
            let _e469 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e463, _e466, _e469)), 0.000001f));
            let _e475 = (*s_2).n;
            let _e478 = matrix[0][2u];
            let _e481 = matrix[1][2u];
            let _e484 = matrix[2][2u];
            let _e488 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e475, vec3<f32>(_e478, _e481, _e484))) * _e488), 0.1f, 1f);
            let _e491 = texelMetres;
            let _e492 = cosSlope;
            let _e493 = cosSlope;
            let _e499 = cosSlope;
            let _e501 = cascadeDepth;
            receiverSlope = (((_e491 * sqrt(max((1f - (_e492 * _e493)), 0f))) / _e499) / _e501);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e503 = attempt;
            attempt = (_e503 + 1i);
        }
    }
    let _e505 = found;
    if !(_e505) {
        return 1f;
    }
    let _e507 = cascade;
    if (_e507 == 0i) {
        let _e511 = frag_info.shadow_bias[0u];
        local_13 = _e511;
    } else {
        let _e512 = cascade;
        if (_e512 == 1i) {
            let _e516 = frag_info.shadow_bias[1u];
            local_14 = _e516;
        } else {
            let _e519 = frag_info.shadow_bias[2u];
            local_14 = _e519;
        }
        let _e520 = local_14;
        local_13 = _e520;
    }
    let _e521 = local_13;
    bias = _e521;
    let _e524 = frag_info.shadow_params[1u];
    storage_ = _e524;
    let _e525 = storage_;
    let _e527 = storage_;
    if ((_e525 > 0.5f) && (_e527 < 1.5f)) {
        let _e530 = bias;
        let _e532 = projected[2u];
        param_55 = _e532;
        let _e533 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e530, _e533);
    }
    let _e537 = frag_info.shadow_params[0u];
    let _e540 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e537, _e540);
    let _e542 = cascade;
    let _e544 = cascadeCount;
    let _e548 = texel_1;
    tileLo = (vec2<f32>((f32(_e542) / f32(_e544)), 0f) + (_e548 * 0.5f));
    let _e551 = cascade;
    let _e554 = cascadeCount;
    let _e558 = texel_1;
    tileHi = (vec2<f32>((f32((_e551 + 1i)) / f32(_e554)), 1f) - (_e558 * 0.5f));
    let _e563 = frag_info.shadow_bias[3u];
    if (_e563 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e565 = y;
            if (_e565 <= 1i) {
                x = -1i;
                loop {
                    let _e567 = x;
                    if (_e567 <= 1i) {
                        let _e569 = uv_4;
                        let _e570 = x;
                        let _e572 = y;
                        let _e575 = texel_1;
                        let _e578 = tileLo;
                        let _e579 = tileHi;
                        let _e581 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e569 + (vec2<f32>(f32(_e570), f32(_e572)) * _e575)), _e578, _e579), 0f);
                        let _e582 = stored_4;
                        stored_4 = (_e582 + _e581);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e584 = x;
                        x = (_e584 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e586 = y;
                y = (_e586 + 1i);
            }
        }
        let _e588 = stored_4;
        stored_4 = (_e588 * 0.11111111f);
        let _e591 = stored_4[1u];
        let _e594 = stored_4[2u];
        let _e597 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e591), (1f - _e594), _e597), vec3(0f), vec3(4f));
        let _e602 = through;
        let _e603 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e602, vec3(clamp(_e603, 0f, 1f)));
    }
    let _e609 = frag_info.ambient_ground[3u];
    softness = _e609;
    lit_1 = 0f;
    let _e610 = softness;
    if (_e610 < 0f) {
        let _e612 = uv_4;
        let _e613 = tileLo;
        let _e614 = tileHi;
        let _e616 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e612, _e613, _e614), 0f);
        moments_2 = _e616;
        let _e618 = projected[2u];
        let _e619 = bias;
        let _e621 = softness;
        let _e625 = moments_2;
        param_56 = _e625;
        param_57 = (_e618 - _e619);
        param_58 = clamp((-(_e621) - 1f), 0f, 0.95f);
        let _e626 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e626;
    } else {
        let _e627 = softness;
        if (_e627 <= 0f) {
            y_1 = -1i;
            loop {
                let _e629 = y_1;
                if (_e629 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e631 = x_1;
                        if (_e631 <= 1i) {
                            let _e633 = uv_4;
                            let _e634 = x_1;
                            let _e636 = y_1;
                            let _e639 = texel_1;
                            let _e642 = tileLo;
                            let _e643 = tileHi;
                            let _e645 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e633 + (vec2<f32>(f32(_e634), f32(_e636)) * _e639)), _e642, _e643), 0f);
                            param_59 = _e645.x;
                            let _e647 = storage_;
                            param_60 = _e647;
                            let _e648 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e648;
                            let _e650 = projected[2u];
                            let _e651 = bias;
                            let _e653 = occluder;
                            let _e656 = lit_1;
                            lit_1 = (_e656 + select(1f, 0f, ((_e650 - _e651) > _e653)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e658 = x_1;
                            x_1 = (_e658 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e660 = y_1;
                    y_1 = (_e660 + 1i);
                }
            }
            let _e662 = lit_1;
            lit_1 = (_e662 * 0.11111111f);
        } else {
            let _e664 = softness;
            spread = tan(min(_e664, 0.5f));
            let _e667 = ShadowNoise_u0028_();
            turn_1 = (_e667 * 6.2831855f);
            let _e669 = spread;
            let _e671 = projected[2u];
            let _e673 = cascadeDepth;
            let _e675 = cascadeTexel;
            searchRadius = clamp((((_e669 * _e671) * _e673) / _e675), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e678 = i_5;
                if (_e678 < 16i) {
                    let _e680 = i_5;
                    param_61 = _e680;
                    param_62 = 16i;
                    let _e681 = turn_1;
                    param_63 = _e681;
                    let _e682 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e682;
                    let _e683 = bias;
                    let _e684 = disc;
                    let _e686 = searchRadius;
                    let _e690 = receiverSlope;
                    tapBias = (_e683 + (max(((length(_e684) * _e686) - 1.5f), 0f) * _e690));
                    let _e693 = uv_4;
                    let _e694 = disc;
                    let _e695 = texel_1;
                    let _e697 = searchRadius;
                    let _e700 = tileLo;
                    let _e701 = tileHi;
                    let _e703 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e693 + ((_e694 * _e695) * _e697)), _e700, _e701), 0f);
                    param_64 = _e703.x;
                    let _e705 = storage_;
                    param_65 = _e705;
                    let _e706 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e706;
                    let _e708 = projected[2u];
                    let _e709 = tapBias;
                    let _e711 = occluder_1;
                    if ((_e708 - _e709) > _e711) {
                        let _e713 = occluder_1;
                        let _e714 = blockerSum;
                        blockerSum = (_e714 + _e713);
                        let _e716 = blockerCount;
                        blockerCount = (_e716 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e718 = i_5;
                    i_5 = (_e718 + 1i);
                }
            }
            let _e720 = blockerCount;
            if (_e720 <= 0f) {
                return 1f;
            }
            let _e723 = projected[2u];
            let _e724 = blockerSum;
            let _e725 = blockerCount;
            let _e729 = cascadeDepth;
            gap = (max((_e723 - (_e724 / _e725)), 0f) * _e729);
            let _e731 = spread;
            let _e732 = gap;
            let _e734 = cascadeTexel;
            radius_2 = clamp(((_e731 * _e732) / _e734), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e737 = i_6;
                if (_e737 < 16i) {
                    let _e739 = turn_1;
                    let _e741 = i_6;
                    param_66 = _e741;
                    param_67 = 16i;
                    param_68 = (_e739 + 1f);
                    let _e742 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e742;
                    let _e743 = bias;
                    let _e744 = disc_1;
                    let _e746 = radius_2;
                    let _e750 = receiverSlope;
                    tapBias_1 = (_e743 + (max(((length(_e744) * _e746) - 1.5f), 0f) * _e750));
                    let _e753 = uv_4;
                    let _e754 = disc_1;
                    let _e755 = texel_1;
                    let _e757 = radius_2;
                    let _e760 = tileLo;
                    let _e761 = tileHi;
                    let _e763 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e753 + ((_e754 * _e755) * _e757)), _e760, _e761), 0f);
                    param_69 = _e763.x;
                    let _e765 = storage_;
                    param_70 = _e765;
                    let _e766 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e766;
                    let _e768 = projected[2u];
                    let _e769 = tapBias_1;
                    let _e771 = occluder_2;
                    let _e774 = lit_1;
                    lit_1 = (_e774 + select(1f, 0f, ((_e768 - _e769) > _e771)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e776 = i_6;
                    i_6 = (_e776 + 1i);
                }
            }
            let _e778 = lit_1;
            lit_1 = (_e778 * 0.0625f);
        }
    }
    let _e780 = lit_1;
    let _e781 = strength_1;
    return mix(1f, _e780, clamp(_e781, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e186 = (*s_3);
    param_71 = _e186;
    let _e187 = (*light_2);
    param_72 = _e187;
    let _e188 = (*index);
    param_73 = _e188;
    let _e189 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e189;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e181 = (*index_1);
    return (_e181 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e185 = (*distance_1);
    let _e186 = (*distance_1);
    attenuation = (1f / max((_e185 * _e186), 0.0001f));
    let _e190 = (*range_4);
    if (_e190 > 0f) {
        let _e192 = (*distance_1);
        let _e193 = (*range_4);
        ratio = (_e192 / _e193);
        let _e195 = ratio;
        let _e196 = ratio;
        let _e198 = ratio;
        let _e200 = ratio;
        window = clamp((1f - (((_e195 * _e196) * _e198) * _e200)), 0f, 1f);
        let _e204 = window;
        let _e205 = window;
        let _e207 = attenuation;
        attenuation = (_e207 * (_e204 * _e205));
    }
    let _e209 = attenuation;
    return _e209;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_15: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e197 = (*halfWidth);
    let _e198 = (*halfHeight);
    n_2 = cross(_e197, _e198);
    let _e200 = n_2;
    nLen = length(_e200);
    let _e202 = nLen;
    if (_e202 < 0.000000000001f) {
        let _e204 = (*centre);
        return _e204;
    }
    let _e205 = nLen;
    let _e206 = n_2;
    n_2 = (_e206 / vec3(_e205));
    let _e209 = (*centre);
    let _e210 = (*world_2);
    toPlane = (_e209 - _e210);
    let _e212 = (*mirror);
    let _e213 = n_2;
    denom = dot(_e212, _e213);
    let _e215 = denom;
    if (abs(_e215) < 0.00001f) {
        let _e218 = toPlane;
        let _e219 = n_2;
        let _e220 = toPlane;
        let _e221 = n_2;
        onPlane = (_e218 - (_e219 * dot(_e220, _e221)));
    } else {
        let _e225 = toPlane;
        let _e226 = n_2;
        let _e228 = denom;
        t_1 = (dot(_e225, _e226) / _e228);
        let _e230 = t_1;
        if (_e230 > 0f) {
            let _e232 = (*mirror);
            let _e233 = t_1;
            local_15 = (_e232 * _e233);
        } else {
            let _e235 = toPlane;
            let _e236 = n_2;
            let _e237 = toPlane;
            let _e238 = n_2;
            local_15 = (_e235 - (_e236 * dot(_e237, _e238)));
        }
        let _e242 = local_15;
        onPlane = _e242;
    }
    let _e243 = onPlane;
    let _e244 = toPlane;
    offset_2 = (_e243 - _e244);
    let _e246 = (*halfWidth);
    let _e247 = (*halfWidth);
    wLen2_ = max(dot(_e246, _e247), 0.000000000001f);
    let _e250 = (*halfHeight);
    let _e251 = (*halfHeight);
    hLen2_ = max(dot(_e250, _e251), 0.000000000001f);
    let _e254 = offset_2;
    let _e255 = (*halfWidth);
    let _e257 = wLen2_;
    u = clamp((dot(_e254, _e255) / _e257), -1f, 1f);
    let _e260 = offset_2;
    let _e261 = (*halfHeight);
    let _e263 = hLen2_;
    v = clamp((dot(_e260, _e261) / _e263), -1f, 1f);
    let _e266 = (*centre);
    let _e267 = (*halfWidth);
    let _e268 = u;
    let _e271 = (*halfHeight);
    let _e272 = v;
    return ((_e266 + (_e267 * _e268)) + (_e271 * _e272));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_16: f32;

    let _e189 = (*a_1);
    let _e190 = (*a_1);
    ua = (_e189 / vec3(max(length(_e190), 0.000000000001f)));
    let _e195 = (*b);
    let _e196 = (*b);
    ub = (_e195 / vec3(max(length(_e196), 0.000000000001f)));
    let _e201 = ua;
    let _e202 = ub;
    angle_1 = acos(clamp(dot(_e201, _e202), -1f, 1f));
    let _e206 = ua;
    let _e207 = ub;
    axis = cross(_e206, _e207);
    let _e209 = axis;
    len = length(_e209);
    let _e211 = len;
    if (_e211 > 0.000001f) {
        let _e213 = angle_1;
        let _e214 = axis;
        let _e215 = (*n_3);
        let _e218 = len;
        local_16 = ((_e213 * dot(_e214, _e215)) / _e218);
    } else {
        local_16 = 0f;
    }
    let _e220 = local_16;
    return _e220;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_17: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_18: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_19: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e203 = i_7;
        if (_e203 < 4i) {
            let _e205 = i_7;
            let _e207 = (*corners)[_e205];
            a_2 = _e207;
            let _e208 = i_7;
            if (_e208 == 3i) {
                local_17 = 0i;
            } else {
                let _e210 = i_7;
                local_17 = (_e210 + 1i);
            }
            let _e212 = local_17;
            let _e214 = (*corners)[_e212];
            b_1 = _e214;
            let _e215 = a_2;
            let _e216 = (*n_4);
            ha = dot(_e215, _e216);
            let _e218 = b_1;
            let _e219 = (*n_4);
            hb = dot(_e218, _e219);
            let _e221 = ha;
            let _e222 = hb;
            d_3 = (_e221 - _e222);
            let _e224 = a_2;
            let _e225 = b_1;
            let _e226 = a_2;
            let _e228 = d_3;
            if (abs(_e228) > 0.000000000001f) {
                let _e231 = ha;
                let _e232 = d_3;
                local_18 = (_e231 / _e232);
            } else {
                local_18 = 0f;
            }
            let _e234 = local_18;
            q = (_e224 + ((_e225 - _e226) * _e234));
            let _e237 = ha;
            aAbove = (_e237 > 0f);
            let _e239 = hb;
            bAbove = (_e239 > 0f);
            let _e241 = aAbove;
            let _e242 = bAbove;
            if (_e241 || _e242) {
                let _e244 = aAbove;
                let _e245 = a_2;
                let _e246 = q;
                let _e249 = bAbove;
                let _e250 = b_1;
                let _e251 = q;
                param_74 = select(_e246, _e245, vec3(_e244));
                param_75 = select(_e251, _e250, vec3(_e249));
                let _e254 = (*n_4);
                param_76 = _e254;
                let _e255 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_19 = _e255;
            } else {
                local_19 = 0f;
            }
            let _e256 = local_19;
            let _e257 = total;
            total = (_e257 + _e256);
            let _e259 = aAbove;
            let _e260 = bAbove;
            let _e263 = q;
            let _e264 = exit;
            exit = select(_e264, _e263, vec3((_e259 && !(_e260))));
            let _e267 = aAbove;
            let _e269 = bAbove;
            let _e271 = q;
            let _e272 = entry;
            entry = select(_e272, _e271, vec3((!(_e267) && _e269)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e275 = i_7;
            i_7 = (_e275 + 1i);
        }
    }
    let _e277 = exit;
    param_77 = _e277;
    let _e278 = entry;
    param_78 = _e278;
    let _e279 = (*n_4);
    param_79 = _e279;
    let _e280 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e281 = total;
    total = (_e281 + _e280);
    let _e283 = total;
    return max((-(_e283) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_20: f32;
    var local_21: f32;
    var local_22: f32;

    let _e186 = (*slot_1);
    let _e187 = (*slot_1);
    lane = (_e186 - ((_e187 / 4i) * 4i));
    let _e191 = lane;
    if (_e191 == 0i) {
        let _e194 = (*four)[0u];
        local_20 = _e194;
    } else {
        let _e195 = lane;
        if (_e195 == 1i) {
            let _e198 = (*four)[1u];
            local_21 = _e198;
        } else {
            let _e199 = lane;
            if (_e199 == 2i) {
                let _e202 = (*four)[2u];
                local_22 = _e202;
            } else {
                let _e204 = (*four)[3u];
                local_22 = _e204;
            }
            let _e205 = local_22;
            local_21 = _e205;
        }
        let _e206 = local_21;
        local_20 = _e206;
    }
    let _e207 = local_20;
    return _e207;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e183 = (*slot_2);
    let _e187 = light_list_info.scales[(_e183 / 4i)];
    param_80 = _e187;
    let _e188 = (*slot_2);
    param_81 = _e188;
    let _e189 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e189;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e185 = light_list_info.slot_rows[0i];
    let _e186 = (*row);
    a_3 = abs((_e185 - vec4(_e186)));
    let _e192 = light_list_info.slot_rows[1i];
    let _e193 = (*row);
    b_2 = abs((_e192 - vec4(_e193)));
    let _e198 = a_3[0u];
    let _e200 = a_3[1u];
    let _e203 = a_3[2u];
    let _e205 = a_3[3u];
    let _e209 = b_2[0u];
    let _e211 = b_2[1u];
    let _e214 = b_2[2u];
    let _e216 = b_2[3u];
    return (min(min(min(_e198, _e200), min(_e203, _e205)), min(min(_e209, _e211), min(_e214, _e216))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e183 = (*slot_3);
    let _e187 = light_list_info.indices[(_e183 / 4i)];
    param_82 = _e187;
    let _e188 = (*slot_3);
    param_83 = _e188;
    let _e189 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e189;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e182 = (*texel_2);
    let _e186 = light_list_info.list[1u];
    let _e188 = (*row_1);
    let _e192 = light_list_info.list[2u];
    let _e195 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e182 + 0.5f) * _e186), ((_e188 + 0.5f) * _e192)), 0f);
    return _e195;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e190 = g_cluster_offset;
    let _e191 = (*slot_4);
    entry_1 = (_e190 + f32(_e191));
    let _e194 = entry_1;
    row_2 = floor((_e194 / 16f));
    let _e197 = entry_1;
    let _e198 = row_2;
    within = (_e197 - (_e198 * 16f));
    let _e201 = within;
    texel_3 = floor((_e201 / 4f));
    let _e206 = light_list_info.cluster_depth[3u];
    let _e207 = row_2;
    let _e209 = texel_3;
    param_84 = _e209;
    param_85 = (_e206 + _e207);
    let _e210 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e210;
    let _e211 = within;
    let _e212 = texel_3;
    let _e217 = four_1;
    param_86 = _e217;
    param_87 = i32(((_e211 - (_e212 * 4f)) + 0.5f));
    let _e218 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e218;
}

fn Clustered_u0028_() -> bool {
    let _e182 = light_list_info.cluster_grid[3u];
    return (_e182 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_23: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_24: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_25: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_26: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_27: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e234 = (*index_2);
    if (_e234 < 8i) {
        let _e236 = (*index_2);
        let _e239 = frag_info.light_position[_e236];
        position = _e239;
        let _e240 = (*index_2);
        let _e243 = frag_info.light_color[_e240];
        color_1 = _e243;
        let _e244 = (*index_2);
        let _e247 = frag_info.light_direction[_e244];
        direction = _e247;
        let _e248 = (*index_2);
        let _e251 = frag_info.light_cone[_e248];
        cone = _e251;
    } else {
        let _e252 = (*index_2);
        slot_5 = (_e252 - 8i);
        let _e254 = Clustered_u0028_();
        clustered = _e254;
        let _e255 = clustered;
        if _e255 {
            let _e256 = slot_5;
            param_88 = _e256;
            let _e257 = ClusterRow_u0028_i1_u003b((&param_88));
            local_23 = _e257;
        } else {
            let _e258 = slot_5;
            param_89 = _e258;
            let _e259 = LightListRow_u0028_i1_u003b((&param_89));
            local_23 = _e259;
        }
        let _e260 = local_23;
        listRow = _e260;
        let _e261 = listRow;
        let _e265 = light_list_info.list[2u];
        v_1 = ((_e261 + 0.5f) * _e265);
        let _e269 = light_list_info.list[1u];
        u_1 = _e269;
        let _e270 = u_1;
        let _e272 = v_1;
        let _e274 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e270), _e272), 0f);
        position = _e274;
        let _e275 = u_1;
        let _e277 = v_1;
        let _e279 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e275), _e277), 0f);
        color_1 = _e279;
        let _e280 = u_1;
        let _e282 = v_1;
        let _e284 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e280), _e282), 0f);
        direction = _e284;
        let _e285 = u_1;
        let _e287 = v_1;
        let _e289 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e285), _e287), 0f);
        cone = _e289;
        let _e290 = clustered;
        if _e290 {
            let _e291 = listRow;
            param_90 = _e291;
            let _e292 = InSlots_u0028_f1_u003b((&param_90));
            local_24 = select(1f, 0f, _e292);
        } else {
            let _e294 = slot_5;
            param_91 = _e294;
            let _e295 = LightListScale_u0028_i1_u003b((&param_91));
            local_24 = _e295;
        }
        let _e296 = local_24;
        let _e298 = color_1[3u];
        color_1[3u] = (_e298 * _e296);
    }
    let _e302 = position[3u];
    type_39 = _e302;
    let _e303 = type_39;
    if (_e303 > 15.5f) {
        let _e306 = (*s_4).n;
        light_3.l = _e306;
        let _e309 = (*s_4).n;
        light_3.h = _e309;
        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 _e315 = light_3;
        return _e315;
    }
    let _e316 = type_39;
    if (_e316 > 2.5f) {
        let _e318 = direction;
        halfWidth_1 = _e318.xyz;
        let _e320 = cone;
        halfHeight_1 = _e320.xyz;
        let _e322 = position;
        let _e324 = v_world_position_1;
        toCentre = (_e322.xyz - _e324);
        let _e326 = toCentre;
        let _e327 = halfWidth_1;
        let _e329 = halfHeight_1;
        corners_1[0i] = ((_e326 - _e327) - _e329);
        let _e332 = toCentre;
        let _e333 = halfWidth_1;
        let _e335 = halfHeight_1;
        corners_1[1i] = ((_e332 + _e333) - _e335);
        let _e338 = toCentre;
        let _e339 = halfWidth_1;
        let _e341 = halfHeight_1;
        corners_1[2i] = ((_e338 + _e339) + _e341);
        let _e344 = toCentre;
        let _e345 = halfWidth_1;
        let _e347 = halfHeight_1;
        corners_1[3i] = ((_e344 - _e345) + _e347);
        let _e350 = toCentre;
        let _e351 = halfWidth_1;
        let _e352 = halfHeight_1;
        behind = (dot(_e350, cross(_e351, _e352)) >= 0f);
        let _e356 = behind;
        if _e356 {
            local_25 = 0f;
        } else {
            let _e357 = corners_1;
            param_92 = _e357;
            let _e359 = (*s_4).n;
            param_93 = _e359;
            let _e360 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_25 = _e360;
        }
        let _e361 = local_25;
        formFactor = _e361;
        let _e362 = halfWidth_1;
        let _e363 = halfHeight_1;
        area = (length(cross(_e362, _e363)) * 4f);
        let _e367 = area;
        if (_e367 > 0.000000001f) {
            let _e369 = area;
            local_26 = (1f / _e369);
        } else {
            local_26 = 0f;
        }
        let _e371 = local_26;
        radiance = _e371;
        let _e372 = toCentre;
        distance_2 = length(_e372);
        let _e375 = direction[3u];
        if (_e375 > 0f) {
            let _e377 = distance_2;
            let _e379 = direction[3u];
            ratio_1 = (_e377 / _e379);
            let _e381 = ratio_1;
            let _e382 = ratio_1;
            let _e384 = ratio_1;
            let _e386 = ratio_1;
            window_1 = clamp((1f - (((_e381 * _e382) * _e384) * _e386)), 0f, 1f);
            let _e390 = window_1;
            let _e391 = window_1;
            let _e393 = radiance;
            radiance = (_e393 * (_e390 * _e391));
        }
        let _e396 = (*s_4).v;
        let _e399 = (*s_4).n;
        mirror_1 = reflect(-(_e396), _e399);
        let _e401 = position;
        param_94 = _e401.xyz;
        let _e403 = halfWidth_1;
        param_95 = _e403;
        let _e404 = halfHeight_1;
        param_96 = _e404;
        let _e405 = v_world_position_1;
        param_97 = _e405;
        let _e406 = mirror_1;
        param_98 = _e406;
        let _e407 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e407;
        let _e408 = representative;
        let _e409 = v_world_position_1;
        toPoint = (_e408 - _e409);
        let _e411 = toPoint;
        pointDistance = length(_e411);
        let _e413 = pointDistance;
        if (_e413 > 0.000001f) {
            let _e415 = toPoint;
            let _e416 = pointDistance;
            local_27 = (_e415 / vec3(_e416));
        } else {
            let _e420 = (*s_4).n;
            local_27 = _e420;
        }
        let _e421 = local_27;
        light_3.l = _e421;
        let _e424 = light_3.l;
        let _e426 = (*s_4).v;
        light_3.h = normalize((_e424 + _e426));
        let _e430 = formFactor;
        light_3.n_dot_l = _e430;
        let _e433 = (*s_4).n;
        let _e435 = light_3.h;
        light_3.n_dot_h = max(dot(_e433, _e435), 0f);
        let _e440 = (*s_4).v;
        let _e442 = light_3.h;
        light_3.v_dot_h = max(dot(_e440, _e442), 0f);
        let _e446 = color_1;
        let _e449 = color_1[3u];
        let _e451 = radiance;
        light_3.radiance = ((_e446.xyz * _e449) * _e451);
        let _e454 = light_3;
        return _e454;
    }
    let _e455 = direction;
    aim = normalize(_e455.xyz);
    attenuation_1 = 1f;
    let _e458 = type_39;
    if (_e458 < 0.5f) {
        let _e460 = aim;
        light_3.l = -(_e460);
    } else {
        let _e463 = position;
        let _e465 = v_world_position_1;
        toLight_1 = (_e463.xyz - _e465);
        let _e467 = toLight_1;
        distance_3 = length(_e467);
        let _e469 = distance_3;
        if (_e469 < 0.000001f) {
            let _e472 = (*s_4).n;
            light_3.l = _e472;
            let _e475 = (*s_4).n;
            light_3.h = _e475;
            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 _e481 = light_3;
            return _e481;
        }
        let _e482 = toLight_1;
        let _e483 = distance_3;
        light_3.l = (_e482 / vec3(_e483));
        let _e487 = distance_3;
        param_99 = _e487;
        let _e489 = direction[3u];
        param_100 = _e489;
        let _e490 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e490;
        let _e491 = type_39;
        if (_e491 > 1.5f) {
            let _e493 = aim;
            let _e495 = light_3.l;
            cosAngle = dot(_e493, -(_e495));
            let _e498 = cosAngle;
            let _e500 = cone[1u];
            let _e503 = cone[0u];
            let _e505 = cone[1u];
            ramp = clamp(((_e498 - _e500) / (_e503 - _e505)), 0f, 1f);
            let _e509 = ramp;
            let _e510 = ramp;
            let _e512 = attenuation_1;
            attenuation_1 = (_e512 * (_e509 * _e510));
        }
    }
    let _e515 = light_3.l;
    let _e517 = (*s_4).v;
    light_3.h = normalize((_e515 + _e517));
    let _e522 = (*s_4).n;
    let _e524 = light_3.l;
    light_3.n_dot_l = max(dot(_e522, _e524), 0f);
    let _e529 = (*s_4).n;
    let _e531 = light_3.h;
    light_3.n_dot_h = max(dot(_e529, _e531), 0f);
    let _e536 = (*s_4).v;
    let _e538 = light_3.h;
    light_3.v_dot_h = max(dot(_e536, _e538), 0f);
    let _e542 = color_1;
    let _e545 = color_1[3u];
    let _e547 = attenuation_1;
    light_3.radiance = ((_e542.xyz * _e545) * _e547);
    let _e550 = light_3;
    return _e550;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_28: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e195 = light_list_info.cluster_view_projection;
    let _e196 = (*world_3);
    clip_1 = (_e195 * vec4<f32>(_e196.x, _e196.y, _e196.z, 1f));
    let _e202 = clip_1;
    let _e205 = clip_1[3u];
    ndc_1 = (_e202.xy / vec2(max(_e205, 0.000001f)));
    let _e210 = light_list_info.cluster_grid;
    grid = _e210.xyz;
    let _e214 = light_list_info.cluster_depth[0u];
    near_1 = _e214;
    let _e216 = ndc_1[0u];
    let _e220 = grid[0u];
    let _e224 = grid[0u];
    tx = clamp(floor((((_e216 * 0.5f) + 0.5f) * _e220)), 0f, (_e224 - 1f));
    let _e228 = ndc_1[1u];
    let _e232 = grid[1u];
    let _e236 = grid[1u];
    ty = clamp(floor((((_e228 * 0.5f) + 0.5f) * _e232)), 0f, (_e236 - 1f));
    let _e240 = clip_1[3u];
    let _e241 = near_1;
    if (_e240 <= _e241) {
        local_28 = 0f;
    } else {
        let _e244 = clip_1[3u];
        let _e245 = near_1;
        let _e250 = light_list_info.cluster_depth[1u];
        let _e254 = grid[2u];
        local_28 = clamp(floor((log((_e244 / _e245)) * _e250)), 0f, (_e254 - 1f));
    }
    let _e257 = local_28;
    tz = _e257;
    let _e258 = tx;
    let _e259 = ty;
    let _e261 = grid[0u];
    let _e264 = tz;
    let _e266 = grid[0u];
    let _e269 = grid[1u];
    cell = ((_e258 + (_e259 * _e261)) + ((_e264 * _e266) * _e269));
    let _e272 = cell;
    row_3 = floor((_e272 / 4f));
    let _e275 = cell;
    let _e276 = row_3;
    let _e281 = light_list_info.cluster_depth[2u];
    let _e282 = row_3;
    param_101 = (_e275 - (_e276 * 4f));
    param_102 = (_e281 + _e282);
    let _e284 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e284;
    let _e286 = header[0u];
    g_cluster_offset = _e286;
    let _e288 = header[1u];
    g_cluster_count = _e288;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e184 = light_list_info.list[0u];
    tail = _e184;
    let _e185 = Clustered_u0028_();
    if _e185 {
        let _e186 = v_world_position_1;
        param_103 = _e186;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e187 = g_cluster_count;
        tail = _e187;
    }
    let _e190 = frag_info.frame_params[1u];
    let _e194 = tail;
    return (clamp(i32((_e190 + 0.5f)), 0i, 8i) + clamp(i32((_e194 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_29: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e198 = LightCount_u0028_();
    count_1 = _e198;
    i_8 = 0i;
    loop {
        let _e199 = i_8;
        if (_e199 < 32i) {
            let _e201 = i_8;
            let _e202 = count_1;
            if (_e201 >= _e202) {
                break;
            }
            let _e204 = i_8;
            param_104 = _e204;
            let _e205 = (*s_5);
            param_105 = _e205;
            let _e206 = 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((&param_104), (&param_105));
            light_4 = _e206;
            let _e208 = light_4.n_dot_l;
            if (_e208 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e210 = i_8;
            param_106 = _e210;
            let _e211 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e211 {
                let _e212 = (*s_5);
                param_107 = _e212;
                let _e213 = light_4;
                param_108 = _e213;
                let _e214 = i_8;
                param_109 = _e214;
                let _e215 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e216 = v_world_position_1;
                param_110 = _e216;
                let _e218 = (*s_5).n;
                param_111 = _e218;
                let _e219 = i_8;
                param_112 = _e219;
                let _e220 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_29 = (_e215 * _e220);
            } else {
                local_29 = 1f;
            }
            let _e222 = local_29;
            visibility = _e222;
            let _e223 = visibility;
            if (_e223 <= 0f) {
                continue;
            }
            let _e225 = (*s_5);
            param_113 = _e225;
            let _e226 = light_4;
            param_114 = _e226;
            let _e227 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e229 = light_4.radiance;
            let _e232 = light_4.n_dot_l;
            let _e234 = visibility;
            let _e236 = light_transmittance;
            let _e238 = total_1;
            total_1 = (_e238 + ((((_e227 * _e229) * _e232) * _e234) * _e236));
            continue;
        } else {
            break;
        }
        continuing {
            let _e240 = i_8;
            i_8 = (_e240 + 1i);
        }
    }
    let _e242 = total_1;
    return _e242;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_30: f32;
    var local_31: f32;

    let _e184 = OcclusionTarget_u0028_();
    target_ = _e184;
    let _e185 = target_;
    let _e187 = target_;
    if ((_e185 > 0.5f) && (_e187 < 1.5f)) {
        local_30 = 1f;
    } else {
        let _e191 = (*s_6).occlusion;
        local_30 = _e191;
    }
    let _e192 = local_30;
    local_31 = _e192;
    let _e193 = local_31;
    return _e193;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e181 = v_lightmap_uv_1;
    let _e182 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e181);
    texel_4 = _e182;
    let _e183 = texel_4;
    let _e186 = texel_4[3u];
    return ((_e183.xyz * _e186) * 8f);
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e181 = (*srgb);
    let _e184 = (*srgb);
    let _e189 = (*srgb);
    return mix((_e181 / vec3(12.92f)), pow(((_e184 + 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), _e189));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e182 = frag_info.target_origin[1u];
    return _e182;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_115: vec3<f32>;

    let _e183 = v_texcoord_1;
    let _e184 = MaterialLodBias_u0028_();
    let _e185 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e183, _e184);
    param_115 = _e185.xyz;
    let _e187 = SrgbToLinear_u0028_vf3_u003b((&param_115));
    emissive = _e187;
    let _e188 = emissive;
    let _e190 = frag_info.emissive;
    let _e195 = frag_info.material2_[3u];
    (*s_7).emissive = ((_e188 * _e190.xyz) * _e195);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e183 = v_texcoord_1;
    let _e184 = MaterialLodBias_u0028_();
    let _e185 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e183, _e184);
    occlusion = _e185.x;
    let _e189 = frag_info.material2_[2u];
    let _e190 = OcclusionTarget_u0028_();
    strength_2 = (_e189 - (2f * _e190));
    let _e193 = occlusion;
    let _e194 = strength_2;
    (*s_8).occlusion = mix(1f, _e193, clamp(_e194, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e185 = v_texcoord_1;
    let _e186 = MaterialLodBias_u0028_();
    let _e187 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e185, _e186);
    sampledTexel = _e187;
    let _e188 = v_tangent_1;
    t_2 = _e188.xyz;
    let _e190 = t_2;
    let _e192 = (*s_9).n;
    let _e194 = (*s_9).n;
    let _e195 = t_2;
    t_2 = (_e190 - (_e192 * dot(_e194, _e195)));
    let _e199 = t_2;
    let _e200 = t_2;
    if (dot(_e199, _e200) < 0.000000000001f) {
        return;
    }
    let _e203 = t_2;
    t_2 = normalize(_e203);
    let _e206 = (*s_9).n;
    let _e207 = t_2;
    let _e210 = v_tangent_1[3u];
    b_3 = (cross(_e206, _e207) * _e210);
    let _e212 = gl_FrontFacing_1;
    if !(_e212) {
        let _e214 = t_2;
        t_2 = -(_e214);
    }
    let _e216 = sampledTexel;
    sampled = ((_e216.xyz * 2f) - vec3(1f));
    let _e223 = frag_info.emissive[3u];
    if (_e223 > 0.5f) {
        let _e225 = sampled;
        let _e227 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e225.xy, _e227.xy)), 0f));
    }
    let _e236 = frag_info.material2_[1u];
    let _e237 = sampled;
    let _e239 = (_e237.xy * _e236);
    sampled[0u] = _e239.x;
    sampled[1u] = _e239.y;
    let _e244 = t_2;
    let _e246 = sampled[0u];
    let _e248 = b_3;
    let _e250 = sampled[1u];
    let _e254 = (*s_9).n;
    let _e256 = sampled[2u];
    (*s_9).n = normalize((((_e244 * _e246) + (_e248 * _e250)) + (_e254 * _e256)));
    let _e262 = (*s_9).n;
    let _e264 = (*s_9).v;
    (*s_9).n_dot_v = max(dot(_e262, _e264), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e181 = (*texel_5);
    let _e185 = irradiance_info.atlas;
    let _e188 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e181 + vec2(0.5f)) * _e185.xy), 0f);
    return _e188;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_116: vec2<f32>;
    var b_4: vec4<f32>;
    var param_117: vec2<f32>;
    var c: vec4<f32>;
    var param_118: vec2<f32>;
    var d_4: vec4<f32>;
    var param_119: vec2<f32>;

    let _e194 = (*uv_5);
    let _e195 = (*interior);
    at_1 = ((vec2(1f) + (_e194 * _e195)) - vec2(0.5f));
    let _e201 = at_1;
    low = floor(_e201);
    let _e203 = at_1;
    let _e204 = low;
    f = (_e203 - _e204);
    let _e206 = (*corner);
    let _e207 = low;
    param_116 = (_e206 + _e207);
    let _e209 = AtlasTexel_u0028_vf2_u003b((&param_116));
    a_4 = _e209;
    let _e210 = (*corner);
    let _e211 = low;
    param_117 = ((_e210 + _e211) + vec2<f32>(1f, 0f));
    let _e214 = AtlasTexel_u0028_vf2_u003b((&param_117));
    b_4 = _e214;
    let _e215 = (*corner);
    let _e216 = low;
    param_118 = ((_e215 + _e216) + vec2<f32>(0f, 1f));
    let _e219 = AtlasTexel_u0028_vf2_u003b((&param_118));
    c = _e219;
    let _e220 = (*corner);
    let _e221 = low;
    param_119 = ((_e220 + _e221) + vec2<f32>(1f, 1f));
    let _e224 = AtlasTexel_u0028_vf2_u003b((&param_119));
    d_4 = _e224;
    let _e225 = a_4;
    let _e226 = b_4;
    let _e228 = f[0u];
    let _e231 = c;
    let _e232 = d_4;
    let _e234 = f[0u];
    let _e238 = f[1u];
    return mix(mix(_e225, _e226, vec4(_e228)), mix(_e231, _e232, vec4(_e234)), vec4(_e238));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e185 = (*direction_1)[0u];
    let _e188 = (*direction_1)[1u];
    let _e192 = (*direction_1)[2u];
    sum_1 = ((abs(_e185) + abs(_e188)) + abs(_e192));
    let _e195 = sum_1;
    if (_e195 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e197 = (*direction_1);
    let _e198 = sum_1;
    n_5 = (_e197 / vec3(_e198));
    let _e201 = n_5;
    xy = _e201.xy;
    let _e204 = n_5[2u];
    if (_e204 < 0f) {
        let _e207 = n_5[1u];
        let _e211 = n_5[0u];
        let _e216 = n_5[0u];
        let _e220 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e207)) * select(-1f, 1f, (_e211 >= 0f))), ((1f - abs(_e216)) * select(-1f, 1f, (_e220 >= 0f))));
    }
    let _e225 = xy;
    return ((_e225 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_120: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_121: vec3<f32>;
    var param_122: vec2<f32>;
    var param_123: f32;
    var param_124: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_125: vec3<f32>;
    var param_126: vec2<f32>;
    var param_127: f32;
    var param_128: vec2<f32>;
    var local_32: vec3<f32>;

    let _e227 = irradiance_info.origin;
    origin_2 = _e227.xyz;
    let _e230 = irradiance_info.spacing;
    spacing = _e230.xyz;
    let _e233 = irradiance_info.counts;
    counts = _e233.xyz;
    let _e237 = irradiance_info.tiles[0u];
    irradianceTile = _e237;
    let _e240 = irradiance_info.tiles[1u];
    depthTile = _e240;
    let _e243 = irradiance_info.tiles[2u];
    columns = _e243;
    let _e246 = irradiance_info.tiles[3u];
    momentsTop = _e246;
    let _e247 = (*normal_1);
    unit = normalize(_e247);
    let _e249 = (*world_4);
    let _e250 = unit;
    let _e253 = irradiance_info.spacing[3u];
    let _e256 = (*view);
    let _e259 = irradiance_info.counts[3u];
    biased = ((_e249 + (_e250 * _e253)) + (_e256 * _e259));
    let _e262 = biased;
    let _e263 = origin_2;
    let _e265 = spacing;
    grid_1 = ((_e262 - _e263) / _e265);
    let _e267 = grid_1;
    let _e269 = counts;
    base = clamp(floor(_e267), vec3<f32>(0f, 0f, 0f), (_e269 - vec3(2f)));
    let _e273 = grid_1;
    let _e274 = base;
    f_1 = clamp((_e273 - _e274), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e277 = corner_1;
        if (_e277 < 8i) {
            let _e279 = corner_1;
            let _e282 = corner_1;
            let _e287 = corner_1;
            offset_3 = vec3<f32>(f32((_e279 & 1i)), f32(((_e282 >> bitcast<u32>(1i)) & 1i)), f32(((_e287 >> bitcast<u32>(2i)) & 1i)));
            let _e293 = base;
            let _e294 = offset_3;
            cell_1 = (_e293 + _e294);
            let _e297 = cell_1[2u];
            let _e299 = counts[1u];
            let _e302 = cell_1[1u];
            let _e305 = counts[0u];
            let _e308 = cell_1[0u];
            probe = ((((_e297 * _e299) + _e302) * _e305) + _e308);
            let _e310 = probe;
            let _e311 = columns;
            let _e316 = probe;
            let _e317 = columns;
            tile_4 = vec2<f32>((_e310 - (floor((_e310 / _e311)) * _e311)), floor((_e316 / _e317)));
            let _e321 = tile_4;
            let _e322 = irradianceTile;
            irradianceCorner = (_e321 * (_e322 + 2f));
            let _e326 = tile_4[0u];
            let _e327 = depthTile;
            let _e330 = momentsTop;
            let _e332 = tile_4[1u];
            let _e333 = depthTile;
            momentCorner = vec2<f32>((_e326 * (_e327 + 2f)), (_e330 + (_e332 * (_e333 + 2f))));
            let _e338 = irradianceCorner;
            param_120 = (_e338 + vec2(1f));
            let _e341 = AtlasTexel_u0028_vf2_u003b((&param_120));
            if (_e341.w < 0.5f) {
                continue;
            }
            let _e344 = f_1;
            let _e346 = f_1;
            let _e347 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e344), _e346, _e347);
            let _e350 = trilinear[0u];
            let _e352 = trilinear[1u];
            let _e355 = trilinear[2u];
            weight_2 = max(((_e350 * _e352) * _e355), 0.001f);
            let _e358 = origin_2;
            let _e359 = spacing;
            let _e360 = cell_1;
            probePosition = (_e358 + (_e359 * _e360));
            let _e363 = probePosition;
            let _e364 = biased;
            toProbe = (_e363 - _e364);
            let _e366 = toProbe;
            distance_4 = length(_e366);
            let _e368 = distance_4;
            if (_e368 > 0.000001f) {
                let _e370 = toProbe;
                let _e371 = distance_4;
                direction_2 = (_e370 / vec3(_e371));
                let _e374 = unit;
                let _e375 = probePosition;
                let _e376 = (*world_4);
                facing = ((dot(_e374, normalize((_e375 - _e376))) * 0.5f) + 0.5f);
                let _e382 = facing;
                let _e383 = facing;
                probeWeight = ((_e382 * _e383) + 0.2f);
                let _e386 = direction_2;
                param_121 = -(_e386);
                let _e388 = ProbeOctahedral_u0028_vf3_u003b((&param_121));
                let _e389 = momentCorner;
                param_122 = _e389;
                let _e390 = depthTile;
                param_123 = _e390;
                param_124 = _e388;
                let _e391 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_122), (&param_123), (&param_124));
                moments_3 = _e391.xy;
                chebyshev = 1f;
                let _e393 = distance_4;
                let _e395 = moments_3[0u];
                if (_e393 > _e395) {
                    let _e398 = moments_3[1u];
                    let _e400 = moments_3[0u];
                    let _e402 = moments_3[0u];
                    variance_1 = max((_e398 - (_e400 * _e402)), 0.000001f);
                    let _e406 = distance_4;
                    let _e408 = moments_3[0u];
                    difference = (_e406 - _e408);
                    let _e410 = variance_1;
                    let _e411 = variance_1;
                    let _e412 = difference;
                    let _e413 = difference;
                    chebyshev = (_e410 / (_e411 + (_e412 * _e413)));
                    let _e417 = chebyshev;
                    let _e418 = chebyshev;
                    let _e420 = chebyshev;
                    chebyshev = ((_e417 * _e418) * _e420);
                }
                let _e422 = probeWeight;
                let _e423 = chebyshev;
                probeWeight = max((_e422 * max(_e423, 0.05f)), 0.000001f);
                let _e427 = probeWeight;
                if (_e427 < 0.2f) {
                    let _e429 = probeWeight;
                    let _e430 = probeWeight;
                    let _e433 = probeWeight;
                    probeWeight = (_e433 * ((_e429 * _e430) * 25f));
                }
                let _e435 = probeWeight;
                let _e436 = weight_2;
                weight_2 = (_e436 * _e435);
            }
            let _e438 = unit;
            param_125 = _e438;
            let _e439 = ProbeOctahedral_u0028_vf3_u003b((&param_125));
            let _e440 = irradianceCorner;
            param_126 = _e440;
            let _e441 = irradianceTile;
            param_127 = _e441;
            param_128 = _e439;
            let _e442 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_126), (&param_127), (&param_128));
            let _e444 = weight_2;
            let _e446 = total_2;
            total_2 = (_e446 + (_e442.xyz * _e444));
            let _e448 = weight_2;
            let _e449 = weights;
            weights = (_e449 + _e448);
            continue;
        } else {
            break;
        }
        continuing {
            let _e451 = corner_1;
            corner_1 = (_e451 + 1i);
        }
    }
    let _e453 = weights;
    if (_e453 > 0f) {
        let _e455 = total_2;
        let _e456 = weights;
        local_32 = (_e455 / vec3(_e456));
    } else {
        local_32 = vec3<f32>(0f, 0f, 0f);
    }
    let _e459 = local_32;
    return _e459;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e182 = irradiance_info.origin[3u];
    return (_e182 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;
    var param_132: Surface;
    var param_133: Surface;
    var param_134: Surface;

    let _e187 = IrradianceEnabled_u0028_();
    if _e187 {
        let _e188 = v_world_position_1;
        param_129 = _e188;
        let _e190 = (*s_10).n;
        param_130 = _e190;
        let _e192 = (*s_10).v;
        param_131 = _e192;
        let _e193 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
        let _e196 = frag_info.material[2u];
        (*s_10).ambient = (_e193 * _e196);
    }
    let _e199 = (*s_10);
    param_132 = _e199;
    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((&param_132));
    let _e200 = param_132;
    (*s_10) = _e200;
    let _e201 = (*s_10);
    param_133 = _e201;
    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((&param_133));
    let _e202 = param_133;
    (*s_10) = _e202;
    let _e203 = (*s_10);
    param_134 = _e203;
    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((&param_134));
    let _e204 = param_134;
    (*s_10) = _e204;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_33: vec3<f32>;

    let _e181 = Orthographic_u0028_();
    if _e181 {
        let _e183 = fog_info.forward;
        local_33 = -(_e183.xyz);
    } else {
        let _e187 = fog_info.eye;
        let _e189 = v_world_position_1;
        local_33 = normalize((_e187.xyz - _e189));
    }
    let _e192 = local_33;
    return _e192;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var p3_: vec3<f32>;

    let _e186 = (*cutoff);
    key = (-2f - _e186);
    let _e188 = key;
    let _e191 = key;
    let _e193 = floor((_e191 / 128f));
    let _e198 = key;
    origin_3 = vec3<f32>(floor((_e188 / 16384f)), (_e193 - (floor((_e193 / 128f)) * 128f)), (_e198 - (floor((_e198 / 128f)) * 128f)));
    let _e204 = (*scenePosition);
    let _e207 = origin_3;
    let _e208 = (floor((_e204 * 16f)) + _e207);
    let _e209 = vec3(128f);
    cell_2 = (_e208 - (floor((_e208 / _e209)) * _e209));
    let _e214 = cell_2;
    p3_ = fract((_e214 * 0.1031f));
    let _e217 = p3_;
    let _e218 = p3_;
    let _e223 = p3_;
    p3_ = (_e223 + vec3(dot(_e217, (_e218.zyx + vec3(31.32f)))));
    let _e227 = p3_[0u];
    let _e229 = p3_[1u];
    let _e232 = p3_[2u];
    return fract(((_e227 + _e229) * _e232));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_11: Surface;
    var param_135: vec3<f32>;
    var param_136: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_137: vec3<f32>;
    var param_138: f32;

    let _e188 = v_texcoord_1;
    let _e189 = MaterialLodBias_u0028_();
    let _e190 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e188, _e189);
    texel_6 = _e190;
    let _e191 = texel_6;
    param_135 = _e191.xyz;
    let _e193 = SrgbToLinear_u0028_vf3_u003b((&param_135));
    let _e195 = frag_info.base_color;
    param_136 = _e195.xyz;
    let _e197 = SrgbToLinear_u0028_vf3_u003b((&param_136));
    let _e199 = v_color_1;
    s_11.albedo = ((_e193 * _e197) * _e199.xyz);
    let _e204 = texel_6[3u];
    let _e207 = frag_info.base_color[3u];
    let _e210 = v_color_1[3u];
    s_11.alpha = ((_e204 * _e207) * _e210);
    let _e214 = s_11.albedo;
    g_albedo = _e214;
    let _e217 = frag_info.material2_[0u];
    cutoff_1 = _e217;
    let _e218 = cutoff_1;
    if (_e218 > 1f) {
        let _e220 = cutoff_1;
        edge = (_e220 - 1f);
        let _e223 = s_11.alpha;
        let _e224 = edge;
        let _e227 = s_11.alpha;
        let _e228 = fwidth(_e227);
        s_11.alpha = clamp((((_e223 - _e224) / max(_e228, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e234 = cutoff_1;
        if (_e234 >= 0f) {
            let _e237 = s_11.alpha;
            let _e238 = cutoff_1;
            if (_e237 < _e238) {
                discard;
            }
            s_11.alpha = 1f;
        } else {
            let _e241 = cutoff_1;
            if (_e241 < -1.5f) {
                let _e244 = s_11.alpha;
                let _e245 = v_world_position_1;
                param_137 = _e245;
                let _e246 = cutoff_1;
                param_138 = _e246;
                let _e247 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_137), (&param_138));
                if (_e244 < _e247) {
                    discard;
                }
            }
        }
    }
    let _e249 = cutoff_1;
    let _e251 = cutoff_1;
    g_premultiply = ((_e249 < 0f) && (_e251 > -0.75f));
    let _e254 = v_normal_1;
    s_11.n = normalize(_e254);
    let _e257 = gl_FrontFacing_1;
    if !(_e257) {
        let _e260 = s_11.n;
        s_11.n = -(_e260);
    }
    let _e263 = TowardsEye_u0028_();
    s_11.v = _e263;
    let _e266 = s_11.n;
    let _e268 = s_11.v;
    s_11.n_dot_v = max(dot(_e266, _e268), 0.0001f);
    let _e274 = frag_info.material[0u];
    s_11.metallic = clamp(_e274, 0f, 1f);
    let _e279 = frag_info.material[1u];
    s_11.roughness = clamp(_e279, 0.02f, 1f);
    let _e283 = frag_info.ambient_ground;
    let _e286 = frag_info.ambient_sky;
    let _e290 = s_11.n[1u];
    let _e297 = frag_info.material[2u];
    s_11.ambient = (mix(_e283.xyz, _e286.xyz, vec3(((_e290 * 0.5f) + 0.5f))) * _e297);
    let _e302 = frag_info.frame_params[0u];
    s_11.exposure = max(_e302, 0f);
    s_11.occlusion = 1f;
    s_11.emissive = vec3<f32>(0f, 0f, 0f);
    let _e307 = s_11;
    return _e307;
}

fn main_1() {
    var s_12: Surface;
    var param_139: Surface;
    var ambient: vec3<f32>;
    var param_140: Surface;
    var lit_2: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: vec3<f32>;
    var param_144: f32;
    var param_145: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e190 = ReadSurface_u0028_();
    s_12 = _e190;
    let _e191 = s_12;
    param_139 = _e191;
    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((&param_139));
    let _e192 = param_139;
    s_12 = _e192;
    let _e194 = s_12.albedo;
    let _e196 = s_12.ambient;
    let _e197 = SampleLightmap_u0028_();
    let _e200 = s_12;
    param_140 = _e200;
    let _e201 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_140));
    ambient = ((_e194 * (_e196 + _e197)) * _e201);
    let _e203 = s_12;
    param_141 = _e203;
    let _e204 = 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((&param_141));
    let _e205 = s_12;
    param_142 = _e205;
    let _e206 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_142));
    let _e208 = ambient;
    let _e211 = s_12.emissive;
    lit_2 = (((_e204 * _e206) + _e208) + _e211);
    let _e213 = lit_2;
    param_143 = _e213;
    let _e215 = s_12.alpha;
    param_144 = _e215;
    let _e217 = s_12.roughness;
    param_145 = _e217;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_143), (&param_144), (&param_145));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'BlinnPhong': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e181 = v_world_position_1;
    let _e183 = fog_info.eye;
    let _e187 = fog_info.forward;
    return dot((_e181 - _e183.xyz), _e187.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e186 = ViewDepth_u0028_();
    z = abs(_e186);
    let _e188 = z;
    near = (_e188 / 5f);
    let _e190 = z;
    far = (_e190 / 200f);
    let _e192 = far;
    let _e193 = far;
    let _e195 = far;
    far3_ = ((_e192 * _e193) * _e195);
    let _e197 = (*alpha);
    let _e198 = near;
    let _e199 = near;
    let _e202 = far3_;
    let _e203 = far3_;
    return (_e197 * clamp((10f / ((0.00001f + (_e198 * _e199)) + (_e202 * _e203))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e190 = fog_info.forward[3u];
    mode = _e190;
    let _e191 = mode;
    if (_e191 > 0.5f) {
        let _e194 = frag_color[3u];
        alpha_1 = _e194;
        let _e195 = alpha_1;
        param = _e195;
        let _e196 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e196;
        let _e197 = frag_color;
        let _e199 = weight;
        let _e200 = (_e197.xyz * _e199);
        let _e201 = alpha_1;
        let _e202 = weight;
        accumulate = vec4<f32>(_e200.x, _e200.y, _e200.z, (_e201 * _e202));
        let _e208 = mode;
        let _e210 = mode;
        revealage = ((_e208 > 1.5f) && (_e210 < 2.5f));
        let _e213 = revealage;
        if _e213 {
            let _e214 = alpha_1;
            local = vec4(_e214);
        } else {
            let _e216 = accumulate;
            local = _e216;
        }
        let _e217 = local;
        frag_color = _e217;
        let _e218 = mode;
        if (_e218 > 2.5f) {
            let _e220 = alpha_1;
            frag_surface = vec4(_e220);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e184 = (*n)[0u];
    let _e187 = (*n)[1u];
    let _e191 = (*n)[2u];
    let _e194 = (*n);
    (*n) = (_e194 / vec3(((abs(_e184) + abs(_e187)) + abs(_e191))));
    let _e197 = (*n);
    e = _e197.xy;
    let _e200 = (*n)[2u];
    if (_e200 < 0f) {
        let _e202 = (*n);
        let _e208 = (*n)[0u];
        let _e212 = (*n)[1u];
        e = ((vec2(1f) - abs(_e202.yx)) * vec2<f32>(select(-1f, 1f, (_e208 >= 0f)), select(-1f, 1f, (_e212 >= 0f))));
    }
    let _e217 = e;
    return ((_e217 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e182 = (*linear);
    let _e184 = (*linear);
    let _e188 = (*linear);
    return mix((_e182 * 12.92f), ((pow(_e184, 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), _e188));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e185 = g_albedo;
    param_1 = clamp(_e185, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e187 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e187.x, _e187.y, _e187.z, 1f);
    let _e192 = g_debug_surface_on;
    if _e192 {
        let _e193 = g_debug_surface;
        let _e194 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e193.x, _e193.y, _e193.z, _e194);
        return;
    }
    let _e199 = v_normal_1;
    geometric = normalize(_e199);
    let _e201 = gl_FrontFacing_1;
    if !(_e201) {
        let _e203 = geometric;
        geometric = -(_e203);
    }
    let _e205 = geometric;
    param_2 = _e205;
    let _e206 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e207 = (*roughness);
    let _e209 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e206.x, _e206.y, clamp(_e207, 0f, 1f), _e209);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e183 = fog_info.projection[0u];
    return (_e183 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e182 = Orthographic_u0028_();
    if _e182 {
        let _e183 = ViewDepth_u0028_();
        local_1 = max(_e183, 0f);
    } else {
        let _e185 = v_world_position_1;
        let _e187 = fog_info.eye;
        local_1 = distance(_e185, _e187.xyz);
    }
    let _e190 = local_1;
    return _e190;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e189 = fog_info.fog[3u];
    density = _e189;
    let _e190 = density;
    if (_e190 <= 0f) {
        let _e192 = (*color);
        return _e192;
    }
    let _e193 = EyeDistance_u0028_();
    d = _e193;
    let _e196 = fog_info.eye[3u];
    falloff = _e196;
    let _e197 = falloff;
    if (_e197 > 0f) {
        let _e199 = falloff;
        let _e201 = v_world_position_1[1u];
        let _e204 = fog_info.eye[1u];
        k = (_e199 * (_e201 - _e204));
        let _e207 = k;
        if (abs(_e207) > 0.001f) {
            let _e210 = k;
            let _e214 = k;
            local_2 = ((1f - exp(-(_e210))) / _e214);
        } else {
            let _e216 = k;
            local_2 = (1f - (0.5f * _e216));
        }
        let _e219 = local_2;
        let _e220 = density;
        density = (_e220 * _e219);
    }
    let _e223 = fog_info.fog;
    let _e225 = (*color);
    let _e226 = density;
    let _e228 = d;
    return mix(_e223.xyz, _e225, vec3(clamp(exp((-(_e226) * _e228)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e187 = g_premultiply;
    let _e188 = (*alpha_2);
    weight_1 = select(1f, _e188, _e187);
    let _e190 = (*linearColor);
    param_3 = _e190;
    let _e191 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e192 = weight_1;
    let _e193 = (_e191 * _e192);
    let _e194 = (*alpha_2);
    let _e195 = g_pass_through;
    frag_color = vec4<f32>(_e193.x, _e193.y, _e193.z, (_e194 * (1f - _e195)));
    let _e202 = (*roughness_1);
    param_4 = _e202;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_3: f32;

    let _e184 = frag_info.material2_[2u];
    local_3 = floor((_e184 * 0.5f));
    let _e187 = local_3;
    return _e187;
}

fn DirectOcclusion_u0028_struct_u002d_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: ptr<function, Surface>) -> f32 {
    var local_4: f32;
    var local_5: f32;

    let _e184 = OcclusionTarget_u0028_();
    if (_e184 > 1.5f) {
        local_4 = 1f;
    } else {
        let _e187 = (*s).occlusion;
        local_4 = _e187;
    }
    let _e188 = local_4;
    local_5 = _e188;
    let _e189 = local_5;
    return _e189;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var shininess: f32;
    var specular: f32;

    let _e186 = (*s_1).roughness;
    shininess = mix(256f, 4f, _e186);
    let _e189 = (*light).n_dot_h;
    let _e190 = shininess;
    let _e194 = frag_info.material[3u];
    specular = (pow(_e189, _e190) * _e194);
    let _e197 = (*s_1).albedo;
    let _e198 = specular;
    return (_e197 + vec3(_e198));
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e182 = (*i);
    if (_e182 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e184 = (*i);
    if (_e184 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e186 = (*i);
    if (_e186 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e188 = (*i);
    if (_e188 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e190 = (*i);
    if (_e190 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e192 = (*i);
    if (_e192 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e194 = (*i);
    if (_e194 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e187 = (*i_1);
    param_5 = _e187;
    let _e188 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e188;
    let _e190 = p[0u];
    let _e191 = (*ca);
    let _e194 = p[1u];
    let _e195 = (*sa);
    let _e199 = p[0u];
    let _e200 = (*sa);
    let _e203 = p[1u];
    let _e204 = (*ca);
    let _e208 = (*radius);
    return (vec2<f32>(((_e190 * _e191) - (_e194 * _e195)), ((_e199 * _e200) + (_e203 * _e204))) * _e208);
}

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_6: vec2<f32>;
    var atlas: vec2<f32>;

    let _e190 = point_shadow.params[0u];
    inset = _e190;
    let _e191 = (*uv);
    let _e192 = (*offset);
    let _e194 = inset;
    let _e195 = inset;
    local_6 = clamp((_e191 + _e192), vec2(_e194), vec2((1f - _e195)));
    let _e200 = local_6;
    let _e201 = (*tile);
    atlas = ((_e200 + _e201) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e206 = point_shadow.params3_[0u];
    if (_e206 > 0.5f) {
        let _e209 = atlas[1u];
        atlas[1u] = (1f - _e209);
    }
    let _e212 = atlas;
    let _e213 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e212, 0f);
    let _e215 = atlas;
    let _e216 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e215, 0f);
    let _e219 = (*range);
    return (min(_e213.x, _e216.x) * _e219);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e191 = (*uv_1);
    param_6 = _e191;
    let _e192 = (*offset_1);
    param_7 = _e192;
    let _e193 = (*tile_1);
    param_8 = _e193;
    let _e194 = (*range_1);
    param_9 = _e194;
    let _e195 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e195;
    let _e196 = stored;
    let _e197 = (*range_1);
    if (_e196 >= (_e197 * 0.999f)) {
        return 1f;
    }
    let _e200 = (*receiver);
    let _e201 = stored;
    return select(1f, 0f, (_e200 > _e201));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e212 = point_shadow.params2_[1u];
    lightRadius = _e212;
    let _e215 = point_shadow.params2_[0u];
    minRadius = _e215;
    let _e218 = point_shadow.params2_[2u];
    maxRadius = _e218;
    let _e219 = lightRadius;
    if (_e219 <= 0f) {
        let _e221 = (*uv_2);
        param_10 = _e221;
        param_11 = vec2<f32>(0f, 0f);
        let _e222 = (*tile_2);
        param_12 = _e222;
        let _e223 = (*range_2);
        param_13 = _e223;
        let _e224 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e224;
        let _e225 = minRadius;
        return _e225;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e226 = i_2;
        if (_e226 < 8i) {
            let _e228 = i_2;
            param_14 = _e228;
            let _e229 = (*ca_1);
            param_15 = _e229;
            let _e230 = (*sa_1);
            param_16 = _e230;
            let _e231 = maxRadius;
            param_17 = _e231;
            let _e232 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e233 = (*uv_2);
            param_18 = _e233;
            param_19 = _e232;
            let _e234 = (*tile_2);
            param_20 = _e234;
            let _e235 = (*range_2);
            param_21 = _e235;
            let _e236 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e236;
            let _e237 = stored_1;
            let _e238 = (*range_2);
            if (_e237 >= (_e238 * 0.999f)) {
                continue;
            }
            let _e241 = stored_1;
            let _e242 = (*receiver_1);
            if (_e241 >= _e242) {
                continue;
            }
            let _e244 = stored_1;
            let _e245 = sum;
            sum = (_e245 + _e244);
            let _e247 = count;
            count = (_e247 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e249 = i_2;
            i_2 = (_e249 + 1i);
        }
    }
    let _e251 = count;
    if (_e251 < 0.5f) {
        return -1f;
    }
    let _e253 = sum;
    let _e254 = count;
    blocker = max((_e253 / _e254), 0.0001f);
    let _e257 = blocker;
    (*blockerOut) = _e257;
    let _e258 = lightRadius;
    let _e259 = (*receiver_1);
    let _e260 = blocker;
    let _e264 = blocker;
    world = ((_e258 * max((_e259 - _e260), 0f)) / _e264);
    let _e266 = world;
    let _e267 = (*receiver_1);
    let _e269 = (*tanHalf);
    let _e272 = minRadius;
    let _e273 = maxRadius;
    return clamp((_e266 / ((2f * _e267) * _e269)), _e272, _e273);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_7: vec2<f32>;

    let _e183 = (*rows);
    if (_e183 > 0f) {
        let _e186 = gl_FragCoord_1[0u];
        let _e187 = (*rows);
        let _e189 = gl_FragCoord_1[1u];
        local_7 = vec2<f32>(_e186, (_e187 - _e189));
    } else {
        let _e192 = gl_FragCoord_1;
        local_7 = _e192.xy;
    }
    let _e194 = local_7;
    return _e194;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_8: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2322_: bool;
    var phi_2383_: bool;

    let _e235 = (*lightIndex);
    let _e239 = point_shadow.slots[_e235][0u];
    slot = i32((_e239 + 0.5f));
    let _e242 = (*lightIndex);
    let _e246 = point_shadow.slots[_e242][0u];
    if (_e246 < 0f) {
        return 1f;
    }
    let _e250 = point_shadow.params[2u];
    strength = _e250;
    let _e251 = strength;
    if (_e251 <= 0f) {
        return 1f;
    }
    let _e253 = slot;
    let _e256 = point_shadow.lights[_e253];
    let _e258 = (*world_1);
    toLight = (_e256.xyz - _e258);
    let _e260 = toLight;
    toLightLength = max(length(_e260), 0.000001f);
    let _e263 = (*normal);
    let _e264 = toLight;
    let _e265 = toLightLength;
    nDotL = max(dot(_e263, (_e264 / vec3(_e265))), 0.15f);
    let _e270 = nDotL;
    let _e271 = nDotL;
    let _e276 = nDotL;
    let _e277 = nDotL;
    slope = min((sqrt(max((1f - (_e270 * _e271)), 0f)) / (_e276 * _e277)), 8f);
    let _e281 = toLightLength;
    let _e283 = (*lightIndex);
    let _e287 = point_shadow.slots[_e283][2u];
    let _e292 = point_shadow.params3_[1u];
    texel = (((2f * _e281) * max(_e287, 0.0001f)) * _e292);
    let _e294 = (*world_1);
    let _e295 = (*normal);
    let _e296 = texel;
    let _e300 = point_shadow.params[3u];
    let _e302 = slope;
    origin = (_e294 + (((_e295 * _e296) * _e300) * (1f + _e302)));
    let _e306 = origin;
    let _e307 = slot;
    let _e310 = point_shadow.lights[_e307];
    toFragment = (_e306 - _e310.xyz);
    let _e313 = toFragment;
    distance_ = length(_e313);
    let _e315 = slot;
    let _e319 = point_shadow.lights[_e315][3u];
    range_3 = max(_e319, 0.0001f);
    let _e321 = distance_;
    let _e322 = range_3;
    if (_e321 >= _e322) {
        return 1f;
    }
    face = 0i;
    let _e324 = (*lightIndex);
    let _e328 = point_shadow.slots[_e324][1u];
    if (_e328 < 0.5f) {
        let _e330 = toFragment;
        a = abs(_e330);
        let _e333 = a[0u];
        let _e335 = a[1u];
        let _e336 = (_e333 >= _e335);
        phi_2322_ = _e336;
        if _e336 {
            let _e338 = a[0u];
            let _e340 = a[2u];
            phi_2322_ = (_e338 >= _e340);
        }
        let _e343 = phi_2322_;
        if _e343 {
            let _e345 = toFragment[0u];
            face = select(1i, 0i, (_e345 > 0f));
        } else {
            let _e349 = a[1u];
            let _e351 = a[2u];
            if (_e349 >= _e351) {
                let _e354 = toFragment[1u];
                face = select(3i, 2i, (_e354 > 0f));
            } else {
                let _e358 = toFragment[2u];
                face = select(5i, 4i, (_e358 > 0f));
            }
        }
    }
    let _e361 = slot;
    let _e363 = face;
    let _e367 = point_shadow.faces[((_e361 * 6i) + _e363)];
    let _e368 = origin;
    clip = (_e367 * vec4<f32>(_e368.x, _e368.y, _e368.z, 1f));
    let _e375 = clip[3u];
    if (_e375 <= 0f) {
        return 1f;
    }
    let _e377 = clip;
    let _e380 = clip[3u];
    ndc = (_e377.xy / vec2(_e380));
    let _e384 = ndc[0u];
    let _e386 = (abs(_e384) > 1f);
    phi_2383_ = _e386;
    if !(_e386) {
        let _e389 = ndc[1u];
        phi_2383_ = (abs(_e389) > 1f);
    }
    let _e393 = phi_2383_;
    if _e393 {
        return 1f;
    }
    let _e395 = ndc[0u];
    let _e399 = ndc[1u];
    uv_3 = vec2<f32>(((_e395 * 0.5f) + 0.5f), (0.5f - (_e399 * 0.5f)));
    let _e403 = face;
    let _e405 = slot;
    tile_3 = vec2<f32>(f32(_e403), f32(_e405));
    let _e408 = distance_;
    let _e411 = point_shadow.params[1u];
    receiver_2 = (_e408 - _e411);
    let _e415 = frag_info.target_origin[0u];
    param_22 = _e415;
    let _e416 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e416, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e421 = noise;
    angle = (_e421 * 6.2831855f);
    let _e423 = angle;
    ca_2 = cos(_e423);
    let _e425 = angle;
    sa_2 = sin(_e425);
    let _e427 = (*lightIndex);
    let _e431 = point_shadow.slots[_e427][2u];
    tanHalf_1 = max(_e431, 0.0001f);
    blocker_1 = -1f;
    let _e433 = uv_3;
    param_23 = _e433;
    let _e434 = tile_3;
    param_24 = _e434;
    let _e435 = range_3;
    param_25 = _e435;
    let _e436 = receiver_2;
    param_26 = _e436;
    let _e437 = ca_2;
    param_27 = _e437;
    let _e438 = sa_2;
    param_28 = _e438;
    let _e439 = tanHalf_1;
    param_29 = _e439;
    let _e440 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e441 = param_30;
    blocker_1 = _e441;
    radius_1 = _e440;
    let _e444 = point_shadow.params2_[3u];
    if (_e444 > 0.5f) {
        g_debug_surface_on = true;
        let _e446 = radius_1;
        if (_e446 < 0f) {
            local_8 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e448 = radius_1;
            let _e451 = point_shadow.params2_[2u];
            let _e455 = blocker_1;
            let _e456 = range_3;
            local_8 = vec3<f32>(clamp((_e448 / max(_e451, 0.000001f)), 0f, 1f), clamp((_e455 / _e456), 0f, 1f), 0f);
        }
        let _e460 = local_8;
        g_debug_surface = _e460;
    }
    let _e461 = radius_1;
    if (_e461 < 0f) {
        return 1f;
    }
    let _e463 = uv_3;
    param_31 = _e463;
    param_32 = vec2<f32>(0f, 0f);
    let _e464 = tile_3;
    param_33 = _e464;
    let _e465 = range_3;
    param_34 = _e465;
    let _e466 = receiver_2;
    param_35 = _e466;
    let _e467 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e467;
    let _e468 = radius_1;
    if (_e468 > 0f) {
        i_3 = 0i;
        loop {
            let _e470 = i_3;
            if (_e470 < 8i) {
                let _e472 = i_3;
                param_36 = _e472;
                let _e473 = ca_2;
                param_37 = _e473;
                let _e474 = sa_2;
                param_38 = _e474;
                let _e475 = radius_1;
                param_39 = _e475;
                let _e476 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e477 = uv_3;
                param_40 = _e477;
                param_41 = _e476;
                let _e478 = tile_3;
                param_42 = _e478;
                let _e479 = range_3;
                param_43 = _e479;
                let _e480 = receiver_2;
                param_44 = _e480;
                let _e481 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e482 = lit;
                lit = (_e482 + _e481);
                continue;
            } else {
                break;
            }
            continuing {
                let _e484 = i_3;
                i_3 = (_e484 + 1i);
            }
        }
        let _e486 = lit;
        lit = (_e486 * 0.11111111f);
    }
    let _e488 = lit;
    let _e489 = strength;
    return mix(1f, _e488, clamp(_e489, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e186 = (*i_4);
    let _e189 = (*n_1);
    r = sqrt(((f32(_e186) + 0.5f) / f32(_e189)));
    let _e193 = (*i_4);
    let _e196 = (*turn);
    theta = ((f32(_e193) * 2.3999631f) + _e196);
    let _e198 = r;
    let _e199 = theta;
    let _e201 = theta;
    return (vec2<f32>(cos(_e199), sin(_e201)) * _e198);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e185 = frag_info.target_origin[0u];
    param_45 = _e185;
    let _e186 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e189 = frag_info.target_origin[3u];
    at = (_e186 + vec2((5.588238f * max(_e189, 0f))));
    let _e194 = at;
    return fract((52.982918f * fract(dot(_e194, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_9: f32;

    let _e184 = (*mode_1);
    if (_e184 > 0.5f) {
        let _e186 = (*stored_2);
        local_9 = (1f - _e186);
    } else {
        let _e188 = (*stored_2);
        local_9 = _e188;
    }
    let _e189 = local_9;
    return _e189;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e190 = (*moments)[1u];
    let _e192 = (*moments)[0u];
    let _e194 = (*moments)[0u];
    let _e197 = (*minVariance);
    variance = max((_e190 - (_e192 * _e194)), _e197);
    let _e199 = (*t);
    let _e201 = (*moments)[0u];
    d_1 = (_e199 - _e201);
    let _e203 = variance;
    let _e204 = variance;
    let _e205 = d_1;
    let _e206 = d_1;
    pMax = (_e203 / (_e204 + (_e205 * _e206)));
    let _e210 = pMax;
    let _e211 = (*bleed);
    let _e213 = (*bleed);
    reduced = clamp(((_e210 - _e211) / max((1f - _e213), 0.0001f)), 0f, 1f);
    let _e218 = (*t);
    let _e220 = (*moments)[0u];
    let _e222 = reduced;
    return select(_e222, 1f, (_e218 <= _e220));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e183 = (*depth);
    d_2 = ((2f * clamp(_e183, 0f, 1f)) - 1f);
    let _e187 = d_2;
    let _e190 = d_2;
    return vec2<f32>(exp((40f * _e187)), -(exp((-5f * _e190))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e197 = (*depth_1);
    param_46 = _e197;
    let _e198 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e198;
    let _e199 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e199);
    let _e202 = scale[0u];
    let _e204 = scale[0u];
    let _e206 = (*moments_1);
    param_47 = _e206.xy;
    let _e209 = warped[0u];
    param_48 = _e209;
    param_49 = (_e202 * _e204);
    let _e210 = (*bleed_1);
    param_50 = _e210;
    let _e211 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e211;
    let _e213 = scale[1u];
    let _e215 = scale[1u];
    let _e217 = (*moments_1);
    param_51 = _e217.zw;
    let _e220 = warped[1u];
    param_52 = _e220;
    param_53 = (_e213 * _e215);
    let _e221 = (*bleed_1);
    param_54 = _e221;
    let _e222 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e222;
    let _e223 = positive;
    let _e224 = negative;
    return min(_e223, _e224);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e183 = (*depth_2);
    stored_3 = max((1f - _e183), 0.000061035156f);
    let _e186 = stored_3;
    return exp2((floor(log2(_e186)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_10: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_11: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_13: f32;
    var local_14: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_3519_: bool;
    var phi_3530_: bool;
    var phi_3691_: bool;
    var phi_3698_: bool;
    var phi_3705_: bool;

    let _e262 = frag_info.shadow_params[3u];
    strength_1 = _e262;
    let _e263 = strength_1;
    if (_e263 <= 0f) {
        return 1f;
    }
    let _e265 = (*lightIndex_1);
    let _e268 = frag_info.frame_params[2u];
    if (_e265 != i32(floor((_e268 + 0.5f)))) {
        return 1f;
    }
    let _e275 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e275 + 0.5f));
    let _e278 = Orthographic_u0028_();
    if _e278 {
        let _e279 = ViewDepth_u0028_();
        local_10 = _e279;
    } else {
        let _e280 = v_world_position_1;
        let _e282 = frag_info.camera_position;
        local_10 = length((_e280 - _e282.xyz));
    }
    let _e286 = local_10;
    viewDistance = _e286;
    cascade = 0i;
    let _e287 = cascadeCount;
    let _e288 = (_e287 > 1i);
    phi_3519_ = _e288;
    if _e288 {
        let _e289 = viewDistance;
        let _e292 = frag_info.shadow_cascades[0u];
        phi_3519_ = (_e289 > _e292);
    }
    let _e295 = phi_3519_;
    if _e295 {
        cascade = 1i;
    }
    let _e296 = cascadeCount;
    let _e297 = (_e296 > 2i);
    phi_3530_ = _e297;
    if _e297 {
        let _e298 = viewDistance;
        let _e301 = frag_info.shadow_cascades[1u];
        phi_3530_ = (_e298 > _e301);
    }
    let _e304 = phi_3530_;
    if _e304 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e305 = attempt;
        if (_e305 < 3i) {
            let _e307 = cascade;
            let _e308 = attempt;
            which = (_e307 + _e308);
            let _e310 = which;
            let _e311 = cascadeCount;
            if (_e310 >= _e311) {
                break;
            }
            let _e313 = which;
            if (_e313 == 0i) {
                let _e316 = frag_info.shadow_matrix;
                local_11 = _e316;
            } else {
                let _e317 = which;
                if (_e317 == 1i) {
                    let _e320 = frag_info.shadow_matrix_far;
                    local_12 = _e320;
                } else {
                    let _e322 = frag_info.shadow_matrix_farthest;
                    local_12 = _e322;
                }
                let _e323 = local_12;
                local_11 = _e323;
            }
            let _e324 = local_11;
            matrix = _e324;
            let _e327 = matrix[0][0u];
            let _e330 = matrix[1][0u];
            let _e333 = matrix[2][0u];
            axisX = vec3<f32>(_e327, _e330, _e333);
            let _e337 = matrix[0][1u];
            let _e340 = matrix[1][1u];
            let _e343 = matrix[2][1u];
            axisY = vec3<f32>(_e337, _e340, _e343);
            let _e345 = axisX;
            rowX = max(length(_e345), 0.000001f);
            let _e348 = axisY;
            rowY = max(length(_e348), 0.000001f);
            let _e353 = frag_info.shadow_cascades[3u];
            let _e355 = rowX;
            texelMetres = ((2f * _e353) / _e355);
            let _e359 = frag_info.shadow_cascades[3u];
            let _e362 = (*s_2).n;
            let _e363 = axisX;
            let _e366 = rowX;
            let _e367 = rowX;
            let _e371 = (*s_2).n;
            let _e372 = axisY;
            let _e375 = rowY;
            let _e376 = rowY;
            reach = ((3f * _e359) * ((abs(dot(_e362, _e363)) / (_e366 * _e367)) + (abs(dot(_e371, _e372)) / (_e375 * _e376))));
            let _e383 = frag_info.shadow_params[2u];
            let _e384 = texelMetres;
            flatOffset = min(_e383, _e384);
            let _e386 = v_world_position_1;
            let _e388 = (*s_2).n;
            let _e389 = flatOffset;
            let _e390 = reach;
            origin_1 = (_e386 + (_e388 * (_e389 + _e390)));
            let _e394 = matrix;
            let _e395 = origin_1;
            lightSpace = (_e394 * vec4<f32>(_e395.x, _e395.y, _e395.z, 1f));
            let _e402 = lightSpace[3u];
            if (_e402 <= 0f) {
                continue;
            }
            let _e404 = lightSpace;
            let _e407 = lightSpace[3u];
            candidate = (_e404.xyz / vec3(_e407));
            let _e411 = candidate[0u];
            let _e415 = candidate[1u];
            inTile = vec2<f32>(((_e411 * 0.5f) + 0.5f), (0.5f - (_e415 * 0.5f)));
            let _e420 = inTile[0u];
            let _e421 = (_e420 < 0f);
            phi_3691_ = _e421;
            if !(_e421) {
                let _e424 = inTile[0u];
                phi_3691_ = (_e424 > 1f);
            }
            let _e427 = phi_3691_;
            phi_3698_ = _e427;
            if !(_e427) {
                let _e430 = inTile[1u];
                phi_3698_ = (_e430 < 0f);
            }
            let _e433 = phi_3698_;
            phi_3705_ = _e433;
            if !(_e433) {
                let _e436 = inTile[1u];
                phi_3705_ = (_e436 > 1f);
            }
            let _e439 = phi_3705_;
            if _e439 {
                continue;
            }
            let _e441 = candidate[2u];
            if (_e441 > 1f) {
                let _e443 = which;
                let _e444 = cascadeCount;
                if (_e443 < (_e444 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e449 = inTile[0u];
            let _e450 = which;
            let _e453 = cascadeCount;
            let _e457 = inTile[1u];
            uv_4 = vec2<f32>(((_e449 + f32(_e450)) / f32(_e453)), _e457);
            let _e459 = candidate;
            projected = _e459;
            let _e460 = which;
            cascade = _e460;
            let _e461 = texelMetres;
            cascadeTexel = _e461;
            let _e464 = matrix[0][2u];
            let _e467 = matrix[1][2u];
            let _e470 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e464, _e467, _e470)), 0.000001f));
            let _e476 = (*s_2).n;
            let _e479 = matrix[0][2u];
            let _e482 = matrix[1][2u];
            let _e485 = matrix[2][2u];
            let _e489 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e476, vec3<f32>(_e479, _e482, _e485))) * _e489), 0.1f, 1f);
            let _e492 = texelMetres;
            let _e493 = cosSlope;
            let _e494 = cosSlope;
            let _e500 = cosSlope;
            let _e502 = cascadeDepth;
            receiverSlope = (((_e492 * sqrt(max((1f - (_e493 * _e494)), 0f))) / _e500) / _e502);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e504 = attempt;
            attempt = (_e504 + 1i);
        }
    }
    let _e506 = found;
    if !(_e506) {
        return 1f;
    }
    let _e508 = cascade;
    if (_e508 == 0i) {
        let _e512 = frag_info.shadow_bias[0u];
        local_13 = _e512;
    } else {
        let _e513 = cascade;
        if (_e513 == 1i) {
            let _e517 = frag_info.shadow_bias[1u];
            local_14 = _e517;
        } else {
            let _e520 = frag_info.shadow_bias[2u];
            local_14 = _e520;
        }
        let _e521 = local_14;
        local_13 = _e521;
    }
    let _e522 = local_13;
    bias = _e522;
    let _e525 = frag_info.shadow_params[1u];
    storage_ = _e525;
    let _e526 = storage_;
    let _e528 = storage_;
    if ((_e526 > 0.5f) && (_e528 < 1.5f)) {
        let _e531 = bias;
        let _e533 = projected[2u];
        param_55 = _e533;
        let _e534 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e531, _e534);
    }
    let _e538 = frag_info.shadow_params[0u];
    let _e541 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e538, _e541);
    let _e543 = cascade;
    let _e545 = cascadeCount;
    let _e549 = texel_1;
    tileLo = (vec2<f32>((f32(_e543) / f32(_e545)), 0f) + (_e549 * 0.5f));
    let _e552 = cascade;
    let _e555 = cascadeCount;
    let _e559 = texel_1;
    tileHi = (vec2<f32>((f32((_e552 + 1i)) / f32(_e555)), 1f) - (_e559 * 0.5f));
    let _e564 = frag_info.shadow_bias[3u];
    if (_e564 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e566 = y;
            if (_e566 <= 1i) {
                x = -1i;
                loop {
                    let _e568 = x;
                    if (_e568 <= 1i) {
                        let _e570 = uv_4;
                        let _e571 = x;
                        let _e573 = y;
                        let _e576 = texel_1;
                        let _e579 = tileLo;
                        let _e580 = tileHi;
                        let _e582 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e570 + (vec2<f32>(f32(_e571), f32(_e573)) * _e576)), _e579, _e580), 0f);
                        let _e583 = stored_4;
                        stored_4 = (_e583 + _e582);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e585 = x;
                        x = (_e585 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e587 = y;
                y = (_e587 + 1i);
            }
        }
        let _e589 = stored_4;
        stored_4 = (_e589 * 0.11111111f);
        let _e592 = stored_4[1u];
        let _e595 = stored_4[2u];
        let _e598 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e592), (1f - _e595), _e598), vec3(0f), vec3(4f));
        let _e603 = through;
        let _e604 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e603, vec3(clamp(_e604, 0f, 1f)));
    }
    let _e610 = frag_info.ambient_ground[3u];
    softness = _e610;
    lit_1 = 0f;
    let _e611 = softness;
    if (_e611 < 0f) {
        let _e613 = uv_4;
        let _e614 = tileLo;
        let _e615 = tileHi;
        let _e617 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e613, _e614, _e615), 0f);
        moments_2 = _e617;
        let _e619 = projected[2u];
        let _e620 = bias;
        let _e622 = softness;
        let _e626 = moments_2;
        param_56 = _e626;
        param_57 = (_e619 - _e620);
        param_58 = clamp((-(_e622) - 1f), 0f, 0.95f);
        let _e627 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e627;
    } else {
        let _e628 = softness;
        if (_e628 <= 0f) {
            y_1 = -1i;
            loop {
                let _e630 = y_1;
                if (_e630 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e632 = x_1;
                        if (_e632 <= 1i) {
                            let _e634 = uv_4;
                            let _e635 = x_1;
                            let _e637 = y_1;
                            let _e640 = texel_1;
                            let _e643 = tileLo;
                            let _e644 = tileHi;
                            let _e646 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e634 + (vec2<f32>(f32(_e635), f32(_e637)) * _e640)), _e643, _e644), 0f);
                            param_59 = _e646.x;
                            let _e648 = storage_;
                            param_60 = _e648;
                            let _e649 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e649;
                            let _e651 = projected[2u];
                            let _e652 = bias;
                            let _e654 = occluder;
                            let _e657 = lit_1;
                            lit_1 = (_e657 + select(1f, 0f, ((_e651 - _e652) > _e654)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e659 = x_1;
                            x_1 = (_e659 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e661 = y_1;
                    y_1 = (_e661 + 1i);
                }
            }
            let _e663 = lit_1;
            lit_1 = (_e663 * 0.11111111f);
        } else {
            let _e665 = softness;
            spread = tan(min(_e665, 0.5f));
            let _e668 = ShadowNoise_u0028_();
            turn_1 = (_e668 * 6.2831855f);
            let _e670 = spread;
            let _e672 = projected[2u];
            let _e674 = cascadeDepth;
            let _e676 = cascadeTexel;
            searchRadius = clamp((((_e670 * _e672) * _e674) / _e676), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e679 = i_5;
                if (_e679 < 16i) {
                    let _e681 = i_5;
                    param_61 = _e681;
                    param_62 = 16i;
                    let _e682 = turn_1;
                    param_63 = _e682;
                    let _e683 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e683;
                    let _e684 = bias;
                    let _e685 = disc;
                    let _e687 = searchRadius;
                    let _e691 = receiverSlope;
                    tapBias = (_e684 + (max(((length(_e685) * _e687) - 1.5f), 0f) * _e691));
                    let _e694 = uv_4;
                    let _e695 = disc;
                    let _e696 = texel_1;
                    let _e698 = searchRadius;
                    let _e701 = tileLo;
                    let _e702 = tileHi;
                    let _e704 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e694 + ((_e695 * _e696) * _e698)), _e701, _e702), 0f);
                    param_64 = _e704.x;
                    let _e706 = storage_;
                    param_65 = _e706;
                    let _e707 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e707;
                    let _e709 = projected[2u];
                    let _e710 = tapBias;
                    let _e712 = occluder_1;
                    if ((_e709 - _e710) > _e712) {
                        let _e714 = occluder_1;
                        let _e715 = blockerSum;
                        blockerSum = (_e715 + _e714);
                        let _e717 = blockerCount;
                        blockerCount = (_e717 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e719 = i_5;
                    i_5 = (_e719 + 1i);
                }
            }
            let _e721 = blockerCount;
            if (_e721 <= 0f) {
                return 1f;
            }
            let _e724 = projected[2u];
            let _e725 = blockerSum;
            let _e726 = blockerCount;
            let _e730 = cascadeDepth;
            gap = (max((_e724 - (_e725 / _e726)), 0f) * _e730);
            let _e732 = spread;
            let _e733 = gap;
            let _e735 = cascadeTexel;
            radius_2 = clamp(((_e732 * _e733) / _e735), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e738 = i_6;
                if (_e738 < 16i) {
                    let _e740 = turn_1;
                    let _e742 = i_6;
                    param_66 = _e742;
                    param_67 = 16i;
                    param_68 = (_e740 + 1f);
                    let _e743 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e743;
                    let _e744 = bias;
                    let _e745 = disc_1;
                    let _e747 = radius_2;
                    let _e751 = receiverSlope;
                    tapBias_1 = (_e744 + (max(((length(_e745) * _e747) - 1.5f), 0f) * _e751));
                    let _e754 = uv_4;
                    let _e755 = disc_1;
                    let _e756 = texel_1;
                    let _e758 = radius_2;
                    let _e761 = tileLo;
                    let _e762 = tileHi;
                    let _e764 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e754 + ((_e755 * _e756) * _e758)), _e761, _e762), 0f);
                    param_69 = _e764.x;
                    let _e766 = storage_;
                    param_70 = _e766;
                    let _e767 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e767;
                    let _e769 = projected[2u];
                    let _e770 = tapBias_1;
                    let _e772 = occluder_2;
                    let _e775 = lit_1;
                    lit_1 = (_e775 + select(1f, 0f, ((_e769 - _e770) > _e772)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e777 = i_6;
                    i_6 = (_e777 + 1i);
                }
            }
            let _e779 = lit_1;
            lit_1 = (_e779 * 0.0625f);
        }
    }
    let _e781 = lit_1;
    let _e782 = strength_1;
    return mix(1f, _e781, clamp(_e782, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e187 = (*s_3);
    param_71 = _e187;
    let _e188 = (*light_2);
    param_72 = _e188;
    let _e189 = (*index);
    param_73 = _e189;
    let _e190 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e190;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e182 = (*index_1);
    return (_e182 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e186 = (*distance_1);
    let _e187 = (*distance_1);
    attenuation = (1f / max((_e186 * _e187), 0.0001f));
    let _e191 = (*range_4);
    if (_e191 > 0f) {
        let _e193 = (*distance_1);
        let _e194 = (*range_4);
        ratio = (_e193 / _e194);
        let _e196 = ratio;
        let _e197 = ratio;
        let _e199 = ratio;
        let _e201 = ratio;
        window = clamp((1f - (((_e196 * _e197) * _e199) * _e201)), 0f, 1f);
        let _e205 = window;
        let _e206 = window;
        let _e208 = attenuation;
        attenuation = (_e208 * (_e205 * _e206));
    }
    let _e210 = attenuation;
    return _e210;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_15: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e198 = (*halfWidth);
    let _e199 = (*halfHeight);
    n_2 = cross(_e198, _e199);
    let _e201 = n_2;
    nLen = length(_e201);
    let _e203 = nLen;
    if (_e203 < 0.000000000001f) {
        let _e205 = (*centre);
        return _e205;
    }
    let _e206 = nLen;
    let _e207 = n_2;
    n_2 = (_e207 / vec3(_e206));
    let _e210 = (*centre);
    let _e211 = (*world_2);
    toPlane = (_e210 - _e211);
    let _e213 = (*mirror);
    let _e214 = n_2;
    denom = dot(_e213, _e214);
    let _e216 = denom;
    if (abs(_e216) < 0.00001f) {
        let _e219 = toPlane;
        let _e220 = n_2;
        let _e221 = toPlane;
        let _e222 = n_2;
        onPlane = (_e219 - (_e220 * dot(_e221, _e222)));
    } else {
        let _e226 = toPlane;
        let _e227 = n_2;
        let _e229 = denom;
        t_1 = (dot(_e226, _e227) / _e229);
        let _e231 = t_1;
        if (_e231 > 0f) {
            let _e233 = (*mirror);
            let _e234 = t_1;
            local_15 = (_e233 * _e234);
        } else {
            let _e236 = toPlane;
            let _e237 = n_2;
            let _e238 = toPlane;
            let _e239 = n_2;
            local_15 = (_e236 - (_e237 * dot(_e238, _e239)));
        }
        let _e243 = local_15;
        onPlane = _e243;
    }
    let _e244 = onPlane;
    let _e245 = toPlane;
    offset_2 = (_e244 - _e245);
    let _e247 = (*halfWidth);
    let _e248 = (*halfWidth);
    wLen2_ = max(dot(_e247, _e248), 0.000000000001f);
    let _e251 = (*halfHeight);
    let _e252 = (*halfHeight);
    hLen2_ = max(dot(_e251, _e252), 0.000000000001f);
    let _e255 = offset_2;
    let _e256 = (*halfWidth);
    let _e258 = wLen2_;
    u = clamp((dot(_e255, _e256) / _e258), -1f, 1f);
    let _e261 = offset_2;
    let _e262 = (*halfHeight);
    let _e264 = hLen2_;
    v = clamp((dot(_e261, _e262) / _e264), -1f, 1f);
    let _e267 = (*centre);
    let _e268 = (*halfWidth);
    let _e269 = u;
    let _e272 = (*halfHeight);
    let _e273 = v;
    return ((_e267 + (_e268 * _e269)) + (_e272 * _e273));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_16: f32;

    let _e190 = (*a_1);
    let _e191 = (*a_1);
    ua = (_e190 / vec3(max(length(_e191), 0.000000000001f)));
    let _e196 = (*b);
    let _e197 = (*b);
    ub = (_e196 / vec3(max(length(_e197), 0.000000000001f)));
    let _e202 = ua;
    let _e203 = ub;
    angle_1 = acos(clamp(dot(_e202, _e203), -1f, 1f));
    let _e207 = ua;
    let _e208 = ub;
    axis = cross(_e207, _e208);
    let _e210 = axis;
    len = length(_e210);
    let _e212 = len;
    if (_e212 > 0.000001f) {
        let _e214 = angle_1;
        let _e215 = axis;
        let _e216 = (*n_3);
        let _e219 = len;
        local_16 = ((_e214 * dot(_e215, _e216)) / _e219);
    } else {
        local_16 = 0f;
    }
    let _e221 = local_16;
    return _e221;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_17: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_18: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_19: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e204 = i_7;
        if (_e204 < 4i) {
            let _e206 = i_7;
            let _e208 = (*corners)[_e206];
            a_2 = _e208;
            let _e209 = i_7;
            if (_e209 == 3i) {
                local_17 = 0i;
            } else {
                let _e211 = i_7;
                local_17 = (_e211 + 1i);
            }
            let _e213 = local_17;
            let _e215 = (*corners)[_e213];
            b_1 = _e215;
            let _e216 = a_2;
            let _e217 = (*n_4);
            ha = dot(_e216, _e217);
            let _e219 = b_1;
            let _e220 = (*n_4);
            hb = dot(_e219, _e220);
            let _e222 = ha;
            let _e223 = hb;
            d_3 = (_e222 - _e223);
            let _e225 = a_2;
            let _e226 = b_1;
            let _e227 = a_2;
            let _e229 = d_3;
            if (abs(_e229) > 0.000000000001f) {
                let _e232 = ha;
                let _e233 = d_3;
                local_18 = (_e232 / _e233);
            } else {
                local_18 = 0f;
            }
            let _e235 = local_18;
            q = (_e225 + ((_e226 - _e227) * _e235));
            let _e238 = ha;
            aAbove = (_e238 > 0f);
            let _e240 = hb;
            bAbove = (_e240 > 0f);
            let _e242 = aAbove;
            let _e243 = bAbove;
            if (_e242 || _e243) {
                let _e245 = aAbove;
                let _e246 = a_2;
                let _e247 = q;
                let _e250 = bAbove;
                let _e251 = b_1;
                let _e252 = q;
                param_74 = select(_e247, _e246, vec3(_e245));
                param_75 = select(_e252, _e251, vec3(_e250));
                let _e255 = (*n_4);
                param_76 = _e255;
                let _e256 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_19 = _e256;
            } else {
                local_19 = 0f;
            }
            let _e257 = local_19;
            let _e258 = total;
            total = (_e258 + _e257);
            let _e260 = aAbove;
            let _e261 = bAbove;
            let _e264 = q;
            let _e265 = exit;
            exit = select(_e265, _e264, vec3((_e260 && !(_e261))));
            let _e268 = aAbove;
            let _e270 = bAbove;
            let _e272 = q;
            let _e273 = entry;
            entry = select(_e273, _e272, vec3((!(_e268) && _e270)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e276 = i_7;
            i_7 = (_e276 + 1i);
        }
    }
    let _e278 = exit;
    param_77 = _e278;
    let _e279 = entry;
    param_78 = _e279;
    let _e280 = (*n_4);
    param_79 = _e280;
    let _e281 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e282 = total;
    total = (_e282 + _e281);
    let _e284 = total;
    return max((-(_e284) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_20: f32;
    var local_21: f32;
    var local_22: f32;

    let _e187 = (*slot_1);
    let _e188 = (*slot_1);
    lane = (_e187 - ((_e188 / 4i) * 4i));
    let _e192 = lane;
    if (_e192 == 0i) {
        let _e195 = (*four)[0u];
        local_20 = _e195;
    } else {
        let _e196 = lane;
        if (_e196 == 1i) {
            let _e199 = (*four)[1u];
            local_21 = _e199;
        } else {
            let _e200 = lane;
            if (_e200 == 2i) {
                let _e203 = (*four)[2u];
                local_22 = _e203;
            } else {
                let _e205 = (*four)[3u];
                local_22 = _e205;
            }
            let _e206 = local_22;
            local_21 = _e206;
        }
        let _e207 = local_21;
        local_20 = _e207;
    }
    let _e208 = local_20;
    return _e208;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e184 = (*slot_2);
    let _e188 = light_list_info.scales[(_e184 / 4i)];
    param_80 = _e188;
    let _e189 = (*slot_2);
    param_81 = _e189;
    let _e190 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e190;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e186 = light_list_info.slot_rows[0i];
    let _e187 = (*row);
    a_3 = abs((_e186 - vec4(_e187)));
    let _e193 = light_list_info.slot_rows[1i];
    let _e194 = (*row);
    b_2 = abs((_e193 - vec4(_e194)));
    let _e199 = a_3[0u];
    let _e201 = a_3[1u];
    let _e204 = a_3[2u];
    let _e206 = a_3[3u];
    let _e210 = b_2[0u];
    let _e212 = b_2[1u];
    let _e215 = b_2[2u];
    let _e217 = b_2[3u];
    return (min(min(min(_e199, _e201), min(_e204, _e206)), min(min(_e210, _e212), min(_e215, _e217))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e184 = (*slot_3);
    let _e188 = light_list_info.indices[(_e184 / 4i)];
    param_82 = _e188;
    let _e189 = (*slot_3);
    param_83 = _e189;
    let _e190 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e190;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e183 = (*texel_2);
    let _e187 = light_list_info.list[1u];
    let _e189 = (*row_1);
    let _e193 = light_list_info.list[2u];
    let _e196 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e183 + 0.5f) * _e187), ((_e189 + 0.5f) * _e193)), 0f);
    return _e196;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e191 = g_cluster_offset;
    let _e192 = (*slot_4);
    entry_1 = (_e191 + f32(_e192));
    let _e195 = entry_1;
    row_2 = floor((_e195 / 16f));
    let _e198 = entry_1;
    let _e199 = row_2;
    within = (_e198 - (_e199 * 16f));
    let _e202 = within;
    texel_3 = floor((_e202 / 4f));
    let _e207 = light_list_info.cluster_depth[3u];
    let _e208 = row_2;
    let _e210 = texel_3;
    param_84 = _e210;
    param_85 = (_e207 + _e208);
    let _e211 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e211;
    let _e212 = within;
    let _e213 = texel_3;
    let _e218 = four_1;
    param_86 = _e218;
    param_87 = i32(((_e212 - (_e213 * 4f)) + 0.5f));
    let _e219 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e219;
}

fn Clustered_u0028_() -> bool {
    let _e183 = light_list_info.cluster_grid[3u];
    return (_e183 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_23: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_24: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_25: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_26: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_27: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e235 = (*index_2);
    if (_e235 < 8i) {
        let _e237 = (*index_2);
        let _e240 = frag_info.light_position[_e237];
        position = _e240;
        let _e241 = (*index_2);
        let _e244 = frag_info.light_color[_e241];
        color_1 = _e244;
        let _e245 = (*index_2);
        let _e248 = frag_info.light_direction[_e245];
        direction = _e248;
        let _e249 = (*index_2);
        let _e252 = frag_info.light_cone[_e249];
        cone = _e252;
    } else {
        let _e253 = (*index_2);
        slot_5 = (_e253 - 8i);
        let _e255 = Clustered_u0028_();
        clustered = _e255;
        let _e256 = clustered;
        if _e256 {
            let _e257 = slot_5;
            param_88 = _e257;
            let _e258 = ClusterRow_u0028_i1_u003b((&param_88));
            local_23 = _e258;
        } else {
            let _e259 = slot_5;
            param_89 = _e259;
            let _e260 = LightListRow_u0028_i1_u003b((&param_89));
            local_23 = _e260;
        }
        let _e261 = local_23;
        listRow = _e261;
        let _e262 = listRow;
        let _e266 = light_list_info.list[2u];
        v_1 = ((_e262 + 0.5f) * _e266);
        let _e270 = light_list_info.list[1u];
        u_1 = _e270;
        let _e271 = u_1;
        let _e273 = v_1;
        let _e275 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e271), _e273), 0f);
        position = _e275;
        let _e276 = u_1;
        let _e278 = v_1;
        let _e280 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e276), _e278), 0f);
        color_1 = _e280;
        let _e281 = u_1;
        let _e283 = v_1;
        let _e285 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e281), _e283), 0f);
        direction = _e285;
        let _e286 = u_1;
        let _e288 = v_1;
        let _e290 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e286), _e288), 0f);
        cone = _e290;
        let _e291 = clustered;
        if _e291 {
            let _e292 = listRow;
            param_90 = _e292;
            let _e293 = InSlots_u0028_f1_u003b((&param_90));
            local_24 = select(1f, 0f, _e293);
        } else {
            let _e295 = slot_5;
            param_91 = _e295;
            let _e296 = LightListScale_u0028_i1_u003b((&param_91));
            local_24 = _e296;
        }
        let _e297 = local_24;
        let _e299 = color_1[3u];
        color_1[3u] = (_e299 * _e297);
    }
    let _e303 = position[3u];
    type_39 = _e303;
    let _e304 = type_39;
    if (_e304 > 15.5f) {
        let _e307 = (*s_4).n;
        light_3.l = _e307;
        let _e310 = (*s_4).n;
        light_3.h = _e310;
        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 _e316 = light_3;
        return _e316;
    }
    let _e317 = type_39;
    if (_e317 > 2.5f) {
        let _e319 = direction;
        halfWidth_1 = _e319.xyz;
        let _e321 = cone;
        halfHeight_1 = _e321.xyz;
        let _e323 = position;
        let _e325 = v_world_position_1;
        toCentre = (_e323.xyz - _e325);
        let _e327 = toCentre;
        let _e328 = halfWidth_1;
        let _e330 = halfHeight_1;
        corners_1[0i] = ((_e327 - _e328) - _e330);
        let _e333 = toCentre;
        let _e334 = halfWidth_1;
        let _e336 = halfHeight_1;
        corners_1[1i] = ((_e333 + _e334) - _e336);
        let _e339 = toCentre;
        let _e340 = halfWidth_1;
        let _e342 = halfHeight_1;
        corners_1[2i] = ((_e339 + _e340) + _e342);
        let _e345 = toCentre;
        let _e346 = halfWidth_1;
        let _e348 = halfHeight_1;
        corners_1[3i] = ((_e345 - _e346) + _e348);
        let _e351 = toCentre;
        let _e352 = halfWidth_1;
        let _e353 = halfHeight_1;
        behind = (dot(_e351, cross(_e352, _e353)) >= 0f);
        let _e357 = behind;
        if _e357 {
            local_25 = 0f;
        } else {
            let _e358 = corners_1;
            param_92 = _e358;
            let _e360 = (*s_4).n;
            param_93 = _e360;
            let _e361 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_25 = _e361;
        }
        let _e362 = local_25;
        formFactor = _e362;
        let _e363 = halfWidth_1;
        let _e364 = halfHeight_1;
        area = (length(cross(_e363, _e364)) * 4f);
        let _e368 = area;
        if (_e368 > 0.000000001f) {
            let _e370 = area;
            local_26 = (1f / _e370);
        } else {
            local_26 = 0f;
        }
        let _e372 = local_26;
        radiance = _e372;
        let _e373 = toCentre;
        distance_2 = length(_e373);
        let _e376 = direction[3u];
        if (_e376 > 0f) {
            let _e378 = distance_2;
            let _e380 = direction[3u];
            ratio_1 = (_e378 / _e380);
            let _e382 = ratio_1;
            let _e383 = ratio_1;
            let _e385 = ratio_1;
            let _e387 = ratio_1;
            window_1 = clamp((1f - (((_e382 * _e383) * _e385) * _e387)), 0f, 1f);
            let _e391 = window_1;
            let _e392 = window_1;
            let _e394 = radiance;
            radiance = (_e394 * (_e391 * _e392));
        }
        let _e397 = (*s_4).v;
        let _e400 = (*s_4).n;
        mirror_1 = reflect(-(_e397), _e400);
        let _e402 = position;
        param_94 = _e402.xyz;
        let _e404 = halfWidth_1;
        param_95 = _e404;
        let _e405 = halfHeight_1;
        param_96 = _e405;
        let _e406 = v_world_position_1;
        param_97 = _e406;
        let _e407 = mirror_1;
        param_98 = _e407;
        let _e408 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e408;
        let _e409 = representative;
        let _e410 = v_world_position_1;
        toPoint = (_e409 - _e410);
        let _e412 = toPoint;
        pointDistance = length(_e412);
        let _e414 = pointDistance;
        if (_e414 > 0.000001f) {
            let _e416 = toPoint;
            let _e417 = pointDistance;
            local_27 = (_e416 / vec3(_e417));
        } else {
            let _e421 = (*s_4).n;
            local_27 = _e421;
        }
        let _e422 = local_27;
        light_3.l = _e422;
        let _e425 = light_3.l;
        let _e427 = (*s_4).v;
        light_3.h = normalize((_e425 + _e427));
        let _e431 = formFactor;
        light_3.n_dot_l = _e431;
        let _e434 = (*s_4).n;
        let _e436 = light_3.h;
        light_3.n_dot_h = max(dot(_e434, _e436), 0f);
        let _e441 = (*s_4).v;
        let _e443 = light_3.h;
        light_3.v_dot_h = max(dot(_e441, _e443), 0f);
        let _e447 = color_1;
        let _e450 = color_1[3u];
        let _e452 = radiance;
        light_3.radiance = ((_e447.xyz * _e450) * _e452);
        let _e455 = light_3;
        return _e455;
    }
    let _e456 = direction;
    aim = normalize(_e456.xyz);
    attenuation_1 = 1f;
    let _e459 = type_39;
    if (_e459 < 0.5f) {
        let _e461 = aim;
        light_3.l = -(_e461);
    } else {
        let _e464 = position;
        let _e466 = v_world_position_1;
        toLight_1 = (_e464.xyz - _e466);
        let _e468 = toLight_1;
        distance_3 = length(_e468);
        let _e470 = distance_3;
        if (_e470 < 0.000001f) {
            let _e473 = (*s_4).n;
            light_3.l = _e473;
            let _e476 = (*s_4).n;
            light_3.h = _e476;
            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 _e482 = light_3;
            return _e482;
        }
        let _e483 = toLight_1;
        let _e484 = distance_3;
        light_3.l = (_e483 / vec3(_e484));
        let _e488 = distance_3;
        param_99 = _e488;
        let _e490 = direction[3u];
        param_100 = _e490;
        let _e491 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e491;
        let _e492 = type_39;
        if (_e492 > 1.5f) {
            let _e494 = aim;
            let _e496 = light_3.l;
            cosAngle = dot(_e494, -(_e496));
            let _e499 = cosAngle;
            let _e501 = cone[1u];
            let _e504 = cone[0u];
            let _e506 = cone[1u];
            ramp = clamp(((_e499 - _e501) / (_e504 - _e506)), 0f, 1f);
            let _e510 = ramp;
            let _e511 = ramp;
            let _e513 = attenuation_1;
            attenuation_1 = (_e513 * (_e510 * _e511));
        }
    }
    let _e516 = light_3.l;
    let _e518 = (*s_4).v;
    light_3.h = normalize((_e516 + _e518));
    let _e523 = (*s_4).n;
    let _e525 = light_3.l;
    light_3.n_dot_l = max(dot(_e523, _e525), 0f);
    let _e530 = (*s_4).n;
    let _e532 = light_3.h;
    light_3.n_dot_h = max(dot(_e530, _e532), 0f);
    let _e537 = (*s_4).v;
    let _e539 = light_3.h;
    light_3.v_dot_h = max(dot(_e537, _e539), 0f);
    let _e543 = color_1;
    let _e546 = color_1[3u];
    let _e548 = attenuation_1;
    light_3.radiance = ((_e543.xyz * _e546) * _e548);
    let _e551 = light_3;
    return _e551;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_28: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e196 = light_list_info.cluster_view_projection;
    let _e197 = (*world_3);
    clip_1 = (_e196 * vec4<f32>(_e197.x, _e197.y, _e197.z, 1f));
    let _e203 = clip_1;
    let _e206 = clip_1[3u];
    ndc_1 = (_e203.xy / vec2(max(_e206, 0.000001f)));
    let _e211 = light_list_info.cluster_grid;
    grid = _e211.xyz;
    let _e215 = light_list_info.cluster_depth[0u];
    near_1 = _e215;
    let _e217 = ndc_1[0u];
    let _e221 = grid[0u];
    let _e225 = grid[0u];
    tx = clamp(floor((((_e217 * 0.5f) + 0.5f) * _e221)), 0f, (_e225 - 1f));
    let _e229 = ndc_1[1u];
    let _e233 = grid[1u];
    let _e237 = grid[1u];
    ty = clamp(floor((((_e229 * 0.5f) + 0.5f) * _e233)), 0f, (_e237 - 1f));
    let _e241 = clip_1[3u];
    let _e242 = near_1;
    if (_e241 <= _e242) {
        local_28 = 0f;
    } else {
        let _e245 = clip_1[3u];
        let _e246 = near_1;
        let _e251 = light_list_info.cluster_depth[1u];
        let _e255 = grid[2u];
        local_28 = clamp(floor((log((_e245 / _e246)) * _e251)), 0f, (_e255 - 1f));
    }
    let _e258 = local_28;
    tz = _e258;
    let _e259 = tx;
    let _e260 = ty;
    let _e262 = grid[0u];
    let _e265 = tz;
    let _e267 = grid[0u];
    let _e270 = grid[1u];
    cell = ((_e259 + (_e260 * _e262)) + ((_e265 * _e267) * _e270));
    let _e273 = cell;
    row_3 = floor((_e273 / 4f));
    let _e276 = cell;
    let _e277 = row_3;
    let _e282 = light_list_info.cluster_depth[2u];
    let _e283 = row_3;
    param_101 = (_e276 - (_e277 * 4f));
    param_102 = (_e282 + _e283);
    let _e285 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e285;
    let _e287 = header[0u];
    g_cluster_offset = _e287;
    let _e289 = header[1u];
    g_cluster_count = _e289;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e185 = light_list_info.list[0u];
    tail = _e185;
    let _e186 = Clustered_u0028_();
    if _e186 {
        let _e187 = v_world_position_1;
        param_103 = _e187;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e188 = g_cluster_count;
        tail = _e188;
    }
    let _e191 = frag_info.frame_params[1u];
    let _e195 = tail;
    return (clamp(i32((_e191 + 0.5f)), 0i, 8i) + clamp(i32((_e195 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_29: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e199 = LightCount_u0028_();
    count_1 = _e199;
    i_8 = 0i;
    loop {
        let _e200 = i_8;
        if (_e200 < 32i) {
            let _e202 = i_8;
            let _e203 = count_1;
            if (_e202 >= _e203) {
                break;
            }
            let _e205 = i_8;
            param_104 = _e205;
            let _e206 = (*s_5);
            param_105 = _e206;
            let _e207 = 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((&param_104), (&param_105));
            light_4 = _e207;
            let _e209 = light_4.n_dot_l;
            if (_e209 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e211 = i_8;
            param_106 = _e211;
            let _e212 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e212 {
                let _e213 = (*s_5);
                param_107 = _e213;
                let _e214 = light_4;
                param_108 = _e214;
                let _e215 = i_8;
                param_109 = _e215;
                let _e216 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e217 = v_world_position_1;
                param_110 = _e217;
                let _e219 = (*s_5).n;
                param_111 = _e219;
                let _e220 = i_8;
                param_112 = _e220;
                let _e221 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_29 = (_e216 * _e221);
            } else {
                local_29 = 1f;
            }
            let _e223 = local_29;
            visibility = _e223;
            let _e224 = visibility;
            if (_e224 <= 0f) {
                continue;
            }
            let _e226 = (*s_5);
            param_113 = _e226;
            let _e227 = light_4;
            param_114 = _e227;
            let _e228 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e230 = light_4.radiance;
            let _e233 = light_4.n_dot_l;
            let _e235 = visibility;
            let _e237 = light_transmittance;
            let _e239 = total_1;
            total_1 = (_e239 + ((((_e228 * _e230) * _e233) * _e235) * _e237));
            continue;
        } else {
            break;
        }
        continuing {
            let _e241 = i_8;
            i_8 = (_e241 + 1i);
        }
    }
    let _e243 = total_1;
    return _e243;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_30: f32;
    var local_31: f32;

    let _e185 = OcclusionTarget_u0028_();
    target_ = _e185;
    let _e186 = target_;
    let _e188 = target_;
    if ((_e186 > 0.5f) && (_e188 < 1.5f)) {
        local_30 = 1f;
    } else {
        let _e192 = (*s_6).occlusion;
        local_30 = _e192;
    }
    let _e193 = local_30;
    local_31 = _e193;
    let _e194 = local_31;
    return _e194;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e182 = v_lightmap_uv_1;
    let _e183 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e182);
    texel_4 = _e183;
    let _e184 = texel_4;
    let _e187 = texel_4[3u];
    return ((_e184.xyz * _e187) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e183 = frag_info.target_origin[1u];
    return _e183;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e183 = v_texcoord_1;
    let _e184 = MaterialLodBias_u0028_();
    let _e185 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e183, _e184);
    orm = _e185.xyz;
    let _e188 = (*s_7).metallic;
    let _e190 = orm[2u];
    (*s_7).metallic = clamp((_e188 * _e190), 0f, 1f);
    let _e195 = (*s_7).roughness;
    let _e197 = orm[1u];
    (*s_7).roughness = clamp((_e195 * _e197), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e182 = (*srgb);
    let _e185 = (*srgb);
    let _e190 = (*srgb);
    return mix((_e182 / vec3(12.92f)), pow(((_e185 + 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), _e190));
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_115: vec3<f32>;

    let _e184 = v_texcoord_1;
    let _e185 = MaterialLodBias_u0028_();
    let _e186 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e184, _e185);
    param_115 = _e186.xyz;
    let _e188 = SrgbToLinear_u0028_vf3_u003b((&param_115));
    emissive = _e188;
    let _e189 = emissive;
    let _e191 = frag_info.emissive;
    let _e196 = frag_info.material2_[3u];
    (*s_8).emissive = ((_e189 * _e191.xyz) * _e196);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e184 = v_texcoord_1;
    let _e185 = MaterialLodBias_u0028_();
    let _e186 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e184, _e185);
    occlusion = _e186.x;
    let _e190 = frag_info.material2_[2u];
    let _e191 = OcclusionTarget_u0028_();
    strength_2 = (_e190 - (2f * _e191));
    let _e194 = occlusion;
    let _e195 = strength_2;
    (*s_9).occlusion = mix(1f, _e194, clamp(_e195, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e186 = v_texcoord_1;
    let _e187 = MaterialLodBias_u0028_();
    let _e188 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e186, _e187);
    sampledTexel = _e188;
    let _e189 = v_tangent_1;
    t_2 = _e189.xyz;
    let _e191 = t_2;
    let _e193 = (*s_10).n;
    let _e195 = (*s_10).n;
    let _e196 = t_2;
    t_2 = (_e191 - (_e193 * dot(_e195, _e196)));
    let _e200 = t_2;
    let _e201 = t_2;
    if (dot(_e200, _e201) < 0.000000000001f) {
        return;
    }
    let _e204 = t_2;
    t_2 = normalize(_e204);
    let _e207 = (*s_10).n;
    let _e208 = t_2;
    let _e211 = v_tangent_1[3u];
    b_3 = (cross(_e207, _e208) * _e211);
    let _e213 = gl_FrontFacing_1;
    if !(_e213) {
        let _e215 = t_2;
        t_2 = -(_e215);
    }
    let _e217 = sampledTexel;
    sampled = ((_e217.xyz * 2f) - vec3(1f));
    let _e224 = frag_info.emissive[3u];
    if (_e224 > 0.5f) {
        let _e226 = sampled;
        let _e228 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e226.xy, _e228.xy)), 0f));
    }
    let _e237 = frag_info.material2_[1u];
    let _e238 = sampled;
    let _e240 = (_e238.xy * _e237);
    sampled[0u] = _e240.x;
    sampled[1u] = _e240.y;
    let _e245 = t_2;
    let _e247 = sampled[0u];
    let _e249 = b_3;
    let _e251 = sampled[1u];
    let _e255 = (*s_10).n;
    let _e257 = sampled[2u];
    (*s_10).n = normalize((((_e245 * _e247) + (_e249 * _e251)) + (_e255 * _e257)));
    let _e263 = (*s_10).n;
    let _e265 = (*s_10).v;
    (*s_10).n_dot_v = max(dot(_e263, _e265), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e182 = (*texel_5);
    let _e186 = irradiance_info.atlas;
    let _e189 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e182 + vec2(0.5f)) * _e186.xy), 0f);
    return _e189;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_116: vec2<f32>;
    var b_4: vec4<f32>;
    var param_117: vec2<f32>;
    var c: vec4<f32>;
    var param_118: vec2<f32>;
    var d_4: vec4<f32>;
    var param_119: vec2<f32>;

    let _e195 = (*uv_5);
    let _e196 = (*interior);
    at_1 = ((vec2(1f) + (_e195 * _e196)) - vec2(0.5f));
    let _e202 = at_1;
    low = floor(_e202);
    let _e204 = at_1;
    let _e205 = low;
    f = (_e204 - _e205);
    let _e207 = (*corner);
    let _e208 = low;
    param_116 = (_e207 + _e208);
    let _e210 = AtlasTexel_u0028_vf2_u003b((&param_116));
    a_4 = _e210;
    let _e211 = (*corner);
    let _e212 = low;
    param_117 = ((_e211 + _e212) + vec2<f32>(1f, 0f));
    let _e215 = AtlasTexel_u0028_vf2_u003b((&param_117));
    b_4 = _e215;
    let _e216 = (*corner);
    let _e217 = low;
    param_118 = ((_e216 + _e217) + vec2<f32>(0f, 1f));
    let _e220 = AtlasTexel_u0028_vf2_u003b((&param_118));
    c = _e220;
    let _e221 = (*corner);
    let _e222 = low;
    param_119 = ((_e221 + _e222) + vec2<f32>(1f, 1f));
    let _e225 = AtlasTexel_u0028_vf2_u003b((&param_119));
    d_4 = _e225;
    let _e226 = a_4;
    let _e227 = b_4;
    let _e229 = f[0u];
    let _e232 = c;
    let _e233 = d_4;
    let _e235 = f[0u];
    let _e239 = f[1u];
    return mix(mix(_e226, _e227, vec4(_e229)), mix(_e232, _e233, vec4(_e235)), vec4(_e239));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e186 = (*direction_1)[0u];
    let _e189 = (*direction_1)[1u];
    let _e193 = (*direction_1)[2u];
    sum_1 = ((abs(_e186) + abs(_e189)) + abs(_e193));
    let _e196 = sum_1;
    if (_e196 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e198 = (*direction_1);
    let _e199 = sum_1;
    n_5 = (_e198 / vec3(_e199));
    let _e202 = n_5;
    xy = _e202.xy;
    let _e205 = n_5[2u];
    if (_e205 < 0f) {
        let _e208 = n_5[1u];
        let _e212 = n_5[0u];
        let _e217 = n_5[0u];
        let _e221 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e208)) * select(-1f, 1f, (_e212 >= 0f))), ((1f - abs(_e217)) * select(-1f, 1f, (_e221 >= 0f))));
    }
    let _e226 = xy;
    return ((_e226 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_120: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_121: vec3<f32>;
    var param_122: vec2<f32>;
    var param_123: f32;
    var param_124: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_125: vec3<f32>;
    var param_126: vec2<f32>;
    var param_127: f32;
    var param_128: vec2<f32>;
    var local_32: vec3<f32>;

    let _e228 = irradiance_info.origin;
    origin_2 = _e228.xyz;
    let _e231 = irradiance_info.spacing;
    spacing = _e231.xyz;
    let _e234 = irradiance_info.counts;
    counts = _e234.xyz;
    let _e238 = irradiance_info.tiles[0u];
    irradianceTile = _e238;
    let _e241 = irradiance_info.tiles[1u];
    depthTile = _e241;
    let _e244 = irradiance_info.tiles[2u];
    columns = _e244;
    let _e247 = irradiance_info.tiles[3u];
    momentsTop = _e247;
    let _e248 = (*normal_1);
    unit = normalize(_e248);
    let _e250 = (*world_4);
    let _e251 = unit;
    let _e254 = irradiance_info.spacing[3u];
    let _e257 = (*view);
    let _e260 = irradiance_info.counts[3u];
    biased = ((_e250 + (_e251 * _e254)) + (_e257 * _e260));
    let _e263 = biased;
    let _e264 = origin_2;
    let _e266 = spacing;
    grid_1 = ((_e263 - _e264) / _e266);
    let _e268 = grid_1;
    let _e270 = counts;
    base = clamp(floor(_e268), vec3<f32>(0f, 0f, 0f), (_e270 - vec3(2f)));
    let _e274 = grid_1;
    let _e275 = base;
    f_1 = clamp((_e274 - _e275), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e278 = corner_1;
        if (_e278 < 8i) {
            let _e280 = corner_1;
            let _e283 = corner_1;
            let _e288 = corner_1;
            offset_3 = vec3<f32>(f32((_e280 & 1i)), f32(((_e283 >> bitcast<u32>(1i)) & 1i)), f32(((_e288 >> bitcast<u32>(2i)) & 1i)));
            let _e294 = base;
            let _e295 = offset_3;
            cell_1 = (_e294 + _e295);
            let _e298 = cell_1[2u];
            let _e300 = counts[1u];
            let _e303 = cell_1[1u];
            let _e306 = counts[0u];
            let _e309 = cell_1[0u];
            probe = ((((_e298 * _e300) + _e303) * _e306) + _e309);
            let _e311 = probe;
            let _e312 = columns;
            let _e317 = probe;
            let _e318 = columns;
            tile_4 = vec2<f32>((_e311 - (floor((_e311 / _e312)) * _e312)), floor((_e317 / _e318)));
            let _e322 = tile_4;
            let _e323 = irradianceTile;
            irradianceCorner = (_e322 * (_e323 + 2f));
            let _e327 = tile_4[0u];
            let _e328 = depthTile;
            let _e331 = momentsTop;
            let _e333 = tile_4[1u];
            let _e334 = depthTile;
            momentCorner = vec2<f32>((_e327 * (_e328 + 2f)), (_e331 + (_e333 * (_e334 + 2f))));
            let _e339 = irradianceCorner;
            param_120 = (_e339 + vec2(1f));
            let _e342 = AtlasTexel_u0028_vf2_u003b((&param_120));
            if (_e342.w < 0.5f) {
                continue;
            }
            let _e345 = f_1;
            let _e347 = f_1;
            let _e348 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e345), _e347, _e348);
            let _e351 = trilinear[0u];
            let _e353 = trilinear[1u];
            let _e356 = trilinear[2u];
            weight_2 = max(((_e351 * _e353) * _e356), 0.001f);
            let _e359 = origin_2;
            let _e360 = spacing;
            let _e361 = cell_1;
            probePosition = (_e359 + (_e360 * _e361));
            let _e364 = probePosition;
            let _e365 = biased;
            toProbe = (_e364 - _e365);
            let _e367 = toProbe;
            distance_4 = length(_e367);
            let _e369 = distance_4;
            if (_e369 > 0.000001f) {
                let _e371 = toProbe;
                let _e372 = distance_4;
                direction_2 = (_e371 / vec3(_e372));
                let _e375 = unit;
                let _e376 = probePosition;
                let _e377 = (*world_4);
                facing = ((dot(_e375, normalize((_e376 - _e377))) * 0.5f) + 0.5f);
                let _e383 = facing;
                let _e384 = facing;
                probeWeight = ((_e383 * _e384) + 0.2f);
                let _e387 = direction_2;
                param_121 = -(_e387);
                let _e389 = ProbeOctahedral_u0028_vf3_u003b((&param_121));
                let _e390 = momentCorner;
                param_122 = _e390;
                let _e391 = depthTile;
                param_123 = _e391;
                param_124 = _e389;
                let _e392 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_122), (&param_123), (&param_124));
                moments_3 = _e392.xy;
                chebyshev = 1f;
                let _e394 = distance_4;
                let _e396 = moments_3[0u];
                if (_e394 > _e396) {
                    let _e399 = moments_3[1u];
                    let _e401 = moments_3[0u];
                    let _e403 = moments_3[0u];
                    variance_1 = max((_e399 - (_e401 * _e403)), 0.000001f);
                    let _e407 = distance_4;
                    let _e409 = moments_3[0u];
                    difference = (_e407 - _e409);
                    let _e411 = variance_1;
                    let _e412 = variance_1;
                    let _e413 = difference;
                    let _e414 = difference;
                    chebyshev = (_e411 / (_e412 + (_e413 * _e414)));
                    let _e418 = chebyshev;
                    let _e419 = chebyshev;
                    let _e421 = chebyshev;
                    chebyshev = ((_e418 * _e419) * _e421);
                }
                let _e423 = probeWeight;
                let _e424 = chebyshev;
                probeWeight = max((_e423 * max(_e424, 0.05f)), 0.000001f);
                let _e428 = probeWeight;
                if (_e428 < 0.2f) {
                    let _e430 = probeWeight;
                    let _e431 = probeWeight;
                    let _e434 = probeWeight;
                    probeWeight = (_e434 * ((_e430 * _e431) * 25f));
                }
                let _e436 = probeWeight;
                let _e437 = weight_2;
                weight_2 = (_e437 * _e436);
            }
            let _e439 = unit;
            param_125 = _e439;
            let _e440 = ProbeOctahedral_u0028_vf3_u003b((&param_125));
            let _e441 = irradianceCorner;
            param_126 = _e441;
            let _e442 = irradianceTile;
            param_127 = _e442;
            param_128 = _e440;
            let _e443 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_126), (&param_127), (&param_128));
            let _e445 = weight_2;
            let _e447 = total_2;
            total_2 = (_e447 + (_e443.xyz * _e445));
            let _e449 = weight_2;
            let _e450 = weights;
            weights = (_e450 + _e449);
            continue;
        } else {
            break;
        }
        continuing {
            let _e452 = corner_1;
            corner_1 = (_e452 + 1i);
        }
    }
    let _e454 = weights;
    if (_e454 > 0f) {
        let _e456 = total_2;
        let _e457 = weights;
        local_32 = (_e456 / vec3(_e457));
    } else {
        local_32 = vec3<f32>(0f, 0f, 0f);
    }
    let _e460 = local_32;
    return _e460;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e183 = irradiance_info.origin[3u];
    return (_e183 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;
    var param_132: Surface;
    var param_133: Surface;
    var param_134: Surface;

    let _e188 = IrradianceEnabled_u0028_();
    if _e188 {
        let _e189 = v_world_position_1;
        param_129 = _e189;
        let _e191 = (*s_11).n;
        param_130 = _e191;
        let _e193 = (*s_11).v;
        param_131 = _e193;
        let _e194 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
        let _e197 = frag_info.material[2u];
        (*s_11).ambient = (_e194 * _e197);
    }
    let _e200 = (*s_11);
    param_132 = _e200;
    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((&param_132));
    let _e201 = param_132;
    (*s_11) = _e201;
    let _e202 = (*s_11);
    param_133 = _e202;
    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((&param_133));
    let _e203 = param_133;
    (*s_11) = _e203;
    let _e204 = (*s_11);
    param_134 = _e204;
    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((&param_134));
    let _e205 = param_134;
    (*s_11) = _e205;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_33: vec3<f32>;

    let _e182 = Orthographic_u0028_();
    if _e182 {
        let _e184 = fog_info.forward;
        local_33 = -(_e184.xyz);
    } else {
        let _e188 = fog_info.eye;
        let _e190 = v_world_position_1;
        local_33 = normalize((_e188.xyz - _e190));
    }
    let _e193 = local_33;
    return _e193;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var p3_: vec3<f32>;

    let _e187 = (*cutoff);
    key = (-2f - _e187);
    let _e189 = key;
    let _e192 = key;
    let _e194 = floor((_e192 / 128f));
    let _e199 = key;
    origin_3 = vec3<f32>(floor((_e189 / 16384f)), (_e194 - (floor((_e194 / 128f)) * 128f)), (_e199 - (floor((_e199 / 128f)) * 128f)));
    let _e205 = (*scenePosition);
    let _e208 = origin_3;
    let _e209 = (floor((_e205 * 16f)) + _e208);
    let _e210 = vec3(128f);
    cell_2 = (_e209 - (floor((_e209 / _e210)) * _e210));
    let _e215 = cell_2;
    p3_ = fract((_e215 * 0.1031f));
    let _e218 = p3_;
    let _e219 = p3_;
    let _e224 = p3_;
    p3_ = (_e224 + vec3(dot(_e218, (_e219.zyx + vec3(31.32f)))));
    let _e228 = p3_[0u];
    let _e230 = p3_[1u];
    let _e233 = p3_[2u];
    return fract(((_e228 + _e230) * _e233));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_12: Surface;
    var param_135: vec3<f32>;
    var param_136: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_137: vec3<f32>;
    var param_138: f32;

    let _e189 = v_texcoord_1;
    let _e190 = MaterialLodBias_u0028_();
    let _e191 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e189, _e190);
    texel_6 = _e191;
    let _e192 = texel_6;
    param_135 = _e192.xyz;
    let _e194 = SrgbToLinear_u0028_vf3_u003b((&param_135));
    let _e196 = frag_info.base_color;
    param_136 = _e196.xyz;
    let _e198 = SrgbToLinear_u0028_vf3_u003b((&param_136));
    let _e200 = v_color_1;
    s_12.albedo = ((_e194 * _e198) * _e200.xyz);
    let _e205 = texel_6[3u];
    let _e208 = frag_info.base_color[3u];
    let _e211 = v_color_1[3u];
    s_12.alpha = ((_e205 * _e208) * _e211);
    let _e215 = s_12.albedo;
    g_albedo = _e215;
    let _e218 = frag_info.material2_[0u];
    cutoff_1 = _e218;
    let _e219 = cutoff_1;
    if (_e219 > 1f) {
        let _e221 = cutoff_1;
        edge = (_e221 - 1f);
        let _e224 = s_12.alpha;
        let _e225 = edge;
        let _e228 = s_12.alpha;
        let _e229 = fwidth(_e228);
        s_12.alpha = clamp((((_e224 - _e225) / max(_e229, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e235 = cutoff_1;
        if (_e235 >= 0f) {
            let _e238 = s_12.alpha;
            let _e239 = cutoff_1;
            if (_e238 < _e239) {
                discard;
            }
            s_12.alpha = 1f;
        } else {
            let _e242 = cutoff_1;
            if (_e242 < -1.5f) {
                let _e245 = s_12.alpha;
                let _e246 = v_world_position_1;
                param_137 = _e246;
                let _e247 = cutoff_1;
                param_138 = _e247;
                let _e248 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_137), (&param_138));
                if (_e245 < _e248) {
                    discard;
                }
            }
        }
    }
    let _e250 = cutoff_1;
    let _e252 = cutoff_1;
    g_premultiply = ((_e250 < 0f) && (_e252 > -0.75f));
    let _e255 = v_normal_1;
    s_12.n = normalize(_e255);
    let _e258 = gl_FrontFacing_1;
    if !(_e258) {
        let _e261 = s_12.n;
        s_12.n = -(_e261);
    }
    let _e264 = TowardsEye_u0028_();
    s_12.v = _e264;
    let _e267 = s_12.n;
    let _e269 = s_12.v;
    s_12.n_dot_v = max(dot(_e267, _e269), 0.0001f);
    let _e275 = frag_info.material[0u];
    s_12.metallic = clamp(_e275, 0f, 1f);
    let _e280 = frag_info.material[1u];
    s_12.roughness = clamp(_e280, 0.02f, 1f);
    let _e284 = frag_info.ambient_ground;
    let _e287 = frag_info.ambient_sky;
    let _e291 = s_12.n[1u];
    let _e298 = frag_info.material[2u];
    s_12.ambient = (mix(_e284.xyz, _e287.xyz, vec3(((_e291 * 0.5f) + 0.5f))) * _e298);
    let _e303 = frag_info.frame_params[0u];
    s_12.exposure = max(_e303, 0f);
    s_12.occlusion = 1f;
    s_12.emissive = vec3<f32>(0f, 0f, 0f);
    let _e308 = s_12;
    return _e308;
}

fn main_1() {
    var s_13: Surface;
    var param_139: Surface;
    var param_140: Surface;
    var ambient: vec3<f32>;
    var param_141: Surface;
    var lit_2: vec3<f32>;
    var param_142: Surface;
    var param_143: Surface;
    var param_144: vec3<f32>;
    var param_145: f32;
    var param_146: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e192 = ReadSurface_u0028_();
    s_13 = _e192;
    let _e193 = s_13;
    param_139 = _e193;
    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((&param_139));
    let _e194 = param_139;
    s_13 = _e194;
    let _e195 = s_13;
    param_140 = _e195;
    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((&param_140));
    let _e196 = param_140;
    s_13 = _e196;
    let _e198 = s_13.albedo;
    let _e200 = s_13.ambient;
    let _e201 = SampleLightmap_u0028_();
    let _e204 = s_13;
    param_141 = _e204;
    let _e205 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    ambient = ((_e198 * (_e200 + _e201)) * _e205);
    let _e207 = s_13;
    param_142 = _e207;
    let _e208 = 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((&param_142));
    let _e209 = s_13;
    param_143 = _e209;
    let _e210 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_143));
    let _e212 = ambient;
    let _e215 = s_13.emissive;
    lit_2 = (((_e208 * _e210) + _e212) + _e215);
    let _e217 = lit_2;
    param_144 = _e217;
    let _e219 = s_13.alpha;
    param_145 = _e219;
    let _e221 = s_13.roughness;
    param_146 = _e221;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_144), (&param_145), (&param_146));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Pbr': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(13)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(17)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var ltc_texture_smp: sampler;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(27)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(28)
var point_shadow_texture_smp: sampler;
@group(1) @binding(25)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(11)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var irradiance_texture_smp: sampler;
@group(1) @binding(15)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(23)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(21)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(29)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(30)
var shadow_texture_smp: sampler;
@group(1) @binding(9)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(10)
var environment_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e200 = v_world_position_1;
    let _e202 = fog_info.eye;
    let _e206 = fog_info.forward;
    return dot((_e200 - _e202.xyz), _e206.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e205 = ViewDepth_u0028_();
    z = abs(_e205);
    let _e207 = z;
    near = (_e207 / 5f);
    let _e209 = z;
    far = (_e209 / 200f);
    let _e211 = far;
    let _e212 = far;
    let _e214 = far;
    far3_ = ((_e211 * _e212) * _e214);
    let _e216 = (*alpha);
    let _e217 = near;
    let _e218 = near;
    let _e221 = far3_;
    let _e222 = far3_;
    return (_e216 * clamp((10f / ((0.00001f + (_e217 * _e218)) + (_e221 * _e222))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e209 = fog_info.forward[3u];
    mode = _e209;
    let _e210 = mode;
    if (_e210 > 0.5f) {
        let _e213 = frag_color[3u];
        alpha_1 = _e213;
        let _e214 = alpha_1;
        param = _e214;
        let _e215 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e215;
        let _e216 = frag_color;
        let _e218 = weight;
        let _e219 = (_e216.xyz * _e218);
        let _e220 = alpha_1;
        let _e221 = weight;
        accumulate = vec4<f32>(_e219.x, _e219.y, _e219.z, (_e220 * _e221));
        let _e227 = mode;
        let _e229 = mode;
        revealage = ((_e227 > 1.5f) && (_e229 < 2.5f));
        let _e232 = revealage;
        if _e232 {
            let _e233 = alpha_1;
            local = vec4(_e233);
        } else {
            let _e235 = accumulate;
            local = _e235;
        }
        let _e236 = local;
        frag_color = _e236;
        let _e237 = mode;
        if (_e237 > 2.5f) {
            let _e239 = alpha_1;
            frag_surface = vec4(_e239);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e203 = (*n)[0u];
    let _e206 = (*n)[1u];
    let _e210 = (*n)[2u];
    let _e213 = (*n);
    (*n) = (_e213 / vec3(((abs(_e203) + abs(_e206)) + abs(_e210))));
    let _e216 = (*n);
    e = _e216.xy;
    let _e219 = (*n)[2u];
    if (_e219 < 0f) {
        let _e221 = (*n);
        let _e227 = (*n)[0u];
        let _e231 = (*n)[1u];
        e = ((vec2(1f) - abs(_e221.yx)) * vec2<f32>(select(-1f, 1f, (_e227 >= 0f)), select(-1f, 1f, (_e231 >= 0f))));
    }
    let _e236 = e;
    return ((_e236 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e201 = (*linear);
    let _e203 = (*linear);
    let _e207 = (*linear);
    return mix((_e201 * 12.92f), ((pow(_e203, 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), _e207));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e204 = g_albedo;
    param_1 = clamp(_e204, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e206 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e206.x, _e206.y, _e206.z, 1f);
    let _e211 = g_debug_surface_on;
    if _e211 {
        let _e212 = g_debug_surface;
        let _e213 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e212.x, _e212.y, _e212.z, _e213);
        return;
    }
    let _e218 = v_normal_1;
    geometric = normalize(_e218);
    let _e220 = gl_FrontFacing_1;
    if !(_e220) {
        let _e222 = geometric;
        geometric = -(_e222);
    }
    let _e224 = geometric;
    param_2 = _e224;
    let _e225 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e226 = (*roughness);
    let _e228 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e225.x, _e225.y, clamp(_e226, 0f, 1f), _e228);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e202 = fog_info.projection[0u];
    return (_e202 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e201 = Orthographic_u0028_();
    if _e201 {
        let _e202 = ViewDepth_u0028_();
        local_1 = max(_e202, 0f);
    } else {
        let _e204 = v_world_position_1;
        let _e206 = fog_info.eye;
        local_1 = distance(_e204, _e206.xyz);
    }
    let _e209 = local_1;
    return _e209;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e208 = fog_info.fog[3u];
    density = _e208;
    let _e209 = density;
    if (_e209 <= 0f) {
        let _e211 = (*color);
        return _e211;
    }
    let _e212 = EyeDistance_u0028_();
    d = _e212;
    let _e215 = fog_info.eye[3u];
    falloff = _e215;
    let _e216 = falloff;
    if (_e216 > 0f) {
        let _e218 = falloff;
        let _e220 = v_world_position_1[1u];
        let _e223 = fog_info.eye[1u];
        k = (_e218 * (_e220 - _e223));
        let _e226 = k;
        if (abs(_e226) > 0.001f) {
            let _e229 = k;
            let _e233 = k;
            local_2 = ((1f - exp(-(_e229))) / _e233);
        } else {
            let _e235 = k;
            local_2 = (1f - (0.5f * _e235));
        }
        let _e238 = local_2;
        let _e239 = density;
        density = (_e239 * _e238);
    }
    let _e242 = fog_info.fog;
    let _e244 = (*color);
    let _e245 = density;
    let _e247 = d;
    return mix(_e242.xyz, _e244, vec3(clamp(exp((-(_e245) * _e247)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e206 = g_premultiply;
    let _e207 = (*alpha_2);
    weight_1 = select(1f, _e207, _e206);
    let _e209 = (*linearColor);
    param_3 = _e209;
    let _e210 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e211 = weight_1;
    let _e212 = (_e210 * _e211);
    let _e213 = (*alpha_2);
    let _e214 = g_pass_through;
    frag_color = vec4<f32>(_e212.x, _e212.y, _e212.z, (_e213 * (1f - _e214)));
    let _e221 = (*roughness_1);
    param_4 = _e221;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m: f32;
    var g: f32;

    let _e204 = (*mu);
    m = (1f - _e204);
    let _e206 = m;
    let _e207 = m;
    let _e208 = m;
    let _e209 = m;
    g = (_e206 * (0.05710853f + (_e207 * (0.49188188f + (_e208 * (-0.33218145f + (_e209 * 0.071443f)))))));
    let _e217 = (*r);
    let _e218 = g;
    let _e221 = (*r);
    return ((1f + (_e217 * _e218)) / (1f + (0.2877934f * _e221)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e202 = (*rho);
    let _e203 = (*rho);
    let _e205 = (*average);
    let _e207 = (*rho);
    let _e208 = (*average);
    return (((_e202 * _e203) * _e205) / (vec3<f32>(1f, 1f, 1f) - (_e207 * (1f - _e208))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e201 = (*r_1);
    let _e204 = (*r_1);
    return ((1f + (0.07248821f * _e201)) / (1f + (0.2877934f * _e204)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s: f32;
    var s_over_t: f32;
    var local_3: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_5: f32;
    var multi: vec3<f32>;
    var param_6: vec3<f32>;
    var param_7: f32;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;
    var param_11: f32;

    let _e219 = (*l_dot_v);
    let _e220 = (*mu_i);
    let _e221 = (*mu_o);
    s = (_e219 - (_e220 * _e221));
    let _e224 = s;
    if (_e224 > 0f) {
        let _e226 = s;
        let _e227 = (*mu_i);
        let _e228 = (*mu_o);
        local_3 = (_e226 / max(_e227, _e228));
    } else {
        let _e231 = s;
        local_3 = _e231;
    }
    let _e232 = local_3;
    s_over_t = _e232;
    let _e233 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e233)));
    let _e237 = (*rho_1);
    let _e238 = af;
    let _e239 = (*r_2);
    let _e240 = s_over_t;
    single = (_e237 * (_e238 * (1f + (_e239 * _e240))));
    let _e245 = (*r_2);
    param_5 = _e245;
    let _e246 = FonAverage_u0028_f1_u003b((&param_5));
    average_1 = _e246;
    let _e247 = (*rho_1);
    param_6 = _e247;
    let _e248 = average_1;
    param_7 = _e248;
    let _e249 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_6), (&param_7));
    let _e250 = (*mu_o);
    param_8 = _e250;
    let _e251 = (*r_2);
    param_9 = _e251;
    let _e252 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_8), (&param_9));
    let _e255 = (*mu_i);
    param_10 = _e255;
    let _e256 = (*r_2);
    param_11 = _e256;
    let _e257 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_10), (&param_11));
    let _e261 = average_1;
    multi = (_e249 * ((max((1f - _e252), 0.0000001f) * max((1f - _e257), 0.0000001f)) / max((1f - _e261), 0.0000001f)));
    let _e266 = single;
    let _e267 = multi;
    return ((_e266 + _e267) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e202 = frag_info.ambient_sky[3u];
    return (_e202 > 0.5f);
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e204 = (*x);
    let _e205 = (*y);
    inTable = ((vec2<f32>(_e204, _e205) * 0.984375f) + vec2(0.0078125f));
    let _e211 = inTable[0u];
    let _e213 = inTable[1u];
    let _e214 = (*table);
    return vec2<f32>(_e211, ((_e213 + _e214) * 0.5f));
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_12: f32;
    var param_13: f32;
    var param_14: f32;

    let _e206 = (*roughness_2);
    let _e208 = (*n_dot_v);
    param_12 = clamp(_e206, 0f, 1f);
    param_13 = sqrt(clamp((1f - _e208), 0f, 1f));
    param_14 = 1f;
    let _e212 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_12), (&param_13), (&param_14));
    let _e213 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e212, 0f);
    dfg = _e213.xy;
    let _e216 = dfg[0u];
    let _e218 = dfg[1u];
    let _e221 = dfg[1u];
    return vec2<f32>((_e216 - _e218), _e221);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_1: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_15: f32;
    var param_16: f32;
    var ess: f32;

    let _e207 = (*s_1).roughness;
    param_15 = max(_e207, 0.045f);
    let _e210 = (*s_1).n_dot_v;
    param_16 = _e210;
    let _e211 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_15), (&param_16));
    ab = _e211;
    let _e213 = ab[0u];
    let _e215 = ab[1u];
    ess = max((_e213 + _e215), 0.0001f);
    let _e218 = (*f0_);
    let _e219 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e218 * ((1f / _e219) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e202 = frag_info.target_origin[2u];
    return (_e202 > 0.5f);
}

fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f: f32;

    let _e203 = (*v_dot_h);
    f = pow((1f - _e203), 5f);
    let _e206 = (*f0_1);
    let _e207 = (*f0_1);
    let _e209 = f;
    return (_e206 + ((vec3<f32>(1f, 1f, 1f) - _e207) * _e209));
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e206 = (*alpha_3);
    let _e207 = (*alpha_3);
    a2_ = (_e206 * _e207);
    let _e209 = (*n_dot_l);
    let _e210 = (*n_dot_v_1);
    let _e211 = (*n_dot_v_1);
    let _e213 = a2_;
    let _e216 = a2_;
    lambda_v = (_e209 * sqrt((((_e210 * _e211) * (1f - _e213)) + _e216)));
    let _e220 = (*n_dot_v_1);
    let _e221 = (*n_dot_l);
    let _e222 = (*n_dot_l);
    let _e224 = a2_;
    let _e227 = a2_;
    lambda_l = (_e220 * sqrt((((_e221 * _e222) * (1f - _e224)) + _e227)));
    let _e231 = lambda_v;
    let _e232 = lambda_l;
    return (0.5f / max((_e231 + _e232), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_1: f32;

    let _e204 = (*n_dot_h);
    let _e205 = (*alpha_4);
    a = (_e204 * _e205);
    let _e207 = (*alpha_4);
    let _e208 = (*n_dot_h);
    let _e209 = (*n_dot_h);
    let _e212 = a;
    let _e213 = a;
    k_1 = (_e207 / max(((1f - (_e208 * _e209)) + (_e212 * _e213)), 0.0000001f));
    let _e218 = k_1;
    let _e219 = k_1;
    return ((_e218 * _e219) * 0.31830987f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var lobe: f32;
    var alpha_5: f32;
    var f0_2: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_1: f32;
    var param_17: f32;
    var param_18: f32;
    var vis: f32;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;
    var f_1: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: f32;
    var specular: vec3<f32>;
    var param_24: vec3<f32>;
    var param_25: Surface;
    var diffuse: vec3<f32>;
    var param_26: vec3<f32>;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;

    let _e226 = (*s_2).roughness;
    lobe = max(_e226, 0.045f);
    let _e228 = lobe;
    let _e229 = lobe;
    alpha_5 = (_e228 * _e229);
    let _e232 = (*s_2).albedo;
    let _e234 = (*s_2).metallic;
    f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e232, vec3(_e234));
    let _e238 = (*s_2).albedo;
    let _e240 = (*s_2).metallic;
    diffuseColor = (_e238 * (1f - _e240));
    let _e244 = (*light).n_dot_h;
    param_17 = _e244;
    let _e245 = alpha_5;
    param_18 = _e245;
    let _e246 = D_GGX_u0028_f1_u003b_f1_u003b((&param_17), (&param_18));
    d_1 = _e246;
    let _e248 = (*s_2).n_dot_v;
    param_19 = _e248;
    let _e250 = (*light).n_dot_l;
    param_20 = _e250;
    let _e251 = alpha_5;
    param_21 = _e251;
    let _e252 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21));
    vis = _e252;
    let _e253 = f0_2;
    param_22 = _e253;
    let _e255 = (*light).v_dot_h;
    param_23 = _e255;
    let _e256 = F_Schlick_u0028_vf3_u003b_f1_u003b((&param_22), (&param_23));
    f_1 = _e256;
    let _e257 = d_1;
    let _e258 = vis;
    let _e260 = f_1;
    let _e264 = frag_info.material[3u];
    specular = ((_e260 * (_e257 * _e258)) * _e264);
    let _e267 = (*light).integrated;
    if (_e267 > 0.5f) {
        let _e271 = (*light).ltc[0u];
        let _e272 = f0_2;
        let _e275 = (*light).ltc[1u];
        let _e277 = f0_2;
        let _e282 = (*light).ltc[2u];
        let _e288 = frag_info.material[3u];
        let _e291 = (*light).n_dot_l;
        specular = (((((_e272 * _e275) + ((vec3(1f) - _e277) * _e282)) * _e271) * _e288) / vec3(max(_e291, 0.000001f)));
    }
    let _e295 = EnergyCompensation_u0028_();
    if _e295 {
        let _e296 = f0_2;
        param_24 = _e296;
        let _e297 = (*s_2);
        param_25 = _e297;
        let _e298 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_24), (&param_25));
        let _e299 = specular;
        specular = (_e299 * _e298);
    }
    let _e301 = diffuseColor;
    let _e302 = f_1;
    diffuse = ((_e301 * (vec3<f32>(1f, 1f, 1f) - _e302)) / vec3(3.1415927f));
    let _e307 = EonDiffuse_u0028_();
    if _e307 {
        let _e309 = (*s_2).n;
        let _e311 = (*light).l;
        let _e315 = (*light).l;
        let _e317 = (*s_2).v;
        let _e319 = diffuseColor;
        param_26 = _e319;
        let _e321 = (*s_2).roughness;
        param_27 = _e321;
        param_28 = clamp(dot(_e309, _e311), 0.0001f, 1f);
        let _e323 = (*s_2).n_dot_v;
        param_29 = _e323;
        param_30 = dot(_e315, _e317);
        let _e324 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
        let _e325 = f_1;
        diffuse = (_e324 * (vec3<f32>(1f, 1f, 1f) - _e325));
    }
    let _e328 = diffuse;
    let _e329 = specular;
    return ((_e328 + _e329) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e201 = (*i);
    if (_e201 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e203 = (*i);
    if (_e203 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e205 = (*i);
    if (_e205 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e207 = (*i);
    if (_e207 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e209 = (*i);
    if (_e209 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e211 = (*i);
    if (_e211 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e213 = (*i);
    if (_e213 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_31: i32;

    let _e206 = (*i_1);
    param_31 = _e206;
    let _e207 = PointShadowDiskTap_u0028_i1_u003b((&param_31));
    p = _e207;
    let _e209 = p[0u];
    let _e210 = (*ca);
    let _e213 = p[1u];
    let _e214 = (*sa);
    let _e218 = p[0u];
    let _e219 = (*sa);
    let _e222 = p[1u];
    let _e223 = (*ca);
    let _e227 = (*radius);
    return (vec2<f32>(((_e209 * _e210) - (_e213 * _e214)), ((_e218 * _e219) + (_e222 * _e223))) * _e227);
}

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_4: vec2<f32>;
    var atlas: vec2<f32>;

    let _e209 = point_shadow.params[0u];
    inset = _e209;
    let _e210 = (*uv);
    let _e211 = (*offset);
    let _e213 = inset;
    let _e214 = inset;
    local_4 = clamp((_e210 + _e211), vec2(_e213), vec2((1f - _e214)));
    let _e219 = local_4;
    let _e220 = (*tile);
    atlas = ((_e219 + _e220) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e225 = point_shadow.params3_[0u];
    if (_e225 > 0.5f) {
        let _e228 = atlas[1u];
        atlas[1u] = (1f - _e228);
    }
    let _e231 = atlas;
    let _e232 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e231, 0f);
    let _e234 = atlas;
    let _e235 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e234, 0f);
    let _e238 = (*range);
    return (min(_e232.x, _e235.x) * _e238);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: vec2<f32>;
    var param_35: f32;

    let _e210 = (*uv_1);
    param_32 = _e210;
    let _e211 = (*offset_1);
    param_33 = _e211;
    let _e212 = (*tile_1);
    param_34 = _e212;
    let _e213 = (*range_1);
    param_35 = _e213;
    let _e214 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35));
    stored = _e214;
    let _e215 = stored;
    let _e216 = (*range_1);
    if (_e215 >= (_e216 * 0.999f)) {
        return 1f;
    }
    let _e219 = (*receiver);
    let _e220 = stored;
    return select(1f, 0f, (_e219 > _e220));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_36: vec2<f32>;
    var param_37: vec2<f32>;
    var param_38: vec2<f32>;
    var param_39: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_40: i32;
    var param_41: f32;
    var param_42: f32;
    var param_43: f32;
    var param_44: vec2<f32>;
    var param_45: vec2<f32>;
    var param_46: vec2<f32>;
    var param_47: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e231 = point_shadow.params2_[1u];
    lightRadius = _e231;
    let _e234 = point_shadow.params2_[0u];
    minRadius = _e234;
    let _e237 = point_shadow.params2_[2u];
    maxRadius = _e237;
    let _e238 = lightRadius;
    if (_e238 <= 0f) {
        let _e240 = (*uv_2);
        param_36 = _e240;
        param_37 = vec2<f32>(0f, 0f);
        let _e241 = (*tile_2);
        param_38 = _e241;
        let _e242 = (*range_2);
        param_39 = _e242;
        let _e243 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
        (*blockerOut) = _e243;
        let _e244 = minRadius;
        return _e244;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e245 = i_2;
        if (_e245 < 8i) {
            let _e247 = i_2;
            param_40 = _e247;
            let _e248 = (*ca_1);
            param_41 = _e248;
            let _e249 = (*sa_1);
            param_42 = _e249;
            let _e250 = maxRadius;
            param_43 = _e250;
            let _e251 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43));
            let _e252 = (*uv_2);
            param_44 = _e252;
            param_45 = _e251;
            let _e253 = (*tile_2);
            param_46 = _e253;
            let _e254 = (*range_2);
            param_47 = _e254;
            let _e255 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_44), (&param_45), (&param_46), (&param_47));
            stored_1 = _e255;
            let _e256 = stored_1;
            let _e257 = (*range_2);
            if (_e256 >= (_e257 * 0.999f)) {
                continue;
            }
            let _e260 = stored_1;
            let _e261 = (*receiver_1);
            if (_e260 >= _e261) {
                continue;
            }
            let _e263 = stored_1;
            let _e264 = sum;
            sum = (_e264 + _e263);
            let _e266 = count;
            count = (_e266 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e268 = i_2;
            i_2 = (_e268 + 1i);
        }
    }
    let _e270 = count;
    if (_e270 < 0.5f) {
        return -1f;
    }
    let _e272 = sum;
    let _e273 = count;
    blocker = max((_e272 / _e273), 0.0001f);
    let _e276 = blocker;
    (*blockerOut) = _e276;
    let _e277 = lightRadius;
    let _e278 = (*receiver_1);
    let _e279 = blocker;
    let _e283 = blocker;
    world = ((_e277 * max((_e278 - _e279), 0f)) / _e283);
    let _e285 = world;
    let _e286 = (*receiver_1);
    let _e288 = (*tanHalf);
    let _e291 = minRadius;
    let _e292 = maxRadius;
    return clamp((_e285 / ((2f * _e286) * _e288)), _e291, _e292);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_5: vec2<f32>;

    let _e202 = (*rows);
    if (_e202 > 0f) {
        let _e205 = gl_FragCoord_1[0u];
        let _e206 = (*rows);
        let _e208 = gl_FragCoord_1[1u];
        local_5 = vec2<f32>(_e205, (_e206 - _e208));
    } else {
        let _e211 = gl_FragCoord_1;
        local_5 = _e211.xy;
    }
    let _e213 = local_5;
    return _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_1: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_48: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: f32;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;
    var param_55: f32;
    var param_56: f32;
    var local_6: vec3<f32>;
    var lit: f32;
    var param_57: vec2<f32>;
    var param_58: vec2<f32>;
    var param_59: vec2<f32>;
    var param_60: f32;
    var param_61: f32;
    var i_3: i32;
    var param_62: i32;
    var param_63: f32;
    var param_64: f32;
    var param_65: f32;
    var param_66: vec2<f32>;
    var param_67: vec2<f32>;
    var param_68: vec2<f32>;
    var param_69: f32;
    var param_70: f32;
    var phi_2663_: bool;
    var phi_2724_: bool;

    let _e254 = (*lightIndex);
    let _e258 = point_shadow.slots[_e254][0u];
    slot = i32((_e258 + 0.5f));
    let _e261 = (*lightIndex);
    let _e265 = point_shadow.slots[_e261][0u];
    if (_e265 < 0f) {
        return 1f;
    }
    let _e269 = point_shadow.params[2u];
    strength = _e269;
    let _e270 = strength;
    if (_e270 <= 0f) {
        return 1f;
    }
    let _e272 = slot;
    let _e275 = point_shadow.lights[_e272];
    let _e277 = (*world_1);
    toLight = (_e275.xyz - _e277);
    let _e279 = toLight;
    toLightLength = max(length(_e279), 0.000001f);
    let _e282 = (*normal);
    let _e283 = toLight;
    let _e284 = toLightLength;
    nDotL = max(dot(_e282, (_e283 / vec3(_e284))), 0.15f);
    let _e289 = nDotL;
    let _e290 = nDotL;
    let _e295 = nDotL;
    let _e296 = nDotL;
    slope = min((sqrt(max((1f - (_e289 * _e290)), 0f)) / (_e295 * _e296)), 8f);
    let _e300 = toLightLength;
    let _e302 = (*lightIndex);
    let _e306 = point_shadow.slots[_e302][2u];
    let _e311 = point_shadow.params3_[1u];
    texel = (((2f * _e300) * max(_e306, 0.0001f)) * _e311);
    let _e313 = (*world_1);
    let _e314 = (*normal);
    let _e315 = texel;
    let _e319 = point_shadow.params[3u];
    let _e321 = slope;
    origin = (_e313 + (((_e314 * _e315) * _e319) * (1f + _e321)));
    let _e325 = origin;
    let _e326 = slot;
    let _e329 = point_shadow.lights[_e326];
    toFragment = (_e325 - _e329.xyz);
    let _e332 = toFragment;
    distance_ = length(_e332);
    let _e334 = slot;
    let _e338 = point_shadow.lights[_e334][3u];
    range_3 = max(_e338, 0.0001f);
    let _e340 = distance_;
    let _e341 = range_3;
    if (_e340 >= _e341) {
        return 1f;
    }
    face = 0i;
    let _e343 = (*lightIndex);
    let _e347 = point_shadow.slots[_e343][1u];
    if (_e347 < 0.5f) {
        let _e349 = toFragment;
        a_1 = abs(_e349);
        let _e352 = a_1[0u];
        let _e354 = a_1[1u];
        let _e355 = (_e352 >= _e354);
        phi_2663_ = _e355;
        if _e355 {
            let _e357 = a_1[0u];
            let _e359 = a_1[2u];
            phi_2663_ = (_e357 >= _e359);
        }
        let _e362 = phi_2663_;
        if _e362 {
            let _e364 = toFragment[0u];
            face = select(1i, 0i, (_e364 > 0f));
        } else {
            let _e368 = a_1[1u];
            let _e370 = a_1[2u];
            if (_e368 >= _e370) {
                let _e373 = toFragment[1u];
                face = select(3i, 2i, (_e373 > 0f));
            } else {
                let _e377 = toFragment[2u];
                face = select(5i, 4i, (_e377 > 0f));
            }
        }
    }
    let _e380 = slot;
    let _e382 = face;
    let _e386 = point_shadow.faces[((_e380 * 6i) + _e382)];
    let _e387 = origin;
    clip = (_e386 * vec4<f32>(_e387.x, _e387.y, _e387.z, 1f));
    let _e394 = clip[3u];
    if (_e394 <= 0f) {
        return 1f;
    }
    let _e396 = clip;
    let _e399 = clip[3u];
    ndc = (_e396.xy / vec2(_e399));
    let _e403 = ndc[0u];
    let _e405 = (abs(_e403) > 1f);
    phi_2724_ = _e405;
    if !(_e405) {
        let _e408 = ndc[1u];
        phi_2724_ = (abs(_e408) > 1f);
    }
    let _e412 = phi_2724_;
    if _e412 {
        return 1f;
    }
    let _e414 = ndc[0u];
    let _e418 = ndc[1u];
    uv_3 = vec2<f32>(((_e414 * 0.5f) + 0.5f), (0.5f - (_e418 * 0.5f)));
    let _e422 = face;
    let _e424 = slot;
    tile_3 = vec2<f32>(f32(_e422), f32(_e424));
    let _e427 = distance_;
    let _e430 = point_shadow.params[1u];
    receiver_2 = (_e427 - _e430);
    let _e434 = frag_info.target_origin[0u];
    param_48 = _e434;
    let _e435 = FragCoordFromTop_u0028_f1_u003b((&param_48));
    noise = fract((52.982918f * fract(dot(_e435, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e440 = noise;
    angle = (_e440 * 6.2831855f);
    let _e442 = angle;
    ca_2 = cos(_e442);
    let _e444 = angle;
    sa_2 = sin(_e444);
    let _e446 = (*lightIndex);
    let _e450 = point_shadow.slots[_e446][2u];
    tanHalf_1 = max(_e450, 0.0001f);
    blocker_1 = -1f;
    let _e452 = uv_3;
    param_49 = _e452;
    let _e453 = tile_3;
    param_50 = _e453;
    let _e454 = range_3;
    param_51 = _e454;
    let _e455 = receiver_2;
    param_52 = _e455;
    let _e456 = ca_2;
    param_53 = _e456;
    let _e457 = sa_2;
    param_54 = _e457;
    let _e458 = tanHalf_1;
    param_55 = _e458;
    let _e459 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53), (&param_54), (&param_55), (&param_56));
    let _e460 = param_56;
    blocker_1 = _e460;
    radius_1 = _e459;
    let _e463 = point_shadow.params2_[3u];
    if (_e463 > 0.5f) {
        g_debug_surface_on = true;
        let _e465 = radius_1;
        if (_e465 < 0f) {
            local_6 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e467 = radius_1;
            let _e470 = point_shadow.params2_[2u];
            let _e474 = blocker_1;
            let _e475 = range_3;
            local_6 = vec3<f32>(clamp((_e467 / max(_e470, 0.000001f)), 0f, 1f), clamp((_e474 / _e475), 0f, 1f), 0f);
        }
        let _e479 = local_6;
        g_debug_surface = _e479;
    }
    let _e480 = radius_1;
    if (_e480 < 0f) {
        return 1f;
    }
    let _e482 = uv_3;
    param_57 = _e482;
    param_58 = vec2<f32>(0f, 0f);
    let _e483 = tile_3;
    param_59 = _e483;
    let _e484 = range_3;
    param_60 = _e484;
    let _e485 = receiver_2;
    param_61 = _e485;
    let _e486 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60), (&param_61));
    lit = _e486;
    let _e487 = radius_1;
    if (_e487 > 0f) {
        i_3 = 0i;
        loop {
            let _e489 = i_3;
            if (_e489 < 8i) {
                let _e491 = i_3;
                param_62 = _e491;
                let _e492 = ca_2;
                param_63 = _e492;
                let _e493 = sa_2;
                param_64 = _e493;
                let _e494 = radius_1;
                param_65 = _e494;
                let _e495 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_62), (&param_63), (&param_64), (&param_65));
                let _e496 = uv_3;
                param_66 = _e496;
                param_67 = _e495;
                let _e497 = tile_3;
                param_68 = _e497;
                let _e498 = range_3;
                param_69 = _e498;
                let _e499 = receiver_2;
                param_70 = _e499;
                let _e500 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_66), (&param_67), (&param_68), (&param_69), (&param_70));
                let _e501 = lit;
                lit = (_e501 + _e500);
                continue;
            } else {
                break;
            }
            continuing {
                let _e503 = i_3;
                i_3 = (_e503 + 1i);
            }
        }
        let _e505 = lit;
        lit = (_e505 * 0.11111111f);
    }
    let _e507 = lit;
    let _e508 = strength;
    return mix(1f, _e507, clamp(_e508, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e205 = (*i_4);
    let _e208 = (*n_1);
    r_3 = sqrt(((f32(_e205) + 0.5f) / f32(_e208)));
    let _e212 = (*i_4);
    let _e215 = (*turn);
    theta = ((f32(_e212) * 2.3999631f) + _e215);
    let _e217 = r_3;
    let _e218 = theta;
    let _e220 = theta;
    return (vec2<f32>(cos(_e218), sin(_e220)) * _e217);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_71: f32;

    let _e204 = frag_info.target_origin[0u];
    param_71 = _e204;
    let _e205 = FragCoordFromTop_u0028_f1_u003b((&param_71));
    let _e208 = frag_info.target_origin[3u];
    at = (_e205 + vec2((5.588238f * max(_e208, 0f))));
    let _e213 = at;
    return fract((52.982918f * fract(dot(_e213, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_7: f32;

    let _e203 = (*mode_1);
    if (_e203 > 0.5f) {
        let _e205 = (*stored_2);
        local_7 = (1f - _e205);
    } else {
        let _e207 = (*stored_2);
        local_7 = _e207;
    }
    let _e208 = local_7;
    return _e208;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_2: f32;
    var pMax: f32;
    var reduced: f32;

    let _e209 = (*moments)[1u];
    let _e211 = (*moments)[0u];
    let _e213 = (*moments)[0u];
    let _e216 = (*minVariance);
    variance = max((_e209 - (_e211 * _e213)), _e216);
    let _e218 = (*t);
    let _e220 = (*moments)[0u];
    d_2 = (_e218 - _e220);
    let _e222 = variance;
    let _e223 = variance;
    let _e224 = d_2;
    let _e225 = d_2;
    pMax = (_e222 / (_e223 + (_e224 * _e225)));
    let _e229 = pMax;
    let _e230 = (*bleed);
    let _e232 = (*bleed);
    reduced = clamp(((_e229 - _e230) / max((1f - _e232), 0.0001f)), 0f, 1f);
    let _e237 = (*t);
    let _e239 = (*moments)[0u];
    let _e241 = reduced;
    return select(_e241, 1f, (_e237 <= _e239));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_3: f32;

    let _e202 = (*depth);
    d_3 = ((2f * clamp(_e202, 0f, 1f)) - 1f);
    let _e206 = d_3;
    let _e209 = d_3;
    return vec2<f32>(exp((40f * _e206)), -(exp((-5f * _e209))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_72: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_73: vec2<f32>;
    var param_74: f32;
    var param_75: f32;
    var param_76: f32;
    var negative: f32;
    var param_77: vec2<f32>;
    var param_78: f32;
    var param_79: f32;
    var param_80: f32;

    let _e216 = (*depth_1);
    param_72 = _e216;
    let _e217 = EvsmWarp_u0028_f1_u003b((&param_72));
    warped = _e217;
    let _e218 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e218);
    let _e221 = scale[0u];
    let _e223 = scale[0u];
    let _e225 = (*moments_1);
    param_73 = _e225.xy;
    let _e228 = warped[0u];
    param_74 = _e228;
    param_75 = (_e221 * _e223);
    let _e229 = (*bleed_1);
    param_76 = _e229;
    let _e230 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_73), (&param_74), (&param_75), (&param_76));
    positive = _e230;
    let _e232 = scale[1u];
    let _e234 = scale[1u];
    let _e236 = (*moments_1);
    param_77 = _e236.zw;
    let _e239 = warped[1u];
    param_78 = _e239;
    param_79 = (_e232 * _e234);
    let _e240 = (*bleed_1);
    param_80 = _e240;
    let _e241 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_77), (&param_78), (&param_79), (&param_80));
    negative = _e241;
    let _e242 = positive;
    let _e243 = negative;
    return min(_e242, _e243);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e202 = (*depth_2);
    stored_3 = max((1f - _e202), 0.000061035156f);
    let _e205 = stored_3;
    return exp2((floor(log2(_e205)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_8: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_9: mat4x4<f32>;
    var local_10: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_11: f32;
    var local_12: f32;
    var storage_: f32;
    var param_81: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_82: vec4<f32>;
    var param_83: f32;
    var param_84: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_85: f32;
    var param_86: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_87: i32;
    var param_88: i32;
    var param_89: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_90: f32;
    var param_91: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_92: i32;
    var param_93: i32;
    var param_94: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_95: f32;
    var param_96: f32;
    var phi_3858_: bool;
    var phi_3869_: bool;
    var phi_4030_: bool;
    var phi_4037_: bool;
    var phi_4044_: bool;

    let _e281 = frag_info.shadow_params[3u];
    strength_1 = _e281;
    let _e282 = strength_1;
    if (_e282 <= 0f) {
        return 1f;
    }
    let _e284 = (*lightIndex_1);
    let _e287 = frag_info.frame_params[2u];
    if (_e284 != i32(floor((_e287 + 0.5f)))) {
        return 1f;
    }
    let _e294 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e294 + 0.5f));
    let _e297 = Orthographic_u0028_();
    if _e297 {
        let _e298 = ViewDepth_u0028_();
        local_8 = _e298;
    } else {
        let _e299 = v_world_position_1;
        let _e301 = frag_info.camera_position;
        local_8 = length((_e299 - _e301.xyz));
    }
    let _e305 = local_8;
    viewDistance = _e305;
    cascade = 0i;
    let _e306 = cascadeCount;
    let _e307 = (_e306 > 1i);
    phi_3858_ = _e307;
    if _e307 {
        let _e308 = viewDistance;
        let _e311 = frag_info.shadow_cascades[0u];
        phi_3858_ = (_e308 > _e311);
    }
    let _e314 = phi_3858_;
    if _e314 {
        cascade = 1i;
    }
    let _e315 = cascadeCount;
    let _e316 = (_e315 > 2i);
    phi_3869_ = _e316;
    if _e316 {
        let _e317 = viewDistance;
        let _e320 = frag_info.shadow_cascades[1u];
        phi_3869_ = (_e317 > _e320);
    }
    let _e323 = phi_3869_;
    if _e323 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e324 = attempt;
        if (_e324 < 3i) {
            let _e326 = cascade;
            let _e327 = attempt;
            which = (_e326 + _e327);
            let _e329 = which;
            let _e330 = cascadeCount;
            if (_e329 >= _e330) {
                break;
            }
            let _e332 = which;
            if (_e332 == 0i) {
                let _e335 = frag_info.shadow_matrix;
                local_9 = _e335;
            } else {
                let _e336 = which;
                if (_e336 == 1i) {
                    let _e339 = frag_info.shadow_matrix_far;
                    local_10 = _e339;
                } else {
                    let _e341 = frag_info.shadow_matrix_farthest;
                    local_10 = _e341;
                }
                let _e342 = local_10;
                local_9 = _e342;
            }
            let _e343 = local_9;
            matrix = _e343;
            let _e346 = matrix[0][0u];
            let _e349 = matrix[1][0u];
            let _e352 = matrix[2][0u];
            axisX = vec3<f32>(_e346, _e349, _e352);
            let _e356 = matrix[0][1u];
            let _e359 = matrix[1][1u];
            let _e362 = matrix[2][1u];
            axisY = vec3<f32>(_e356, _e359, _e362);
            let _e364 = axisX;
            rowX = max(length(_e364), 0.000001f);
            let _e367 = axisY;
            rowY = max(length(_e367), 0.000001f);
            let _e372 = frag_info.shadow_cascades[3u];
            let _e374 = rowX;
            texelMetres = ((2f * _e372) / _e374);
            let _e378 = frag_info.shadow_cascades[3u];
            let _e381 = (*s_3).n;
            let _e382 = axisX;
            let _e385 = rowX;
            let _e386 = rowX;
            let _e390 = (*s_3).n;
            let _e391 = axisY;
            let _e394 = rowY;
            let _e395 = rowY;
            reach = ((3f * _e378) * ((abs(dot(_e381, _e382)) / (_e385 * _e386)) + (abs(dot(_e390, _e391)) / (_e394 * _e395))));
            let _e402 = frag_info.shadow_params[2u];
            let _e403 = texelMetres;
            flatOffset = min(_e402, _e403);
            let _e405 = v_world_position_1;
            let _e407 = (*s_3).n;
            let _e408 = flatOffset;
            let _e409 = reach;
            origin_1 = (_e405 + (_e407 * (_e408 + _e409)));
            let _e413 = matrix;
            let _e414 = origin_1;
            lightSpace = (_e413 * vec4<f32>(_e414.x, _e414.y, _e414.z, 1f));
            let _e421 = lightSpace[3u];
            if (_e421 <= 0f) {
                continue;
            }
            let _e423 = lightSpace;
            let _e426 = lightSpace[3u];
            candidate = (_e423.xyz / vec3(_e426));
            let _e430 = candidate[0u];
            let _e434 = candidate[1u];
            inTile = vec2<f32>(((_e430 * 0.5f) + 0.5f), (0.5f - (_e434 * 0.5f)));
            let _e439 = inTile[0u];
            let _e440 = (_e439 < 0f);
            phi_4030_ = _e440;
            if !(_e440) {
                let _e443 = inTile[0u];
                phi_4030_ = (_e443 > 1f);
            }
            let _e446 = phi_4030_;
            phi_4037_ = _e446;
            if !(_e446) {
                let _e449 = inTile[1u];
                phi_4037_ = (_e449 < 0f);
            }
            let _e452 = phi_4037_;
            phi_4044_ = _e452;
            if !(_e452) {
                let _e455 = inTile[1u];
                phi_4044_ = (_e455 > 1f);
            }
            let _e458 = phi_4044_;
            if _e458 {
                continue;
            }
            let _e460 = candidate[2u];
            if (_e460 > 1f) {
                let _e462 = which;
                let _e463 = cascadeCount;
                if (_e462 < (_e463 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e468 = inTile[0u];
            let _e469 = which;
            let _e472 = cascadeCount;
            let _e476 = inTile[1u];
            uv_4 = vec2<f32>(((_e468 + f32(_e469)) / f32(_e472)), _e476);
            let _e478 = candidate;
            projected = _e478;
            let _e479 = which;
            cascade = _e479;
            let _e480 = texelMetres;
            cascadeTexel = _e480;
            let _e483 = matrix[0][2u];
            let _e486 = matrix[1][2u];
            let _e489 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e483, _e486, _e489)), 0.000001f));
            let _e495 = (*s_3).n;
            let _e498 = matrix[0][2u];
            let _e501 = matrix[1][2u];
            let _e504 = matrix[2][2u];
            let _e508 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e495, vec3<f32>(_e498, _e501, _e504))) * _e508), 0.1f, 1f);
            let _e511 = texelMetres;
            let _e512 = cosSlope;
            let _e513 = cosSlope;
            let _e519 = cosSlope;
            let _e521 = cascadeDepth;
            receiverSlope = (((_e511 * sqrt(max((1f - (_e512 * _e513)), 0f))) / _e519) / _e521);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e523 = attempt;
            attempt = (_e523 + 1i);
        }
    }
    let _e525 = found;
    if !(_e525) {
        return 1f;
    }
    let _e527 = cascade;
    if (_e527 == 0i) {
        let _e531 = frag_info.shadow_bias[0u];
        local_11 = _e531;
    } else {
        let _e532 = cascade;
        if (_e532 == 1i) {
            let _e536 = frag_info.shadow_bias[1u];
            local_12 = _e536;
        } else {
            let _e539 = frag_info.shadow_bias[2u];
            local_12 = _e539;
        }
        let _e540 = local_12;
        local_11 = _e540;
    }
    let _e541 = local_11;
    bias = _e541;
    let _e544 = frag_info.shadow_params[1u];
    storage_ = _e544;
    let _e545 = storage_;
    let _e547 = storage_;
    if ((_e545 > 0.5f) && (_e547 < 1.5f)) {
        let _e550 = bias;
        let _e552 = projected[2u];
        param_81 = _e552;
        let _e553 = ShadowStoredStep_u0028_f1_u003b((&param_81));
        bias = max(_e550, _e553);
    }
    let _e557 = frag_info.shadow_params[0u];
    let _e560 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e557, _e560);
    let _e562 = cascade;
    let _e564 = cascadeCount;
    let _e568 = texel_1;
    tileLo = (vec2<f32>((f32(_e562) / f32(_e564)), 0f) + (_e568 * 0.5f));
    let _e571 = cascade;
    let _e574 = cascadeCount;
    let _e578 = texel_1;
    tileHi = (vec2<f32>((f32((_e571 + 1i)) / f32(_e574)), 1f) - (_e578 * 0.5f));
    let _e583 = frag_info.shadow_bias[3u];
    if (_e583 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e585 = y_1;
            if (_e585 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e587 = x_1;
                    if (_e587 <= 1i) {
                        let _e589 = uv_4;
                        let _e590 = x_1;
                        let _e592 = y_1;
                        let _e595 = texel_1;
                        let _e598 = tileLo;
                        let _e599 = tileHi;
                        let _e601 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e589 + (vec2<f32>(f32(_e590), f32(_e592)) * _e595)), _e598, _e599), 0f);
                        let _e602 = stored_4;
                        stored_4 = (_e602 + _e601);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e604 = x_1;
                        x_1 = (_e604 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e606 = y_1;
                y_1 = (_e606 + 1i);
            }
        }
        let _e608 = stored_4;
        stored_4 = (_e608 * 0.11111111f);
        let _e611 = stored_4[1u];
        let _e614 = stored_4[2u];
        let _e617 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e611), (1f - _e614), _e617), vec3(0f), vec3(4f));
        let _e622 = through;
        let _e623 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e622, vec3(clamp(_e623, 0f, 1f)));
    }
    let _e629 = frag_info.ambient_ground[3u];
    softness = _e629;
    lit_1 = 0f;
    let _e630 = softness;
    if (_e630 < 0f) {
        let _e632 = uv_4;
        let _e633 = tileLo;
        let _e634 = tileHi;
        let _e636 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e632, _e633, _e634), 0f);
        moments_2 = _e636;
        let _e638 = projected[2u];
        let _e639 = bias;
        let _e641 = softness;
        let _e645 = moments_2;
        param_82 = _e645;
        param_83 = (_e638 - _e639);
        param_84 = clamp((-(_e641) - 1f), 0f, 0.95f);
        let _e646 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_82), (&param_83), (&param_84));
        lit_1 = _e646;
    } else {
        let _e647 = softness;
        if (_e647 <= 0f) {
            y_2 = -1i;
            loop {
                let _e649 = y_2;
                if (_e649 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e651 = x_2;
                        if (_e651 <= 1i) {
                            let _e653 = uv_4;
                            let _e654 = x_2;
                            let _e656 = y_2;
                            let _e659 = texel_1;
                            let _e662 = tileLo;
                            let _e663 = tileHi;
                            let _e665 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e653 + (vec2<f32>(f32(_e654), f32(_e656)) * _e659)), _e662, _e663), 0f);
                            param_85 = _e665.x;
                            let _e667 = storage_;
                            param_86 = _e667;
                            let _e668 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_85), (&param_86));
                            occluder = _e668;
                            let _e670 = projected[2u];
                            let _e671 = bias;
                            let _e673 = occluder;
                            let _e676 = lit_1;
                            lit_1 = (_e676 + select(1f, 0f, ((_e670 - _e671) > _e673)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e678 = x_2;
                            x_2 = (_e678 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e680 = y_2;
                    y_2 = (_e680 + 1i);
                }
            }
            let _e682 = lit_1;
            lit_1 = (_e682 * 0.11111111f);
        } else {
            let _e684 = softness;
            spread = tan(min(_e684, 0.5f));
            let _e687 = ShadowNoise_u0028_();
            turn_1 = (_e687 * 6.2831855f);
            let _e689 = spread;
            let _e691 = projected[2u];
            let _e693 = cascadeDepth;
            let _e695 = cascadeTexel;
            searchRadius = clamp((((_e689 * _e691) * _e693) / _e695), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e698 = i_5;
                if (_e698 < 16i) {
                    let _e700 = i_5;
                    param_87 = _e700;
                    param_88 = 16i;
                    let _e701 = turn_1;
                    param_89 = _e701;
                    let _e702 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_87), (&param_88), (&param_89));
                    disc = _e702;
                    let _e703 = bias;
                    let _e704 = disc;
                    let _e706 = searchRadius;
                    let _e710 = receiverSlope;
                    tapBias = (_e703 + (max(((length(_e704) * _e706) - 1.5f), 0f) * _e710));
                    let _e713 = uv_4;
                    let _e714 = disc;
                    let _e715 = texel_1;
                    let _e717 = searchRadius;
                    let _e720 = tileLo;
                    let _e721 = tileHi;
                    let _e723 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e713 + ((_e714 * _e715) * _e717)), _e720, _e721), 0f);
                    param_90 = _e723.x;
                    let _e725 = storage_;
                    param_91 = _e725;
                    let _e726 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_90), (&param_91));
                    occluder_1 = _e726;
                    let _e728 = projected[2u];
                    let _e729 = tapBias;
                    let _e731 = occluder_1;
                    if ((_e728 - _e729) > _e731) {
                        let _e733 = occluder_1;
                        let _e734 = blockerSum;
                        blockerSum = (_e734 + _e733);
                        let _e736 = blockerCount;
                        blockerCount = (_e736 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e738 = i_5;
                    i_5 = (_e738 + 1i);
                }
            }
            let _e740 = blockerCount;
            if (_e740 <= 0f) {
                return 1f;
            }
            let _e743 = projected[2u];
            let _e744 = blockerSum;
            let _e745 = blockerCount;
            let _e749 = cascadeDepth;
            gap = (max((_e743 - (_e744 / _e745)), 0f) * _e749);
            let _e751 = spread;
            let _e752 = gap;
            let _e754 = cascadeTexel;
            radius_2 = clamp(((_e751 * _e752) / _e754), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e757 = i_6;
                if (_e757 < 16i) {
                    let _e759 = turn_1;
                    let _e761 = i_6;
                    param_92 = _e761;
                    param_93 = 16i;
                    param_94 = (_e759 + 1f);
                    let _e762 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_92), (&param_93), (&param_94));
                    disc_1 = _e762;
                    let _e763 = bias;
                    let _e764 = disc_1;
                    let _e766 = radius_2;
                    let _e770 = receiverSlope;
                    tapBias_1 = (_e763 + (max(((length(_e764) * _e766) - 1.5f), 0f) * _e770));
                    let _e773 = uv_4;
                    let _e774 = disc_1;
                    let _e775 = texel_1;
                    let _e777 = radius_2;
                    let _e780 = tileLo;
                    let _e781 = tileHi;
                    let _e783 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e773 + ((_e774 * _e775) * _e777)), _e780, _e781), 0f);
                    param_95 = _e783.x;
                    let _e785 = storage_;
                    param_96 = _e785;
                    let _e786 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_95), (&param_96));
                    occluder_2 = _e786;
                    let _e788 = projected[2u];
                    let _e789 = tapBias_1;
                    let _e791 = occluder_2;
                    let _e794 = lit_1;
                    lit_1 = (_e794 + select(1f, 0f, ((_e788 - _e789) > _e791)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e796 = i_6;
                    i_6 = (_e796 + 1i);
                }
            }
            let _e798 = lit_1;
            lit_1 = (_e798 * 0.0625f);
        }
    }
    let _e800 = lit_1;
    let _e801 = strength_1;
    return mix(1f, _e800, clamp(_e801, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_97: Surface;
    var param_98: LightSample;
    var param_99: i32;

    let _e206 = (*s_4);
    param_97 = _e206;
    let _e207 = (*light_2);
    param_98 = _e207;
    let _e208 = (*index);
    param_99 = _e208;
    let _e209 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_97), (&param_98), (&param_99));
    return _e209;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e201 = (*index_1);
    return (_e201 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e205 = (*distance_1);
    let _e206 = (*distance_1);
    attenuation = (1f / max((_e205 * _e206), 0.0001f));
    let _e210 = (*range_4);
    if (_e210 > 0f) {
        let _e212 = (*distance_1);
        let _e213 = (*range_4);
        ratio = (_e212 / _e213);
        let _e215 = ratio;
        let _e216 = ratio;
        let _e218 = ratio;
        let _e220 = ratio;
        window = clamp((1f - (((_e215 * _e216) * _e218) * _e220)), 0f, 1f);
        let _e224 = window;
        let _e225 = window;
        let _e227 = attenuation;
        attenuation = (_e227 * (_e224 * _e225));
    }
    let _e229 = attenuation;
    return _e229;
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle_1: f32;
    var local_13: vec3<f32>;

    let _e206 = (*a_2);
    let _e207 = (*b);
    axis = cross(_e206, _e207);
    let _e209 = axis;
    len = length(_e209);
    let _e211 = (*a_2);
    let _e212 = (*b);
    angle_1 = acos(clamp(dot(_e211, _e212), -1f, 1f));
    let _e216 = len;
    if (_e216 > 0.000001f) {
        let _e218 = axis;
        let _e219 = angle_1;
        let _e220 = len;
        local_13 = (_e218 * (_e219 / (_e220 * 6.2831855f)));
    } else {
        local_13 = vec3<f32>(0f, 0f, 0f);
    }
    let _e224 = local_13;
    return _e224;
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_3: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv_5: vec2<f32>;
    var inverse: vec4<f32>;
    var param_100: f32;
    var param_101: f32;
    var param_102: f32;
    var fit: vec4<f32>;
    var param_103: f32;
    var param_104: f32;
    var param_105: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_14: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i_7: i32;
    var p_1: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f_2: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var param_108: vec3<f32>;
    var param_109: vec3<f32>;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: vec3<f32>;
    var param_113: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_15: f32;
    var sphere: f32;
    var param_114: f32;
    var param_115: f32;
    var param_116: f32;

    let _e238 = (*roughness_3);
    let _e240 = (*n_2);
    let _e241 = (*v);
    uv_5 = vec2<f32>(clamp(_e238, 0f, 1f), sqrt(clamp((1f - dot(_e240, _e241)), 0f, 1f)));
    let _e248 = uv_5[0u];
    param_100 = _e248;
    let _e250 = uv_5[1u];
    param_101 = _e250;
    param_102 = 0f;
    let _e251 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_100), (&param_101), (&param_102));
    let _e252 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e251, 0f);
    inverse = _e252;
    let _e254 = uv_5[0u];
    param_103 = _e254;
    let _e256 = uv_5[1u];
    param_104 = _e256;
    param_105 = 1f;
    let _e257 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_103), (&param_104), (&param_105));
    let _e258 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e257, 0f);
    fit = _e258;
    let _e259 = (*v);
    let _e260 = (*n_2);
    let _e261 = (*v);
    let _e262 = (*n_2);
    along = (_e259 - (_e260 * dot(_e261, _e262)));
    let _e266 = along;
    alongLength = length(_e266);
    let _e268 = alongLength;
    if (_e268 > 0.00001f) {
        let _e270 = along;
        let _e271 = alongLength;
        local_14 = (_e270 / vec3(_e271));
    } else {
        let _e274 = (*n_2);
        let _e276 = (*n_2)[2u];
        local_14 = normalize(cross(_e274, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e276) < 0.999f)))));
    }
    let _e283 = local_14;
    t1_ = _e283;
    let _e284 = (*n_2);
    let _e285 = t1_;
    t2_ = cross(_e284, _e285);
    let _e288 = inverse[0u];
    let _e290 = inverse[1u];
    let _e291 = vec3<f32>(_e288, 0f, _e290);
    let _e293 = inverse[2u];
    let _e295 = inverse[3u];
    let _e296 = vec3<f32>(_e293, 0f, _e295);
    minv = mat3x3<f32>(vec3<f32>(_e291.x, _e291.y, _e291.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e296.x, _e296.y, _e296.z));
    i_7 = 0i;
    loop {
        let _e310 = i_7;
        if (_e310 < 4i) {
            let _e312 = i_7;
            let _e314 = (*corners)[_e312];
            p_1 = _e314;
            let _e315 = i_7;
            let _e316 = minv;
            let _e317 = p_1;
            let _e318 = t1_;
            let _e320 = p_1;
            let _e321 = t2_;
            let _e323 = p_1;
            let _e324 = (*n_2);
            l[_e315] = normalize((_e316 * vec3<f32>(dot(_e317, _e318), dot(_e320, _e321), dot(_e323, _e324))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e330 = i_7;
            i_7 = (_e330 + 1i);
        }
    }
    let _e333 = l[0i];
    param_106 = _e333;
    let _e335 = l[1i];
    param_107 = _e335;
    let _e336 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_106), (&param_107));
    let _e338 = l[1i];
    param_108 = _e338;
    let _e340 = l[2i];
    param_109 = _e340;
    let _e341 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_108), (&param_109));
    let _e344 = l[2i];
    param_110 = _e344;
    let _e346 = l[3i];
    param_111 = _e346;
    let _e347 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_110), (&param_111));
    let _e350 = l[3i];
    param_112 = _e350;
    let _e352 = l[0i];
    param_113 = _e352;
    let _e353 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_112), (&param_113));
    f_2 = -((((_e336 + _e341) + _e347) + _e353));
    let _e356 = f_2;
    len_1 = length(_e356);
    let _e358 = len_1;
    if (_e358 > 0.000000001f) {
        let _e361 = f_2[2u];
        let _e362 = len_1;
        local_15 = (_e361 / _e362);
    } else {
        local_15 = 0f;
    }
    let _e364 = local_15;
    z_1 = _e364;
    let _e365 = z_1;
    let _e368 = len_1;
    param_114 = ((_e365 * 0.5f) + 0.5f);
    param_115 = clamp(_e368, 0f, 1f);
    param_116 = 1f;
    let _e370 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_114), (&param_115), (&param_116));
    let _e371 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e370, 0f);
    sphere = _e371.w;
    let _e373 = len_1;
    let _e374 = sphere;
    let _e378 = fit[0u];
    let _e380 = fit[1u];
    return vec3<f32>(max((_e373 * _e374), 0f), _e378, _e380);
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_16: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e217 = (*halfWidth);
    let _e218 = (*halfHeight);
    n_3 = cross(_e217, _e218);
    let _e220 = n_3;
    nLen = length(_e220);
    let _e222 = nLen;
    if (_e222 < 0.000000000001f) {
        let _e224 = (*centre);
        return _e224;
    }
    let _e225 = nLen;
    let _e226 = n_3;
    n_3 = (_e226 / vec3(_e225));
    let _e229 = (*centre);
    let _e230 = (*world_2);
    toPlane = (_e229 - _e230);
    let _e232 = (*mirror);
    let _e233 = n_3;
    denom = dot(_e232, _e233);
    let _e235 = denom;
    if (abs(_e235) < 0.00001f) {
        let _e238 = toPlane;
        let _e239 = n_3;
        let _e240 = toPlane;
        let _e241 = n_3;
        onPlane = (_e238 - (_e239 * dot(_e240, _e241)));
    } else {
        let _e245 = toPlane;
        let _e246 = n_3;
        let _e248 = denom;
        t_1 = (dot(_e245, _e246) / _e248);
        let _e250 = t_1;
        if (_e250 > 0f) {
            let _e252 = (*mirror);
            let _e253 = t_1;
            local_16 = (_e252 * _e253);
        } else {
            let _e255 = toPlane;
            let _e256 = n_3;
            let _e257 = toPlane;
            let _e258 = n_3;
            local_16 = (_e255 - (_e256 * dot(_e257, _e258)));
        }
        let _e262 = local_16;
        onPlane = _e262;
    }
    let _e263 = onPlane;
    let _e264 = toPlane;
    offset_2 = (_e263 - _e264);
    let _e266 = (*halfWidth);
    let _e267 = (*halfWidth);
    wLen2_ = max(dot(_e266, _e267), 0.000000000001f);
    let _e270 = (*halfHeight);
    let _e271 = (*halfHeight);
    hLen2_ = max(dot(_e270, _e271), 0.000000000001f);
    let _e274 = offset_2;
    let _e275 = (*halfWidth);
    let _e277 = wLen2_;
    u = clamp((dot(_e274, _e275) / _e277), -1f, 1f);
    let _e280 = offset_2;
    let _e281 = (*halfHeight);
    let _e283 = hLen2_;
    v_1 = clamp((dot(_e280, _e281) / _e283), -1f, 1f);
    let _e286 = (*centre);
    let _e287 = (*halfWidth);
    let _e288 = u;
    let _e291 = (*halfHeight);
    let _e292 = v_1;
    return ((_e286 + (_e287 * _e288)) + (_e291 * _e292));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_17: f32;

    let _e209 = (*a_3);
    let _e210 = (*a_3);
    ua = (_e209 / vec3(max(length(_e210), 0.000000000001f)));
    let _e215 = (*b_1);
    let _e216 = (*b_1);
    ub = (_e215 / vec3(max(length(_e216), 0.000000000001f)));
    let _e221 = ua;
    let _e222 = ub;
    angle_2 = acos(clamp(dot(_e221, _e222), -1f, 1f));
    let _e226 = ua;
    let _e227 = ub;
    axis_1 = cross(_e226, _e227);
    let _e229 = axis_1;
    len_2 = length(_e229);
    let _e231 = len_2;
    if (_e231 > 0.000001f) {
        let _e233 = angle_2;
        let _e234 = axis_1;
        let _e235 = (*n_4);
        let _e238 = len_2;
        local_17 = ((_e233 * dot(_e234, _e235)) / _e238);
    } else {
        local_17 = 0f;
    }
    let _e240 = local_17;
    return _e240;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_18: i32;
    var ha: f32;
    var hb: f32;
    var d_4: f32;
    var q: vec3<f32>;
    var local_19: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_20: f32;
    var param_117: vec3<f32>;
    var param_118: vec3<f32>;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: vec3<f32>;
    var param_122: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e223 = i_8;
        if (_e223 < 4i) {
            let _e225 = i_8;
            let _e227 = (*corners_1)[_e225];
            a_4 = _e227;
            let _e228 = i_8;
            if (_e228 == 3i) {
                local_18 = 0i;
            } else {
                let _e230 = i_8;
                local_18 = (_e230 + 1i);
            }
            let _e232 = local_18;
            let _e234 = (*corners_1)[_e232];
            b_2 = _e234;
            let _e235 = a_4;
            let _e236 = (*n_5);
            ha = dot(_e235, _e236);
            let _e238 = b_2;
            let _e239 = (*n_5);
            hb = dot(_e238, _e239);
            let _e241 = ha;
            let _e242 = hb;
            d_4 = (_e241 - _e242);
            let _e244 = a_4;
            let _e245 = b_2;
            let _e246 = a_4;
            let _e248 = d_4;
            if (abs(_e248) > 0.000000000001f) {
                let _e251 = ha;
                let _e252 = d_4;
                local_19 = (_e251 / _e252);
            } else {
                local_19 = 0f;
            }
            let _e254 = local_19;
            q = (_e244 + ((_e245 - _e246) * _e254));
            let _e257 = ha;
            aAbove = (_e257 > 0f);
            let _e259 = hb;
            bAbove = (_e259 > 0f);
            let _e261 = aAbove;
            let _e262 = bAbove;
            if (_e261 || _e262) {
                let _e264 = aAbove;
                let _e265 = a_4;
                let _e266 = q;
                let _e269 = bAbove;
                let _e270 = b_2;
                let _e271 = q;
                param_117 = select(_e266, _e265, vec3(_e264));
                param_118 = select(_e271, _e270, vec3(_e269));
                let _e274 = (*n_5);
                param_119 = _e274;
                let _e275 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_117), (&param_118), (&param_119));
                local_20 = _e275;
            } else {
                local_20 = 0f;
            }
            let _e276 = local_20;
            let _e277 = total;
            total = (_e277 + _e276);
            let _e279 = aAbove;
            let _e280 = bAbove;
            let _e283 = q;
            let _e284 = exit;
            exit = select(_e284, _e283, vec3((_e279 && !(_e280))));
            let _e287 = aAbove;
            let _e289 = bAbove;
            let _e291 = q;
            let _e292 = entry;
            entry = select(_e292, _e291, vec3((!(_e287) && _e289)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e295 = i_8;
            i_8 = (_e295 + 1i);
        }
    }
    let _e297 = exit;
    param_120 = _e297;
    let _e298 = entry;
    param_121 = _e298;
    let _e299 = (*n_5);
    param_122 = _e299;
    let _e300 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_120), (&param_121), (&param_122));
    let _e301 = total;
    total = (_e301 + _e300);
    let _e303 = total;
    return max((-(_e303) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_21: f32;
    var local_22: f32;
    var local_23: f32;

    let _e206 = (*slot_1);
    let _e207 = (*slot_1);
    lane = (_e206 - ((_e207 / 4i) * 4i));
    let _e211 = lane;
    if (_e211 == 0i) {
        let _e214 = (*four)[0u];
        local_21 = _e214;
    } else {
        let _e215 = lane;
        if (_e215 == 1i) {
            let _e218 = (*four)[1u];
            local_22 = _e218;
        } else {
            let _e219 = lane;
            if (_e219 == 2i) {
                let _e222 = (*four)[2u];
                local_23 = _e222;
            } else {
                let _e224 = (*four)[3u];
                local_23 = _e224;
            }
            let _e225 = local_23;
            local_22 = _e225;
        }
        let _e226 = local_22;
        local_21 = _e226;
    }
    let _e227 = local_21;
    return _e227;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_123: vec4<f32>;
    var param_124: i32;

    let _e203 = (*slot_2);
    let _e207 = light_list_info.scales[(_e203 / 4i)];
    param_123 = _e207;
    let _e208 = (*slot_2);
    param_124 = _e208;
    let _e209 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_123), (&param_124));
    return _e209;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e205 = light_list_info.slot_rows[0i];
    let _e206 = (*row);
    a_5 = abs((_e205 - vec4(_e206)));
    let _e212 = light_list_info.slot_rows[1i];
    let _e213 = (*row);
    b_3 = abs((_e212 - vec4(_e213)));
    let _e218 = a_5[0u];
    let _e220 = a_5[1u];
    let _e223 = a_5[2u];
    let _e225 = a_5[3u];
    let _e229 = b_3[0u];
    let _e231 = b_3[1u];
    let _e234 = b_3[2u];
    let _e236 = b_3[3u];
    return (min(min(min(_e218, _e220), min(_e223, _e225)), min(min(_e229, _e231), min(_e234, _e236))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_125: vec4<f32>;
    var param_126: i32;

    let _e203 = (*slot_3);
    let _e207 = light_list_info.indices[(_e203 / 4i)];
    param_125 = _e207;
    let _e208 = (*slot_3);
    param_126 = _e208;
    let _e209 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_125), (&param_126));
    return _e209;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e202 = (*texel_2);
    let _e206 = light_list_info.list[1u];
    let _e208 = (*row_1);
    let _e212 = light_list_info.list[2u];
    let _e215 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e202 + 0.5f) * _e206), ((_e208 + 0.5f) * _e212)), 0f);
    return _e215;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_127: f32;
    var param_128: f32;
    var param_129: vec4<f32>;
    var param_130: i32;

    let _e210 = g_cluster_offset;
    let _e211 = (*slot_4);
    entry_1 = (_e210 + f32(_e211));
    let _e214 = entry_1;
    row_2 = floor((_e214 / 16f));
    let _e217 = entry_1;
    let _e218 = row_2;
    within = (_e217 - (_e218 * 16f));
    let _e221 = within;
    texel_3 = floor((_e221 / 4f));
    let _e226 = light_list_info.cluster_depth[3u];
    let _e227 = row_2;
    let _e229 = texel_3;
    param_127 = _e229;
    param_128 = (_e226 + _e227);
    let _e230 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_127), (&param_128));
    four_1 = _e230;
    let _e231 = within;
    let _e232 = texel_3;
    let _e237 = four_1;
    param_129 = _e237;
    param_130 = i32(((_e231 - (_e232 * 4f)) + 0.5f));
    let _e238 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_129), (&param_130));
    return _e238;
}

fn Clustered_u0028_() -> bool {
    let _e202 = light_list_info.cluster_grid[3u];
    return (_e202 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_24: f32;
    var param_131: i32;
    var param_132: i32;
    var v_2: f32;
    var u_1: f32;
    var local_25: f32;
    var param_133: f32;
    var param_134: i32;
    var type_42: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_26: f32;
    var param_135: array<vec3<f32>, 4>;
    var param_136: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_27: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_137: vec3<f32>;
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_28: vec3<f32>;
    var param_142: vec3<f32>;
    var param_143: vec3<f32>;
    var param_144: f32;
    var param_145: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_146: f32;
    var param_147: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e258 = (*index_2);
    if (_e258 < 8i) {
        let _e260 = (*index_2);
        let _e263 = frag_info.light_position[_e260];
        position = _e263;
        let _e264 = (*index_2);
        let _e267 = frag_info.light_color[_e264];
        color_1 = _e267;
        let _e268 = (*index_2);
        let _e271 = frag_info.light_direction[_e268];
        direction = _e271;
        let _e272 = (*index_2);
        let _e275 = frag_info.light_cone[_e272];
        cone = _e275;
    } else {
        let _e276 = (*index_2);
        slot_5 = (_e276 - 8i);
        let _e278 = Clustered_u0028_();
        clustered = _e278;
        let _e279 = clustered;
        if _e279 {
            let _e280 = slot_5;
            param_131 = _e280;
            let _e281 = ClusterRow_u0028_i1_u003b((&param_131));
            local_24 = _e281;
        } else {
            let _e282 = slot_5;
            param_132 = _e282;
            let _e283 = LightListRow_u0028_i1_u003b((&param_132));
            local_24 = _e283;
        }
        let _e284 = local_24;
        listRow = _e284;
        let _e285 = listRow;
        let _e289 = light_list_info.list[2u];
        v_2 = ((_e285 + 0.5f) * _e289);
        let _e293 = light_list_info.list[1u];
        u_1 = _e293;
        let _e294 = u_1;
        let _e296 = v_2;
        let _e298 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e294), _e296), 0f);
        position = _e298;
        let _e299 = u_1;
        let _e301 = v_2;
        let _e303 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e299), _e301), 0f);
        color_1 = _e303;
        let _e304 = u_1;
        let _e306 = v_2;
        let _e308 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e304), _e306), 0f);
        direction = _e308;
        let _e309 = u_1;
        let _e311 = v_2;
        let _e313 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e309), _e311), 0f);
        cone = _e313;
        let _e314 = clustered;
        if _e314 {
            let _e315 = listRow;
            param_133 = _e315;
            let _e316 = InSlots_u0028_f1_u003b((&param_133));
            local_25 = select(1f, 0f, _e316);
        } else {
            let _e318 = slot_5;
            param_134 = _e318;
            let _e319 = LightListScale_u0028_i1_u003b((&param_134));
            local_25 = _e319;
        }
        let _e320 = local_25;
        let _e322 = color_1[3u];
        color_1[3u] = (_e322 * _e320);
    }
    let _e326 = position[3u];
    type_42 = _e326;
    let _e327 = type_42;
    if (_e327 > 15.5f) {
        let _e330 = (*s_5).n;
        light_3.l = _e330;
        let _e333 = (*s_5).n;
        light_3.h = _e333;
        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 _e339 = light_3;
        return _e339;
    }
    let _e340 = type_42;
    if (_e340 > 2.5f) {
        let _e342 = direction;
        halfWidth_1 = _e342.xyz;
        let _e344 = cone;
        halfHeight_1 = _e344.xyz;
        let _e346 = position;
        let _e348 = v_world_position_1;
        toCentre = (_e346.xyz - _e348);
        let _e350 = toCentre;
        let _e351 = halfWidth_1;
        let _e353 = halfHeight_1;
        corners_2[0i] = ((_e350 - _e351) - _e353);
        let _e356 = toCentre;
        let _e357 = halfWidth_1;
        let _e359 = halfHeight_1;
        corners_2[1i] = ((_e356 + _e357) - _e359);
        let _e362 = toCentre;
        let _e363 = halfWidth_1;
        let _e365 = halfHeight_1;
        corners_2[2i] = ((_e362 + _e363) + _e365);
        let _e368 = toCentre;
        let _e369 = halfWidth_1;
        let _e371 = halfHeight_1;
        corners_2[3i] = ((_e368 - _e369) + _e371);
        let _e374 = toCentre;
        let _e375 = halfWidth_1;
        let _e376 = halfHeight_1;
        behind = (dot(_e374, cross(_e375, _e376)) >= 0f);
        let _e380 = behind;
        if _e380 {
            local_26 = 0f;
        } else {
            let _e381 = corners_2;
            param_135 = _e381;
            let _e383 = (*s_5).n;
            param_136 = _e383;
            let _e384 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_135), (&param_136));
            local_26 = _e384;
        }
        let _e385 = local_26;
        formFactor = _e385;
        let _e386 = halfWidth_1;
        let _e387 = halfHeight_1;
        area = (length(cross(_e386, _e387)) * 4f);
        let _e391 = area;
        if (_e391 > 0.000000001f) {
            let _e393 = area;
            local_27 = (1f / _e393);
        } else {
            local_27 = 0f;
        }
        let _e395 = local_27;
        radiance = _e395;
        let _e396 = toCentre;
        distance_2 = length(_e396);
        let _e399 = direction[3u];
        if (_e399 > 0f) {
            let _e401 = distance_2;
            let _e403 = direction[3u];
            ratio_1 = (_e401 / _e403);
            let _e405 = ratio_1;
            let _e406 = ratio_1;
            let _e408 = ratio_1;
            let _e410 = ratio_1;
            window_1 = clamp((1f - (((_e405 * _e406) * _e408) * _e410)), 0f, 1f);
            let _e414 = window_1;
            let _e415 = window_1;
            let _e417 = radiance;
            radiance = (_e417 * (_e414 * _e415));
        }
        let _e420 = (*s_5).v;
        let _e423 = (*s_5).n;
        mirror_1 = reflect(-(_e420), _e423);
        let _e425 = position;
        param_137 = _e425.xyz;
        let _e427 = halfWidth_1;
        param_138 = _e427;
        let _e428 = halfHeight_1;
        param_139 = _e428;
        let _e429 = v_world_position_1;
        param_140 = _e429;
        let _e430 = mirror_1;
        param_141 = _e430;
        let _e431 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_137), (&param_138), (&param_139), (&param_140), (&param_141));
        representative = _e431;
        let _e432 = representative;
        let _e433 = v_world_position_1;
        toPoint = (_e432 - _e433);
        let _e435 = toPoint;
        pointDistance = length(_e435);
        let _e437 = pointDistance;
        if (_e437 > 0.000001f) {
            let _e439 = toPoint;
            let _e440 = pointDistance;
            local_28 = (_e439 / vec3(_e440));
        } else {
            let _e444 = (*s_5).n;
            local_28 = _e444;
        }
        let _e445 = local_28;
        light_3.l = _e445;
        let _e448 = light_3.l;
        let _e450 = (*s_5).v;
        light_3.h = normalize((_e448 + _e450));
        let _e454 = formFactor;
        light_3.n_dot_l = _e454;
        let _e457 = (*s_5).n;
        let _e459 = light_3.h;
        light_3.n_dot_h = max(dot(_e457, _e459), 0f);
        let _e464 = (*s_5).v;
        let _e466 = light_3.h;
        light_3.v_dot_h = max(dot(_e464, _e466), 0f);
        let _e470 = color_1;
        let _e473 = color_1[3u];
        let _e475 = radiance;
        light_3.radiance = ((_e470.xyz * _e473) * _e475);
        light_3.integrated = 1f;
        let _e480 = (*s_5).n;
        param_142 = _e480;
        let _e482 = (*s_5).v;
        param_143 = _e482;
        let _e484 = (*s_5).roughness;
        param_144 = _e484;
        let _e485 = corners_2;
        param_145 = _e485;
        let _e486 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_142), (&param_143), (&param_144), (&param_145));
        light_3.ltc = _e486;
        let _e488 = light_3;
        return _e488;
    }
    let _e489 = direction;
    aim = normalize(_e489.xyz);
    attenuation_1 = 1f;
    let _e492 = type_42;
    if (_e492 < 0.5f) {
        let _e494 = aim;
        light_3.l = -(_e494);
    } else {
        let _e497 = position;
        let _e499 = v_world_position_1;
        toLight_1 = (_e497.xyz - _e499);
        let _e501 = toLight_1;
        distance_3 = length(_e501);
        let _e503 = distance_3;
        if (_e503 < 0.000001f) {
            let _e506 = (*s_5).n;
            light_3.l = _e506;
            let _e509 = (*s_5).n;
            light_3.h = _e509;
            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 _e515 = light_3;
            return _e515;
        }
        let _e516 = toLight_1;
        let _e517 = distance_3;
        light_3.l = (_e516 / vec3(_e517));
        let _e521 = distance_3;
        param_146 = _e521;
        let _e523 = direction[3u];
        param_147 = _e523;
        let _e524 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_146), (&param_147));
        attenuation_1 = _e524;
        let _e525 = type_42;
        if (_e525 > 1.5f) {
            let _e527 = aim;
            let _e529 = light_3.l;
            cosAngle = dot(_e527, -(_e529));
            let _e532 = cosAngle;
            let _e534 = cone[1u];
            let _e537 = cone[0u];
            let _e539 = cone[1u];
            ramp = clamp(((_e532 - _e534) / (_e537 - _e539)), 0f, 1f);
            let _e543 = ramp;
            let _e544 = ramp;
            let _e546 = attenuation_1;
            attenuation_1 = (_e546 * (_e543 * _e544));
        }
    }
    let _e549 = light_3.l;
    let _e551 = (*s_5).v;
    light_3.h = normalize((_e549 + _e551));
    let _e556 = (*s_5).n;
    let _e558 = light_3.l;
    light_3.n_dot_l = max(dot(_e556, _e558), 0f);
    let _e563 = (*s_5).n;
    let _e565 = light_3.h;
    light_3.n_dot_h = max(dot(_e563, _e565), 0f);
    let _e570 = (*s_5).v;
    let _e572 = light_3.h;
    light_3.v_dot_h = max(dot(_e570, _e572), 0f);
    let _e576 = color_1;
    let _e579 = color_1[3u];
    let _e581 = attenuation_1;
    light_3.radiance = ((_e576.xyz * _e579) * _e581);
    let _e584 = light_3;
    return _e584;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_29: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_148: f32;
    var param_149: f32;

    let _e215 = light_list_info.cluster_view_projection;
    let _e216 = (*world_3);
    clip_1 = (_e215 * vec4<f32>(_e216.x, _e216.y, _e216.z, 1f));
    let _e222 = clip_1;
    let _e225 = clip_1[3u];
    ndc_1 = (_e222.xy / vec2(max(_e225, 0.000001f)));
    let _e230 = light_list_info.cluster_grid;
    grid = _e230.xyz;
    let _e234 = light_list_info.cluster_depth[0u];
    near_1 = _e234;
    let _e236 = ndc_1[0u];
    let _e240 = grid[0u];
    let _e244 = grid[0u];
    tx = clamp(floor((((_e236 * 0.5f) + 0.5f) * _e240)), 0f, (_e244 - 1f));
    let _e248 = ndc_1[1u];
    let _e252 = grid[1u];
    let _e256 = grid[1u];
    ty = clamp(floor((((_e248 * 0.5f) + 0.5f) * _e252)), 0f, (_e256 - 1f));
    let _e260 = clip_1[3u];
    let _e261 = near_1;
    if (_e260 <= _e261) {
        local_29 = 0f;
    } else {
        let _e264 = clip_1[3u];
        let _e265 = near_1;
        let _e270 = light_list_info.cluster_depth[1u];
        let _e274 = grid[2u];
        local_29 = clamp(floor((log((_e264 / _e265)) * _e270)), 0f, (_e274 - 1f));
    }
    let _e277 = local_29;
    tz = _e277;
    let _e278 = tx;
    let _e279 = ty;
    let _e281 = grid[0u];
    let _e284 = tz;
    let _e286 = grid[0u];
    let _e289 = grid[1u];
    cell = ((_e278 + (_e279 * _e281)) + ((_e284 * _e286) * _e289));
    let _e292 = cell;
    row_3 = floor((_e292 / 4f));
    let _e295 = cell;
    let _e296 = row_3;
    let _e301 = light_list_info.cluster_depth[2u];
    let _e302 = row_3;
    param_148 = (_e295 - (_e296 * 4f));
    param_149 = (_e301 + _e302);
    let _e304 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_148), (&param_149));
    header = _e304;
    let _e306 = header[0u];
    g_cluster_offset = _e306;
    let _e308 = header[1u];
    g_cluster_count = _e308;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_150: vec3<f32>;

    let _e204 = light_list_info.list[0u];
    tail = _e204;
    let _e205 = Clustered_u0028_();
    if _e205 {
        let _e206 = v_world_position_1;
        param_150 = _e206;
        FindCluster_u0028_vf3_u003b((&param_150));
        let _e207 = g_cluster_count;
        tail = _e207;
    }
    let _e210 = frag_info.frame_params[1u];
    let _e214 = tail;
    return (clamp(i32((_e210 + 0.5f)), 0i, 8i) + clamp(i32((_e214 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_4: LightSample;
    var param_151: i32;
    var param_152: Surface;
    var visibility: f32;
    var param_153: i32;
    var local_30: f32;
    var param_154: Surface;
    var param_155: LightSample;
    var param_156: i32;
    var param_157: vec3<f32>;
    var param_158: vec3<f32>;
    var param_159: i32;
    var param_160: Surface;
    var param_161: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e218 = LightCount_u0028_();
    count_1 = _e218;
    i_9 = 0i;
    loop {
        let _e219 = i_9;
        if (_e219 < 32i) {
            let _e221 = i_9;
            let _e222 = count_1;
            if (_e221 >= _e222) {
                break;
            }
            let _e224 = i_9;
            param_151 = _e224;
            let _e225 = (*s_6);
            param_152 = _e225;
            let _e226 = 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((&param_151), (&param_152));
            light_4 = _e226;
            let _e228 = light_4.n_dot_l;
            if (_e228 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e230 = i_9;
            param_153 = _e230;
            let _e231 = LightHasShadow_u0028_i1_u003b((&param_153));
            if _e231 {
                let _e232 = (*s_6);
                param_154 = _e232;
                let _e233 = light_4;
                param_155 = _e233;
                let _e234 = i_9;
                param_156 = _e234;
                let _e235 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_154), (&param_155), (&param_156));
                let _e236 = v_world_position_1;
                param_157 = _e236;
                let _e238 = (*s_6).n;
                param_158 = _e238;
                let _e239 = i_9;
                param_159 = _e239;
                let _e240 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_157), (&param_158), (&param_159));
                local_30 = (_e235 * _e240);
            } else {
                local_30 = 1f;
            }
            let _e242 = local_30;
            visibility = _e242;
            let _e243 = visibility;
            if (_e243 <= 0f) {
                continue;
            }
            let _e245 = (*s_6);
            param_160 = _e245;
            let _e246 = light_4;
            param_161 = _e246;
            let _e247 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_160), (&param_161));
            let _e249 = light_4.radiance;
            let _e252 = light_4.n_dot_l;
            let _e254 = visibility;
            let _e256 = light_transmittance;
            let _e258 = total_1;
            total_1 = (_e258 + ((((_e247 * _e249) * _e252) * _e254) * _e256));
            continue;
        } else {
            break;
        }
        continuing {
            let _e260 = i_9;
            i_9 = (_e260 + 1i);
        }
    }
    let _e262 = total_1;
    return _e262;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e201 = v_lightmap_uv_1;
    let _e202 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e201);
    texel_4 = _e202;
    let _e203 = texel_4;
    let _e206 = texel_4[3u];
    return ((_e203.xyz * _e206) * 8f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_31: f32;

    let _e203 = frag_info.material2_[2u];
    local_31 = floor((_e203 * 0.5f));
    let _e206 = local_31;
    return _e206;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_32: f32;
    var local_33: f32;

    let _e204 = OcclusionTarget_u0028_();
    target_ = _e204;
    let _e205 = target_;
    let _e207 = target_;
    if ((_e205 > 0.5f) && (_e207 < 1.5f)) {
        local_32 = 1f;
    } else {
        let _e211 = (*s_7).occlusion;
        local_32 = _e211;
    }
    let _e212 = local_32;
    local_33 = _e212;
    let _e213 = local_33;
    return _e213;
}

fn DirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var local_34: f32;
    var local_35: f32;

    let _e203 = OcclusionTarget_u0028_();
    if (_e203 > 1.5f) {
        local_34 = 1f;
    } else {
        let _e206 = (*s_8).occlusion;
        local_34 = _e206;
    }
    let _e207 = local_34;
    local_35 = _e207;
    let _e208 = local_35;
    return _e208;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_162: f32;
    var param_163: f32;
    var param_164: f32;
    var param_165: vec3<f32>;
    var param_166: f32;

    let _e209 = (*mu_1);
    param_162 = _e209;
    let _e210 = (*r_4);
    param_163 = _e210;
    let _e211 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_162), (&param_163));
    e_1 = _e211;
    let _e212 = (*rho_2);
    let _e213 = e_1;
    let _e215 = (*r_4);
    param_164 = _e215;
    let _e216 = FonAverage_u0028_f1_u003b((&param_164));
    let _e217 = (*rho_2);
    param_165 = _e217;
    param_166 = _e216;
    let _e218 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_165), (&param_166));
    let _e219 = e_1;
    return ((_e212 * _e213) + (_e218 * (1f - _e219)));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e202 = frag_info.target_origin[1u];
    return _e202;
}

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_9: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e202 = v_texcoord_1;
    let _e203 = MaterialLodBias_u0028_();
    let _e204 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e202, _e203);
    orm = _e204.xyz;
    let _e207 = (*s_9).metallic;
    let _e209 = orm[2u];
    (*s_9).metallic = clamp((_e207 * _e209), 0f, 1f);
    let _e214 = (*s_9).roughness;
    let _e216 = orm[1u];
    (*s_9).roughness = clamp((_e214 * _e216), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e201 = (*srgb);
    let _e204 = (*srgb);
    let _e209 = (*srgb);
    return mix((_e201 / vec3(12.92f)), pow(((_e204 + 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), _e209));
}

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_10: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_167: vec3<f32>;

    let _e203 = v_texcoord_1;
    let _e204 = MaterialLodBias_u0028_();
    let _e205 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e203, _e204);
    param_167 = _e205.xyz;
    let _e207 = SrgbToLinear_u0028_vf3_u003b((&param_167));
    emissive = _e207;
    let _e208 = emissive;
    let _e210 = frag_info.emissive;
    let _e215 = frag_info.material2_[3u];
    (*s_10).emissive = ((_e208 * _e210.xyz) * _e215);
    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_11: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e203 = v_texcoord_1;
    let _e204 = MaterialLodBias_u0028_();
    let _e205 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e203, _e204);
    occlusion = _e205.x;
    let _e209 = frag_info.material2_[2u];
    let _e210 = OcclusionTarget_u0028_();
    strength_2 = (_e209 - (2f * _e210));
    let _e213 = occlusion;
    let _e214 = strength_2;
    (*s_11).occlusion = mix(1f, _e213, clamp(_e214, 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_12: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_4: vec3<f32>;
    var sampled: vec3<f32>;

    let _e205 = v_texcoord_1;
    let _e206 = MaterialLodBias_u0028_();
    let _e207 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e205, _e206);
    sampledTexel = _e207;
    let _e208 = v_tangent_1;
    t_2 = _e208.xyz;
    let _e210 = t_2;
    let _e212 = (*s_12).n;
    let _e214 = (*s_12).n;
    let _e215 = t_2;
    t_2 = (_e210 - (_e212 * dot(_e214, _e215)));
    let _e219 = t_2;
    let _e220 = t_2;
    if (dot(_e219, _e220) < 0.000000000001f) {
        return;
    }
    let _e223 = t_2;
    t_2 = normalize(_e223);
    let _e226 = (*s_12).n;
    let _e227 = t_2;
    let _e230 = v_tangent_1[3u];
    b_4 = (cross(_e226, _e227) * _e230);
    let _e232 = gl_FrontFacing_1;
    if !(_e232) {
        let _e234 = t_2;
        t_2 = -(_e234);
    }
    let _e236 = sampledTexel;
    sampled = ((_e236.xyz * 2f) - vec3(1f));
    let _e243 = frag_info.emissive[3u];
    if (_e243 > 0.5f) {
        let _e245 = sampled;
        let _e247 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e245.xy, _e247.xy)), 0f));
    }
    let _e256 = frag_info.material2_[1u];
    let _e257 = sampled;
    let _e259 = (_e257.xy * _e256);
    sampled[0u] = _e259.x;
    sampled[1u] = _e259.y;
    let _e264 = t_2;
    let _e266 = sampled[0u];
    let _e268 = b_4;
    let _e270 = sampled[1u];
    let _e274 = (*s_12).n;
    let _e276 = sampled[2u];
    (*s_12).n = normalize((((_e264 * _e266) + (_e268 * _e270)) + (_e274 * _e276)));
    let _e282 = (*s_12).n;
    let _e284 = (*s_12).v;
    (*s_12).n_dot_v = max(dot(_e282, _e284), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e201 = (*texel_5);
    let _e205 = irradiance_info.atlas;
    let _e208 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e201 + vec2(0.5f)) * _e205.xy), 0f);
    return _e208;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f_3: vec2<f32>;
    var a_6: vec4<f32>;
    var param_168: vec2<f32>;
    var b_5: vec4<f32>;
    var param_169: vec2<f32>;
    var c: vec4<f32>;
    var param_170: vec2<f32>;
    var d_5: vec4<f32>;
    var param_171: vec2<f32>;

    let _e214 = (*uv_6);
    let _e215 = (*interior);
    at_1 = ((vec2(1f) + (_e214 * _e215)) - vec2(0.5f));
    let _e221 = at_1;
    low = floor(_e221);
    let _e223 = at_1;
    let _e224 = low;
    f_3 = (_e223 - _e224);
    let _e226 = (*corner);
    let _e227 = low;
    param_168 = (_e226 + _e227);
    let _e229 = AtlasTexel_u0028_vf2_u003b((&param_168));
    a_6 = _e229;
    let _e230 = (*corner);
    let _e231 = low;
    param_169 = ((_e230 + _e231) + vec2<f32>(1f, 0f));
    let _e234 = AtlasTexel_u0028_vf2_u003b((&param_169));
    b_5 = _e234;
    let _e235 = (*corner);
    let _e236 = low;
    param_170 = ((_e235 + _e236) + vec2<f32>(0f, 1f));
    let _e239 = AtlasTexel_u0028_vf2_u003b((&param_170));
    c = _e239;
    let _e240 = (*corner);
    let _e241 = low;
    param_171 = ((_e240 + _e241) + vec2<f32>(1f, 1f));
    let _e244 = AtlasTexel_u0028_vf2_u003b((&param_171));
    d_5 = _e244;
    let _e245 = a_6;
    let _e246 = b_5;
    let _e248 = f_3[0u];
    let _e251 = c;
    let _e252 = d_5;
    let _e254 = f_3[0u];
    let _e258 = f_3[1u];
    return mix(mix(_e245, _e246, vec4(_e248)), mix(_e251, _e252, vec4(_e254)), vec4(_e258));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e205 = (*direction_1)[0u];
    let _e208 = (*direction_1)[1u];
    let _e212 = (*direction_1)[2u];
    sum_1 = ((abs(_e205) + abs(_e208)) + abs(_e212));
    let _e215 = sum_1;
    if (_e215 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e217 = (*direction_1);
    let _e218 = sum_1;
    n_6 = (_e217 / vec3(_e218));
    let _e221 = n_6;
    xy = _e221.xy;
    let _e224 = n_6[2u];
    if (_e224 < 0f) {
        let _e227 = n_6[1u];
        let _e231 = n_6[0u];
        let _e236 = n_6[0u];
        let _e240 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e227)) * select(-1f, 1f, (_e231 >= 0f))), ((1f - abs(_e236)) * select(-1f, 1f, (_e240 >= 0f))));
    }
    let _e245 = xy;
    return ((_e245 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_4: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_172: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_173: vec3<f32>;
    var param_174: vec2<f32>;
    var param_175: f32;
    var param_176: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_177: vec3<f32>;
    var param_178: vec2<f32>;
    var param_179: f32;
    var param_180: vec2<f32>;
    var local_36: vec3<f32>;

    let _e247 = irradiance_info.origin;
    origin_2 = _e247.xyz;
    let _e250 = irradiance_info.spacing;
    spacing = _e250.xyz;
    let _e253 = irradiance_info.counts;
    counts = _e253.xyz;
    let _e257 = irradiance_info.tiles[0u];
    irradianceTile = _e257;
    let _e260 = irradiance_info.tiles[1u];
    depthTile = _e260;
    let _e263 = irradiance_info.tiles[2u];
    columns = _e263;
    let _e266 = irradiance_info.tiles[3u];
    momentsTop = _e266;
    let _e267 = (*normal_1);
    unit = normalize(_e267);
    let _e269 = (*world_4);
    let _e270 = unit;
    let _e273 = irradiance_info.spacing[3u];
    let _e276 = (*view);
    let _e279 = irradiance_info.counts[3u];
    biased = ((_e269 + (_e270 * _e273)) + (_e276 * _e279));
    let _e282 = biased;
    let _e283 = origin_2;
    let _e285 = spacing;
    grid_1 = ((_e282 - _e283) / _e285);
    let _e287 = grid_1;
    let _e289 = counts;
    base = clamp(floor(_e287), vec3<f32>(0f, 0f, 0f), (_e289 - vec3(2f)));
    let _e293 = grid_1;
    let _e294 = base;
    f_4 = clamp((_e293 - _e294), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e297 = corner_1;
        if (_e297 < 8i) {
            let _e299 = corner_1;
            let _e302 = corner_1;
            let _e307 = corner_1;
            offset_3 = vec3<f32>(f32((_e299 & 1i)), f32(((_e302 >> bitcast<u32>(1i)) & 1i)), f32(((_e307 >> bitcast<u32>(2i)) & 1i)));
            let _e313 = base;
            let _e314 = offset_3;
            cell_1 = (_e313 + _e314);
            let _e317 = cell_1[2u];
            let _e319 = counts[1u];
            let _e322 = cell_1[1u];
            let _e325 = counts[0u];
            let _e328 = cell_1[0u];
            probe = ((((_e317 * _e319) + _e322) * _e325) + _e328);
            let _e330 = probe;
            let _e331 = columns;
            let _e336 = probe;
            let _e337 = columns;
            tile_4 = vec2<f32>((_e330 - (floor((_e330 / _e331)) * _e331)), floor((_e336 / _e337)));
            let _e341 = tile_4;
            let _e342 = irradianceTile;
            irradianceCorner = (_e341 * (_e342 + 2f));
            let _e346 = tile_4[0u];
            let _e347 = depthTile;
            let _e350 = momentsTop;
            let _e352 = tile_4[1u];
            let _e353 = depthTile;
            momentCorner = vec2<f32>((_e346 * (_e347 + 2f)), (_e350 + (_e352 * (_e353 + 2f))));
            let _e358 = irradianceCorner;
            param_172 = (_e358 + vec2(1f));
            let _e361 = AtlasTexel_u0028_vf2_u003b((&param_172));
            if (_e361.w < 0.5f) {
                continue;
            }
            let _e364 = f_4;
            let _e366 = f_4;
            let _e367 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e364), _e366, _e367);
            let _e370 = trilinear[0u];
            let _e372 = trilinear[1u];
            let _e375 = trilinear[2u];
            weight_2 = max(((_e370 * _e372) * _e375), 0.001f);
            let _e378 = origin_2;
            let _e379 = spacing;
            let _e380 = cell_1;
            probePosition = (_e378 + (_e379 * _e380));
            let _e383 = probePosition;
            let _e384 = biased;
            toProbe = (_e383 - _e384);
            let _e386 = toProbe;
            distance_4 = length(_e386);
            let _e388 = distance_4;
            if (_e388 > 0.000001f) {
                let _e390 = toProbe;
                let _e391 = distance_4;
                direction_2 = (_e390 / vec3(_e391));
                let _e394 = unit;
                let _e395 = probePosition;
                let _e396 = (*world_4);
                facing = ((dot(_e394, normalize((_e395 - _e396))) * 0.5f) + 0.5f);
                let _e402 = facing;
                let _e403 = facing;
                probeWeight = ((_e402 * _e403) + 0.2f);
                let _e406 = direction_2;
                param_173 = -(_e406);
                let _e408 = ProbeOctahedral_u0028_vf3_u003b((&param_173));
                let _e409 = momentCorner;
                param_174 = _e409;
                let _e410 = depthTile;
                param_175 = _e410;
                param_176 = _e408;
                let _e411 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_174), (&param_175), (&param_176));
                moments_3 = _e411.xy;
                chebyshev = 1f;
                let _e413 = distance_4;
                let _e415 = moments_3[0u];
                if (_e413 > _e415) {
                    let _e418 = moments_3[1u];
                    let _e420 = moments_3[0u];
                    let _e422 = moments_3[0u];
                    variance_1 = max((_e418 - (_e420 * _e422)), 0.000001f);
                    let _e426 = distance_4;
                    let _e428 = moments_3[0u];
                    difference = (_e426 - _e428);
                    let _e430 = variance_1;
                    let _e431 = variance_1;
                    let _e432 = difference;
                    let _e433 = difference;
                    chebyshev = (_e430 / (_e431 + (_e432 * _e433)));
                    let _e437 = chebyshev;
                    let _e438 = chebyshev;
                    let _e440 = chebyshev;
                    chebyshev = ((_e437 * _e438) * _e440);
                }
                let _e442 = probeWeight;
                let _e443 = chebyshev;
                probeWeight = max((_e442 * max(_e443, 0.05f)), 0.000001f);
                let _e447 = probeWeight;
                if (_e447 < 0.2f) {
                    let _e449 = probeWeight;
                    let _e450 = probeWeight;
                    let _e453 = probeWeight;
                    probeWeight = (_e453 * ((_e449 * _e450) * 25f));
                }
                let _e455 = probeWeight;
                let _e456 = weight_2;
                weight_2 = (_e456 * _e455);
            }
            let _e458 = unit;
            param_177 = _e458;
            let _e459 = ProbeOctahedral_u0028_vf3_u003b((&param_177));
            let _e460 = irradianceCorner;
            param_178 = _e460;
            let _e461 = irradianceTile;
            param_179 = _e461;
            param_180 = _e459;
            let _e462 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_178), (&param_179), (&param_180));
            let _e464 = weight_2;
            let _e466 = total_2;
            total_2 = (_e466 + (_e462.xyz * _e464));
            let _e468 = weight_2;
            let _e469 = weights;
            weights = (_e469 + _e468);
            continue;
        } else {
            break;
        }
        continuing {
            let _e471 = corner_1;
            corner_1 = (_e471 + 1i);
        }
    }
    let _e473 = weights;
    if (_e473 > 0f) {
        let _e475 = total_2;
        let _e476 = weights;
        local_36 = (_e475 / vec3(_e476));
    } else {
        local_36 = vec3<f32>(0f, 0f, 0f);
    }
    let _e479 = local_36;
    return _e479;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e202 = irradiance_info.origin[3u];
    return (_e202 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var param_181: vec3<f32>;
    var param_182: vec3<f32>;
    var param_183: vec3<f32>;
    var param_184: Surface;
    var param_185: Surface;
    var param_186: Surface;

    let _e207 = IrradianceEnabled_u0028_();
    if _e207 {
        let _e208 = v_world_position_1;
        param_181 = _e208;
        let _e210 = (*s_13).n;
        param_182 = _e210;
        let _e212 = (*s_13).v;
        param_183 = _e212;
        let _e213 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_181), (&param_182), (&param_183));
        let _e216 = frag_info.material[2u];
        (*s_13).ambient = (_e213 * _e216);
    }
    let _e219 = (*s_13);
    param_184 = _e219;
    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((&param_184));
    let _e220 = param_184;
    (*s_13) = _e220;
    let _e221 = (*s_13);
    param_185 = _e221;
    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((&param_185));
    let _e222 = param_185;
    (*s_13) = _e222;
    let _e223 = (*s_13);
    param_186 = _e223;
    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((&param_186));
    let _e224 = param_186;
    (*s_13) = _e224;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_37: vec3<f32>;

    let _e201 = Orthographic_u0028_();
    if _e201 {
        let _e203 = fog_info.forward;
        local_37 = -(_e203.xyz);
    } else {
        let _e207 = fog_info.eye;
        let _e209 = v_world_position_1;
        local_37 = normalize((_e207.xyz - _e209));
    }
    let _e212 = local_37;
    return _e212;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var p3_: vec3<f32>;

    let _e206 = (*cutoff);
    key = (-2f - _e206);
    let _e208 = key;
    let _e211 = key;
    let _e213 = floor((_e211 / 128f));
    let _e218 = key;
    origin_3 = vec3<f32>(floor((_e208 / 16384f)), (_e213 - (floor((_e213 / 128f)) * 128f)), (_e218 - (floor((_e218 / 128f)) * 128f)));
    let _e224 = (*scenePosition);
    let _e227 = origin_3;
    let _e228 = (floor((_e224 * 16f)) + _e227);
    let _e229 = vec3(128f);
    cell_2 = (_e228 - (floor((_e228 / _e229)) * _e229));
    let _e234 = cell_2;
    p3_ = fract((_e234 * 0.1031f));
    let _e237 = p3_;
    let _e238 = p3_;
    let _e243 = p3_;
    p3_ = (_e243 + vec3(dot(_e237, (_e238.zyx + vec3(31.32f)))));
    let _e247 = p3_[0u];
    let _e249 = p3_[1u];
    let _e252 = p3_[2u];
    return fract(((_e247 + _e249) * _e252));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_14: Surface;
    var param_187: vec3<f32>;
    var param_188: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_189: vec3<f32>;
    var param_190: f32;

    let _e208 = v_texcoord_1;
    let _e209 = MaterialLodBias_u0028_();
    let _e210 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e208, _e209);
    texel_6 = _e210;
    let _e211 = texel_6;
    param_187 = _e211.xyz;
    let _e213 = SrgbToLinear_u0028_vf3_u003b((&param_187));
    let _e215 = frag_info.base_color;
    param_188 = _e215.xyz;
    let _e217 = SrgbToLinear_u0028_vf3_u003b((&param_188));
    let _e219 = v_color_1;
    s_14.albedo = ((_e213 * _e217) * _e219.xyz);
    let _e224 = texel_6[3u];
    let _e227 = frag_info.base_color[3u];
    let _e230 = v_color_1[3u];
    s_14.alpha = ((_e224 * _e227) * _e230);
    let _e234 = s_14.albedo;
    g_albedo = _e234;
    let _e237 = frag_info.material2_[0u];
    cutoff_1 = _e237;
    let _e238 = cutoff_1;
    if (_e238 > 1f) {
        let _e240 = cutoff_1;
        edge = (_e240 - 1f);
        let _e243 = s_14.alpha;
        let _e244 = edge;
        let _e247 = s_14.alpha;
        let _e248 = fwidth(_e247);
        s_14.alpha = clamp((((_e243 - _e244) / max(_e248, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e254 = cutoff_1;
        if (_e254 >= 0f) {
            let _e257 = s_14.alpha;
            let _e258 = cutoff_1;
            if (_e257 < _e258) {
                discard;
            }
            s_14.alpha = 1f;
        } else {
            let _e261 = cutoff_1;
            if (_e261 < -1.5f) {
                let _e264 = s_14.alpha;
                let _e265 = v_world_position_1;
                param_189 = _e265;
                let _e266 = cutoff_1;
                param_190 = _e266;
                let _e267 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_189), (&param_190));
                if (_e264 < _e267) {
                    discard;
                }
            }
        }
    }
    let _e269 = cutoff_1;
    let _e271 = cutoff_1;
    g_premultiply = ((_e269 < 0f) && (_e271 > -0.75f));
    let _e274 = v_normal_1;
    s_14.n = normalize(_e274);
    let _e277 = gl_FrontFacing_1;
    if !(_e277) {
        let _e280 = s_14.n;
        s_14.n = -(_e280);
    }
    let _e283 = TowardsEye_u0028_();
    s_14.v = _e283;
    let _e286 = s_14.n;
    let _e288 = s_14.v;
    s_14.n_dot_v = max(dot(_e286, _e288), 0.0001f);
    let _e294 = frag_info.material[0u];
    s_14.metallic = clamp(_e294, 0f, 1f);
    let _e299 = frag_info.material[1u];
    s_14.roughness = clamp(_e299, 0.02f, 1f);
    let _e303 = frag_info.ambient_ground;
    let _e306 = frag_info.ambient_sky;
    let _e310 = s_14.n[1u];
    let _e317 = frag_info.material[2u];
    s_14.ambient = (mix(_e303.xyz, _e306.xyz, vec3(((_e310 * 0.5f) + 0.5f))) * _e317);
    let _e322 = frag_info.frame_params[0u];
    s_14.exposure = max(_e322, 0f);
    s_14.occlusion = 1f;
    s_14.emissive = vec3<f32>(0f, 0f, 0f);
    let _e327 = s_14;
    return _e327;
}

fn main_1() {
    var s_15: Surface;
    var param_191: Surface;
    var param_192: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_193: vec3<f32>;
    var param_194: f32;
    var param_195: f32;
    var directOcclusion: f32;
    var param_196: Surface;
    var indirectOcclusion: f32;
    var param_197: Surface;
    var ambient: vec3<f32>;
    var levels: f32;
    var f0_3: vec3<f32>;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_1: vec2<f32>;
    var param_198: f32;
    var param_199: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var lit_2: vec3<f32>;
    var param_200: Surface;
    var param_201: vec3<f32>;
    var param_202: f32;
    var param_203: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e231 = ReadSurface_u0028_();
    s_15 = _e231;
    let _e232 = s_15;
    param_191 = _e232;
    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((&param_191));
    let _e233 = param_191;
    s_15 = _e233;
    let _e234 = s_15;
    param_192 = _e234;
    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((&param_192));
    let _e235 = param_192;
    s_15 = _e235;
    let _e237 = s_15.metallic;
    metallic = clamp(_e237, 0f, 1f);
    let _e240 = s_15.albedo;
    let _e241 = metallic;
    diffuseColor_1 = (_e240 * (1f - _e241));
    let _e244 = EonDiffuse_u0028_();
    if _e244 {
        let _e245 = diffuseColor_1;
        param_193 = _e245;
        let _e247 = s_15.roughness;
        param_194 = _e247;
        let _e249 = s_15.n_dot_v;
        param_195 = _e249;
        let _e250 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_193), (&param_194), (&param_195));
        diffuseColor_1 = _e250;
    }
    let _e251 = s_15;
    param_196 = _e251;
    let _e252 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_196));
    directOcclusion = _e252;
    let _e253 = s_15;
    param_197 = _e253;
    let _e254 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_197));
    indirectOcclusion = _e254;
    let _e255 = diffuseColor_1;
    let _e257 = s_15.ambient;
    let _e259 = indirectOcclusion;
    ambient = ((_e255 * _e257) * _e259);
    let _e263 = frag_info.frame_params[3u];
    levels = _e263;
    let _e264 = levels;
    if (_e264 > 0f) {
        let _e267 = s_15.albedo;
        let _e268 = metallic;
        f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e267, vec3(_e268));
        let _e272 = s_15.v;
        let _e275 = s_15.n;
        reflected = reflect(-(_e272), _e275);
        let _e278 = s_15.n;
        let _e279 = levels;
        let _e280 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e278, _e279);
        irradiance = _e280.xyz;
        let _e282 = reflected;
        let _e284 = s_15.roughness;
        let _e285 = levels;
        let _e287 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e282, (_e284 * _e285));
        prefiltered = _e287.xyz;
        let _e290 = s_15.roughness;
        param_198 = _e290;
        let _e292 = s_15.n_dot_v;
        param_199 = _e292;
        let _e293 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_198), (&param_199));
        ab_1 = _e293;
        let _e294 = f0_3;
        let _e296 = ab_1[0u];
        let _e299 = ab_1[1u];
        single_1 = ((_e294 * _e296) + vec3(_e299));
        let _e302 = prefiltered;
        let _e303 = single_1;
        specular_1 = (_e302 * _e303);
        let _e305 = EnergyCompensation_u0028_();
        if _e305 {
            let _e307 = ab_1[0u];
            let _e309 = ab_1[1u];
            missed = (1f - (_e307 + _e309));
            let _e312 = f0_3;
            let _e313 = f0_3;
            average_2 = (_e312 + ((vec3<f32>(1f, 1f, 1f) - _e313) / vec3(21f)));
            let _e318 = single_1;
            let _e319 = average_2;
            let _e321 = missed;
            let _e322 = average_2;
            multiple = ((_e318 * _e319) / (vec3<f32>(1f, 1f, 1f) - (_e322 * _e321)));
            let _e326 = multiple;
            let _e327 = missed;
            let _e329 = irradiance;
            let _e331 = specular_1;
            specular_1 = (_e331 + ((_e326 * _e327) * _e329));
        }
        let _e333 = diffuseColor_1;
        let _e334 = irradiance;
        let _e336 = specular_1;
        let _e340 = frag_info.material[2u];
        let _e342 = indirectOcclusion;
        ambient = ((((_e333 * _e334) + _e336) * _e340) * _e342);
    }
    let _e344 = diffuseColor_1;
    let _e345 = SampleLightmap_u0028_();
    let _e347 = indirectOcclusion;
    let _e349 = ambient;
    ambient = (_e349 + ((_e344 * _e345) * _e347));
    let _e351 = s_15;
    param_200 = _e351;
    let _e352 = 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((&param_200));
    let _e353 = directOcclusion;
    let _e355 = ambient;
    let _e358 = s_15.emissive;
    lit_2 = (((_e352 * _e353) + _e355) + _e358);
    let _e360 = lit_2;
    param_201 = _e360;
    let _e362 = s_15.alpha;
    param_202 = _e362;
    let _e364 = s_15.roughness;
    param_203 = _e364;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_201), (&param_202), (&param_203));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 27,
          samplerBinding: 28,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 29,
          samplerBinding: 30,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrLayered': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct LayerInfo {
    specular: vec4<f32>,
    coat: vec4<f32>,
    sheen: vec4<f32>,
    anisotropy: vec4<f32>,
    transmission: vec4<f32>,
    attenuation: vec4<f32>,
    iridescence: vec4<f32>,
    uv_transform: array<vec4<f32>, 10>,
    scene_color: vec4<f32>,
    scene_viewport: vec4<f32>,
    scene_levels: array<vec4<f32>, 6>,
    scene_view_projection: mat4x4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
var<private> g_f0_dielectric: vec3<f32>;
var<private> g_f90_: f32;
var<private> g_coat: f32;
var<private> g_coat_roughness: f32;
var<private> g_coat_n: vec3<f32>;
var<private> g_coat_n_dot_v: f32;
var<private> g_coat_through: f32;
var<private> g_sheen: vec3<f32>;
var<private> g_sheen_roughness: f32;
var<private> g_sheen_albedo: f32;
var<private> g_sheen_scale: f32;
var<private> g_aniso: f32;
var<private> g_aniso_t: vec3<f32>;
var<private> g_aniso_b: vec3<f32>;
var<private> g_transmission: f32;
var<private> g_thickness: f32;
var<private> g_transmittance: vec3<f32>;
var<private> g_iridescence: f32;
var<private> g_irid_fresnel: vec3<f32>;
var<private> g_pane: bool;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(16)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(6)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var base_color_texture_smp: sampler;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(20)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var ltc_texture_smp: sampler;
var<private> g_rect_corners: array<vec3<f32>, 4>;
@group(1) @binding(5)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(30)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(31)
var point_shadow_texture_smp: sampler;
@group(1) @binding(28)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(29)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(14)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var irradiance_texture_smp: sampler;
@group(1) @binding(18)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(22)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(26)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(27)
var occlusion_texture_smp: sampler;
@group(1) @binding(10)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var emissive_texture_smp: sampler;
@group(1) @binding(24)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(34)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(35)
var shadow_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(3)
var<uniform> layer_info: LayerInfo;
@group(1) @binding(8)
var coat_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var coat_texture_smp: sampler;
@group(1) @binding(36)
var sheen_texture_tex: texture_2d<f32>;
@group(1) @binding(37)
var sheen_texture_smp: sampler;
@group(1) @binding(12)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(13)
var environment_texture_smp: sampler;
@group(1) @binding(32)
var scene_color_texture_tex: texture_2d<f32>;
@group(1) @binding(33)
var scene_color_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e267 = v_world_position_1;
    let _e269 = fog_info.eye;
    let _e273 = fog_info.forward;
    return dot((_e267 - _e269.xyz), _e273.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e272 = ViewDepth_u0028_();
    z = abs(_e272);
    let _e274 = z;
    near = (_e274 / 5f);
    let _e276 = z;
    far = (_e276 / 200f);
    let _e278 = far;
    let _e279 = far;
    let _e281 = far;
    far3_ = ((_e278 * _e279) * _e281);
    let _e283 = (*alpha);
    let _e284 = near;
    let _e285 = near;
    let _e288 = far3_;
    let _e289 = far3_;
    return (_e283 * clamp((10f / ((0.00001f + (_e284 * _e285)) + (_e288 * _e289))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e276 = fog_info.forward[3u];
    mode = _e276;
    let _e277 = mode;
    if (_e277 > 0.5f) {
        let _e280 = frag_color[3u];
        alpha_1 = _e280;
        let _e281 = alpha_1;
        param = _e281;
        let _e282 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e282;
        let _e283 = frag_color;
        let _e285 = weight;
        let _e286 = (_e283.xyz * _e285);
        let _e287 = alpha_1;
        let _e288 = weight;
        accumulate = vec4<f32>(_e286.x, _e286.y, _e286.z, (_e287 * _e288));
        let _e294 = mode;
        let _e296 = mode;
        revealage = ((_e294 > 1.5f) && (_e296 < 2.5f));
        let _e299 = revealage;
        if _e299 {
            let _e300 = alpha_1;
            local = vec4(_e300);
        } else {
            let _e302 = accumulate;
            local = _e302;
        }
        let _e303 = local;
        frag_color = _e303;
        let _e304 = mode;
        if (_e304 > 2.5f) {
            let _e306 = alpha_1;
            frag_surface = vec4(_e306);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e270 = (*n)[0u];
    let _e273 = (*n)[1u];
    let _e277 = (*n)[2u];
    let _e280 = (*n);
    (*n) = (_e280 / vec3(((abs(_e270) + abs(_e273)) + abs(_e277))));
    let _e283 = (*n);
    e = _e283.xy;
    let _e286 = (*n)[2u];
    if (_e286 < 0f) {
        let _e288 = (*n);
        let _e294 = (*n)[0u];
        let _e298 = (*n)[1u];
        e = ((vec2(1f) - abs(_e288.yx)) * vec2<f32>(select(-1f, 1f, (_e294 >= 0f)), select(-1f, 1f, (_e298 >= 0f))));
    }
    let _e303 = e;
    return ((_e303 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e268 = (*linear);
    let _e270 = (*linear);
    let _e274 = (*linear);
    return mix((_e268 * 12.92f), ((pow(_e270, 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), _e274));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e271 = g_albedo;
    param_1 = clamp(_e271, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e273 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e273.x, _e273.y, _e273.z, 1f);
    let _e278 = g_debug_surface_on;
    if _e278 {
        let _e279 = g_debug_surface;
        let _e280 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e279.x, _e279.y, _e279.z, _e280);
        return;
    }
    let _e285 = v_normal_1;
    geometric = normalize(_e285);
    let _e287 = gl_FrontFacing_1;
    if !(_e287) {
        let _e289 = geometric;
        geometric = -(_e289);
    }
    let _e291 = geometric;
    param_2 = _e291;
    let _e292 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e293 = (*roughness);
    let _e295 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e292.x, _e292.y, clamp(_e293, 0f, 1f), _e295);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e269 = fog_info.projection[0u];
    return (_e269 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e268 = Orthographic_u0028_();
    if _e268 {
        let _e269 = ViewDepth_u0028_();
        local_1 = max(_e269, 0f);
    } else {
        let _e271 = v_world_position_1;
        let _e273 = fog_info.eye;
        local_1 = distance(_e271, _e273.xyz);
    }
    let _e276 = local_1;
    return _e276;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e275 = fog_info.fog[3u];
    density = _e275;
    let _e276 = density;
    if (_e276 <= 0f) {
        let _e278 = (*color);
        return _e278;
    }
    let _e279 = EyeDistance_u0028_();
    d = _e279;
    let _e282 = fog_info.eye[3u];
    falloff = _e282;
    let _e283 = falloff;
    if (_e283 > 0f) {
        let _e285 = falloff;
        let _e287 = v_world_position_1[1u];
        let _e290 = fog_info.eye[1u];
        k = (_e285 * (_e287 - _e290));
        let _e293 = k;
        if (abs(_e293) > 0.001f) {
            let _e296 = k;
            let _e300 = k;
            local_2 = ((1f - exp(-(_e296))) / _e300);
        } else {
            let _e302 = k;
            local_2 = (1f - (0.5f * _e302));
        }
        let _e305 = local_2;
        let _e306 = density;
        density = (_e306 * _e305);
    }
    let _e309 = fog_info.fog;
    let _e311 = (*color);
    let _e312 = density;
    let _e314 = d;
    return mix(_e309.xyz, _e311, vec3(clamp(exp((-(_e312) * _e314)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e273 = g_premultiply;
    let _e274 = (*alpha_2);
    weight_1 = select(1f, _e274, _e273);
    let _e276 = (*linearColor);
    param_3 = _e276;
    let _e277 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e278 = weight_1;
    let _e279 = (_e277 * _e278);
    let _e280 = (*alpha_2);
    let _e281 = g_pass_through;
    frag_color = vec4<f32>(_e279.x, _e279.y, _e279.z, (_e280 * (1f - _e281)));
    let _e288 = (*roughness_1);
    param_4 = _e288;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e273 = (*alpha_3);
    let _e274 = (*alpha_3);
    a2_ = (_e273 * _e274);
    let _e276 = (*n_dot_l);
    let _e277 = (*n_dot_v);
    let _e278 = (*n_dot_v);
    let _e280 = a2_;
    let _e283 = a2_;
    lambda_v = (_e276 * sqrt((((_e277 * _e278) * (1f - _e280)) + _e283)));
    let _e287 = (*n_dot_v);
    let _e288 = (*n_dot_l);
    let _e289 = (*n_dot_l);
    let _e291 = a2_;
    let _e294 = a2_;
    lambda_l = (_e287 * sqrt((((_e288 * _e289) * (1f - _e291)) + _e294)));
    let _e298 = lambda_v;
    let _e299 = lambda_l;
    return (0.5f / max((_e298 + _e299), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_1: f32;

    let _e271 = (*n_dot_h);
    let _e272 = (*alpha_4);
    a = (_e271 * _e272);
    let _e274 = (*alpha_4);
    let _e275 = (*n_dot_h);
    let _e276 = (*n_dot_h);
    let _e279 = a;
    let _e280 = a;
    k_1 = (_e274 / max(((1f - (_e275 * _e276)) + (_e279 * _e280)), 0.0000001f));
    let _e285 = k_1;
    let _e286 = k_1;
    return ((_e285 * _e286) * 0.31830987f);
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle: f32;
    var local_3: vec3<f32>;

    let _e273 = (*a_1);
    let _e274 = (*b);
    axis = cross(_e273, _e274);
    let _e276 = axis;
    len = length(_e276);
    let _e278 = (*a_1);
    let _e279 = (*b);
    angle = acos(clamp(dot(_e278, _e279), -1f, 1f));
    let _e283 = len;
    if (_e283 > 0.000001f) {
        let _e285 = axis;
        let _e286 = angle;
        let _e287 = len;
        local_3 = (_e285 * (_e286 / (_e287 * 6.2831855f)));
    } else {
        local_3 = vec3<f32>(0f, 0f, 0f);
    }
    let _e291 = local_3;
    return _e291;
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e271 = (*x);
    let _e272 = (*y);
    inTable = ((vec2<f32>(_e271, _e272) * 0.984375f) + vec2(0.0078125f));
    let _e278 = inTable[0u];
    let _e280 = inTable[1u];
    let _e281 = (*table);
    return vec2<f32>(_e278, ((_e280 + _e281) * 0.5f));
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_2: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv: vec2<f32>;
    var inverse: vec4<f32>;
    var param_5: f32;
    var param_6: f32;
    var param_7: f32;
    var fit: vec4<f32>;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_4: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i: i32;
    var p: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f: vec3<f32>;
    var param_11: vec3<f32>;
    var param_12: vec3<f32>;
    var param_13: vec3<f32>;
    var param_14: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: vec3<f32>;
    var param_17: vec3<f32>;
    var param_18: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_5: f32;
    var sphere: f32;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;

    let _e305 = (*roughness_2);
    let _e307 = (*n_1);
    let _e308 = (*v);
    uv = vec2<f32>(clamp(_e305, 0f, 1f), sqrt(clamp((1f - dot(_e307, _e308)), 0f, 1f)));
    let _e315 = uv[0u];
    param_5 = _e315;
    let _e317 = uv[1u];
    param_6 = _e317;
    param_7 = 0f;
    let _e318 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    let _e319 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e318, 0f);
    inverse = _e319;
    let _e321 = uv[0u];
    param_8 = _e321;
    let _e323 = uv[1u];
    param_9 = _e323;
    param_10 = 1f;
    let _e324 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_8), (&param_9), (&param_10));
    let _e325 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e324, 0f);
    fit = _e325;
    let _e326 = (*v);
    let _e327 = (*n_1);
    let _e328 = (*v);
    let _e329 = (*n_1);
    along = (_e326 - (_e327 * dot(_e328, _e329)));
    let _e333 = along;
    alongLength = length(_e333);
    let _e335 = alongLength;
    if (_e335 > 0.00001f) {
        let _e337 = along;
        let _e338 = alongLength;
        local_4 = (_e337 / vec3(_e338));
    } else {
        let _e341 = (*n_1);
        let _e343 = (*n_1)[2u];
        local_4 = normalize(cross(_e341, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e343) < 0.999f)))));
    }
    let _e350 = local_4;
    t1_ = _e350;
    let _e351 = (*n_1);
    let _e352 = t1_;
    t2_ = cross(_e351, _e352);
    let _e355 = inverse[0u];
    let _e357 = inverse[1u];
    let _e358 = vec3<f32>(_e355, 0f, _e357);
    let _e360 = inverse[2u];
    let _e362 = inverse[3u];
    let _e363 = vec3<f32>(_e360, 0f, _e362);
    minv = mat3x3<f32>(vec3<f32>(_e358.x, _e358.y, _e358.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e363.x, _e363.y, _e363.z));
    i = 0i;
    loop {
        let _e377 = i;
        if (_e377 < 4i) {
            let _e379 = i;
            let _e381 = (*corners)[_e379];
            p = _e381;
            let _e382 = i;
            let _e383 = minv;
            let _e384 = p;
            let _e385 = t1_;
            let _e387 = p;
            let _e388 = t2_;
            let _e390 = p;
            let _e391 = (*n_1);
            l[_e382] = normalize((_e383 * vec3<f32>(dot(_e384, _e385), dot(_e387, _e388), dot(_e390, _e391))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e397 = i;
            i = (_e397 + 1i);
        }
    }
    let _e400 = l[0i];
    param_11 = _e400;
    let _e402 = l[1i];
    param_12 = _e402;
    let _e403 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_11), (&param_12));
    let _e405 = l[1i];
    param_13 = _e405;
    let _e407 = l[2i];
    param_14 = _e407;
    let _e408 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_13), (&param_14));
    let _e411 = l[2i];
    param_15 = _e411;
    let _e413 = l[3i];
    param_16 = _e413;
    let _e414 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_15), (&param_16));
    let _e417 = l[3i];
    param_17 = _e417;
    let _e419 = l[0i];
    param_18 = _e419;
    let _e420 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_17), (&param_18));
    f = -((((_e403 + _e408) + _e414) + _e420));
    let _e423 = f;
    len_1 = length(_e423);
    let _e425 = len_1;
    if (_e425 > 0.000000001f) {
        let _e428 = f[2u];
        let _e429 = len_1;
        local_5 = (_e428 / _e429);
    } else {
        local_5 = 0f;
    }
    let _e431 = local_5;
    z_1 = _e431;
    let _e432 = z_1;
    let _e435 = len_1;
    param_19 = ((_e432 * 0.5f) + 0.5f);
    param_20 = clamp(_e435, 0f, 1f);
    param_21 = 1f;
    let _e437 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21));
    let _e438 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e437, 0f);
    sphere = _e438.w;
    let _e440 = len_1;
    let _e441 = sphere;
    let _e445 = fit[0u];
    let _e447 = fit[1u];
    return vec3<f32>(max((_e440 * _e441), 0f), _e445, _e447);
}

fn CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
    var ltc: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: f32;
    var param_25: array<vec3<f32>, 4>;
    var lobe: f32;
    var alpha_5: f32;
    var n_dot_l_1: f32;
    var n_dot_h_1: f32;
    var d_1: f32;
    var param_26: f32;
    var param_27: f32;
    var vis: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var f_1: f32;

    let _e287 = (*light).integrated;
    if (_e287 > 0.5f) {
        let _e289 = g_coat_n;
        param_22 = _e289;
        let _e291 = (*s).v;
        param_23 = _e291;
        let _e292 = g_coat_roughness;
        param_24 = _e292;
        let _e293 = g_rect_corners;
        param_25 = _e293;
        let _e294 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_22), (&param_23), (&param_24), (&param_25));
        ltc = _e294;
        let _e296 = ltc[0u];
        let _e298 = ltc[1u];
        let _e301 = ltc[2u];
        let _e307 = frag_info.material[3u];
        let _e310 = (*light).n_dot_l;
        return (((_e296 * ((0.04f * _e298) + (0.96f * _e301))) * _e307) / max(_e310, 0.000001f));
    }
    let _e313 = g_coat_roughness;
    lobe = max(_e313, 0.045f);
    let _e315 = lobe;
    let _e316 = lobe;
    alpha_5 = (_e315 * _e316);
    let _e318 = g_coat_n;
    let _e320 = (*light).l;
    n_dot_l_1 = max(dot(_e318, _e320), 0f);
    let _e323 = g_coat_n;
    let _e325 = (*light).h;
    n_dot_h_1 = max(dot(_e323, _e325), 0f);
    let _e328 = n_dot_h_1;
    param_26 = _e328;
    let _e329 = alpha_5;
    param_27 = _e329;
    let _e330 = D_GGX_u0028_f1_u003b_f1_u003b((&param_26), (&param_27));
    d_1 = _e330;
    let _e331 = g_coat_n_dot_v;
    param_28 = _e331;
    let _e332 = n_dot_l_1;
    param_29 = _e332;
    let _e333 = alpha_5;
    param_30 = _e333;
    let _e334 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_28), (&param_29), (&param_30));
    vis = _e334;
    let _e336 = (*light).v_dot_h;
    f_1 = (0.04f + (0.96f * pow((1f - _e336), 5f)));
    let _e341 = d_1;
    let _e342 = vis;
    let _e344 = f_1;
    let _e348 = frag_info.material[3u];
    let _e350 = n_dot_l_1;
    let _e353 = (*light).n_dot_l;
    return (((((_e341 * _e342) * _e344) * _e348) * _e350) / max(_e353, 0.000001f));
}

fn V_Neubelt_u0028_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l_2: ptr<function, f32>) -> f32 {
    let _e269 = (*n_dot_l_2);
    let _e270 = (*n_dot_v_1);
    let _e272 = (*n_dot_l_2);
    let _e273 = (*n_dot_v_1);
    return (1f / (4f * ((_e269 + _e270) - (_e272 * _e273))));
}

fn D_Charlie_u0028_f1_u003b_f1_u003b(roughness_3: ptr<function, f32>, n_dot_h_2: ptr<function, f32>) -> f32 {
    var inv_alpha: f32;
    var sin2h: f32;

    let _e271 = (*roughness_3);
    let _e272 = (*roughness_3);
    inv_alpha = (1f / (_e271 * _e272));
    let _e275 = (*n_dot_h_2);
    let _e276 = (*n_dot_h_2);
    sin2h = max((1f - (_e275 * _e276)), 0.0078125f);
    let _e280 = inv_alpha;
    let _e282 = sin2h;
    let _e283 = inv_alpha;
    return (((2f + _e280) * pow(_e282, (_e283 * 0.5f))) / 6.2831855f);
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m: f32;
    var g: f32;

    let _e271 = (*mu);
    m = (1f - _e271);
    let _e273 = m;
    let _e274 = m;
    let _e275 = m;
    let _e276 = m;
    g = (_e273 * (0.05710853f + (_e274 * (0.49188188f + (_e275 * (-0.33218145f + (_e276 * 0.071443f)))))));
    let _e284 = (*r);
    let _e285 = g;
    let _e288 = (*r);
    return ((1f + (_e284 * _e285)) / (1f + (0.2877934f * _e288)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e269 = (*rho);
    let _e270 = (*rho);
    let _e272 = (*average);
    let _e274 = (*rho);
    let _e275 = (*average);
    return (((_e269 * _e270) * _e272) / (vec3<f32>(1f, 1f, 1f) - (_e274 * (1f - _e275))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e268 = (*r_1);
    let _e271 = (*r_1);
    return ((1f + (0.07248821f * _e268)) / (1f + (0.2877934f * _e271)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s_1: f32;
    var s_over_t: f32;
    var local_6: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_31: f32;
    var multi: vec3<f32>;
    var param_32: vec3<f32>;
    var param_33: f32;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;

    let _e286 = (*l_dot_v);
    let _e287 = (*mu_i);
    let _e288 = (*mu_o);
    s_1 = (_e286 - (_e287 * _e288));
    let _e291 = s_1;
    if (_e291 > 0f) {
        let _e293 = s_1;
        let _e294 = (*mu_i);
        let _e295 = (*mu_o);
        local_6 = (_e293 / max(_e294, _e295));
    } else {
        let _e298 = s_1;
        local_6 = _e298;
    }
    let _e299 = local_6;
    s_over_t = _e299;
    let _e300 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e300)));
    let _e304 = (*rho_1);
    let _e305 = af;
    let _e306 = (*r_2);
    let _e307 = s_over_t;
    single = (_e304 * (_e305 * (1f + (_e306 * _e307))));
    let _e312 = (*r_2);
    param_31 = _e312;
    let _e313 = FonAverage_u0028_f1_u003b((&param_31));
    average_1 = _e313;
    let _e314 = (*rho_1);
    param_32 = _e314;
    let _e315 = average_1;
    param_33 = _e315;
    let _e316 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_32), (&param_33));
    let _e317 = (*mu_o);
    param_34 = _e317;
    let _e318 = (*r_2);
    param_35 = _e318;
    let _e319 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_34), (&param_35));
    let _e322 = (*mu_i);
    param_36 = _e322;
    let _e323 = (*r_2);
    param_37 = _e323;
    let _e324 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_36), (&param_37));
    let _e328 = average_1;
    multi = (_e316 * ((max((1f - _e319), 0.0000001f) * max((1f - _e324), 0.0000001f)) / max((1f - _e328), 0.0000001f)));
    let _e333 = single;
    let _e334 = multi;
    return ((_e333 + _e334) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e269 = frag_info.ambient_sky[3u];
    return (_e269 > 0.5f);
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_38: f32;
    var param_39: f32;
    var param_40: f32;

    let _e273 = (*roughness_4);
    let _e275 = (*n_dot_v_2);
    param_38 = clamp(_e273, 0f, 1f);
    param_39 = sqrt(clamp((1f - _e275), 0f, 1f));
    param_40 = 1f;
    let _e279 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_38), (&param_39), (&param_40));
    let _e280 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e279, 0f);
    dfg = _e280.xy;
    let _e283 = dfg[0u];
    let _e285 = dfg[1u];
    let _e288 = dfg[1u];
    return vec2<f32>((_e283 - _e285), _e288);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_2: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_41: f32;
    var param_42: f32;
    var ess: f32;

    let _e274 = (*s_2).roughness;
    param_41 = max(_e274, 0.045f);
    let _e277 = (*s_2).n_dot_v;
    param_42 = _e277;
    let _e278 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_41), (&param_42));
    ab = _e278;
    let _e280 = ab[0u];
    let _e282 = ab[1u];
    ess = max((_e280 + _e282), 0.0001f);
    let _e285 = (*f0_);
    let _e286 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e285 * ((1f / _e286) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e269 = frag_info.target_origin[2u];
    return (_e269 > 0.5f);
}

fn F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, f90_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f_2: f32;

    let _e271 = (*v_dot_h);
    f_2 = pow((1f - _e271), 5f);
    let _e274 = (*f0_1);
    let _e275 = (*f90_);
    let _e276 = (*f0_1);
    let _e278 = f_2;
    return (_e274 + ((_e275 - _e276) * _e278));
}

fn V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_l_3: ptr<function, f32>, n_dot_v_3: ptr<function, f32>, b_dot_v: ptr<function, f32>, t_dot_v: ptr<function, f32>, t_dot_l: ptr<function, f32>, b_dot_l: ptr<function, f32>, at: ptr<function, f32>, ab_1: ptr<function, f32>) -> f32 {
    var ggx_v: f32;
    var ggx_l: f32;

    let _e277 = (*n_dot_l_3);
    let _e278 = (*at);
    let _e279 = (*t_dot_v);
    let _e281 = (*ab_1);
    let _e282 = (*b_dot_v);
    let _e284 = (*n_dot_v_3);
    ggx_v = (_e277 * length(vec3<f32>((_e278 * _e279), (_e281 * _e282), _e284)));
    let _e288 = (*n_dot_v_3);
    let _e289 = (*at);
    let _e290 = (*t_dot_l);
    let _e292 = (*ab_1);
    let _e293 = (*b_dot_l);
    let _e295 = (*n_dot_l_3);
    ggx_l = (_e288 * length(vec3<f32>((_e289 * _e290), (_e292 * _e293), _e295)));
    let _e299 = ggx_v;
    let _e300 = ggx_l;
    return clamp((0.5f / max((_e299 + _e300), 0.00001f)), 0f, 1f);
}

fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3: ptr<function, f32>, t_dot_h: ptr<function, f32>, b_dot_h: ptr<function, f32>, at_1: ptr<function, f32>, ab_2: ptr<function, f32>) -> f32 {
    var a2_1: f32;
    var f_3: vec3<f32>;
    var w2_: f32;

    let _e275 = (*at_1);
    let _e276 = (*ab_2);
    a2_1 = (_e275 * _e276);
    let _e278 = (*ab_2);
    let _e279 = (*t_dot_h);
    let _e281 = (*at_1);
    let _e282 = (*b_dot_h);
    let _e284 = a2_1;
    let _e285 = (*n_dot_h_3);
    f_3 = vec3<f32>((_e278 * _e279), (_e281 * _e282), (_e284 * _e285));
    let _e288 = a2_1;
    let _e289 = f_3;
    let _e290 = f_3;
    w2_ = (_e288 / max(dot(_e289, _e290), 0.000000000001f));
    let _e294 = a2_1;
    let _e295 = w2_;
    let _e297 = w2_;
    return (((_e294 * _e295) * _e297) / 3.1415927f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>) -> vec3<f32> {
    var lobe_1: f32;
    var alpha_6: f32;
    var f0_2: vec3<f32>;
    var f90_1: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_2: f32;
    var param_43: f32;
    var param_44: f32;
    var vis_1: f32;
    var param_45: f32;
    var param_46: f32;
    var param_47: f32;
    var at_2: f32;
    var ab_3: f32;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var param_51: f32;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;
    var param_55: f32;
    var param_56: f32;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var param_60: f32;
    var f_4: vec3<f32>;
    var param_61: vec3<f32>;
    var param_62: vec3<f32>;
    var param_63: f32;
    var specular: vec3<f32>;
    var param_64: vec3<f32>;
    var param_65: Surface;
    var diffuse: vec3<f32>;
    var param_66: vec3<f32>;
    var param_67: f32;
    var param_68: f32;
    var param_69: f32;
    var param_70: f32;
    var sheen: vec3<f32>;
    var param_71: f32;
    var param_72: f32;
    var param_73: f32;
    var param_74: f32;
    var param_75: Surface;
    var param_76: LightSample;

    let _e317 = (*s_3).roughness;
    lobe_1 = max(_e317, 0.045f);
    let _e319 = lobe_1;
    let _e320 = lobe_1;
    alpha_6 = (_e319 * _e320);
    let _e322 = g_f0_dielectric;
    let _e324 = (*s_3).albedo;
    let _e326 = (*s_3).metallic;
    f0_2 = mix(_e322, _e324, vec3(_e326));
    let _e329 = g_f90_;
    let _e331 = (*s_3).metallic;
    f90_1 = vec3(mix(_e329, 1f, _e331));
    let _e335 = (*s_3).albedo;
    let _e337 = (*s_3).metallic;
    diffuseColor = (_e335 * (1f - _e337));
    let _e341 = (*light_1).n_dot_h;
    param_43 = _e341;
    let _e342 = alpha_6;
    param_44 = _e342;
    let _e343 = D_GGX_u0028_f1_u003b_f1_u003b((&param_43), (&param_44));
    d_2 = _e343;
    let _e345 = (*s_3).n_dot_v;
    param_45 = _e345;
    let _e347 = (*light_1).n_dot_l;
    param_46 = _e347;
    let _e348 = alpha_6;
    param_47 = _e348;
    let _e349 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47));
    vis_1 = _e349;
    let _e350 = g_aniso;
    if (_e350 > 0f) {
        let _e352 = alpha_6;
        let _e353 = g_aniso;
        let _e354 = g_aniso;
        at_2 = mix(_e352, 1f, (_e353 * _e354));
        let _e357 = alpha_6;
        ab_3 = max(_e357, 0.001f);
        let _e359 = g_aniso_t;
        let _e361 = (*light_1).h;
        let _e363 = g_aniso_b;
        let _e365 = (*light_1).h;
        let _e368 = (*light_1).n_dot_h;
        param_48 = _e368;
        param_49 = dot(_e359, _e361);
        param_50 = dot(_e363, _e365);
        let _e369 = at_2;
        param_51 = _e369;
        let _e370 = ab_3;
        param_52 = _e370;
        let _e371 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_48), (&param_49), (&param_50), (&param_51), (&param_52));
        d_2 = _e371;
        let _e372 = g_aniso_b;
        let _e374 = (*s_3).v;
        let _e376 = g_aniso_t;
        let _e378 = (*s_3).v;
        let _e380 = g_aniso_t;
        let _e382 = (*light_1).l;
        let _e384 = g_aniso_b;
        let _e386 = (*light_1).l;
        let _e389 = (*light_1).n_dot_l;
        param_53 = _e389;
        let _e391 = (*s_3).n_dot_v;
        param_54 = _e391;
        param_55 = dot(_e372, _e374);
        param_56 = dot(_e376, _e378);
        param_57 = dot(_e380, _e382);
        param_58 = dot(_e384, _e386);
        let _e392 = at_2;
        param_59 = _e392;
        let _e393 = ab_3;
        param_60 = _e393;
        let _e394 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56), (&param_57), (&param_58), (&param_59), (&param_60));
        vis_1 = _e394;
    }
    let _e395 = f0_2;
    param_61 = _e395;
    let _e396 = f90_1;
    param_62 = _e396;
    let _e398 = (*light_1).v_dot_h;
    param_63 = _e398;
    let _e399 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
    f_4 = _e399;
    let _e400 = f_4;
    let _e401 = g_irid_fresnel;
    let _e402 = g_iridescence;
    f_4 = mix(_e400, _e401, vec3(_e402));
    let _e405 = d_2;
    let _e406 = vis_1;
    let _e408 = f_4;
    let _e412 = frag_info.material[3u];
    specular = ((_e408 * (_e405 * _e406)) * _e412);
    let _e415 = (*light_1).integrated;
    if (_e415 > 0.5f) {
        let _e419 = (*light_1).ltc[0u];
        let _e420 = f0_2;
        let _e423 = (*light_1).ltc[1u];
        let _e425 = f90_1;
        let _e426 = f0_2;
        let _e430 = (*light_1).ltc[2u];
        let _e436 = frag_info.material[3u];
        let _e439 = (*light_1).n_dot_l;
        specular = (((((_e420 * _e423) + ((_e425 - _e426) * _e430)) * _e419) * _e436) / vec3(max(_e439, 0.000001f)));
    }
    let _e443 = EnergyCompensation_u0028_();
    if _e443 {
        let _e444 = f0_2;
        param_64 = _e444;
        let _e445 = (*s_3);
        param_65 = _e445;
        let _e446 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_64), (&param_65));
        let _e447 = specular;
        specular = (_e447 * _e446);
    }
    let _e449 = diffuseColor;
    let _e450 = f_4;
    diffuse = ((_e449 * (vec3<f32>(1f, 1f, 1f) - _e450)) / vec3(3.1415927f));
    let _e455 = EonDiffuse_u0028_();
    if _e455 {
        let _e457 = (*s_3).n;
        let _e459 = (*light_1).l;
        let _e463 = (*light_1).l;
        let _e465 = (*s_3).v;
        let _e467 = diffuseColor;
        param_66 = _e467;
        let _e469 = (*s_3).roughness;
        param_67 = _e469;
        param_68 = clamp(dot(_e457, _e459), 0.0001f, 1f);
        let _e471 = (*s_3).n_dot_v;
        param_69 = _e471;
        param_70 = dot(_e463, _e465);
        let _e472 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_66), (&param_67), (&param_68), (&param_69), (&param_70));
        let _e473 = f_4;
        diffuse = (_e472 * (vec3<f32>(1f, 1f, 1f) - _e473));
    }
    let _e476 = g_transmission;
    let _e478 = diffuse;
    diffuse = (_e478 * (1f - _e476));
    let _e480 = g_sheen;
    let _e481 = g_sheen_roughness;
    param_71 = _e481;
    let _e483 = (*light_1).n_dot_h;
    param_72 = _e483;
    let _e484 = D_Charlie_u0028_f1_u003b_f1_u003b((&param_71), (&param_72));
    let _e487 = (*s_3).n;
    let _e489 = (*light_1).l;
    let _e493 = (*s_3).n_dot_v;
    param_73 = _e493;
    param_74 = clamp(dot(_e487, _e489), 0f, 1f);
    let _e494 = V_Neubelt_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
    sheen = ((_e480 * _e484) * _e494);
    let _e496 = diffuse;
    let _e497 = specular;
    let _e499 = g_sheen_scale;
    let _e501 = sheen;
    let _e503 = g_coat_through;
    let _e505 = g_coat;
    let _e506 = (*s_3);
    param_75 = _e506;
    let _e507 = (*light_1);
    param_76 = _e507;
    let _e508 = CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_75), (&param_76));
    return ((((((_e496 + _e497) * _e499) + _e501) * _e503) + vec3((_e505 * _e508))) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
    let _e268 = (*i_1);
    if (_e268 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e270 = (*i_1);
    if (_e270 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e272 = (*i_1);
    if (_e272 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e274 = (*i_1);
    if (_e274 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e276 = (*i_1);
    if (_e276 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e278 = (*i_1);
    if (_e278 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e280 = (*i_1);
    if (_e280 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_2: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p_1: vec2<f32>;
    var param_77: i32;

    let _e273 = (*i_2);
    param_77 = _e273;
    let _e274 = PointShadowDiskTap_u0028_i1_u003b((&param_77));
    p_1 = _e274;
    let _e276 = p_1[0u];
    let _e277 = (*ca);
    let _e280 = p_1[1u];
    let _e281 = (*sa);
    let _e285 = p_1[0u];
    let _e286 = (*sa);
    let _e289 = p_1[1u];
    let _e290 = (*ca);
    let _e294 = (*radius);
    return (vec2<f32>(((_e276 * _e277) - (_e280 * _e281)), ((_e285 * _e286) + (_e289 * _e290))) * _e294);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_7: vec2<f32>;
    var atlas: vec2<f32>;

    let _e276 = point_shadow.params[0u];
    inset = _e276;
    let _e277 = (*uv_1);
    let _e278 = (*offset);
    let _e280 = inset;
    let _e281 = inset;
    local_7 = clamp((_e277 + _e278), vec2(_e280), vec2((1f - _e281)));
    let _e286 = local_7;
    let _e287 = (*tile);
    atlas = ((_e286 + _e287) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e292 = point_shadow.params3_[0u];
    if (_e292 > 0.5f) {
        let _e295 = atlas[1u];
        atlas[1u] = (1f - _e295);
    }
    let _e298 = atlas;
    let _e299 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e298, 0f);
    let _e301 = atlas;
    let _e302 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e301, 0f);
    let _e305 = (*range);
    return (min(_e299.x, _e302.x) * _e305);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_78: vec2<f32>;
    var param_79: vec2<f32>;
    var param_80: vec2<f32>;
    var param_81: f32;

    let _e277 = (*uv_2);
    param_78 = _e277;
    let _e278 = (*offset_1);
    param_79 = _e278;
    let _e279 = (*tile_1);
    param_80 = _e279;
    let _e280 = (*range_1);
    param_81 = _e280;
    let _e281 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_78), (&param_79), (&param_80), (&param_81));
    stored = _e281;
    let _e282 = stored;
    let _e283 = (*range_1);
    if (_e282 >= (_e283 * 0.999f)) {
        return 1f;
    }
    let _e286 = (*receiver);
    let _e287 = stored;
    return select(1f, 0f, (_e286 > _e287));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_82: vec2<f32>;
    var param_83: vec2<f32>;
    var param_84: vec2<f32>;
    var param_85: f32;
    var sum: f32;
    var count: f32;
    var i_3: i32;
    var stored_1: f32;
    var param_86: i32;
    var param_87: f32;
    var param_88: f32;
    var param_89: f32;
    var param_90: vec2<f32>;
    var param_91: vec2<f32>;
    var param_92: vec2<f32>;
    var param_93: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e298 = point_shadow.params2_[1u];
    lightRadius = _e298;
    let _e301 = point_shadow.params2_[0u];
    minRadius = _e301;
    let _e304 = point_shadow.params2_[2u];
    maxRadius = _e304;
    let _e305 = lightRadius;
    if (_e305 <= 0f) {
        let _e307 = (*uv_3);
        param_82 = _e307;
        param_83 = vec2<f32>(0f, 0f);
        let _e308 = (*tile_2);
        param_84 = _e308;
        let _e309 = (*range_2);
        param_85 = _e309;
        let _e310 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_82), (&param_83), (&param_84), (&param_85));
        (*blockerOut) = _e310;
        let _e311 = minRadius;
        return _e311;
    }
    sum = 0f;
    count = 0f;
    i_3 = 0i;
    loop {
        let _e312 = i_3;
        if (_e312 < 8i) {
            let _e314 = i_3;
            param_86 = _e314;
            let _e315 = (*ca_1);
            param_87 = _e315;
            let _e316 = (*sa_1);
            param_88 = _e316;
            let _e317 = maxRadius;
            param_89 = _e317;
            let _e318 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_86), (&param_87), (&param_88), (&param_89));
            let _e319 = (*uv_3);
            param_90 = _e319;
            param_91 = _e318;
            let _e320 = (*tile_2);
            param_92 = _e320;
            let _e321 = (*range_2);
            param_93 = _e321;
            let _e322 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_90), (&param_91), (&param_92), (&param_93));
            stored_1 = _e322;
            let _e323 = stored_1;
            let _e324 = (*range_2);
            if (_e323 >= (_e324 * 0.999f)) {
                continue;
            }
            let _e327 = stored_1;
            let _e328 = (*receiver_1);
            if (_e327 >= _e328) {
                continue;
            }
            let _e330 = stored_1;
            let _e331 = sum;
            sum = (_e331 + _e330);
            let _e333 = count;
            count = (_e333 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e335 = i_3;
            i_3 = (_e335 + 1i);
        }
    }
    let _e337 = count;
    if (_e337 < 0.5f) {
        return -1f;
    }
    let _e339 = sum;
    let _e340 = count;
    blocker = max((_e339 / _e340), 0.0001f);
    let _e343 = blocker;
    (*blockerOut) = _e343;
    let _e344 = lightRadius;
    let _e345 = (*receiver_1);
    let _e346 = blocker;
    let _e350 = blocker;
    world = ((_e344 * max((_e345 - _e346), 0f)) / _e350);
    let _e352 = world;
    let _e353 = (*receiver_1);
    let _e355 = (*tanHalf);
    let _e358 = minRadius;
    let _e359 = maxRadius;
    return clamp((_e352 / ((2f * _e353) * _e355)), _e358, _e359);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_8: vec2<f32>;

    let _e269 = (*rows);
    if (_e269 > 0f) {
        let _e272 = gl_FragCoord_1[0u];
        let _e273 = (*rows);
        let _e275 = gl_FragCoord_1[1u];
        local_8 = vec2<f32>(_e272, (_e273 - _e275));
    } else {
        let _e278 = gl_FragCoord_1;
        local_8 = _e278.xy;
    }
    let _e280 = local_8;
    return _e280;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_2: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_94: f32;
    var angle_1: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_95: vec2<f32>;
    var param_96: vec2<f32>;
    var param_97: f32;
    var param_98: f32;
    var param_99: f32;
    var param_100: f32;
    var param_101: f32;
    var param_102: f32;
    var local_9: vec3<f32>;
    var lit: f32;
    var param_103: vec2<f32>;
    var param_104: vec2<f32>;
    var param_105: vec2<f32>;
    var param_106: f32;
    var param_107: f32;
    var i_4: i32;
    var param_108: i32;
    var param_109: f32;
    var param_110: f32;
    var param_111: f32;
    var param_112: vec2<f32>;
    var param_113: vec2<f32>;
    var param_114: vec2<f32>;
    var param_115: f32;
    var param_116: f32;
    var phi_2776_: bool;
    var phi_2837_: bool;

    let _e321 = (*lightIndex);
    let _e325 = point_shadow.slots[_e321][0u];
    slot = i32((_e325 + 0.5f));
    let _e328 = (*lightIndex);
    let _e332 = point_shadow.slots[_e328][0u];
    if (_e332 < 0f) {
        return 1f;
    }
    let _e336 = point_shadow.params[2u];
    strength = _e336;
    let _e337 = strength;
    if (_e337 <= 0f) {
        return 1f;
    }
    let _e339 = slot;
    let _e342 = point_shadow.lights[_e339];
    let _e344 = (*world_1);
    toLight = (_e342.xyz - _e344);
    let _e346 = toLight;
    toLightLength = max(length(_e346), 0.000001f);
    let _e349 = (*normal);
    let _e350 = toLight;
    let _e351 = toLightLength;
    nDotL = max(dot(_e349, (_e350 / vec3(_e351))), 0.15f);
    let _e356 = nDotL;
    let _e357 = nDotL;
    let _e362 = nDotL;
    let _e363 = nDotL;
    slope = min((sqrt(max((1f - (_e356 * _e357)), 0f)) / (_e362 * _e363)), 8f);
    let _e367 = toLightLength;
    let _e369 = (*lightIndex);
    let _e373 = point_shadow.slots[_e369][2u];
    let _e378 = point_shadow.params3_[1u];
    texel = (((2f * _e367) * max(_e373, 0.0001f)) * _e378);
    let _e380 = (*world_1);
    let _e381 = (*normal);
    let _e382 = texel;
    let _e386 = point_shadow.params[3u];
    let _e388 = slope;
    origin = (_e380 + (((_e381 * _e382) * _e386) * (1f + _e388)));
    let _e392 = origin;
    let _e393 = slot;
    let _e396 = point_shadow.lights[_e393];
    toFragment = (_e392 - _e396.xyz);
    let _e399 = toFragment;
    distance_ = length(_e399);
    let _e401 = slot;
    let _e405 = point_shadow.lights[_e401][3u];
    range_3 = max(_e405, 0.0001f);
    let _e407 = distance_;
    let _e408 = range_3;
    if (_e407 >= _e408) {
        return 1f;
    }
    face = 0i;
    let _e410 = (*lightIndex);
    let _e414 = point_shadow.slots[_e410][1u];
    if (_e414 < 0.5f) {
        let _e416 = toFragment;
        a_2 = abs(_e416);
        let _e419 = a_2[0u];
        let _e421 = a_2[1u];
        let _e422 = (_e419 >= _e421);
        phi_2776_ = _e422;
        if _e422 {
            let _e424 = a_2[0u];
            let _e426 = a_2[2u];
            phi_2776_ = (_e424 >= _e426);
        }
        let _e429 = phi_2776_;
        if _e429 {
            let _e431 = toFragment[0u];
            face = select(1i, 0i, (_e431 > 0f));
        } else {
            let _e435 = a_2[1u];
            let _e437 = a_2[2u];
            if (_e435 >= _e437) {
                let _e440 = toFragment[1u];
                face = select(3i, 2i, (_e440 > 0f));
            } else {
                let _e444 = toFragment[2u];
                face = select(5i, 4i, (_e444 > 0f));
            }
        }
    }
    let _e447 = slot;
    let _e449 = face;
    let _e453 = point_shadow.faces[((_e447 * 6i) + _e449)];
    let _e454 = origin;
    clip = (_e453 * vec4<f32>(_e454.x, _e454.y, _e454.z, 1f));
    let _e461 = clip[3u];
    if (_e461 <= 0f) {
        return 1f;
    }
    let _e463 = clip;
    let _e466 = clip[3u];
    ndc = (_e463.xy / vec2(_e466));
    let _e470 = ndc[0u];
    let _e472 = (abs(_e470) > 1f);
    phi_2837_ = _e472;
    if !(_e472) {
        let _e475 = ndc[1u];
        phi_2837_ = (abs(_e475) > 1f);
    }
    let _e479 = phi_2837_;
    if _e479 {
        return 1f;
    }
    let _e481 = ndc[0u];
    let _e485 = ndc[1u];
    uv_4 = vec2<f32>(((_e481 * 0.5f) + 0.5f), (0.5f - (_e485 * 0.5f)));
    let _e489 = face;
    let _e491 = slot;
    tile_3 = vec2<f32>(f32(_e489), f32(_e491));
    let _e494 = distance_;
    let _e497 = point_shadow.params[1u];
    receiver_2 = (_e494 - _e497);
    let _e501 = frag_info.target_origin[0u];
    param_94 = _e501;
    let _e502 = FragCoordFromTop_u0028_f1_u003b((&param_94));
    noise = fract((52.982918f * fract(dot(_e502, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e507 = noise;
    angle_1 = (_e507 * 6.2831855f);
    let _e509 = angle_1;
    ca_2 = cos(_e509);
    let _e511 = angle_1;
    sa_2 = sin(_e511);
    let _e513 = (*lightIndex);
    let _e517 = point_shadow.slots[_e513][2u];
    tanHalf_1 = max(_e517, 0.0001f);
    blocker_1 = -1f;
    let _e519 = uv_4;
    param_95 = _e519;
    let _e520 = tile_3;
    param_96 = _e520;
    let _e521 = range_3;
    param_97 = _e521;
    let _e522 = receiver_2;
    param_98 = _e522;
    let _e523 = ca_2;
    param_99 = _e523;
    let _e524 = sa_2;
    param_100 = _e524;
    let _e525 = tanHalf_1;
    param_101 = _e525;
    let _e526 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_95), (&param_96), (&param_97), (&param_98), (&param_99), (&param_100), (&param_101), (&param_102));
    let _e527 = param_102;
    blocker_1 = _e527;
    radius_1 = _e526;
    let _e530 = point_shadow.params2_[3u];
    if (_e530 > 0.5f) {
        g_debug_surface_on = true;
        let _e532 = radius_1;
        if (_e532 < 0f) {
            local_9 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e534 = radius_1;
            let _e537 = point_shadow.params2_[2u];
            let _e541 = blocker_1;
            let _e542 = range_3;
            local_9 = vec3<f32>(clamp((_e534 / max(_e537, 0.000001f)), 0f, 1f), clamp((_e541 / _e542), 0f, 1f), 0f);
        }
        let _e546 = local_9;
        g_debug_surface = _e546;
    }
    let _e547 = radius_1;
    if (_e547 < 0f) {
        return 1f;
    }
    let _e549 = uv_4;
    param_103 = _e549;
    param_104 = vec2<f32>(0f, 0f);
    let _e550 = tile_3;
    param_105 = _e550;
    let _e551 = range_3;
    param_106 = _e551;
    let _e552 = receiver_2;
    param_107 = _e552;
    let _e553 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
    lit = _e553;
    let _e554 = radius_1;
    if (_e554 > 0f) {
        i_4 = 0i;
        loop {
            let _e556 = i_4;
            if (_e556 < 8i) {
                let _e558 = i_4;
                param_108 = _e558;
                let _e559 = ca_2;
                param_109 = _e559;
                let _e560 = sa_2;
                param_110 = _e560;
                let _e561 = radius_1;
                param_111 = _e561;
                let _e562 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_108), (&param_109), (&param_110), (&param_111));
                let _e563 = uv_4;
                param_112 = _e563;
                param_113 = _e562;
                let _e564 = tile_3;
                param_114 = _e564;
                let _e565 = range_3;
                param_115 = _e565;
                let _e566 = receiver_2;
                param_116 = _e566;
                let _e567 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_112), (&param_113), (&param_114), (&param_115), (&param_116));
                let _e568 = lit;
                lit = (_e568 + _e567);
                continue;
            } else {
                break;
            }
            continuing {
                let _e570 = i_4;
                i_4 = (_e570 + 1i);
            }
        }
        let _e572 = lit;
        lit = (_e572 * 0.11111111f);
    }
    let _e574 = lit;
    let _e575 = strength;
    return mix(1f, _e574, clamp(_e575, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_5: ptr<function, i32>, n_2: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e272 = (*i_5);
    let _e275 = (*n_2);
    r_3 = sqrt(((f32(_e272) + 0.5f) / f32(_e275)));
    let _e279 = (*i_5);
    let _e282 = (*turn);
    theta = ((f32(_e279) * 2.3999631f) + _e282);
    let _e284 = r_3;
    let _e285 = theta;
    let _e287 = theta;
    return (vec2<f32>(cos(_e285), sin(_e287)) * _e284);
}

fn ShadowNoise_u0028_() -> f32 {
    var at_3: vec2<f32>;
    var param_117: f32;

    let _e271 = frag_info.target_origin[0u];
    param_117 = _e271;
    let _e272 = FragCoordFromTop_u0028_f1_u003b((&param_117));
    let _e275 = frag_info.target_origin[3u];
    at_3 = (_e272 + vec2((5.588238f * max(_e275, 0f))));
    let _e280 = at_3;
    return fract((52.982918f * fract(dot(_e280, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_10: f32;

    let _e270 = (*mode_1);
    if (_e270 > 0.5f) {
        let _e272 = (*stored_2);
        local_10 = (1f - _e272);
    } else {
        let _e274 = (*stored_2);
        local_10 = _e274;
    }
    let _e275 = local_10;
    return _e275;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_3: f32;
    var pMax: f32;
    var reduced: f32;

    let _e276 = (*moments)[1u];
    let _e278 = (*moments)[0u];
    let _e280 = (*moments)[0u];
    let _e283 = (*minVariance);
    variance = max((_e276 - (_e278 * _e280)), _e283);
    let _e285 = (*t);
    let _e287 = (*moments)[0u];
    d_3 = (_e285 - _e287);
    let _e289 = variance;
    let _e290 = variance;
    let _e291 = d_3;
    let _e292 = d_3;
    pMax = (_e289 / (_e290 + (_e291 * _e292)));
    let _e296 = pMax;
    let _e297 = (*bleed);
    let _e299 = (*bleed);
    reduced = clamp(((_e296 - _e297) / max((1f - _e299), 0.0001f)), 0f, 1f);
    let _e304 = (*t);
    let _e306 = (*moments)[0u];
    let _e308 = reduced;
    return select(_e308, 1f, (_e304 <= _e306));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_4: f32;

    let _e269 = (*depth);
    d_4 = ((2f * clamp(_e269, 0f, 1f)) - 1f);
    let _e273 = d_4;
    let _e276 = d_4;
    return vec2<f32>(exp((40f * _e273)), -(exp((-5f * _e276))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_118: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_119: vec2<f32>;
    var param_120: f32;
    var param_121: f32;
    var param_122: f32;
    var negative: f32;
    var param_123: vec2<f32>;
    var param_124: f32;
    var param_125: f32;
    var param_126: f32;

    let _e283 = (*depth_1);
    param_118 = _e283;
    let _e284 = EvsmWarp_u0028_f1_u003b((&param_118));
    warped = _e284;
    let _e285 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e285);
    let _e288 = scale[0u];
    let _e290 = scale[0u];
    let _e292 = (*moments_1);
    param_119 = _e292.xy;
    let _e295 = warped[0u];
    param_120 = _e295;
    param_121 = (_e288 * _e290);
    let _e296 = (*bleed_1);
    param_122 = _e296;
    let _e297 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_119), (&param_120), (&param_121), (&param_122));
    positive = _e297;
    let _e299 = scale[1u];
    let _e301 = scale[1u];
    let _e303 = (*moments_1);
    param_123 = _e303.zw;
    let _e306 = warped[1u];
    param_124 = _e306;
    param_125 = (_e299 * _e301);
    let _e307 = (*bleed_1);
    param_126 = _e307;
    let _e308 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_123), (&param_124), (&param_125), (&param_126));
    negative = _e308;
    let _e309 = positive;
    let _e310 = negative;
    return min(_e309, _e310);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e269 = (*depth_2);
    stored_3 = max((1f - _e269), 0.000061035156f);
    let _e272 = stored_3;
    return exp2((floor(log2(_e272)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_11: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var local_13: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_14: f32;
    var local_15: f32;
    var storage_: f32;
    var param_127: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_128: vec4<f32>;
    var param_129: f32;
    var param_130: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_131: f32;
    var param_132: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_6: i32;
    var disc: vec2<f32>;
    var param_133: i32;
    var param_134: i32;
    var param_135: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_136: f32;
    var param_137: f32;
    var gap: f32;
    var radius_2: f32;
    var i_7: i32;
    var disc_1: vec2<f32>;
    var param_138: i32;
    var param_139: i32;
    var param_140: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_141: f32;
    var param_142: f32;
    var phi_4074_: bool;
    var phi_4085_: bool;
    var phi_4246_: bool;
    var phi_4253_: bool;
    var phi_4260_: bool;

    let _e348 = frag_info.shadow_params[3u];
    strength_1 = _e348;
    let _e349 = strength_1;
    if (_e349 <= 0f) {
        return 1f;
    }
    let _e351 = (*lightIndex_1);
    let _e354 = frag_info.frame_params[2u];
    if (_e351 != i32(floor((_e354 + 0.5f)))) {
        return 1f;
    }
    let _e361 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e361 + 0.5f));
    let _e364 = Orthographic_u0028_();
    if _e364 {
        let _e365 = ViewDepth_u0028_();
        local_11 = _e365;
    } else {
        let _e366 = v_world_position_1;
        let _e368 = frag_info.camera_position;
        local_11 = length((_e366 - _e368.xyz));
    }
    let _e372 = local_11;
    viewDistance = _e372;
    cascade = 0i;
    let _e373 = cascadeCount;
    let _e374 = (_e373 > 1i);
    phi_4074_ = _e374;
    if _e374 {
        let _e375 = viewDistance;
        let _e378 = frag_info.shadow_cascades[0u];
        phi_4074_ = (_e375 > _e378);
    }
    let _e381 = phi_4074_;
    if _e381 {
        cascade = 1i;
    }
    let _e382 = cascadeCount;
    let _e383 = (_e382 > 2i);
    phi_4085_ = _e383;
    if _e383 {
        let _e384 = viewDistance;
        let _e387 = frag_info.shadow_cascades[1u];
        phi_4085_ = (_e384 > _e387);
    }
    let _e390 = phi_4085_;
    if _e390 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e391 = attempt;
        if (_e391 < 3i) {
            let _e393 = cascade;
            let _e394 = attempt;
            which = (_e393 + _e394);
            let _e396 = which;
            let _e397 = cascadeCount;
            if (_e396 >= _e397) {
                break;
            }
            let _e399 = which;
            if (_e399 == 0i) {
                let _e402 = frag_info.shadow_matrix;
                local_12 = _e402;
            } else {
                let _e403 = which;
                if (_e403 == 1i) {
                    let _e406 = frag_info.shadow_matrix_far;
                    local_13 = _e406;
                } else {
                    let _e408 = frag_info.shadow_matrix_farthest;
                    local_13 = _e408;
                }
                let _e409 = local_13;
                local_12 = _e409;
            }
            let _e410 = local_12;
            matrix = _e410;
            let _e413 = matrix[0][0u];
            let _e416 = matrix[1][0u];
            let _e419 = matrix[2][0u];
            axisX = vec3<f32>(_e413, _e416, _e419);
            let _e423 = matrix[0][1u];
            let _e426 = matrix[1][1u];
            let _e429 = matrix[2][1u];
            axisY = vec3<f32>(_e423, _e426, _e429);
            let _e431 = axisX;
            rowX = max(length(_e431), 0.000001f);
            let _e434 = axisY;
            rowY = max(length(_e434), 0.000001f);
            let _e439 = frag_info.shadow_cascades[3u];
            let _e441 = rowX;
            texelMetres = ((2f * _e439) / _e441);
            let _e445 = frag_info.shadow_cascades[3u];
            let _e448 = (*s_4).n;
            let _e449 = axisX;
            let _e452 = rowX;
            let _e453 = rowX;
            let _e457 = (*s_4).n;
            let _e458 = axisY;
            let _e461 = rowY;
            let _e462 = rowY;
            reach = ((3f * _e445) * ((abs(dot(_e448, _e449)) / (_e452 * _e453)) + (abs(dot(_e457, _e458)) / (_e461 * _e462))));
            let _e469 = frag_info.shadow_params[2u];
            let _e470 = texelMetres;
            flatOffset = min(_e469, _e470);
            let _e472 = v_world_position_1;
            let _e474 = (*s_4).n;
            let _e475 = flatOffset;
            let _e476 = reach;
            origin_1 = (_e472 + (_e474 * (_e475 + _e476)));
            let _e480 = matrix;
            let _e481 = origin_1;
            lightSpace = (_e480 * vec4<f32>(_e481.x, _e481.y, _e481.z, 1f));
            let _e488 = lightSpace[3u];
            if (_e488 <= 0f) {
                continue;
            }
            let _e490 = lightSpace;
            let _e493 = lightSpace[3u];
            candidate = (_e490.xyz / vec3(_e493));
            let _e497 = candidate[0u];
            let _e501 = candidate[1u];
            inTile = vec2<f32>(((_e497 * 0.5f) + 0.5f), (0.5f - (_e501 * 0.5f)));
            let _e506 = inTile[0u];
            let _e507 = (_e506 < 0f);
            phi_4246_ = _e507;
            if !(_e507) {
                let _e510 = inTile[0u];
                phi_4246_ = (_e510 > 1f);
            }
            let _e513 = phi_4246_;
            phi_4253_ = _e513;
            if !(_e513) {
                let _e516 = inTile[1u];
                phi_4253_ = (_e516 < 0f);
            }
            let _e519 = phi_4253_;
            phi_4260_ = _e519;
            if !(_e519) {
                let _e522 = inTile[1u];
                phi_4260_ = (_e522 > 1f);
            }
            let _e525 = phi_4260_;
            if _e525 {
                continue;
            }
            let _e527 = candidate[2u];
            if (_e527 > 1f) {
                let _e529 = which;
                let _e530 = cascadeCount;
                if (_e529 < (_e530 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e535 = inTile[0u];
            let _e536 = which;
            let _e539 = cascadeCount;
            let _e543 = inTile[1u];
            uv_5 = vec2<f32>(((_e535 + f32(_e536)) / f32(_e539)), _e543);
            let _e545 = candidate;
            projected = _e545;
            let _e546 = which;
            cascade = _e546;
            let _e547 = texelMetres;
            cascadeTexel = _e547;
            let _e550 = matrix[0][2u];
            let _e553 = matrix[1][2u];
            let _e556 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e550, _e553, _e556)), 0.000001f));
            let _e562 = (*s_4).n;
            let _e565 = matrix[0][2u];
            let _e568 = matrix[1][2u];
            let _e571 = matrix[2][2u];
            let _e575 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e562, vec3<f32>(_e565, _e568, _e571))) * _e575), 0.1f, 1f);
            let _e578 = texelMetres;
            let _e579 = cosSlope;
            let _e580 = cosSlope;
            let _e586 = cosSlope;
            let _e588 = cascadeDepth;
            receiverSlope = (((_e578 * sqrt(max((1f - (_e579 * _e580)), 0f))) / _e586) / _e588);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e590 = attempt;
            attempt = (_e590 + 1i);
        }
    }
    let _e592 = found;
    if !(_e592) {
        return 1f;
    }
    let _e594 = cascade;
    if (_e594 == 0i) {
        let _e598 = frag_info.shadow_bias[0u];
        local_14 = _e598;
    } else {
        let _e599 = cascade;
        if (_e599 == 1i) {
            let _e603 = frag_info.shadow_bias[1u];
            local_15 = _e603;
        } else {
            let _e606 = frag_info.shadow_bias[2u];
            local_15 = _e606;
        }
        let _e607 = local_15;
        local_14 = _e607;
    }
    let _e608 = local_14;
    bias = _e608;
    let _e611 = frag_info.shadow_params[1u];
    storage_ = _e611;
    let _e612 = storage_;
    let _e614 = storage_;
    if ((_e612 > 0.5f) && (_e614 < 1.5f)) {
        let _e617 = bias;
        let _e619 = projected[2u];
        param_127 = _e619;
        let _e620 = ShadowStoredStep_u0028_f1_u003b((&param_127));
        bias = max(_e617, _e620);
    }
    let _e624 = frag_info.shadow_params[0u];
    let _e627 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e624, _e627);
    let _e629 = cascade;
    let _e631 = cascadeCount;
    let _e635 = texel_1;
    tileLo = (vec2<f32>((f32(_e629) / f32(_e631)), 0f) + (_e635 * 0.5f));
    let _e638 = cascade;
    let _e641 = cascadeCount;
    let _e645 = texel_1;
    tileHi = (vec2<f32>((f32((_e638 + 1i)) / f32(_e641)), 1f) - (_e645 * 0.5f));
    let _e650 = frag_info.shadow_bias[3u];
    if (_e650 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e652 = y_1;
            if (_e652 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e654 = x_1;
                    if (_e654 <= 1i) {
                        let _e656 = uv_5;
                        let _e657 = x_1;
                        let _e659 = y_1;
                        let _e662 = texel_1;
                        let _e665 = tileLo;
                        let _e666 = tileHi;
                        let _e668 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e656 + (vec2<f32>(f32(_e657), f32(_e659)) * _e662)), _e665, _e666), 0f);
                        let _e669 = stored_4;
                        stored_4 = (_e669 + _e668);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e671 = x_1;
                        x_1 = (_e671 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e673 = y_1;
                y_1 = (_e673 + 1i);
            }
        }
        let _e675 = stored_4;
        stored_4 = (_e675 * 0.11111111f);
        let _e678 = stored_4[1u];
        let _e681 = stored_4[2u];
        let _e684 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e678), (1f - _e681), _e684), vec3(0f), vec3(4f));
        let _e689 = through;
        let _e690 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e689, vec3(clamp(_e690, 0f, 1f)));
    }
    let _e696 = frag_info.ambient_ground[3u];
    softness = _e696;
    lit_1 = 0f;
    let _e697 = softness;
    if (_e697 < 0f) {
        let _e699 = uv_5;
        let _e700 = tileLo;
        let _e701 = tileHi;
        let _e703 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e699, _e700, _e701), 0f);
        moments_2 = _e703;
        let _e705 = projected[2u];
        let _e706 = bias;
        let _e708 = softness;
        let _e712 = moments_2;
        param_128 = _e712;
        param_129 = (_e705 - _e706);
        param_130 = clamp((-(_e708) - 1f), 0f, 0.95f);
        let _e713 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_128), (&param_129), (&param_130));
        lit_1 = _e713;
    } else {
        let _e714 = softness;
        if (_e714 <= 0f) {
            y_2 = -1i;
            loop {
                let _e716 = y_2;
                if (_e716 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e718 = x_2;
                        if (_e718 <= 1i) {
                            let _e720 = uv_5;
                            let _e721 = x_2;
                            let _e723 = y_2;
                            let _e726 = texel_1;
                            let _e729 = tileLo;
                            let _e730 = tileHi;
                            let _e732 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e720 + (vec2<f32>(f32(_e721), f32(_e723)) * _e726)), _e729, _e730), 0f);
                            param_131 = _e732.x;
                            let _e734 = storage_;
                            param_132 = _e734;
                            let _e735 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_131), (&param_132));
                            occluder = _e735;
                            let _e737 = projected[2u];
                            let _e738 = bias;
                            let _e740 = occluder;
                            let _e743 = lit_1;
                            lit_1 = (_e743 + select(1f, 0f, ((_e737 - _e738) > _e740)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e745 = x_2;
                            x_2 = (_e745 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e747 = y_2;
                    y_2 = (_e747 + 1i);
                }
            }
            let _e749 = lit_1;
            lit_1 = (_e749 * 0.11111111f);
        } else {
            let _e751 = softness;
            spread = tan(min(_e751, 0.5f));
            let _e754 = ShadowNoise_u0028_();
            turn_1 = (_e754 * 6.2831855f);
            let _e756 = spread;
            let _e758 = projected[2u];
            let _e760 = cascadeDepth;
            let _e762 = cascadeTexel;
            searchRadius = clamp((((_e756 * _e758) * _e760) / _e762), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_6 = 0i;
            loop {
                let _e765 = i_6;
                if (_e765 < 16i) {
                    let _e767 = i_6;
                    param_133 = _e767;
                    param_134 = 16i;
                    let _e768 = turn_1;
                    param_135 = _e768;
                    let _e769 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_133), (&param_134), (&param_135));
                    disc = _e769;
                    let _e770 = bias;
                    let _e771 = disc;
                    let _e773 = searchRadius;
                    let _e777 = receiverSlope;
                    tapBias = (_e770 + (max(((length(_e771) * _e773) - 1.5f), 0f) * _e777));
                    let _e780 = uv_5;
                    let _e781 = disc;
                    let _e782 = texel_1;
                    let _e784 = searchRadius;
                    let _e787 = tileLo;
                    let _e788 = tileHi;
                    let _e790 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e780 + ((_e781 * _e782) * _e784)), _e787, _e788), 0f);
                    param_136 = _e790.x;
                    let _e792 = storage_;
                    param_137 = _e792;
                    let _e793 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_136), (&param_137));
                    occluder_1 = _e793;
                    let _e795 = projected[2u];
                    let _e796 = tapBias;
                    let _e798 = occluder_1;
                    if ((_e795 - _e796) > _e798) {
                        let _e800 = occluder_1;
                        let _e801 = blockerSum;
                        blockerSum = (_e801 + _e800);
                        let _e803 = blockerCount;
                        blockerCount = (_e803 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e805 = i_6;
                    i_6 = (_e805 + 1i);
                }
            }
            let _e807 = blockerCount;
            if (_e807 <= 0f) {
                return 1f;
            }
            let _e810 = projected[2u];
            let _e811 = blockerSum;
            let _e812 = blockerCount;
            let _e816 = cascadeDepth;
            gap = (max((_e810 - (_e811 / _e812)), 0f) * _e816);
            let _e818 = spread;
            let _e819 = gap;
            let _e821 = cascadeTexel;
            radius_2 = clamp(((_e818 * _e819) / _e821), 1f, 16f);
            i_7 = 0i;
            loop {
                let _e824 = i_7;
                if (_e824 < 16i) {
                    let _e826 = turn_1;
                    let _e828 = i_7;
                    param_138 = _e828;
                    param_139 = 16i;
                    param_140 = (_e826 + 1f);
                    let _e829 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_138), (&param_139), (&param_140));
                    disc_1 = _e829;
                    let _e830 = bias;
                    let _e831 = disc_1;
                    let _e833 = radius_2;
                    let _e837 = receiverSlope;
                    tapBias_1 = (_e830 + (max(((length(_e831) * _e833) - 1.5f), 0f) * _e837));
                    let _e840 = uv_5;
                    let _e841 = disc_1;
                    let _e842 = texel_1;
                    let _e844 = radius_2;
                    let _e847 = tileLo;
                    let _e848 = tileHi;
                    let _e850 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e840 + ((_e841 * _e842) * _e844)), _e847, _e848), 0f);
                    param_141 = _e850.x;
                    let _e852 = storage_;
                    param_142 = _e852;
                    let _e853 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_141), (&param_142));
                    occluder_2 = _e853;
                    let _e855 = projected[2u];
                    let _e856 = tapBias_1;
                    let _e858 = occluder_2;
                    let _e861 = lit_1;
                    lit_1 = (_e861 + select(1f, 0f, ((_e855 - _e856) > _e858)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e863 = i_7;
                    i_7 = (_e863 + 1i);
                }
            }
            let _e865 = lit_1;
            lit_1 = (_e865 * 0.0625f);
        }
    }
    let _e867 = lit_1;
    let _e868 = strength_1;
    return mix(1f, _e867, clamp(_e868, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_143: Surface;
    var param_144: LightSample;
    var param_145: i32;

    let _e273 = (*s_5);
    param_143 = _e273;
    let _e274 = (*light_3);
    param_144 = _e274;
    let _e275 = (*index);
    param_145 = _e275;
    let _e276 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_143), (&param_144), (&param_145));
    return _e276;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e268 = (*index_1);
    return (_e268 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e272 = (*distance_1);
    let _e273 = (*distance_1);
    attenuation = (1f / max((_e272 * _e273), 0.0001f));
    let _e277 = (*range_4);
    if (_e277 > 0f) {
        let _e279 = (*distance_1);
        let _e280 = (*range_4);
        ratio = (_e279 / _e280);
        let _e282 = ratio;
        let _e283 = ratio;
        let _e285 = ratio;
        let _e287 = ratio;
        window = clamp((1f - (((_e282 * _e283) * _e285) * _e287)), 0f, 1f);
        let _e291 = window;
        let _e292 = window;
        let _e294 = attenuation;
        attenuation = (_e294 * (_e291 * _e292));
    }
    let _e296 = attenuation;
    return _e296;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_16: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e284 = (*halfWidth);
    let _e285 = (*halfHeight);
    n_3 = cross(_e284, _e285);
    let _e287 = n_3;
    nLen = length(_e287);
    let _e289 = nLen;
    if (_e289 < 0.000000000001f) {
        let _e291 = (*centre);
        return _e291;
    }
    let _e292 = nLen;
    let _e293 = n_3;
    n_3 = (_e293 / vec3(_e292));
    let _e296 = (*centre);
    let _e297 = (*world_2);
    toPlane = (_e296 - _e297);
    let _e299 = (*mirror);
    let _e300 = n_3;
    denom = dot(_e299, _e300);
    let _e302 = denom;
    if (abs(_e302) < 0.00001f) {
        let _e305 = toPlane;
        let _e306 = n_3;
        let _e307 = toPlane;
        let _e308 = n_3;
        onPlane = (_e305 - (_e306 * dot(_e307, _e308)));
    } else {
        let _e312 = toPlane;
        let _e313 = n_3;
        let _e315 = denom;
        t_1 = (dot(_e312, _e313) / _e315);
        let _e317 = t_1;
        if (_e317 > 0f) {
            let _e319 = (*mirror);
            let _e320 = t_1;
            local_16 = (_e319 * _e320);
        } else {
            let _e322 = toPlane;
            let _e323 = n_3;
            let _e324 = toPlane;
            let _e325 = n_3;
            local_16 = (_e322 - (_e323 * dot(_e324, _e325)));
        }
        let _e329 = local_16;
        onPlane = _e329;
    }
    let _e330 = onPlane;
    let _e331 = toPlane;
    offset_2 = (_e330 - _e331);
    let _e333 = (*halfWidth);
    let _e334 = (*halfWidth);
    wLen2_ = max(dot(_e333, _e334), 0.000000000001f);
    let _e337 = (*halfHeight);
    let _e338 = (*halfHeight);
    hLen2_ = max(dot(_e337, _e338), 0.000000000001f);
    let _e341 = offset_2;
    let _e342 = (*halfWidth);
    let _e344 = wLen2_;
    u = clamp((dot(_e341, _e342) / _e344), -1f, 1f);
    let _e347 = offset_2;
    let _e348 = (*halfHeight);
    let _e350 = hLen2_;
    v_1 = clamp((dot(_e347, _e348) / _e350), -1f, 1f);
    let _e353 = (*centre);
    let _e354 = (*halfWidth);
    let _e355 = u;
    let _e358 = (*halfHeight);
    let _e359 = v_1;
    return ((_e353 + (_e354 * _e355)) + (_e358 * _e359));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_17: f32;

    let _e276 = (*a_3);
    let _e277 = (*a_3);
    ua = (_e276 / vec3(max(length(_e277), 0.000000000001f)));
    let _e282 = (*b_1);
    let _e283 = (*b_1);
    ub = (_e282 / vec3(max(length(_e283), 0.000000000001f)));
    let _e288 = ua;
    let _e289 = ub;
    angle_2 = acos(clamp(dot(_e288, _e289), -1f, 1f));
    let _e293 = ua;
    let _e294 = ub;
    axis_1 = cross(_e293, _e294);
    let _e296 = axis_1;
    len_2 = length(_e296);
    let _e298 = len_2;
    if (_e298 > 0.000001f) {
        let _e300 = angle_2;
        let _e301 = axis_1;
        let _e302 = (*n_4);
        let _e305 = len_2;
        local_17 = ((_e300 * dot(_e301, _e302)) / _e305);
    } else {
        local_17 = 0f;
    }
    let _e307 = local_17;
    return _e307;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_18: i32;
    var ha: f32;
    var hb: f32;
    var d_5: f32;
    var q: vec3<f32>;
    var local_19: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_20: f32;
    var param_146: vec3<f32>;
    var param_147: vec3<f32>;
    var param_148: vec3<f32>;
    var param_149: vec3<f32>;
    var param_150: vec3<f32>;
    var param_151: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e290 = i_8;
        if (_e290 < 4i) {
            let _e292 = i_8;
            let _e294 = (*corners_1)[_e292];
            a_4 = _e294;
            let _e295 = i_8;
            if (_e295 == 3i) {
                local_18 = 0i;
            } else {
                let _e297 = i_8;
                local_18 = (_e297 + 1i);
            }
            let _e299 = local_18;
            let _e301 = (*corners_1)[_e299];
            b_2 = _e301;
            let _e302 = a_4;
            let _e303 = (*n_5);
            ha = dot(_e302, _e303);
            let _e305 = b_2;
            let _e306 = (*n_5);
            hb = dot(_e305, _e306);
            let _e308 = ha;
            let _e309 = hb;
            d_5 = (_e308 - _e309);
            let _e311 = a_4;
            let _e312 = b_2;
            let _e313 = a_4;
            let _e315 = d_5;
            if (abs(_e315) > 0.000000000001f) {
                let _e318 = ha;
                let _e319 = d_5;
                local_19 = (_e318 / _e319);
            } else {
                local_19 = 0f;
            }
            let _e321 = local_19;
            q = (_e311 + ((_e312 - _e313) * _e321));
            let _e324 = ha;
            aAbove = (_e324 > 0f);
            let _e326 = hb;
            bAbove = (_e326 > 0f);
            let _e328 = aAbove;
            let _e329 = bAbove;
            if (_e328 || _e329) {
                let _e331 = aAbove;
                let _e332 = a_4;
                let _e333 = q;
                let _e336 = bAbove;
                let _e337 = b_2;
                let _e338 = q;
                param_146 = select(_e333, _e332, vec3(_e331));
                param_147 = select(_e338, _e337, vec3(_e336));
                let _e341 = (*n_5);
                param_148 = _e341;
                let _e342 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_146), (&param_147), (&param_148));
                local_20 = _e342;
            } else {
                local_20 = 0f;
            }
            let _e343 = local_20;
            let _e344 = total;
            total = (_e344 + _e343);
            let _e346 = aAbove;
            let _e347 = bAbove;
            let _e350 = q;
            let _e351 = exit;
            exit = select(_e351, _e350, vec3((_e346 && !(_e347))));
            let _e354 = aAbove;
            let _e356 = bAbove;
            let _e358 = q;
            let _e359 = entry;
            entry = select(_e359, _e358, vec3((!(_e354) && _e356)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e362 = i_8;
            i_8 = (_e362 + 1i);
        }
    }
    let _e364 = exit;
    param_149 = _e364;
    let _e365 = entry;
    param_150 = _e365;
    let _e366 = (*n_5);
    param_151 = _e366;
    let _e367 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_149), (&param_150), (&param_151));
    let _e368 = total;
    total = (_e368 + _e367);
    let _e370 = total;
    return max((-(_e370) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_21: f32;
    var local_22: f32;
    var local_23: f32;

    let _e273 = (*slot_1);
    let _e274 = (*slot_1);
    lane = (_e273 - ((_e274 / 4i) * 4i));
    let _e278 = lane;
    if (_e278 == 0i) {
        let _e281 = (*four)[0u];
        local_21 = _e281;
    } else {
        let _e282 = lane;
        if (_e282 == 1i) {
            let _e285 = (*four)[1u];
            local_22 = _e285;
        } else {
            let _e286 = lane;
            if (_e286 == 2i) {
                let _e289 = (*four)[2u];
                local_23 = _e289;
            } else {
                let _e291 = (*four)[3u];
                local_23 = _e291;
            }
            let _e292 = local_23;
            local_22 = _e292;
        }
        let _e293 = local_22;
        local_21 = _e293;
    }
    let _e294 = local_21;
    return _e294;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_152: vec4<f32>;
    var param_153: i32;

    let _e270 = (*slot_2);
    let _e274 = light_list_info.scales[(_e270 / 4i)];
    param_152 = _e274;
    let _e275 = (*slot_2);
    param_153 = _e275;
    let _e276 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_152), (&param_153));
    return _e276;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e272 = light_list_info.slot_rows[0i];
    let _e273 = (*row);
    a_5 = abs((_e272 - vec4(_e273)));
    let _e279 = light_list_info.slot_rows[1i];
    let _e280 = (*row);
    b_3 = abs((_e279 - vec4(_e280)));
    let _e285 = a_5[0u];
    let _e287 = a_5[1u];
    let _e290 = a_5[2u];
    let _e292 = a_5[3u];
    let _e296 = b_3[0u];
    let _e298 = b_3[1u];
    let _e301 = b_3[2u];
    let _e303 = b_3[3u];
    return (min(min(min(_e285, _e287), min(_e290, _e292)), min(min(_e296, _e298), min(_e301, _e303))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_154: vec4<f32>;
    var param_155: i32;

    let _e270 = (*slot_3);
    let _e274 = light_list_info.indices[(_e270 / 4i)];
    param_154 = _e274;
    let _e275 = (*slot_3);
    param_155 = _e275;
    let _e276 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_154), (&param_155));
    return _e276;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e269 = (*texel_2);
    let _e273 = light_list_info.list[1u];
    let _e275 = (*row_1);
    let _e279 = light_list_info.list[2u];
    let _e282 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e269 + 0.5f) * _e273), ((_e275 + 0.5f) * _e279)), 0f);
    return _e282;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_156: f32;
    var param_157: f32;
    var param_158: vec4<f32>;
    var param_159: i32;

    let _e277 = g_cluster_offset;
    let _e278 = (*slot_4);
    entry_1 = (_e277 + f32(_e278));
    let _e281 = entry_1;
    row_2 = floor((_e281 / 16f));
    let _e284 = entry_1;
    let _e285 = row_2;
    within = (_e284 - (_e285 * 16f));
    let _e288 = within;
    texel_3 = floor((_e288 / 4f));
    let _e293 = light_list_info.cluster_depth[3u];
    let _e294 = row_2;
    let _e296 = texel_3;
    param_156 = _e296;
    param_157 = (_e293 + _e294);
    let _e297 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_156), (&param_157));
    four_1 = _e297;
    let _e298 = within;
    let _e299 = texel_3;
    let _e304 = four_1;
    param_158 = _e304;
    param_159 = i32(((_e298 - (_e299 * 4f)) + 0.5f));
    let _e305 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_158), (&param_159));
    return _e305;
}

fn Clustered_u0028_() -> bool {
    let _e269 = light_list_info.cluster_grid[3u];
    return (_e269 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_6: ptr<function, Surface>) -> LightSample {
    var light_4: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_24: f32;
    var param_160: i32;
    var param_161: i32;
    var v_2: f32;
    var u_1: f32;
    var local_25: f32;
    var param_162: f32;
    var param_163: i32;
    var type_45: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_26: f32;
    var param_164: array<vec3<f32>, 4>;
    var param_165: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_27: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_166: vec3<f32>;
    var param_167: vec3<f32>;
    var param_168: vec3<f32>;
    var param_169: vec3<f32>;
    var param_170: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_28: vec3<f32>;
    var param_171: vec3<f32>;
    var param_172: vec3<f32>;
    var param_173: f32;
    var param_174: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_175: f32;
    var param_176: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_4.integrated = 0f;
    light_4.ltc = vec3<f32>(0f, 0f, 0f);
    let _e325 = (*index_2);
    if (_e325 < 8i) {
        let _e327 = (*index_2);
        let _e330 = frag_info.light_position[_e327];
        position = _e330;
        let _e331 = (*index_2);
        let _e334 = frag_info.light_color[_e331];
        color_1 = _e334;
        let _e335 = (*index_2);
        let _e338 = frag_info.light_direction[_e335];
        direction = _e338;
        let _e339 = (*index_2);
        let _e342 = frag_info.light_cone[_e339];
        cone = _e342;
    } else {
        let _e343 = (*index_2);
        slot_5 = (_e343 - 8i);
        let _e345 = Clustered_u0028_();
        clustered = _e345;
        let _e346 = clustered;
        if _e346 {
            let _e347 = slot_5;
            param_160 = _e347;
            let _e348 = ClusterRow_u0028_i1_u003b((&param_160));
            local_24 = _e348;
        } else {
            let _e349 = slot_5;
            param_161 = _e349;
            let _e350 = LightListRow_u0028_i1_u003b((&param_161));
            local_24 = _e350;
        }
        let _e351 = local_24;
        listRow = _e351;
        let _e352 = listRow;
        let _e356 = light_list_info.list[2u];
        v_2 = ((_e352 + 0.5f) * _e356);
        let _e360 = light_list_info.list[1u];
        u_1 = _e360;
        let _e361 = u_1;
        let _e363 = v_2;
        let _e365 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e361), _e363), 0f);
        position = _e365;
        let _e366 = u_1;
        let _e368 = v_2;
        let _e370 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e366), _e368), 0f);
        color_1 = _e370;
        let _e371 = u_1;
        let _e373 = v_2;
        let _e375 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e371), _e373), 0f);
        direction = _e375;
        let _e376 = u_1;
        let _e378 = v_2;
        let _e380 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e376), _e378), 0f);
        cone = _e380;
        let _e381 = clustered;
        if _e381 {
            let _e382 = listRow;
            param_162 = _e382;
            let _e383 = InSlots_u0028_f1_u003b((&param_162));
            local_25 = select(1f, 0f, _e383);
        } else {
            let _e385 = slot_5;
            param_163 = _e385;
            let _e386 = LightListScale_u0028_i1_u003b((&param_163));
            local_25 = _e386;
        }
        let _e387 = local_25;
        let _e389 = color_1[3u];
        color_1[3u] = (_e389 * _e387);
    }
    let _e393 = position[3u];
    type_45 = _e393;
    let _e394 = type_45;
    if (_e394 > 15.5f) {
        let _e397 = (*s_6).n;
        light_4.l = _e397;
        let _e400 = (*s_6).n;
        light_4.h = _e400;
        light_4.radiance = vec3<f32>(0f, 0f, 0f);
        light_4.n_dot_l = 0f;
        light_4.n_dot_h = 0f;
        light_4.v_dot_h = 0f;
        let _e406 = light_4;
        return _e406;
    }
    let _e407 = type_45;
    if (_e407 > 2.5f) {
        let _e409 = direction;
        halfWidth_1 = _e409.xyz;
        let _e411 = cone;
        halfHeight_1 = _e411.xyz;
        let _e413 = position;
        let _e415 = v_world_position_1;
        toCentre = (_e413.xyz - _e415);
        let _e417 = toCentre;
        let _e418 = halfWidth_1;
        let _e420 = halfHeight_1;
        corners_2[0i] = ((_e417 - _e418) - _e420);
        let _e423 = toCentre;
        let _e424 = halfWidth_1;
        let _e426 = halfHeight_1;
        corners_2[1i] = ((_e423 + _e424) - _e426);
        let _e429 = toCentre;
        let _e430 = halfWidth_1;
        let _e432 = halfHeight_1;
        corners_2[2i] = ((_e429 + _e430) + _e432);
        let _e435 = toCentre;
        let _e436 = halfWidth_1;
        let _e438 = halfHeight_1;
        corners_2[3i] = ((_e435 - _e436) + _e438);
        let _e441 = toCentre;
        let _e442 = halfWidth_1;
        let _e443 = halfHeight_1;
        behind = (dot(_e441, cross(_e442, _e443)) >= 0f);
        let _e447 = behind;
        if _e447 {
            local_26 = 0f;
        } else {
            let _e448 = corners_2;
            param_164 = _e448;
            let _e450 = (*s_6).n;
            param_165 = _e450;
            let _e451 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_164), (&param_165));
            local_26 = _e451;
        }
        let _e452 = local_26;
        formFactor = _e452;
        let _e453 = halfWidth_1;
        let _e454 = halfHeight_1;
        area = (length(cross(_e453, _e454)) * 4f);
        let _e458 = area;
        if (_e458 > 0.000000001f) {
            let _e460 = area;
            local_27 = (1f / _e460);
        } else {
            local_27 = 0f;
        }
        let _e462 = local_27;
        radiance = _e462;
        let _e463 = toCentre;
        distance_2 = length(_e463);
        let _e466 = direction[3u];
        if (_e466 > 0f) {
            let _e468 = distance_2;
            let _e470 = direction[3u];
            ratio_1 = (_e468 / _e470);
            let _e472 = ratio_1;
            let _e473 = ratio_1;
            let _e475 = ratio_1;
            let _e477 = ratio_1;
            window_1 = clamp((1f - (((_e472 * _e473) * _e475) * _e477)), 0f, 1f);
            let _e481 = window_1;
            let _e482 = window_1;
            let _e484 = radiance;
            radiance = (_e484 * (_e481 * _e482));
        }
        let _e487 = (*s_6).v;
        let _e490 = (*s_6).n;
        mirror_1 = reflect(-(_e487), _e490);
        let _e492 = position;
        param_166 = _e492.xyz;
        let _e494 = halfWidth_1;
        param_167 = _e494;
        let _e495 = halfHeight_1;
        param_168 = _e495;
        let _e496 = v_world_position_1;
        param_169 = _e496;
        let _e497 = mirror_1;
        param_170 = _e497;
        let _e498 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_166), (&param_167), (&param_168), (&param_169), (&param_170));
        representative = _e498;
        let _e499 = representative;
        let _e500 = v_world_position_1;
        toPoint = (_e499 - _e500);
        let _e502 = toPoint;
        pointDistance = length(_e502);
        let _e504 = pointDistance;
        if (_e504 > 0.000001f) {
            let _e506 = toPoint;
            let _e507 = pointDistance;
            local_28 = (_e506 / vec3(_e507));
        } else {
            let _e511 = (*s_6).n;
            local_28 = _e511;
        }
        let _e512 = local_28;
        light_4.l = _e512;
        let _e515 = light_4.l;
        let _e517 = (*s_6).v;
        light_4.h = normalize((_e515 + _e517));
        let _e521 = formFactor;
        light_4.n_dot_l = _e521;
        let _e524 = (*s_6).n;
        let _e526 = light_4.h;
        light_4.n_dot_h = max(dot(_e524, _e526), 0f);
        let _e531 = (*s_6).v;
        let _e533 = light_4.h;
        light_4.v_dot_h = max(dot(_e531, _e533), 0f);
        let _e537 = color_1;
        let _e540 = color_1[3u];
        let _e542 = radiance;
        light_4.radiance = ((_e537.xyz * _e540) * _e542);
        light_4.integrated = 1f;
        let _e547 = (*s_6).n;
        param_171 = _e547;
        let _e549 = (*s_6).v;
        param_172 = _e549;
        let _e551 = (*s_6).roughness;
        param_173 = _e551;
        let _e552 = corners_2;
        param_174 = _e552;
        let _e553 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_171), (&param_172), (&param_173), (&param_174));
        light_4.ltc = _e553;
        let _e555 = corners_2;
        g_rect_corners = _e555;
        let _e556 = light_4;
        return _e556;
    }
    let _e557 = direction;
    aim = normalize(_e557.xyz);
    attenuation_1 = 1f;
    let _e560 = type_45;
    if (_e560 < 0.5f) {
        let _e562 = aim;
        light_4.l = -(_e562);
    } else {
        let _e565 = position;
        let _e567 = v_world_position_1;
        toLight_1 = (_e565.xyz - _e567);
        let _e569 = toLight_1;
        distance_3 = length(_e569);
        let _e571 = distance_3;
        if (_e571 < 0.000001f) {
            let _e574 = (*s_6).n;
            light_4.l = _e574;
            let _e577 = (*s_6).n;
            light_4.h = _e577;
            light_4.radiance = vec3<f32>(0f, 0f, 0f);
            light_4.n_dot_l = 0f;
            light_4.n_dot_h = 0f;
            light_4.v_dot_h = 0f;
            let _e583 = light_4;
            return _e583;
        }
        let _e584 = toLight_1;
        let _e585 = distance_3;
        light_4.l = (_e584 / vec3(_e585));
        let _e589 = distance_3;
        param_175 = _e589;
        let _e591 = direction[3u];
        param_176 = _e591;
        let _e592 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_175), (&param_176));
        attenuation_1 = _e592;
        let _e593 = type_45;
        if (_e593 > 1.5f) {
            let _e595 = aim;
            let _e597 = light_4.l;
            cosAngle = dot(_e595, -(_e597));
            let _e600 = cosAngle;
            let _e602 = cone[1u];
            let _e605 = cone[0u];
            let _e607 = cone[1u];
            ramp = clamp(((_e600 - _e602) / (_e605 - _e607)), 0f, 1f);
            let _e611 = ramp;
            let _e612 = ramp;
            let _e614 = attenuation_1;
            attenuation_1 = (_e614 * (_e611 * _e612));
        }
    }
    let _e617 = light_4.l;
    let _e619 = (*s_6).v;
    light_4.h = normalize((_e617 + _e619));
    let _e624 = (*s_6).n;
    let _e626 = light_4.l;
    light_4.n_dot_l = max(dot(_e624, _e626), 0f);
    let _e631 = (*s_6).n;
    let _e633 = light_4.h;
    light_4.n_dot_h = max(dot(_e631, _e633), 0f);
    let _e638 = (*s_6).v;
    let _e640 = light_4.h;
    light_4.v_dot_h = max(dot(_e638, _e640), 0f);
    let _e644 = color_1;
    let _e647 = color_1[3u];
    let _e649 = attenuation_1;
    light_4.radiance = ((_e644.xyz * _e647) * _e649);
    let _e652 = light_4;
    return _e652;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_29: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_177: f32;
    var param_178: f32;

    let _e282 = light_list_info.cluster_view_projection;
    let _e283 = (*world_3);
    clip_1 = (_e282 * vec4<f32>(_e283.x, _e283.y, _e283.z, 1f));
    let _e289 = clip_1;
    let _e292 = clip_1[3u];
    ndc_1 = (_e289.xy / vec2(max(_e292, 0.000001f)));
    let _e297 = light_list_info.cluster_grid;
    grid = _e297.xyz;
    let _e301 = light_list_info.cluster_depth[0u];
    near_1 = _e301;
    let _e303 = ndc_1[0u];
    let _e307 = grid[0u];
    let _e311 = grid[0u];
    tx = clamp(floor((((_e303 * 0.5f) + 0.5f) * _e307)), 0f, (_e311 - 1f));
    let _e315 = ndc_1[1u];
    let _e319 = grid[1u];
    let _e323 = grid[1u];
    ty = clamp(floor((((_e315 * 0.5f) + 0.5f) * _e319)), 0f, (_e323 - 1f));
    let _e327 = clip_1[3u];
    let _e328 = near_1;
    if (_e327 <= _e328) {
        local_29 = 0f;
    } else {
        let _e331 = clip_1[3u];
        let _e332 = near_1;
        let _e337 = light_list_info.cluster_depth[1u];
        let _e341 = grid[2u];
        local_29 = clamp(floor((log((_e331 / _e332)) * _e337)), 0f, (_e341 - 1f));
    }
    let _e344 = local_29;
    tz = _e344;
    let _e345 = tx;
    let _e346 = ty;
    let _e348 = grid[0u];
    let _e351 = tz;
    let _e353 = grid[0u];
    let _e356 = grid[1u];
    cell = ((_e345 + (_e346 * _e348)) + ((_e351 * _e353) * _e356));
    let _e359 = cell;
    row_3 = floor((_e359 / 4f));
    let _e362 = cell;
    let _e363 = row_3;
    let _e368 = light_list_info.cluster_depth[2u];
    let _e369 = row_3;
    param_177 = (_e362 - (_e363 * 4f));
    param_178 = (_e368 + _e369);
    let _e371 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_177), (&param_178));
    header = _e371;
    let _e373 = header[0u];
    g_cluster_offset = _e373;
    let _e375 = header[1u];
    g_cluster_count = _e375;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_179: vec3<f32>;

    let _e271 = light_list_info.list[0u];
    tail = _e271;
    let _e272 = Clustered_u0028_();
    if _e272 {
        let _e273 = v_world_position_1;
        param_179 = _e273;
        FindCluster_u0028_vf3_u003b((&param_179));
        let _e274 = g_cluster_count;
        tail = _e274;
    }
    let _e277 = frag_info.frame_params[1u];
    let _e281 = tail;
    return (clamp(i32((_e277 + 0.5f)), 0i, 8i) + clamp(i32((_e281 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_5: LightSample;
    var param_180: i32;
    var param_181: Surface;
    var visibility: f32;
    var param_182: i32;
    var local_30: f32;
    var param_183: Surface;
    var param_184: LightSample;
    var param_185: i32;
    var param_186: vec3<f32>;
    var param_187: vec3<f32>;
    var param_188: i32;
    var param_189: Surface;
    var param_190: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e285 = LightCount_u0028_();
    count_1 = _e285;
    i_9 = 0i;
    loop {
        let _e286 = i_9;
        if (_e286 < 32i) {
            let _e288 = i_9;
            let _e289 = count_1;
            if (_e288 >= _e289) {
                break;
            }
            let _e291 = i_9;
            param_180 = _e291;
            let _e292 = (*s_7);
            param_181 = _e292;
            let _e293 = 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((&param_180), (&param_181));
            light_5 = _e293;
            let _e295 = light_5.n_dot_l;
            if (_e295 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e297 = i_9;
            param_182 = _e297;
            let _e298 = LightHasShadow_u0028_i1_u003b((&param_182));
            if _e298 {
                let _e299 = (*s_7);
                param_183 = _e299;
                let _e300 = light_5;
                param_184 = _e300;
                let _e301 = i_9;
                param_185 = _e301;
                let _e302 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_183), (&param_184), (&param_185));
                let _e303 = v_world_position_1;
                param_186 = _e303;
                let _e305 = (*s_7).n;
                param_187 = _e305;
                let _e306 = i_9;
                param_188 = _e306;
                let _e307 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_186), (&param_187), (&param_188));
                local_30 = (_e302 * _e307);
            } else {
                local_30 = 1f;
            }
            let _e309 = local_30;
            visibility = _e309;
            let _e310 = visibility;
            if (_e310 <= 0f) {
                continue;
            }
            let _e312 = (*s_7);
            param_189 = _e312;
            let _e313 = light_5;
            param_190 = _e313;
            let _e314 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_189), (&param_190));
            let _e316 = light_5.radiance;
            let _e319 = light_5.n_dot_l;
            let _e321 = visibility;
            let _e323 = light_transmittance;
            let _e325 = total_1;
            total_1 = (_e325 + ((((_e314 * _e316) * _e319) * _e321) * _e323));
            continue;
        } else {
            break;
        }
        continuing {
            let _e327 = i_9;
            i_9 = (_e327 + 1i);
        }
    }
    let _e329 = total_1;
    return _e329;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e268 = v_lightmap_uv_1;
    let _e269 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e268);
    texel_4 = _e269;
    let _e270 = texel_4;
    let _e273 = texel_4[3u];
    return ((_e270.xyz * _e273) * 8f);
}

fn SceneColorLevel_u0028_vf2_u003b_i1_u003b(uv_6: ptr<function, vec2<f32>>, level: ptr<function, i32>) -> vec3<f32> {
    var rect: vec4<f32>;
    var inset_1: vec2<f32>;
    var at_4: vec2<f32>;

    let _e272 = (*level);
    let _e275 = layer_info.scene_levels[_e272];
    rect = _e275;
    let _e277 = layer_info.scene_color;
    inset_1 = (_e277.yz * 0.5f);
    let _e280 = rect;
    let _e282 = (*uv_6);
    let _e283 = rect;
    let _e286 = inset_1;
    let _e287 = rect;
    let _e289 = inset_1;
    let _e291 = inset_1;
    at_4 = (_e280.xy + clamp((_e282 * _e283.zw), _e286, max((_e287.zw - _e289), _e291)));
    let _e295 = at_4;
    let _e296 = textureSampleLevel(scene_color_texture_tex, scene_color_texture_smp, _e295, 0f);
    return _e296.xyz;
}

fn SceneColorAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod: ptr<function, f32>) -> vec3<f32> {
    var clip_2: vec4<f32>;
    var ndc_2: vec2<f32>;
    var view: vec2<f32>;
    var uv_7: vec2<f32>;
    var top: f32;
    var level_1: f32;
    var lower: f32;
    var near_2: vec3<f32>;
    var param_191: vec2<f32>;
    var param_192: i32;
    var far_1: vec3<f32>;
    var param_193: vec2<f32>;
    var param_194: i32;

    let _e283 = layer_info.scene_view_projection;
    let _e284 = (*world_4);
    clip_2 = (_e283 * vec4<f32>(_e284.x, _e284.y, _e284.z, 1f));
    let _e290 = clip_2;
    let _e293 = clip_2[3u];
    ndc_2 = (_e290.xy / vec2(max(_e293, 0.000001f)));
    let _e298 = ndc_2[0u];
    let _e302 = ndc_2[1u];
    view = clamp(vec2<f32>(((_e298 * 0.5f) + 0.5f), (0.5f - (_e302 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
    let _e308 = layer_info.scene_viewport;
    let _e310 = view;
    let _e312 = layer_info.scene_viewport;
    uv_7 = (_e308.xy + (_e310 * _e312.zw));
    let _e318 = layer_info.scene_color[0u];
    top = (_e318 - 1f);
    let _e320 = (*lod);
    let _e321 = top;
    level_1 = clamp(_e320, 0f, _e321);
    let _e323 = level_1;
    lower = floor(_e323);
    let _e325 = lower;
    let _e327 = uv_7;
    param_191 = _e327;
    param_192 = i32(_e325);
    let _e328 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_191), (&param_192));
    near_2 = _e328;
    let _e329 = lower;
    let _e331 = top;
    let _e334 = uv_7;
    param_193 = _e334;
    param_194 = i32(min((_e329 + 1f), _e331));
    let _e335 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_193), (&param_194));
    far_1 = _e335;
    let _e336 = near_2;
    let _e337 = far_1;
    let _e338 = level_1;
    let _e339 = lower;
    return mix(_e336, _e337, vec3((_e338 - _e339)));
}

fn IorInfinite_u0028_() -> bool {
    let _e269 = layer_info.coat[2u];
    return (_e269 == 0f);
}

fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
    var local_31: f32;

    let _e269 = IorInfinite_u0028_();
    if _e269 {
        local_31 = 0f;
    } else {
        let _e270 = (*ior);
        let _e275 = layer_info.transmission[3u];
        local_31 = (((_e270 - 1f) * 0.025f) * _e275);
    }
    let _e277 = local_31;
    return _e277;
}

fn RefractionIor_u0028_() -> f32 {
    var local_32: f32;

    let _e268 = IorInfinite_u0028_();
    if _e268 {
        local_32 = 10000f;
    } else {
        let _e271 = layer_info.coat[2u];
        local_32 = max(_e271, 1f);
    }
    let _e273 = local_32;
    return _e273;
}

fn SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) -> vec3<f32> {
    var ior_1: f32;
    var spread_1: f32;
    var param_195: f32;
    var width: f32;
    var lod_1: f32;
    var thin: bool;
    var red: vec3<f32>;
    var local_33: vec3<f32>;
    var green: vec3<f32>;
    var local_34: vec3<f32>;
    var blue: vec3<f32>;
    var local_35: vec3<f32>;
    var param_196: vec3<f32>;
    var param_197: f32;
    var param_198: vec3<f32>;
    var param_199: f32;
    var param_200: vec3<f32>;
    var param_201: f32;

    let _e286 = RefractionIor_u0028_();
    ior_1 = _e286;
    let _e287 = ior_1;
    param_195 = _e287;
    let _e288 = DispersionSpread_u0028_f1_u003b((&param_195));
    spread_1 = _e288;
    let _e292 = layer_info.scene_levels[0i][2u];
    let _e295 = layer_info.scene_color[1u];
    width = (_e292 / max(_e295, 0.000000001f));
    let _e298 = width;
    let _e302 = (*s_8).roughness;
    let _e304 = ior_1;
    lod_1 = ((log2(max(_e298, 1f)) * _e302) * clamp(((_e304 * 2f) - 2f), 0f, 1f));
    let _e309 = g_thickness;
    thin = (_e309 <= 0f);
    let _e311 = thin;
    if _e311 {
        let _e313 = (*s_8).v;
        local_33 = -(_e313);
    } else {
        let _e316 = (*s_8).v;
        let _e319 = (*s_8).n;
        let _e320 = ior_1;
        let _e321 = spread_1;
        local_33 = refract(-(_e316), _e319, (1f / max((_e320 - _e321), 1f)));
    }
    let _e326 = local_33;
    red = _e326;
    let _e327 = thin;
    if _e327 {
        let _e329 = (*s_8).v;
        local_34 = -(_e329);
    } else {
        let _e332 = (*s_8).v;
        let _e335 = (*s_8).n;
        let _e336 = ior_1;
        local_34 = refract(-(_e332), _e335, (1f / _e336));
    }
    let _e339 = local_34;
    green = _e339;
    let _e340 = thin;
    if _e340 {
        let _e342 = (*s_8).v;
        local_35 = -(_e342);
    } else {
        let _e345 = (*s_8).v;
        let _e348 = (*s_8).n;
        let _e349 = ior_1;
        let _e350 = spread_1;
        local_35 = refract(-(_e345), _e348, (1f / (_e349 + _e350)));
    }
    let _e354 = local_35;
    blue = _e354;
    let _e355 = v_world_position_1;
    let _e356 = red;
    let _e357 = g_thickness;
    param_196 = (_e355 + (_e356 * _e357));
    let _e360 = lod_1;
    param_197 = _e360;
    let _e361 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_196), (&param_197));
    let _e363 = v_world_position_1;
    let _e364 = green;
    let _e365 = g_thickness;
    param_198 = (_e363 + (_e364 * _e365));
    let _e368 = lod_1;
    param_199 = _e368;
    let _e369 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_198), (&param_199));
    let _e371 = v_world_position_1;
    let _e372 = blue;
    let _e373 = g_thickness;
    param_200 = (_e371 + (_e372 * _e373));
    let _e376 = lod_1;
    param_201 = _e376;
    let _e377 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_200), (&param_201));
    return vec3<f32>(_e361.x, _e369.y, _e377.z);
}

fn TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b(s_9: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
    var ior_2: f32;
    var spread_2: f32;
    var param_202: f32;
    var lod_2: f32;
    var thin_1: bool;
    var red_1: vec3<f32>;
    var local_36: vec3<f32>;
    var green_1: vec3<f32>;
    var local_37: vec3<f32>;
    var blue_1: vec3<f32>;
    var local_38: vec3<f32>;

    let _e280 = RefractionIor_u0028_();
    ior_2 = _e280;
    let _e281 = ior_2;
    param_202 = _e281;
    let _e282 = DispersionSpread_u0028_f1_u003b((&param_202));
    spread_2 = _e282;
    let _e284 = (*s_9).roughness;
    let _e285 = ior_2;
    let _e290 = (*levels);
    lod_2 = ((_e284 * clamp(((_e285 * 2f) - 2f), 0f, 1f)) * _e290);
    let _e292 = g_thickness;
    thin_1 = (_e292 <= 0f);
    let _e294 = thin_1;
    if _e294 {
        let _e296 = (*s_9).v;
        local_36 = -(_e296);
    } else {
        let _e299 = (*s_9).v;
        let _e302 = (*s_9).n;
        let _e303 = ior_2;
        let _e304 = spread_2;
        local_36 = refract(-(_e299), _e302, (1f / max((_e303 - _e304), 1f)));
    }
    let _e309 = local_36;
    red_1 = _e309;
    let _e310 = thin_1;
    if _e310 {
        let _e312 = (*s_9).v;
        local_37 = -(_e312);
    } else {
        let _e315 = (*s_9).v;
        let _e318 = (*s_9).n;
        let _e319 = ior_2;
        local_37 = refract(-(_e315), _e318, (1f / _e319));
    }
    let _e322 = local_37;
    green_1 = _e322;
    let _e323 = thin_1;
    if _e323 {
        let _e325 = (*s_9).v;
        local_38 = -(_e325);
    } else {
        let _e328 = (*s_9).v;
        let _e331 = (*s_9).n;
        let _e332 = ior_2;
        let _e333 = spread_2;
        local_38 = refract(-(_e328), _e331, (1f / (_e332 + _e333)));
    }
    let _e337 = local_38;
    blue_1 = _e337;
    let _e338 = red_1;
    let _e339 = lod_2;
    let _e340 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e338, _e339);
    let _e342 = green_1;
    let _e343 = lod_2;
    let _e344 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e342, _e343);
    let _e346 = blue_1;
    let _e347 = lod_2;
    let _e348 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e346, _e347);
    return vec3<f32>(_e340.x, _e344.y, _e348.z);
}

fn SceneColorBound_u0028_() -> bool {
    let _e269 = layer_info.scene_color[0u];
    return (_e269 > 0f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_39: f32;

    let _e270 = frag_info.material2_[2u];
    local_39 = floor((_e270 * 0.5f));
    let _e273 = local_39;
    return _e273;
}

fn IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) -> f32 {
    var target_: f32;
    var local_40: f32;
    var local_41: f32;

    let _e271 = OcclusionTarget_u0028_();
    target_ = _e271;
    let _e272 = target_;
    let _e274 = target_;
    if ((_e272 > 0.5f) && (_e274 < 1.5f)) {
        local_40 = 1f;
    } else {
        let _e278 = (*s_10).occlusion;
        local_40 = _e278;
    }
    let _e279 = local_40;
    local_41 = _e279;
    let _e280 = local_41;
    return _e280;
}

fn DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) -> f32 {
    var local_42: f32;
    var local_43: f32;

    let _e270 = OcclusionTarget_u0028_();
    if (_e270 > 1.5f) {
        local_42 = 1f;
    } else {
        let _e273 = (*s_11).occlusion;
        local_42 = _e273;
    }
    let _e274 = local_42;
    local_43 = _e274;
    let _e275 = local_43;
    return _e275;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_203: f32;
    var param_204: f32;
    var param_205: f32;
    var param_206: vec3<f32>;
    var param_207: f32;

    let _e276 = (*mu_1);
    param_203 = _e276;
    let _e277 = (*r_4);
    param_204 = _e277;
    let _e278 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_203), (&param_204));
    e_1 = _e278;
    let _e279 = (*rho_2);
    let _e280 = e_1;
    let _e282 = (*r_4);
    param_205 = _e282;
    let _e283 = FonAverage_u0028_f1_u003b((&param_205));
    let _e284 = (*rho_2);
    param_206 = _e284;
    param_207 = _e283;
    let _e285 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_206), (&param_207));
    let _e286 = e_1;
    return ((_e279 * _e280) + (_e285 * (1f - _e286)));
}

fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shift: ptr<function, vec3<f32>>) -> vec3<f32> {
    var phase: f32;
    var val: vec3<f32>;
    var pos: vec3<f32>;
    var variance_1: vec3<f32>;
    var xyz: vec3<f32>;

    let _e274 = (*opd);
    phase = ((6.2831855f * _e274) * 0.000000001f);
    val = vec3<f32>(0.00000000000054856f, 0.00000000000044201f, 0.00000000000052481f);
    pos = vec3<f32>(1681000f, 1795300f, 2208400f);
    variance_1 = vec3<f32>(4327800000f, 9304600000f, 6612100000f);
    let _e277 = val;
    let _e278 = variance_1;
    let _e282 = pos;
    let _e283 = phase;
    let _e285 = (*shift);
    let _e289 = phase;
    let _e290 = phase;
    let _e293 = variance_1;
    xyz = (((_e277 * sqrt((_e278 * 6.2831855f))) * cos(((_e282 * _e283) + _e285))) * exp((_e293 * -((_e289 * _e290)))));
    let _e297 = phase;
    let _e300 = (*shift)[0u];
    let _e304 = phase;
    let _e306 = phase;
    let _e311 = xyz[0u];
    xyz[0u] = (_e311 + ((0.00000001644083f * cos(((2239900f * _e297) + _e300))) * exp(((-4528200000f * _e304) * _e306))));
    let _e314 = xyz;
    xyz = (_e314 / vec3(0.00000010685f));
    let _e317 = xyz;
    return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e317);
}

fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<function, f32>, cos1_: ptr<function, f32>, thickness: ptr<function, f32>, base: ptr<function, vec3<f32>>) -> vec3<f32> {
    var eta2_: f32;
    var sin2Sq: f32;
    var cos2Sq: f32;
    var cos2_: f32;
    var r0_: f32;
    var r12_: f32;
    var t121_: f32;
    var phi12_: f32;
    var phi21_: f32;
    var sqrtBase: vec3<f32>;
    var baseIor: vec3<f32>;
    var r1_: vec3<f32>;
    var r23_: vec3<f32>;
    var phi23_: vec3<f32>;
    var opd_1: f32;
    var phi: vec3<f32>;
    var r123_: vec3<f32>;
    var rootR123_: vec3<f32>;
    var rs: vec3<f32>;
    var total_2: vec3<f32>;
    var cm: vec3<f32>;
    var m_1: i32;
    var param_208: f32;
    var param_209: vec3<f32>;
    var local_44: vec3<f32>;

    let _e296 = (*film);
    let _e297 = (*thickness);
    eta2_ = mix(1f, _e296, smoothstep(0f, 0.03f, _e297));
    let _e300 = (*cos1_);
    let _e301 = (*cos1_);
    let _e304 = eta2_;
    let _e305 = eta2_;
    sin2Sq = ((1f - (_e300 * _e301)) / (_e304 * _e305));
    let _e308 = sin2Sq;
    cos2Sq = (1f - _e308);
    let _e310 = cos2Sq;
    cos2_ = sqrt(max(_e310, 0f));
    let _e313 = eta2_;
    let _e315 = eta2_;
    r0_ = ((_e313 - 1f) / (_e315 + 1f));
    let _e318 = r0_;
    let _e319 = r0_;
    let _e321 = r0_;
    let _e322 = r0_;
    let _e325 = (*cos1_);
    r12_ = ((_e318 * _e319) + ((1f - (_e321 * _e322)) * pow((1f - _e325), 5f)));
    let _e330 = r12_;
    t121_ = (1f - _e330);
    let _e332 = eta2_;
    phi12_ = select(0f, 3.1415927f, (_e332 < 1f));
    let _e335 = phi12_;
    phi21_ = (3.1415927f - _e335);
    let _e337 = (*base);
    sqrtBase = sqrt(clamp(_e337, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
    let _e340 = sqrtBase;
    let _e342 = sqrtBase;
    baseIor = ((vec3<f32>(1f, 1f, 1f) + _e340) / (vec3<f32>(1f, 1f, 1f) - _e342));
    let _e345 = baseIor;
    let _e346 = eta2_;
    let _e349 = baseIor;
    let _e350 = eta2_;
    r1_ = ((_e345 - vec3(_e346)) / (_e349 + vec3(_e350)));
    let _e354 = r1_;
    let _e355 = r1_;
    r1_ = (_e355 * _e354);
    let _e357 = r1_;
    let _e358 = r1_;
    let _e360 = cos2_;
    r23_ = (_e357 + ((vec3<f32>(1f, 1f, 1f) - _e358) * pow((1f - _e360), 5f)));
    let _e366 = baseIor[0u];
    let _e367 = eta2_;
    let _e371 = baseIor[1u];
    let _e372 = eta2_;
    let _e376 = baseIor[2u];
    let _e377 = eta2_;
    phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e366 < _e367)), select(0f, 3.1415927f, (_e371 < _e372)), select(0f, 3.1415927f, (_e376 < _e377)));
    let _e381 = eta2_;
    let _e383 = (*thickness);
    let _e385 = cos2_;
    opd_1 = (((2f * _e381) * _e383) * _e385);
    let _e387 = phi21_;
    let _e389 = phi23_;
    phi = (vec3(_e387) + _e389);
    let _e391 = r12_;
    let _e392 = r23_;
    r123_ = clamp((_e392 * _e391), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
    let _e395 = r123_;
    rootR123_ = sqrt(_e395);
    let _e397 = t121_;
    let _e398 = t121_;
    let _e400 = r23_;
    let _e402 = r123_;
    rs = ((_e400 * (_e397 * _e398)) / (vec3<f32>(1f, 1f, 1f) - _e402));
    let _e405 = r12_;
    let _e407 = rs;
    total_2 = (vec3(_e405) + _e407);
    let _e409 = rs;
    let _e410 = t121_;
    cm = (_e409 - vec3(_e410));
    m_1 = 1i;
    loop {
        let _e413 = m_1;
        if (_e413 <= 2i) {
            let _e415 = rootR123_;
            let _e416 = cm;
            cm = (_e416 * _e415);
            let _e418 = cm;
            let _e420 = m_1;
            let _e422 = opd_1;
            let _e424 = m_1;
            let _e426 = phi;
            param_208 = (f32(_e420) * _e422);
            param_209 = (_e426 * f32(_e424));
            let _e428 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((&param_208), (&param_209));
            let _e430 = total_2;
            total_2 = (_e430 + ((_e418 * 2f) * _e428));
            continue;
        } else {
            break;
        }
        continuing {
            let _e432 = m_1;
            m_1 = (_e432 + 1i);
        }
    }
    let _e434 = cos2Sq;
    if (_e434 < 0f) {
        local_44 = vec3<f32>(1f, 1f, 1f);
    } else {
        let _e436 = total_2;
        local_44 = max(_e436, vec3<f32>(0f, 0f, 0f));
    }
    let _e438 = local_44;
    return _e438;
}

fn ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
    var f0_3: vec3<f32>;
    var param_210: f32;
    var param_211: f32;
    var param_212: f32;
    var param_213: vec3<f32>;

    let _e273 = g_f0_dielectric;
    let _e275 = (*s_12).albedo;
    let _e277 = (*s_12).metallic;
    f0_3 = mix(_e273, _e275, vec3(clamp(_e277, 0f, 1f)));
    let _e283 = layer_info.iridescence[1u];
    param_210 = _e283;
    let _e285 = (*s_12).n_dot_v;
    param_211 = _e285;
    let _e288 = layer_info.iridescence[2u];
    param_212 = _e288;
    let _e289 = f0_3;
    param_213 = _e289;
    let _e290 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((&param_210), (&param_211), (&param_212), (&param_213));
    g_irid_fresnel = _e290;
    return;
}

fn ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var param_214: f32;
    var param_215: f32;
    var param_216: f32;
    var t_2: vec3<f32>;
    var usable: bool;
    var local_45: vec3<f32>;
    var b_4: vec3<f32>;
    var turn_2: vec2<f32>;
    var along_1: vec3<f32>;
    var local_46: f32;
    var local_47: vec3<f32>;
    var phi_5055_: bool;

    let _e280 = (*s_13).n_dot_v;
    let _e284 = g_sheen_roughness;
    param_214 = _e284;
    param_215 = sqrt(clamp((1f - _e280), 0f, 1f));
    param_216 = 1f;
    let _e285 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_214), (&param_215), (&param_216));
    let _e286 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e285, 0f);
    g_sheen_albedo = _e286.z;
    let _e289 = g_sheen[0u];
    let _e291 = g_sheen[1u];
    let _e294 = g_sheen[2u];
    let _e296 = g_sheen_albedo;
    g_sheen_scale = (1f - (max(max(_e289, _e291), _e294) * _e296));
    let _e299 = v_tangent_1;
    let _e302 = (*s_13).n;
    let _e304 = (*s_13).n;
    let _e305 = v_tangent_1;
    t_2 = (_e299.xyz - (_e302 * dot(_e304, _e305.xyz)));
    let _e310 = t_2;
    let _e311 = t_2;
    usable = (dot(_e310, _e311) > 0.000000000001f);
    let _e314 = usable;
    if _e314 {
        let _e315 = t_2;
        local_45 = normalize(_e315);
    } else {
        local_45 = vec3<f32>(1f, 0f, 0f);
    }
    let _e317 = local_45;
    t_2 = _e317;
    let _e319 = (*s_13).n;
    let _e320 = t_2;
    let _e323 = v_tangent_1[3u];
    b_4 = (cross(_e319, _e320) * _e323);
    let _e325 = gl_FrontFacing_1;
    if !(_e325) {
        let _e327 = t_2;
        t_2 = -(_e327);
    }
    let _e330 = layer_info.anisotropy;
    turn_2 = _e330.yz;
    let _e332 = t_2;
    let _e334 = turn_2[0u];
    let _e336 = b_4;
    let _e338 = turn_2[1u];
    along_1 = ((_e332 * _e334) + (_e336 * _e338));
    let _e341 = usable;
    phi_5055_ = _e341;
    if _e341 {
        let _e342 = along_1;
        let _e343 = along_1;
        phi_5055_ = (dot(_e342, _e343) > 0.000000000001f);
    }
    let _e347 = phi_5055_;
    if _e347 {
        let _e350 = layer_info.anisotropy[0u];
        local_46 = clamp(_e350, 0f, 1f);
    } else {
        local_46 = 0f;
    }
    let _e352 = local_46;
    g_aniso = _e352;
    let _e353 = g_aniso;
    if (_e353 > 0f) {
        let _e355 = along_1;
        local_47 = normalize(_e355);
    } else {
        let _e357 = t_2;
        local_47 = _e357;
    }
    let _e358 = local_47;
    g_aniso_t = _e358;
    let _e360 = (*s_13).n;
    let _e361 = g_aniso_t;
    g_aniso_b = cross(_e360, _e361);
    return;
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e269 = frag_info.target_origin[1u];
    return _e269;
}

fn MapUv_u0028_i1_u003b(slot_6: ptr<function, i32>) -> vec2<f32> {
    var uvw: vec3<f32>;

    let _e269 = v_texcoord_1;
    uvw = vec3<f32>(_e269.x, _e269.y, 1f);
    let _e273 = (*slot_6);
    let _e277 = layer_info.uv_transform[(_e273 * 2i)];
    let _e279 = uvw;
    let _e281 = (*slot_6);
    let _e286 = layer_info.uv_transform[((_e281 * 2i) + 1i)];
    let _e288 = uvw;
    return vec2<f32>(dot(_e277.xyz, _e279), dot(_e286.xyz, _e288));
}

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_14: ptr<function, Surface>) {
    var orm: vec3<f32>;
    var param_217: i32;

    param_217 = 1i;
    let _e270 = MapUv_u0028_i1_u003b((&param_217));
    let _e271 = MaterialLodBias_u0028_();
    let _e272 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e270, _e271);
    orm = _e272.xyz;
    let _e275 = (*s_14).metallic;
    let _e277 = orm[2u];
    (*s_14).metallic = clamp((_e275 * _e277), 0f, 1f);
    let _e282 = (*s_14).roughness;
    let _e284 = orm[1u];
    (*s_14).roughness = clamp((_e282 * _e284), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e268 = (*srgb);
    let _e271 = (*srgb);
    let _e276 = (*srgb);
    return mix((_e268 / vec3(12.92f)), pow(((_e271 + 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), _e276));
}

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_15: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_218: i32;
    var param_219: vec3<f32>;

    param_218 = 4i;
    let _e271 = MapUv_u0028_i1_u003b((&param_218));
    let _e272 = MaterialLodBias_u0028_();
    let _e273 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e271, _e272);
    param_219 = _e273.xyz;
    let _e275 = SrgbToLinear_u0028_vf3_u003b((&param_219));
    emissive = _e275;
    let _e276 = emissive;
    let _e278 = frag_info.emissive;
    let _e283 = frag_info.material2_[3u];
    (*s_15).emissive = ((_e276 * _e278.xyz) * _e283);
    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_16: ptr<function, Surface>) {
    var occlusion: f32;
    var param_220: i32;
    var strength_2: f32;

    param_220 = 3i;
    let _e271 = MapUv_u0028_i1_u003b((&param_220));
    let _e272 = MaterialLodBias_u0028_();
    let _e273 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e271, _e272);
    occlusion = _e273.x;
    let _e277 = frag_info.material2_[2u];
    let _e278 = OcclusionTarget_u0028_();
    strength_2 = (_e277 - (2f * _e278));
    let _e281 = occlusion;
    let _e282 = strength_2;
    (*s_16).occlusion = mix(1f, _e281, clamp(_e282, 0f, 1f));
    return;
}

fn MapMatrix_u0028_i1_u003b(slot_7: ptr<function, i32>) -> vec4<f32> {
    var u_2: vec4<f32>;
    var v_3: vec4<f32>;

    let _e270 = (*slot_7);
    let _e274 = layer_info.uv_transform[(_e270 * 2i)];
    u_2 = _e274;
    let _e275 = (*slot_7);
    let _e280 = layer_info.uv_transform[((_e275 * 2i) + 1i)];
    v_3 = _e280;
    let _e282 = u_2[0u];
    let _e284 = u_2[1u];
    let _e286 = v_3[0u];
    let _e288 = v_3[1u];
    return vec4<f32>(_e282, _e284, _e286, _e288);
}

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_17: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var param_221: i32;
    var t_3: vec3<f32>;
    var b_5: vec3<f32>;
    var m_2: vec4<f32>;
    var param_222: i32;
    var det: f32;
    var flip: f32;
    var front: vec3<f32>;
    var local_48: vec3<f32>;
    var turned: vec3<f32>;
    var turns: bool;
    var local_49: vec3<f32>;
    var local_50: vec3<f32>;
    var sampled: vec3<f32>;
    var phi_3721_: bool;
    var phi_3728_: bool;
    var phi_3735_: bool;
    var phi_3742_: bool;

    param_221 = 2i;
    let _e283 = MapUv_u0028_i1_u003b((&param_221));
    let _e284 = MaterialLodBias_u0028_();
    let _e285 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e283, _e284);
    sampledTexel = _e285;
    let _e286 = v_tangent_1;
    t_3 = _e286.xyz;
    let _e288 = t_3;
    let _e290 = (*s_17).n;
    let _e292 = (*s_17).n;
    let _e293 = t_3;
    t_3 = (_e288 - (_e290 * dot(_e292, _e293)));
    let _e297 = t_3;
    let _e298 = t_3;
    if (dot(_e297, _e298) < 0.000000000001f) {
        return;
    }
    let _e301 = t_3;
    t_3 = normalize(_e301);
    let _e304 = (*s_17).n;
    let _e305 = t_3;
    let _e308 = v_tangent_1[3u];
    b_5 = (cross(_e304, _e305) * _e308);
    param_222 = 2i;
    let _e310 = MapMatrix_u0028_i1_u003b((&param_222));
    m_2 = _e310;
    let _e312 = m_2[0u];
    let _e314 = m_2[3u];
    let _e317 = m_2[1u];
    let _e319 = m_2[2u];
    det = ((_e312 * _e314) - (_e317 * _e319));
    let _e322 = det;
    flip = select(1f, -1f, (_e322 < 0f));
    let _e325 = gl_FrontFacing_1;
    if _e325 {
        let _e326 = b_5;
        local_48 = _e326;
    } else {
        let _e327 = b_5;
        local_48 = -(_e327);
    }
    let _e329 = local_48;
    front = _e329;
    let _e330 = t_3;
    let _e332 = m_2[3u];
    let _e334 = front;
    let _e336 = m_2[2u];
    let _e339 = flip;
    turned = (((_e330 * _e332) + (_e334 * _e336)) * _e339);
    let _e342 = m_2[1u];
    let _e343 = (_e342 != 0f);
    phi_3721_ = _e343;
    if !(_e343) {
        let _e346 = m_2[2u];
        phi_3721_ = (_e346 != 0f);
    }
    let _e349 = phi_3721_;
    phi_3728_ = _e349;
    if !(_e349) {
        let _e352 = m_2[0u];
        phi_3728_ = (_e352 < 0f);
    }
    let _e355 = phi_3728_;
    phi_3735_ = _e355;
    if !(_e355) {
        let _e358 = m_2[3u];
        phi_3735_ = (_e358 < 0f);
    }
    let _e361 = phi_3735_;
    phi_3742_ = _e361;
    if _e361 {
        let _e362 = turned;
        let _e363 = turned;
        phi_3742_ = (dot(_e362, _e363) > 0.000000000001f);
    }
    let _e367 = phi_3742_;
    turns = _e367;
    let _e368 = turns;
    if _e368 {
        let _e369 = turned;
        local_49 = normalize(_e369);
    } else {
        let _e371 = t_3;
        local_49 = _e371;
    }
    let _e372 = local_49;
    t_3 = _e372;
    let _e373 = turns;
    if _e373 {
        let _e375 = (*s_17).n;
        let _e376 = t_3;
        let _e379 = v_tangent_1[3u];
        let _e381 = flip;
        local_50 = ((cross(_e375, _e376) * _e379) * _e381);
    } else {
        let _e383 = b_5;
        local_50 = _e383;
    }
    let _e384 = local_50;
    b_5 = _e384;
    let _e385 = gl_FrontFacing_1;
    if !(_e385) {
        let _e387 = t_3;
        t_3 = -(_e387);
    }
    let _e389 = sampledTexel;
    sampled = ((_e389.xyz * 2f) - vec3(1f));
    let _e396 = frag_info.emissive[3u];
    if (_e396 > 0.5f) {
        let _e398 = sampled;
        let _e400 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e398.xy, _e400.xy)), 0f));
    }
    let _e409 = frag_info.material2_[1u];
    let _e410 = sampled;
    let _e412 = (_e410.xy * _e409);
    sampled[0u] = _e412.x;
    sampled[1u] = _e412.y;
    let _e417 = t_3;
    let _e419 = sampled[0u];
    let _e421 = b_5;
    let _e423 = sampled[1u];
    let _e427 = (*s_17).n;
    let _e429 = sampled[2u];
    (*s_17).n = normalize((((_e417 * _e419) + (_e421 * _e423)) + (_e427 * _e429)));
    let _e435 = (*s_17).n;
    let _e437 = (*s_17).v;
    (*s_17).n_dot_v = max(dot(_e435, _e437), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e268 = (*texel_5);
    let _e272 = irradiance_info.atlas;
    let _e275 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e268 + vec2(0.5f)) * _e272.xy), 0f);
    return _e275;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_8: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_5: vec2<f32>;
    var low: vec2<f32>;
    var f_5: vec2<f32>;
    var a_6: vec4<f32>;
    var param_223: vec2<f32>;
    var b_6: vec4<f32>;
    var param_224: vec2<f32>;
    var c: vec4<f32>;
    var param_225: vec2<f32>;
    var d_6: vec4<f32>;
    var param_226: vec2<f32>;

    let _e281 = (*uv_8);
    let _e282 = (*interior);
    at_5 = ((vec2(1f) + (_e281 * _e282)) - vec2(0.5f));
    let _e288 = at_5;
    low = floor(_e288);
    let _e290 = at_5;
    let _e291 = low;
    f_5 = (_e290 - _e291);
    let _e293 = (*corner);
    let _e294 = low;
    param_223 = (_e293 + _e294);
    let _e296 = AtlasTexel_u0028_vf2_u003b((&param_223));
    a_6 = _e296;
    let _e297 = (*corner);
    let _e298 = low;
    param_224 = ((_e297 + _e298) + vec2<f32>(1f, 0f));
    let _e301 = AtlasTexel_u0028_vf2_u003b((&param_224));
    b_6 = _e301;
    let _e302 = (*corner);
    let _e303 = low;
    param_225 = ((_e302 + _e303) + vec2<f32>(0f, 1f));
    let _e306 = AtlasTexel_u0028_vf2_u003b((&param_225));
    c = _e306;
    let _e307 = (*corner);
    let _e308 = low;
    param_226 = ((_e307 + _e308) + vec2<f32>(1f, 1f));
    let _e311 = AtlasTexel_u0028_vf2_u003b((&param_226));
    d_6 = _e311;
    let _e312 = a_6;
    let _e313 = b_6;
    let _e315 = f_5[0u];
    let _e318 = c;
    let _e319 = d_6;
    let _e321 = f_5[0u];
    let _e325 = f_5[1u];
    return mix(mix(_e312, _e313, vec4(_e315)), mix(_e318, _e319, vec4(_e321)), vec4(_e325));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e272 = (*direction_1)[0u];
    let _e275 = (*direction_1)[1u];
    let _e279 = (*direction_1)[2u];
    sum_1 = ((abs(_e272) + abs(_e275)) + abs(_e279));
    let _e282 = sum_1;
    if (_e282 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e284 = (*direction_1);
    let _e285 = sum_1;
    n_6 = (_e284 / vec3(_e285));
    let _e288 = n_6;
    xy = _e288.xy;
    let _e291 = n_6[2u];
    if (_e291 < 0f) {
        let _e294 = n_6[1u];
        let _e298 = n_6[0u];
        let _e303 = n_6[0u];
        let _e307 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e294)) * select(-1f, 1f, (_e298 >= 0f))), ((1f - abs(_e303)) * select(-1f, 1f, (_e307 >= 0f))));
    }
    let _e312 = xy;
    return ((_e312 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base_1: vec3<f32>;
    var f_6: vec3<f32>;
    var total_3: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_227: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_228: vec3<f32>;
    var param_229: vec2<f32>;
    var param_230: f32;
    var param_231: vec2<f32>;
    var chebyshev: f32;
    var variance_2: f32;
    var difference: f32;
    var param_232: vec3<f32>;
    var param_233: vec2<f32>;
    var param_234: f32;
    var param_235: vec2<f32>;
    var local_51: vec3<f32>;

    let _e314 = irradiance_info.origin;
    origin_2 = _e314.xyz;
    let _e317 = irradiance_info.spacing;
    spacing = _e317.xyz;
    let _e320 = irradiance_info.counts;
    counts = _e320.xyz;
    let _e324 = irradiance_info.tiles[0u];
    irradianceTile = _e324;
    let _e327 = irradiance_info.tiles[1u];
    depthTile = _e327;
    let _e330 = irradiance_info.tiles[2u];
    columns = _e330;
    let _e333 = irradiance_info.tiles[3u];
    momentsTop = _e333;
    let _e334 = (*normal_1);
    unit = normalize(_e334);
    let _e336 = (*world_5);
    let _e337 = unit;
    let _e340 = irradiance_info.spacing[3u];
    let _e343 = (*view_1);
    let _e346 = irradiance_info.counts[3u];
    biased = ((_e336 + (_e337 * _e340)) + (_e343 * _e346));
    let _e349 = biased;
    let _e350 = origin_2;
    let _e352 = spacing;
    grid_1 = ((_e349 - _e350) / _e352);
    let _e354 = grid_1;
    let _e356 = counts;
    base_1 = clamp(floor(_e354), vec3<f32>(0f, 0f, 0f), (_e356 - vec3(2f)));
    let _e360 = grid_1;
    let _e361 = base_1;
    f_6 = clamp((_e360 - _e361), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_3 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e364 = corner_1;
        if (_e364 < 8i) {
            let _e366 = corner_1;
            let _e369 = corner_1;
            let _e374 = corner_1;
            offset_3 = vec3<f32>(f32((_e366 & 1i)), f32(((_e369 >> bitcast<u32>(1i)) & 1i)), f32(((_e374 >> bitcast<u32>(2i)) & 1i)));
            let _e380 = base_1;
            let _e381 = offset_3;
            cell_1 = (_e380 + _e381);
            let _e384 = cell_1[2u];
            let _e386 = counts[1u];
            let _e389 = cell_1[1u];
            let _e392 = counts[0u];
            let _e395 = cell_1[0u];
            probe = ((((_e384 * _e386) + _e389) * _e392) + _e395);
            let _e397 = probe;
            let _e398 = columns;
            let _e403 = probe;
            let _e404 = columns;
            tile_4 = vec2<f32>((_e397 - (floor((_e397 / _e398)) * _e398)), floor((_e403 / _e404)));
            let _e408 = tile_4;
            let _e409 = irradianceTile;
            irradianceCorner = (_e408 * (_e409 + 2f));
            let _e413 = tile_4[0u];
            let _e414 = depthTile;
            let _e417 = momentsTop;
            let _e419 = tile_4[1u];
            let _e420 = depthTile;
            momentCorner = vec2<f32>((_e413 * (_e414 + 2f)), (_e417 + (_e419 * (_e420 + 2f))));
            let _e425 = irradianceCorner;
            param_227 = (_e425 + vec2(1f));
            let _e428 = AtlasTexel_u0028_vf2_u003b((&param_227));
            if (_e428.w < 0.5f) {
                continue;
            }
            let _e431 = f_6;
            let _e433 = f_6;
            let _e434 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e431), _e433, _e434);
            let _e437 = trilinear[0u];
            let _e439 = trilinear[1u];
            let _e442 = trilinear[2u];
            weight_2 = max(((_e437 * _e439) * _e442), 0.001f);
            let _e445 = origin_2;
            let _e446 = spacing;
            let _e447 = cell_1;
            probePosition = (_e445 + (_e446 * _e447));
            let _e450 = probePosition;
            let _e451 = biased;
            toProbe = (_e450 - _e451);
            let _e453 = toProbe;
            distance_4 = length(_e453);
            let _e455 = distance_4;
            if (_e455 > 0.000001f) {
                let _e457 = toProbe;
                let _e458 = distance_4;
                direction_2 = (_e457 / vec3(_e458));
                let _e461 = unit;
                let _e462 = probePosition;
                let _e463 = (*world_5);
                facing = ((dot(_e461, normalize((_e462 - _e463))) * 0.5f) + 0.5f);
                let _e469 = facing;
                let _e470 = facing;
                probeWeight = ((_e469 * _e470) + 0.2f);
                let _e473 = direction_2;
                param_228 = -(_e473);
                let _e475 = ProbeOctahedral_u0028_vf3_u003b((&param_228));
                let _e476 = momentCorner;
                param_229 = _e476;
                let _e477 = depthTile;
                param_230 = _e477;
                param_231 = _e475;
                let _e478 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_229), (&param_230), (&param_231));
                moments_3 = _e478.xy;
                chebyshev = 1f;
                let _e480 = distance_4;
                let _e482 = moments_3[0u];
                if (_e480 > _e482) {
                    let _e485 = moments_3[1u];
                    let _e487 = moments_3[0u];
                    let _e489 = moments_3[0u];
                    variance_2 = max((_e485 - (_e487 * _e489)), 0.000001f);
                    let _e493 = distance_4;
                    let _e495 = moments_3[0u];
                    difference = (_e493 - _e495);
                    let _e497 = variance_2;
                    let _e498 = variance_2;
                    let _e499 = difference;
                    let _e500 = difference;
                    chebyshev = (_e497 / (_e498 + (_e499 * _e500)));
                    let _e504 = chebyshev;
                    let _e505 = chebyshev;
                    let _e507 = chebyshev;
                    chebyshev = ((_e504 * _e505) * _e507);
                }
                let _e509 = probeWeight;
                let _e510 = chebyshev;
                probeWeight = max((_e509 * max(_e510, 0.05f)), 0.000001f);
                let _e514 = probeWeight;
                if (_e514 < 0.2f) {
                    let _e516 = probeWeight;
                    let _e517 = probeWeight;
                    let _e520 = probeWeight;
                    probeWeight = (_e520 * ((_e516 * _e517) * 25f));
                }
                let _e522 = probeWeight;
                let _e523 = weight_2;
                weight_2 = (_e523 * _e522);
            }
            let _e525 = unit;
            param_232 = _e525;
            let _e526 = ProbeOctahedral_u0028_vf3_u003b((&param_232));
            let _e527 = irradianceCorner;
            param_233 = _e527;
            let _e528 = irradianceTile;
            param_234 = _e528;
            param_235 = _e526;
            let _e529 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_233), (&param_234), (&param_235));
            let _e531 = weight_2;
            let _e533 = total_3;
            total_3 = (_e533 + (_e529.xyz * _e531));
            let _e535 = weight_2;
            let _e536 = weights;
            weights = (_e536 + _e535);
            continue;
        } else {
            break;
        }
        continuing {
            let _e538 = corner_1;
            corner_1 = (_e538 + 1i);
        }
    }
    let _e540 = weights;
    if (_e540 > 0f) {
        let _e542 = total_3;
        let _e543 = weights;
        local_51 = (_e542 / vec3(_e543));
    } else {
        local_51 = vec3<f32>(0f, 0f, 0f);
    }
    let _e546 = local_51;
    return _e546;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e269 = irradiance_info.origin[3u];
    return (_e269 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_18: ptr<function, Surface>) {
    var param_236: vec3<f32>;
    var param_237: vec3<f32>;
    var param_238: vec3<f32>;
    var param_239: Surface;
    var param_240: Surface;
    var param_241: Surface;

    let _e274 = IrradianceEnabled_u0028_();
    if _e274 {
        let _e275 = v_world_position_1;
        param_236 = _e275;
        let _e277 = (*s_18).n;
        param_237 = _e277;
        let _e279 = (*s_18).v;
        param_238 = _e279;
        let _e280 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_236), (&param_237), (&param_238));
        let _e283 = frag_info.material[2u];
        (*s_18).ambient = (_e280 * _e283);
    }
    let _e286 = (*s_18);
    param_239 = _e286;
    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((&param_239));
    let _e287 = param_239;
    (*s_18) = _e287;
    let _e288 = (*s_18);
    param_240 = _e288;
    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((&param_240));
    let _e289 = param_240;
    (*s_18) = _e289;
    let _e290 = (*s_18);
    param_241 = _e290;
    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((&param_241));
    let _e291 = param_241;
    (*s_18) = _e291;
    return;
}

fn ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_19: ptr<function, Surface>) {
    var coatTexel: vec4<f32>;
    var sheenTexel: vec4<f32>;
    var param_242: vec3<f32>;
    var ior_3: f32;
    var r_5: f32;
    var local_52: f32;
    var bent: vec3<f32>;
    var distance_5: f32;
    var local_53: vec3<f32>;
    var fc: f32;

    let _e278 = v_texcoord_1;
    let _e279 = MaterialLodBias_u0028_();
    let _e280 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e278, _e279);
    coatTexel = _e280;
    let _e281 = v_texcoord_1;
    let _e282 = MaterialLodBias_u0028_();
    let _e283 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e281, _e282);
    sheenTexel = _e283;
    let _e285 = layer_info.sheen;
    let _e287 = sheenTexel;
    param_242 = _e287.xyz;
    let _e289 = SrgbToLinear_u0028_vf3_u003b((&param_242));
    g_sheen = (_e285.xyz * _e289);
    let _e293 = layer_info.sheen[3u];
    let _e295 = sheenTexel[3u];
    g_sheen_roughness = clamp((_e293 * _e295), 0.07f, 1f);
    let _e300 = layer_info.coat[2u];
    ior_3 = max(_e300, 1f);
    let _e302 = IorInfinite_u0028_();
    if _e302 {
        local_52 = 1f;
    } else {
        let _e303 = ior_3;
        let _e305 = ior_3;
        local_52 = ((_e303 - 1f) / (_e305 + 1f));
    }
    let _e308 = local_52;
    r_5 = _e308;
    let _e309 = r_5;
    let _e310 = r_5;
    let _e314 = layer_info.specular;
    let _e320 = layer_info.specular[3u];
    g_f0_dielectric = (min((vec3((_e309 * _e310)) * _e314.xyz), vec3<f32>(1f, 1f, 1f)) * _e320);
    let _e324 = layer_info.specular[3u];
    g_f90_ = _e324;
    let _e327 = layer_info.coat[0u];
    let _e329 = coatTexel[0u];
    g_coat = clamp((_e327 * _e329), 0f, 1f);
    let _e334 = layer_info.coat[1u];
    let _e336 = coatTexel[1u];
    g_coat_roughness = clamp((_e334 * _e336), 0.02f, 1f);
    let _e341 = layer_info.transmission[0u];
    let _e343 = coatTexel[2u];
    g_transmission = clamp((_e341 * _e343), 0f, 1f);
    let _e348 = layer_info.transmission[1u];
    let _e350 = coatTexel[3u];
    g_thickness = max((_e348 * _e350), 0f);
    let _e355 = layer_info.attenuation[3u];
    let _e357 = g_thickness;
    if ((_e355 > 0.5f) && (_e357 > 0f)) {
        let _e361 = (*s_19).v;
        let _e364 = (*s_19).n;
        let _e365 = RefractionIor_u0028_();
        bent = refract(-(_e361), _e364, (1f / _e365));
        let _e368 = g_thickness;
        let _e370 = (*s_19).n;
        let _e371 = bent;
        let _e376 = g_thickness;
        g_thickness = max((_e368 * max(-(dot(_e370, _e371)), 0f)), (0.0001f * _e376));
    }
    let _e381 = layer_info.transmission[2u];
    distance_5 = _e381;
    let _e382 = distance_5;
    if (_e382 > 0f) {
        let _e385 = layer_info.attenuation;
        let _e388 = g_thickness;
        let _e389 = distance_5;
        local_53 = pow(max(_e385.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e388 / _e389)));
    } else {
        local_53 = vec3<f32>(1f, 1f, 1f);
    }
    let _e393 = local_53;
    g_transmittance = _e393;
    let _e396 = layer_info.iridescence[0u];
    g_iridescence = clamp(_e396, 0f, 1f);
    let _e399 = (*s_19).n;
    g_coat_n = _e399;
    let _e401 = (*s_19).n;
    let _e403 = (*s_19).v;
    g_coat_n_dot_v = max(dot(_e401, _e403), 0.0001f);
    let _e406 = g_coat_n_dot_v;
    fc = (0.04f + (0.96f * pow((1f - _e406), 5f)));
    let _e411 = g_coat;
    let _e412 = fc;
    g_coat_through = (1f - (_e411 * _e412));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_54: vec3<f32>;

    let _e268 = Orthographic_u0028_();
    if _e268 {
        let _e270 = fog_info.forward;
        local_54 = -(_e270.xyz);
    } else {
        let _e274 = fog_info.eye;
        let _e276 = v_world_position_1;
        local_54 = normalize((_e274.xyz - _e276));
    }
    let _e279 = local_54;
    return _e279;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var p3_: vec3<f32>;

    let _e273 = (*cutoff);
    key = (-2f - _e273);
    let _e275 = key;
    let _e278 = key;
    let _e280 = floor((_e278 / 128f));
    let _e285 = key;
    origin_3 = vec3<f32>(floor((_e275 / 16384f)), (_e280 - (floor((_e280 / 128f)) * 128f)), (_e285 - (floor((_e285 / 128f)) * 128f)));
    let _e291 = (*scenePosition);
    let _e294 = origin_3;
    let _e295 = (floor((_e291 * 16f)) + _e294);
    let _e296 = vec3(128f);
    cell_2 = (_e295 - (floor((_e295 / _e296)) * _e296));
    let _e301 = cell_2;
    p3_ = fract((_e301 * 0.1031f));
    let _e304 = p3_;
    let _e305 = p3_;
    let _e310 = p3_;
    p3_ = (_e310 + vec3(dot(_e304, (_e305.zyx + vec3(31.32f)))));
    let _e314 = p3_[0u];
    let _e316 = p3_[1u];
    let _e319 = p3_[2u];
    return fract(((_e314 + _e316) * _e319));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var param_243: i32;
    var s_20: Surface;
    var param_244: vec3<f32>;
    var param_245: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_246: vec3<f32>;
    var param_247: f32;

    param_243 = 0i;
    let _e276 = MapUv_u0028_i1_u003b((&param_243));
    let _e277 = MaterialLodBias_u0028_();
    let _e278 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e276, _e277);
    texel_6 = _e278;
    let _e279 = texel_6;
    param_244 = _e279.xyz;
    let _e281 = SrgbToLinear_u0028_vf3_u003b((&param_244));
    let _e283 = frag_info.base_color;
    param_245 = _e283.xyz;
    let _e285 = SrgbToLinear_u0028_vf3_u003b((&param_245));
    let _e287 = v_color_1;
    s_20.albedo = ((_e281 * _e285) * _e287.xyz);
    let _e292 = texel_6[3u];
    let _e295 = frag_info.base_color[3u];
    let _e298 = v_color_1[3u];
    s_20.alpha = ((_e292 * _e295) * _e298);
    let _e302 = s_20.albedo;
    g_albedo = _e302;
    let _e305 = frag_info.material2_[0u];
    cutoff_1 = _e305;
    let _e306 = cutoff_1;
    if (_e306 > 1f) {
        let _e308 = cutoff_1;
        edge = (_e308 - 1f);
        let _e311 = s_20.alpha;
        let _e312 = edge;
        let _e315 = s_20.alpha;
        let _e316 = fwidth(_e315);
        s_20.alpha = clamp((((_e311 - _e312) / max(_e316, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e322 = cutoff_1;
        if (_e322 >= 0f) {
            let _e325 = s_20.alpha;
            let _e326 = cutoff_1;
            if (_e325 < _e326) {
                discard;
            }
            s_20.alpha = 1f;
        } else {
            let _e329 = cutoff_1;
            if (_e329 < -1.5f) {
                let _e332 = s_20.alpha;
                let _e333 = v_world_position_1;
                param_246 = _e333;
                let _e334 = cutoff_1;
                param_247 = _e334;
                let _e335 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_246), (&param_247));
                if (_e332 < _e335) {
                    discard;
                }
            }
        }
    }
    let _e337 = cutoff_1;
    let _e339 = cutoff_1;
    g_premultiply = ((_e337 < 0f) && (_e339 > -0.75f));
    let _e342 = v_normal_1;
    s_20.n = normalize(_e342);
    let _e345 = gl_FrontFacing_1;
    if !(_e345) {
        let _e348 = s_20.n;
        s_20.n = -(_e348);
    }
    let _e351 = TowardsEye_u0028_();
    s_20.v = _e351;
    let _e354 = s_20.n;
    let _e356 = s_20.v;
    s_20.n_dot_v = max(dot(_e354, _e356), 0.0001f);
    let _e362 = frag_info.material[0u];
    s_20.metallic = clamp(_e362, 0f, 1f);
    let _e367 = frag_info.material[1u];
    s_20.roughness = clamp(_e367, 0.02f, 1f);
    let _e371 = frag_info.ambient_ground;
    let _e374 = frag_info.ambient_sky;
    let _e378 = s_20.n[1u];
    let _e385 = frag_info.material[2u];
    s_20.ambient = (mix(_e371.xyz, _e374.xyz, vec3(((_e378 * 0.5f) + 0.5f))) * _e385);
    let _e390 = frag_info.frame_params[0u];
    s_20.exposure = max(_e390, 0f);
    s_20.occlusion = 1f;
    s_20.emissive = vec3<f32>(0f, 0f, 0f);
    let _e395 = s_20;
    return _e395;
}

fn main_1() {
    var s_21: Surface;
    var param_248: Surface;
    var param_249: Surface;
    var param_250: Surface;
    var param_251: Surface;
    var param_252: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_253: vec3<f32>;
    var param_254: f32;
    var param_255: f32;
    var directOcclusion: f32;
    var param_256: Surface;
    var indirectOcclusion: f32;
    var param_257: Surface;
    var ambient: vec3<f32>;
    var levels_1: f32;
    var coatAmbient: vec3<f32>;
    var sheenIncoming: vec3<f32>;
    var f0_4: vec3<f32>;
    var f90_2: f32;
    var bent_1: vec3<f32>;
    var across: vec3<f32>;
    var anisoN: vec3<f32>;
    var bend: f32;
    var bend4_: f32;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_4: vec2<f32>;
    var param_258: f32;
    var param_259: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var reflects: vec3<f32>;
    var through_1: vec3<f32>;
    var local_55: vec3<f32>;
    var param_260: Surface;
    var param_261: f32;
    var coatPrefiltered: vec3<f32>;
    var coatAb: vec2<f32>;
    var param_262: f32;
    var param_263: f32;
    var sceneAb: vec2<f32>;
    var param_264: f32;
    var param_265: f32;
    var sceneReflects: vec3<f32>;
    var passes: vec3<f32>;
    var param_266: Surface;
    var sheenAmbient: vec3<f32>;
    var lit_2: vec3<f32>;
    var param_267: Surface;
    var param_268: vec3<f32>;
    var param_269: f32;
    var param_270: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    g_f0_dielectric = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_f90_ = 1f;
    g_coat = 0f;
    g_coat_roughness = 0.02f;
    g_coat_n = vec3<f32>(0f, 0f, 1f);
    g_coat_n_dot_v = 1f;
    g_coat_through = 1f;
    g_sheen = vec3<f32>(0f, 0f, 0f);
    g_sheen_roughness = 0.07f;
    g_sheen_albedo = 0f;
    g_sheen_scale = 1f;
    g_aniso = 0f;
    g_aniso_t = vec3<f32>(1f, 0f, 0f);
    g_aniso_b = vec3<f32>(0f, 1f, 0f);
    g_transmission = 0f;
    g_thickness = 0f;
    g_transmittance = vec3<f32>(1f, 1f, 1f);
    g_iridescence = 0f;
    g_irid_fresnel = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_pane = false;
    let _e325 = ReadSurface_u0028_();
    s_21 = _e325;
    let _e326 = s_21;
    param_248 = _e326;
    ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_248));
    let _e327 = s_21;
    param_249 = _e327;
    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((&param_249));
    let _e328 = param_249;
    s_21 = _e328;
    let _e329 = s_21;
    param_250 = _e329;
    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((&param_250));
    let _e330 = param_250;
    s_21 = _e330;
    let _e331 = s_21;
    param_251 = _e331;
    ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_251));
    let _e332 = s_21;
    param_252 = _e332;
    ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_252));
    let _e334 = s_21.metallic;
    metallic = clamp(_e334, 0f, 1f);
    let _e337 = s_21.albedo;
    let _e338 = metallic;
    diffuseColor_1 = (_e337 * (1f - _e338));
    let _e341 = EonDiffuse_u0028_();
    if _e341 {
        let _e342 = diffuseColor_1;
        param_253 = _e342;
        let _e344 = s_21.roughness;
        param_254 = _e344;
        let _e346 = s_21.n_dot_v;
        param_255 = _e346;
        let _e347 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_253), (&param_254), (&param_255));
        diffuseColor_1 = _e347;
    }
    let _e348 = s_21;
    param_256 = _e348;
    let _e349 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_256));
    directOcclusion = _e349;
    let _e350 = s_21;
    param_257 = _e350;
    let _e351 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_257));
    indirectOcclusion = _e351;
    let _e352 = diffuseColor_1;
    let _e354 = s_21.ambient;
    let _e356 = indirectOcclusion;
    ambient = ((_e352 * _e354) * _e356);
    let _e358 = g_premultiply;
    let _e359 = g_transmission;
    let _e362 = g_thickness;
    g_pane = ((_e358 && (_e359 > 0f)) && (_e362 <= 0f));
    let _e365 = SceneColorBound_u0028_();
    let _e366 = g_pane;
    let _e368 = g_transmittance;
    let _e371 = g_transmission;
    let _e374 = ambient;
    ambient = (_e374 * mix(vec3<f32>(1f, 1f, 1f), select(_e368, vec3<f32>(0f, 0f, 0f), vec3((_e365 || _e366))), vec3(_e371)));
    let _e378 = frag_info.frame_params[3u];
    levels_1 = _e378;
    coatAmbient = vec3<f32>(0f, 0f, 0f);
    let _e380 = s_21.ambient;
    sheenIncoming = _e380;
    let _e381 = levels_1;
    if (_e381 > 0f) {
        let _e383 = g_f0_dielectric;
        let _e385 = s_21.albedo;
        let _e386 = metallic;
        f0_4 = mix(_e383, _e385, vec3(_e386));
        let _e389 = g_f90_;
        let _e390 = metallic;
        f90_2 = mix(_e389, 1f, _e390);
        let _e393 = s_21.n;
        bent_1 = _e393;
        let _e394 = g_aniso;
        if (_e394 > 0f) {
            let _e396 = g_aniso_t;
            let _e398 = s_21.v;
            across = cross(_e396, _e398);
            let _e400 = across;
            let _e401 = g_aniso_t;
            anisoN = cross(_e400, _e401);
            let _e403 = g_aniso;
            let _e405 = s_21.roughness;
            bend = (1f - (_e403 * (1f - _e405)));
            let _e409 = bend;
            let _e410 = bend;
            let _e412 = bend;
            let _e414 = bend;
            bend4_ = (((_e409 * _e410) * _e412) * _e414);
            let _e416 = anisoN;
            let _e418 = s_21.n;
            let _e419 = bend4_;
            bent_1 = normalize(mix(_e416, _e418, vec3(_e419)));
        }
        let _e424 = s_21.v;
        let _e426 = bent_1;
        reflected = reflect(-(_e424), _e426);
        let _e429 = s_21.n;
        let _e430 = levels_1;
        let _e431 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e429, _e430);
        irradiance = _e431.xyz;
        let _e433 = reflected;
        let _e435 = s_21.roughness;
        let _e436 = levels_1;
        let _e438 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e433, (_e435 * _e436));
        prefiltered = _e438.xyz;
        let _e441 = s_21.roughness;
        param_258 = _e441;
        let _e443 = s_21.n_dot_v;
        param_259 = _e443;
        let _e444 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_258), (&param_259));
        ab_4 = _e444;
        let _e445 = f0_4;
        let _e446 = g_irid_fresnel;
        let _e447 = g_iridescence;
        let _e451 = ab_4[0u];
        let _e453 = f90_2;
        let _e455 = ab_4[1u];
        single_1 = ((mix(_e445, _e446, vec3(_e447)) * _e451) + vec3((_e453 * _e455)));
        let _e459 = prefiltered;
        let _e460 = single_1;
        specular_1 = (_e459 * _e460);
        let _e462 = EnergyCompensation_u0028_();
        if _e462 {
            let _e464 = ab_4[0u];
            let _e466 = ab_4[1u];
            missed = (1f - (_e464 + _e466));
            let _e469 = f0_4;
            let _e470 = f0_4;
            average_2 = (_e469 + ((vec3<f32>(1f, 1f, 1f) - _e470) / vec3(21f)));
            let _e475 = single_1;
            let _e476 = average_2;
            let _e478 = missed;
            let _e479 = average_2;
            multiple = ((_e475 * _e476) / (vec3<f32>(1f, 1f, 1f) - (_e479 * _e478)));
            let _e483 = multiple;
            let _e484 = missed;
            let _e486 = irradiance;
            let _e488 = specular_1;
            specular_1 = (_e488 + ((_e483 * _e484) * _e486));
        }
        let _e490 = diffuseColor_1;
        let _e491 = irradiance;
        let _e493 = specular_1;
        let _e497 = frag_info.material[2u];
        let _e499 = indirectOcclusion;
        ambient = ((((_e490 * _e491) + _e493) * _e497) * _e499);
        let _e501 = g_f0_dielectric;
        let _e502 = g_irid_fresnel;
        let _e503 = g_iridescence;
        let _e507 = ab_4[0u];
        let _e509 = g_f90_;
        let _e511 = ab_4[1u];
        reflects = ((mix(_e501, _e502, vec3(_e503)) * _e507) + vec3((_e509 * _e511)));
        let _e515 = SceneColorBound_u0028_();
        let _e516 = g_pane;
        if (_e515 || _e516) {
            local_55 = vec3<f32>(0f, 0f, 0f);
        } else {
            let _e518 = s_21;
            param_260 = _e518;
            let _e519 = levels_1;
            param_261 = _e519;
            let _e520 = TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b((&param_260), (&param_261));
            let _e521 = g_transmittance;
            let _e523 = reflects;
            local_55 = ((_e520 * _e521) * (vec3<f32>(1f, 1f, 1f) - min(_e523, vec3<f32>(1f, 1f, 1f))));
        }
        let _e527 = local_55;
        through_1 = _e527;
        let _e528 = diffuseColor_1;
        let _e529 = through_1;
        let _e530 = irradiance;
        let _e533 = g_transmission;
        let _e537 = frag_info.material[2u];
        let _e539 = indirectOcclusion;
        let _e541 = ambient;
        ambient = (_e541 + ((((_e528 * (_e529 - _e530)) * _e533) * _e537) * _e539));
        let _e544 = s_21.v;
        let _e546 = g_coat_n;
        let _e548 = g_coat_roughness;
        let _e549 = levels_1;
        let _e551 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e544), _e546), (_e548 * _e549));
        coatPrefiltered = _e551.xyz;
        let _e553 = g_coat_roughness;
        param_262 = _e553;
        let _e554 = g_coat_n_dot_v;
        param_263 = _e554;
        let _e555 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_262), (&param_263));
        coatAb = _e555;
        let _e556 = coatPrefiltered;
        let _e558 = coatAb[0u];
        let _e561 = coatAb[1u];
        let _e564 = g_coat;
        let _e568 = frag_info.material[2u];
        let _e570 = indirectOcclusion;
        coatAmbient = ((((_e556 * ((0.04f * _e558) + _e561)) * _e564) * _e568) * _e570);
        let _e573 = s_21.n;
        let _e574 = g_sheen_roughness;
        let _e575 = levels_1;
        let _e577 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e573, (_e574 * _e575));
        let _e581 = frag_info.material[2u];
        sheenIncoming = (_e577.xyz * _e581);
    }
    let _e584 = s_21.roughness;
    param_264 = _e584;
    let _e586 = s_21.n_dot_v;
    param_265 = _e586;
    let _e587 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_264), (&param_265));
    sceneAb = _e587;
    let _e588 = g_f0_dielectric;
    let _e589 = g_irid_fresnel;
    let _e590 = g_iridescence;
    let _e594 = sceneAb[0u];
    let _e596 = g_f90_;
    let _e598 = sceneAb[1u];
    sceneReflects = ((mix(_e588, _e589, vec3(_e590)) * _e594) + vec3((_e596 * _e598)));
    let _e602 = diffuseColor_1;
    let _e603 = g_transmittance;
    let _e605 = sceneReflects;
    let _e609 = g_transmission;
    passes = (((_e602 * _e603) * (vec3<f32>(1f, 1f, 1f) - min(_e605, vec3<f32>(1f, 1f, 1f)))) * _e609);
    let _e611 = g_pane;
    if _e611 {
        let _e613 = passes[0u];
        let _e615 = passes[1u];
        let _e618 = passes[2u];
        g_pass_through = clamp((((_e613 + _e615) + _e618) / 3f), 0f, 1f);
    } else {
        let _e622 = SceneColorBound_u0028_();
        if _e622 {
            let _e623 = s_21;
            param_266 = _e623;
            let _e624 = SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_266));
            let _e625 = passes;
            let _e627 = ambient;
            ambient = (_e627 + (_e624 * _e625));
        }
    }
    let _e629 = diffuseColor_1;
    let _e630 = SampleLightmap_u0028_();
    let _e632 = indirectOcclusion;
    let _e634 = ambient;
    ambient = (_e634 + ((_e629 * _e630) * _e632));
    let _e636 = g_sheen;
    let _e637 = g_sheen_albedo;
    let _e639 = sheenIncoming;
    let _e641 = indirectOcclusion;
    sheenAmbient = (((_e636 * _e637) * _e639) * _e641);
    let _e643 = s_21;
    param_267 = _e643;
    let _e644 = 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((&param_267));
    let _e645 = directOcclusion;
    let _e647 = ambient;
    let _e648 = g_sheen_scale;
    let _e650 = sheenAmbient;
    let _e653 = s_21.emissive;
    let _e655 = g_coat_through;
    let _e658 = coatAmbient;
    lit_2 = (((_e644 * _e645) + ((((_e647 * _e648) + _e650) + _e653) * _e655)) + _e658);
    let _e660 = lit_2;
    param_268 = _e660;
    let _e662 = s_21.alpha;
    param_269 = _e662;
    let _e664 = s_21.roughness;
    param_270 = _e664;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_268), (&param_269), (&param_270));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(5) v_texcoord: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    v_texcoord_1 = v_texcoord;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LayerInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 464,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'specular',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'coat', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'sheen',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'anisotropy',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'transmission',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'attenuation',
              offsetInBytes: 80,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'iridescence',
              offsetInBytes: 96,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'uv_transform',
              offsetInBytes: 112,
              sizeInBytes: 160,
            ),
            WebGpuBlockMember(
              name: 'scene_color',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_viewport',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_levels',
              offsetInBytes: 304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scene_view_projection',
              offsetInBytes: 400,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 4,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 5,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'coat_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 16,
          samplerBinding: 17,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 18,
          samplerBinding: 19,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 20,
          samplerBinding: 21,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 22,
          samplerBinding: 23,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 24,
          samplerBinding: 25,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 26,
          samplerBinding: 27,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 28,
          samplerBinding: 29,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 30,
          samplerBinding: 31,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_color_texture',
          group: 1,
          textureBinding: 32,
          samplerBinding: 33,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 34,
          samplerBinding: 35,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'sheen_texture',
          group: 1,
          textureBinding: 36,
          samplerBinding: 37,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Toon': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e182 = v_world_position_1;
    let _e184 = fog_info.eye;
    let _e188 = fog_info.forward;
    return dot((_e182 - _e184.xyz), _e188.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e187 = ViewDepth_u0028_();
    z = abs(_e187);
    let _e189 = z;
    near = (_e189 / 5f);
    let _e191 = z;
    far = (_e191 / 200f);
    let _e193 = far;
    let _e194 = far;
    let _e196 = far;
    far3_ = ((_e193 * _e194) * _e196);
    let _e198 = (*alpha);
    let _e199 = near;
    let _e200 = near;
    let _e203 = far3_;
    let _e204 = far3_;
    return (_e198 * clamp((10f / ((0.00001f + (_e199 * _e200)) + (_e203 * _e204))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e191 = fog_info.forward[3u];
    mode = _e191;
    let _e192 = mode;
    if (_e192 > 0.5f) {
        let _e195 = frag_color[3u];
        alpha_1 = _e195;
        let _e196 = alpha_1;
        param = _e196;
        let _e197 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e197;
        let _e198 = frag_color;
        let _e200 = weight;
        let _e201 = (_e198.xyz * _e200);
        let _e202 = alpha_1;
        let _e203 = weight;
        accumulate = vec4<f32>(_e201.x, _e201.y, _e201.z, (_e202 * _e203));
        let _e209 = mode;
        let _e211 = mode;
        revealage = ((_e209 > 1.5f) && (_e211 < 2.5f));
        let _e214 = revealage;
        if _e214 {
            let _e215 = alpha_1;
            local = vec4(_e215);
        } else {
            let _e217 = accumulate;
            local = _e217;
        }
        let _e218 = local;
        frag_color = _e218;
        let _e219 = mode;
        if (_e219 > 2.5f) {
            let _e221 = alpha_1;
            frag_surface = vec4(_e221);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e185 = (*n)[0u];
    let _e188 = (*n)[1u];
    let _e192 = (*n)[2u];
    let _e195 = (*n);
    (*n) = (_e195 / vec3(((abs(_e185) + abs(_e188)) + abs(_e192))));
    let _e198 = (*n);
    e = _e198.xy;
    let _e201 = (*n)[2u];
    if (_e201 < 0f) {
        let _e203 = (*n);
        let _e209 = (*n)[0u];
        let _e213 = (*n)[1u];
        e = ((vec2(1f) - abs(_e203.yx)) * vec2<f32>(select(-1f, 1f, (_e209 >= 0f)), select(-1f, 1f, (_e213 >= 0f))));
    }
    let _e218 = e;
    return ((_e218 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e183 = (*linear);
    let _e185 = (*linear);
    let _e189 = (*linear);
    return mix((_e183 * 12.92f), ((pow(_e185, 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), _e189));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e186 = g_albedo;
    param_1 = clamp(_e186, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e188 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e188.x, _e188.y, _e188.z, 1f);
    let _e193 = g_debug_surface_on;
    if _e193 {
        let _e194 = g_debug_surface;
        let _e195 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e194.x, _e194.y, _e194.z, _e195);
        return;
    }
    let _e200 = v_normal_1;
    geometric = normalize(_e200);
    let _e202 = gl_FrontFacing_1;
    if !(_e202) {
        let _e204 = geometric;
        geometric = -(_e204);
    }
    let _e206 = geometric;
    param_2 = _e206;
    let _e207 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e208 = (*roughness);
    let _e210 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e207.x, _e207.y, clamp(_e208, 0f, 1f), _e210);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e184 = fog_info.projection[0u];
    return (_e184 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e183 = Orthographic_u0028_();
    if _e183 {
        let _e184 = ViewDepth_u0028_();
        local_1 = max(_e184, 0f);
    } else {
        let _e186 = v_world_position_1;
        let _e188 = fog_info.eye;
        local_1 = distance(_e186, _e188.xyz);
    }
    let _e191 = local_1;
    return _e191;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e190 = fog_info.fog[3u];
    density = _e190;
    let _e191 = density;
    if (_e191 <= 0f) {
        let _e193 = (*color);
        return _e193;
    }
    let _e194 = EyeDistance_u0028_();
    d = _e194;
    let _e197 = fog_info.eye[3u];
    falloff = _e197;
    let _e198 = falloff;
    if (_e198 > 0f) {
        let _e200 = falloff;
        let _e202 = v_world_position_1[1u];
        let _e205 = fog_info.eye[1u];
        k = (_e200 * (_e202 - _e205));
        let _e208 = k;
        if (abs(_e208) > 0.001f) {
            let _e211 = k;
            let _e215 = k;
            local_2 = ((1f - exp(-(_e211))) / _e215);
        } else {
            let _e217 = k;
            local_2 = (1f - (0.5f * _e217));
        }
        let _e220 = local_2;
        let _e221 = density;
        density = (_e221 * _e220);
    }
    let _e224 = fog_info.fog;
    let _e226 = (*color);
    let _e227 = density;
    let _e229 = d;
    return mix(_e224.xyz, _e226, vec3(clamp(exp((-(_e227) * _e229)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e188 = g_premultiply;
    let _e189 = (*alpha_2);
    weight_1 = select(1f, _e189, _e188);
    let _e191 = (*linearColor);
    param_3 = _e191;
    let _e192 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e193 = weight_1;
    let _e194 = (_e192 * _e193);
    let _e195 = (*alpha_2);
    let _e196 = g_pass_through;
    frag_color = vec4<f32>(_e194.x, _e194.y, _e194.z, (_e195 * (1f - _e196)));
    let _e203 = (*roughness_1);
    param_4 = _e203;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_3: f32;

    let _e185 = frag_info.material2_[2u];
    local_3 = floor((_e185 * 0.5f));
    let _e188 = local_3;
    return _e188;
}

fn DirectOcclusion_u0028_struct_u002d_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: ptr<function, Surface>) -> f32 {
    var local_4: f32;
    var local_5: f32;

    let _e185 = OcclusionTarget_u0028_();
    if (_e185 > 1.5f) {
        local_4 = 1f;
    } else {
        let _e188 = (*s).occlusion;
        local_4 = _e188;
    }
    let _e189 = local_4;
    local_5 = _e189;
    let _e190 = local_5;
    return _e190;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var bands: f32;
    var quantized: f32;
    var fraction: f32;
    var ramp: f32;

    let _e189 = (*s_1).roughness;
    bands = mix(5f, 2f, _e189);
    let _e192 = (*light).n_dot_l;
    let _e193 = bands;
    let _e196 = bands;
    quantized = (floor((_e192 * _e193)) / _e196);
    let _e199 = (*light).n_dot_l;
    let _e200 = bands;
    fraction = fract((_e199 * _e200));
    let _e203 = fraction;
    let _e205 = bands;
    let _e207 = quantized;
    quantized = (_e207 + (smoothstep(0.85f, 1f, _e203) / _e205));
    let _e209 = quantized;
    let _e211 = (*light).n_dot_l;
    ramp = (_e209 / max(_e211, 0.001f));
    let _e215 = (*s_1).albedo;
    let _e216 = ramp;
    return (_e215 * _e216);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e183 = (*i);
    if (_e183 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e185 = (*i);
    if (_e185 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e187 = (*i);
    if (_e187 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e189 = (*i);
    if (_e189 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e191 = (*i);
    if (_e191 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e193 = (*i);
    if (_e193 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e195 = (*i);
    if (_e195 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e188 = (*i_1);
    param_5 = _e188;
    let _e189 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e189;
    let _e191 = p[0u];
    let _e192 = (*ca);
    let _e195 = p[1u];
    let _e196 = (*sa);
    let _e200 = p[0u];
    let _e201 = (*sa);
    let _e204 = p[1u];
    let _e205 = (*ca);
    let _e209 = (*radius);
    return (vec2<f32>(((_e191 * _e192) - (_e195 * _e196)), ((_e200 * _e201) + (_e204 * _e205))) * _e209);
}

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_6: vec2<f32>;
    var atlas: vec2<f32>;

    let _e191 = point_shadow.params[0u];
    inset = _e191;
    let _e192 = (*uv);
    let _e193 = (*offset);
    let _e195 = inset;
    let _e196 = inset;
    local_6 = clamp((_e192 + _e193), vec2(_e195), vec2((1f - _e196)));
    let _e201 = local_6;
    let _e202 = (*tile);
    atlas = ((_e201 + _e202) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e207 = point_shadow.params3_[0u];
    if (_e207 > 0.5f) {
        let _e210 = atlas[1u];
        atlas[1u] = (1f - _e210);
    }
    let _e213 = atlas;
    let _e214 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e213, 0f);
    let _e216 = atlas;
    let _e217 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e216, 0f);
    let _e220 = (*range);
    return (min(_e214.x, _e217.x) * _e220);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e192 = (*uv_1);
    param_6 = _e192;
    let _e193 = (*offset_1);
    param_7 = _e193;
    let _e194 = (*tile_1);
    param_8 = _e194;
    let _e195 = (*range_1);
    param_9 = _e195;
    let _e196 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e196;
    let _e197 = stored;
    let _e198 = (*range_1);
    if (_e197 >= (_e198 * 0.999f)) {
        return 1f;
    }
    let _e201 = (*receiver);
    let _e202 = stored;
    return select(1f, 0f, (_e201 > _e202));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e213 = point_shadow.params2_[1u];
    lightRadius = _e213;
    let _e216 = point_shadow.params2_[0u];
    minRadius = _e216;
    let _e219 = point_shadow.params2_[2u];
    maxRadius = _e219;
    let _e220 = lightRadius;
    if (_e220 <= 0f) {
        let _e222 = (*uv_2);
        param_10 = _e222;
        param_11 = vec2<f32>(0f, 0f);
        let _e223 = (*tile_2);
        param_12 = _e223;
        let _e224 = (*range_2);
        param_13 = _e224;
        let _e225 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e225;
        let _e226 = minRadius;
        return _e226;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e227 = i_2;
        if (_e227 < 8i) {
            let _e229 = i_2;
            param_14 = _e229;
            let _e230 = (*ca_1);
            param_15 = _e230;
            let _e231 = (*sa_1);
            param_16 = _e231;
            let _e232 = maxRadius;
            param_17 = _e232;
            let _e233 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e234 = (*uv_2);
            param_18 = _e234;
            param_19 = _e233;
            let _e235 = (*tile_2);
            param_20 = _e235;
            let _e236 = (*range_2);
            param_21 = _e236;
            let _e237 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e237;
            let _e238 = stored_1;
            let _e239 = (*range_2);
            if (_e238 >= (_e239 * 0.999f)) {
                continue;
            }
            let _e242 = stored_1;
            let _e243 = (*receiver_1);
            if (_e242 >= _e243) {
                continue;
            }
            let _e245 = stored_1;
            let _e246 = sum;
            sum = (_e246 + _e245);
            let _e248 = count;
            count = (_e248 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e250 = i_2;
            i_2 = (_e250 + 1i);
        }
    }
    let _e252 = count;
    if (_e252 < 0.5f) {
        return -1f;
    }
    let _e254 = sum;
    let _e255 = count;
    blocker = max((_e254 / _e255), 0.0001f);
    let _e258 = blocker;
    (*blockerOut) = _e258;
    let _e259 = lightRadius;
    let _e260 = (*receiver_1);
    let _e261 = blocker;
    let _e265 = blocker;
    world = ((_e259 * max((_e260 - _e261), 0f)) / _e265);
    let _e267 = world;
    let _e268 = (*receiver_1);
    let _e270 = (*tanHalf);
    let _e273 = minRadius;
    let _e274 = maxRadius;
    return clamp((_e267 / ((2f * _e268) * _e270)), _e273, _e274);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_7: vec2<f32>;

    let _e184 = (*rows);
    if (_e184 > 0f) {
        let _e187 = gl_FragCoord_1[0u];
        let _e188 = (*rows);
        let _e190 = gl_FragCoord_1[1u];
        local_7 = vec2<f32>(_e187, (_e188 - _e190));
    } else {
        let _e193 = gl_FragCoord_1;
        local_7 = _e193.xy;
    }
    let _e195 = local_7;
    return _e195;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_8: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2322_: bool;
    var phi_2383_: bool;

    let _e236 = (*lightIndex);
    let _e240 = point_shadow.slots[_e236][0u];
    slot = i32((_e240 + 0.5f));
    let _e243 = (*lightIndex);
    let _e247 = point_shadow.slots[_e243][0u];
    if (_e247 < 0f) {
        return 1f;
    }
    let _e251 = point_shadow.params[2u];
    strength = _e251;
    let _e252 = strength;
    if (_e252 <= 0f) {
        return 1f;
    }
    let _e254 = slot;
    let _e257 = point_shadow.lights[_e254];
    let _e259 = (*world_1);
    toLight = (_e257.xyz - _e259);
    let _e261 = toLight;
    toLightLength = max(length(_e261), 0.000001f);
    let _e264 = (*normal);
    let _e265 = toLight;
    let _e266 = toLightLength;
    nDotL = max(dot(_e264, (_e265 / vec3(_e266))), 0.15f);
    let _e271 = nDotL;
    let _e272 = nDotL;
    let _e277 = nDotL;
    let _e278 = nDotL;
    slope = min((sqrt(max((1f - (_e271 * _e272)), 0f)) / (_e277 * _e278)), 8f);
    let _e282 = toLightLength;
    let _e284 = (*lightIndex);
    let _e288 = point_shadow.slots[_e284][2u];
    let _e293 = point_shadow.params3_[1u];
    texel = (((2f * _e282) * max(_e288, 0.0001f)) * _e293);
    let _e295 = (*world_1);
    let _e296 = (*normal);
    let _e297 = texel;
    let _e301 = point_shadow.params[3u];
    let _e303 = slope;
    origin = (_e295 + (((_e296 * _e297) * _e301) * (1f + _e303)));
    let _e307 = origin;
    let _e308 = slot;
    let _e311 = point_shadow.lights[_e308];
    toFragment = (_e307 - _e311.xyz);
    let _e314 = toFragment;
    distance_ = length(_e314);
    let _e316 = slot;
    let _e320 = point_shadow.lights[_e316][3u];
    range_3 = max(_e320, 0.0001f);
    let _e322 = distance_;
    let _e323 = range_3;
    if (_e322 >= _e323) {
        return 1f;
    }
    face = 0i;
    let _e325 = (*lightIndex);
    let _e329 = point_shadow.slots[_e325][1u];
    if (_e329 < 0.5f) {
        let _e331 = toFragment;
        a = abs(_e331);
        let _e334 = a[0u];
        let _e336 = a[1u];
        let _e337 = (_e334 >= _e336);
        phi_2322_ = _e337;
        if _e337 {
            let _e339 = a[0u];
            let _e341 = a[2u];
            phi_2322_ = (_e339 >= _e341);
        }
        let _e344 = phi_2322_;
        if _e344 {
            let _e346 = toFragment[0u];
            face = select(1i, 0i, (_e346 > 0f));
        } else {
            let _e350 = a[1u];
            let _e352 = a[2u];
            if (_e350 >= _e352) {
                let _e355 = toFragment[1u];
                face = select(3i, 2i, (_e355 > 0f));
            } else {
                let _e359 = toFragment[2u];
                face = select(5i, 4i, (_e359 > 0f));
            }
        }
    }
    let _e362 = slot;
    let _e364 = face;
    let _e368 = point_shadow.faces[((_e362 * 6i) + _e364)];
    let _e369 = origin;
    clip = (_e368 * vec4<f32>(_e369.x, _e369.y, _e369.z, 1f));
    let _e376 = clip[3u];
    if (_e376 <= 0f) {
        return 1f;
    }
    let _e378 = clip;
    let _e381 = clip[3u];
    ndc = (_e378.xy / vec2(_e381));
    let _e385 = ndc[0u];
    let _e387 = (abs(_e385) > 1f);
    phi_2383_ = _e387;
    if !(_e387) {
        let _e390 = ndc[1u];
        phi_2383_ = (abs(_e390) > 1f);
    }
    let _e394 = phi_2383_;
    if _e394 {
        return 1f;
    }
    let _e396 = ndc[0u];
    let _e400 = ndc[1u];
    uv_3 = vec2<f32>(((_e396 * 0.5f) + 0.5f), (0.5f - (_e400 * 0.5f)));
    let _e404 = face;
    let _e406 = slot;
    tile_3 = vec2<f32>(f32(_e404), f32(_e406));
    let _e409 = distance_;
    let _e412 = point_shadow.params[1u];
    receiver_2 = (_e409 - _e412);
    let _e416 = frag_info.target_origin[0u];
    param_22 = _e416;
    let _e417 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e417, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e422 = noise;
    angle = (_e422 * 6.2831855f);
    let _e424 = angle;
    ca_2 = cos(_e424);
    let _e426 = angle;
    sa_2 = sin(_e426);
    let _e428 = (*lightIndex);
    let _e432 = point_shadow.slots[_e428][2u];
    tanHalf_1 = max(_e432, 0.0001f);
    blocker_1 = -1f;
    let _e434 = uv_3;
    param_23 = _e434;
    let _e435 = tile_3;
    param_24 = _e435;
    let _e436 = range_3;
    param_25 = _e436;
    let _e437 = receiver_2;
    param_26 = _e437;
    let _e438 = ca_2;
    param_27 = _e438;
    let _e439 = sa_2;
    param_28 = _e439;
    let _e440 = tanHalf_1;
    param_29 = _e440;
    let _e441 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e442 = param_30;
    blocker_1 = _e442;
    radius_1 = _e441;
    let _e445 = point_shadow.params2_[3u];
    if (_e445 > 0.5f) {
        g_debug_surface_on = true;
        let _e447 = radius_1;
        if (_e447 < 0f) {
            local_8 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e449 = radius_1;
            let _e452 = point_shadow.params2_[2u];
            let _e456 = blocker_1;
            let _e457 = range_3;
            local_8 = vec3<f32>(clamp((_e449 / max(_e452, 0.000001f)), 0f, 1f), clamp((_e456 / _e457), 0f, 1f), 0f);
        }
        let _e461 = local_8;
        g_debug_surface = _e461;
    }
    let _e462 = radius_1;
    if (_e462 < 0f) {
        return 1f;
    }
    let _e464 = uv_3;
    param_31 = _e464;
    param_32 = vec2<f32>(0f, 0f);
    let _e465 = tile_3;
    param_33 = _e465;
    let _e466 = range_3;
    param_34 = _e466;
    let _e467 = receiver_2;
    param_35 = _e467;
    let _e468 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e468;
    let _e469 = radius_1;
    if (_e469 > 0f) {
        i_3 = 0i;
        loop {
            let _e471 = i_3;
            if (_e471 < 8i) {
                let _e473 = i_3;
                param_36 = _e473;
                let _e474 = ca_2;
                param_37 = _e474;
                let _e475 = sa_2;
                param_38 = _e475;
                let _e476 = radius_1;
                param_39 = _e476;
                let _e477 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e478 = uv_3;
                param_40 = _e478;
                param_41 = _e477;
                let _e479 = tile_3;
                param_42 = _e479;
                let _e480 = range_3;
                param_43 = _e480;
                let _e481 = receiver_2;
                param_44 = _e481;
                let _e482 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e483 = lit;
                lit = (_e483 + _e482);
                continue;
            } else {
                break;
            }
            continuing {
                let _e485 = i_3;
                i_3 = (_e485 + 1i);
            }
        }
        let _e487 = lit;
        lit = (_e487 * 0.11111111f);
    }
    let _e489 = lit;
    let _e490 = strength;
    return mix(1f, _e489, clamp(_e490, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e187 = (*i_4);
    let _e190 = (*n_1);
    r = sqrt(((f32(_e187) + 0.5f) / f32(_e190)));
    let _e194 = (*i_4);
    let _e197 = (*turn);
    theta = ((f32(_e194) * 2.3999631f) + _e197);
    let _e199 = r;
    let _e200 = theta;
    let _e202 = theta;
    return (vec2<f32>(cos(_e200), sin(_e202)) * _e199);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e186 = frag_info.target_origin[0u];
    param_45 = _e186;
    let _e187 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e190 = frag_info.target_origin[3u];
    at = (_e187 + vec2((5.588238f * max(_e190, 0f))));
    let _e195 = at;
    return fract((52.982918f * fract(dot(_e195, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_9: f32;

    let _e185 = (*mode_1);
    if (_e185 > 0.5f) {
        let _e187 = (*stored_2);
        local_9 = (1f - _e187);
    } else {
        let _e189 = (*stored_2);
        local_9 = _e189;
    }
    let _e190 = local_9;
    return _e190;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e191 = (*moments)[1u];
    let _e193 = (*moments)[0u];
    let _e195 = (*moments)[0u];
    let _e198 = (*minVariance);
    variance = max((_e191 - (_e193 * _e195)), _e198);
    let _e200 = (*t);
    let _e202 = (*moments)[0u];
    d_1 = (_e200 - _e202);
    let _e204 = variance;
    let _e205 = variance;
    let _e206 = d_1;
    let _e207 = d_1;
    pMax = (_e204 / (_e205 + (_e206 * _e207)));
    let _e211 = pMax;
    let _e212 = (*bleed);
    let _e214 = (*bleed);
    reduced = clamp(((_e211 - _e212) / max((1f - _e214), 0.0001f)), 0f, 1f);
    let _e219 = (*t);
    let _e221 = (*moments)[0u];
    let _e223 = reduced;
    return select(_e223, 1f, (_e219 <= _e221));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e184 = (*depth);
    d_2 = ((2f * clamp(_e184, 0f, 1f)) - 1f);
    let _e188 = d_2;
    let _e191 = d_2;
    return vec2<f32>(exp((40f * _e188)), -(exp((-5f * _e191))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e198 = (*depth_1);
    param_46 = _e198;
    let _e199 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e199;
    let _e200 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e200);
    let _e203 = scale[0u];
    let _e205 = scale[0u];
    let _e207 = (*moments_1);
    param_47 = _e207.xy;
    let _e210 = warped[0u];
    param_48 = _e210;
    param_49 = (_e203 * _e205);
    let _e211 = (*bleed_1);
    param_50 = _e211;
    let _e212 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e212;
    let _e214 = scale[1u];
    let _e216 = scale[1u];
    let _e218 = (*moments_1);
    param_51 = _e218.zw;
    let _e221 = warped[1u];
    param_52 = _e221;
    param_53 = (_e214 * _e216);
    let _e222 = (*bleed_1);
    param_54 = _e222;
    let _e223 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e223;
    let _e224 = positive;
    let _e225 = negative;
    return min(_e224, _e225);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e184 = (*depth_2);
    stored_3 = max((1f - _e184), 0.000061035156f);
    let _e187 = stored_3;
    return exp2((floor(log2(_e187)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_10: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_11: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_13: f32;
    var local_14: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_3519_: bool;
    var phi_3530_: bool;
    var phi_3691_: bool;
    var phi_3698_: bool;
    var phi_3705_: bool;

    let _e263 = frag_info.shadow_params[3u];
    strength_1 = _e263;
    let _e264 = strength_1;
    if (_e264 <= 0f) {
        return 1f;
    }
    let _e266 = (*lightIndex_1);
    let _e269 = frag_info.frame_params[2u];
    if (_e266 != i32(floor((_e269 + 0.5f)))) {
        return 1f;
    }
    let _e276 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e276 + 0.5f));
    let _e279 = Orthographic_u0028_();
    if _e279 {
        let _e280 = ViewDepth_u0028_();
        local_10 = _e280;
    } else {
        let _e281 = v_world_position_1;
        let _e283 = frag_info.camera_position;
        local_10 = length((_e281 - _e283.xyz));
    }
    let _e287 = local_10;
    viewDistance = _e287;
    cascade = 0i;
    let _e288 = cascadeCount;
    let _e289 = (_e288 > 1i);
    phi_3519_ = _e289;
    if _e289 {
        let _e290 = viewDistance;
        let _e293 = frag_info.shadow_cascades[0u];
        phi_3519_ = (_e290 > _e293);
    }
    let _e296 = phi_3519_;
    if _e296 {
        cascade = 1i;
    }
    let _e297 = cascadeCount;
    let _e298 = (_e297 > 2i);
    phi_3530_ = _e298;
    if _e298 {
        let _e299 = viewDistance;
        let _e302 = frag_info.shadow_cascades[1u];
        phi_3530_ = (_e299 > _e302);
    }
    let _e305 = phi_3530_;
    if _e305 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e306 = attempt;
        if (_e306 < 3i) {
            let _e308 = cascade;
            let _e309 = attempt;
            which = (_e308 + _e309);
            let _e311 = which;
            let _e312 = cascadeCount;
            if (_e311 >= _e312) {
                break;
            }
            let _e314 = which;
            if (_e314 == 0i) {
                let _e317 = frag_info.shadow_matrix;
                local_11 = _e317;
            } else {
                let _e318 = which;
                if (_e318 == 1i) {
                    let _e321 = frag_info.shadow_matrix_far;
                    local_12 = _e321;
                } else {
                    let _e323 = frag_info.shadow_matrix_farthest;
                    local_12 = _e323;
                }
                let _e324 = local_12;
                local_11 = _e324;
            }
            let _e325 = local_11;
            matrix = _e325;
            let _e328 = matrix[0][0u];
            let _e331 = matrix[1][0u];
            let _e334 = matrix[2][0u];
            axisX = vec3<f32>(_e328, _e331, _e334);
            let _e338 = matrix[0][1u];
            let _e341 = matrix[1][1u];
            let _e344 = matrix[2][1u];
            axisY = vec3<f32>(_e338, _e341, _e344);
            let _e346 = axisX;
            rowX = max(length(_e346), 0.000001f);
            let _e349 = axisY;
            rowY = max(length(_e349), 0.000001f);
            let _e354 = frag_info.shadow_cascades[3u];
            let _e356 = rowX;
            texelMetres = ((2f * _e354) / _e356);
            let _e360 = frag_info.shadow_cascades[3u];
            let _e363 = (*s_2).n;
            let _e364 = axisX;
            let _e367 = rowX;
            let _e368 = rowX;
            let _e372 = (*s_2).n;
            let _e373 = axisY;
            let _e376 = rowY;
            let _e377 = rowY;
            reach = ((3f * _e360) * ((abs(dot(_e363, _e364)) / (_e367 * _e368)) + (abs(dot(_e372, _e373)) / (_e376 * _e377))));
            let _e384 = frag_info.shadow_params[2u];
            let _e385 = texelMetres;
            flatOffset = min(_e384, _e385);
            let _e387 = v_world_position_1;
            let _e389 = (*s_2).n;
            let _e390 = flatOffset;
            let _e391 = reach;
            origin_1 = (_e387 + (_e389 * (_e390 + _e391)));
            let _e395 = matrix;
            let _e396 = origin_1;
            lightSpace = (_e395 * vec4<f32>(_e396.x, _e396.y, _e396.z, 1f));
            let _e403 = lightSpace[3u];
            if (_e403 <= 0f) {
                continue;
            }
            let _e405 = lightSpace;
            let _e408 = lightSpace[3u];
            candidate = (_e405.xyz / vec3(_e408));
            let _e412 = candidate[0u];
            let _e416 = candidate[1u];
            inTile = vec2<f32>(((_e412 * 0.5f) + 0.5f), (0.5f - (_e416 * 0.5f)));
            let _e421 = inTile[0u];
            let _e422 = (_e421 < 0f);
            phi_3691_ = _e422;
            if !(_e422) {
                let _e425 = inTile[0u];
                phi_3691_ = (_e425 > 1f);
            }
            let _e428 = phi_3691_;
            phi_3698_ = _e428;
            if !(_e428) {
                let _e431 = inTile[1u];
                phi_3698_ = (_e431 < 0f);
            }
            let _e434 = phi_3698_;
            phi_3705_ = _e434;
            if !(_e434) {
                let _e437 = inTile[1u];
                phi_3705_ = (_e437 > 1f);
            }
            let _e440 = phi_3705_;
            if _e440 {
                continue;
            }
            let _e442 = candidate[2u];
            if (_e442 > 1f) {
                let _e444 = which;
                let _e445 = cascadeCount;
                if (_e444 < (_e445 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e450 = inTile[0u];
            let _e451 = which;
            let _e454 = cascadeCount;
            let _e458 = inTile[1u];
            uv_4 = vec2<f32>(((_e450 + f32(_e451)) / f32(_e454)), _e458);
            let _e460 = candidate;
            projected = _e460;
            let _e461 = which;
            cascade = _e461;
            let _e462 = texelMetres;
            cascadeTexel = _e462;
            let _e465 = matrix[0][2u];
            let _e468 = matrix[1][2u];
            let _e471 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e465, _e468, _e471)), 0.000001f));
            let _e477 = (*s_2).n;
            let _e480 = matrix[0][2u];
            let _e483 = matrix[1][2u];
            let _e486 = matrix[2][2u];
            let _e490 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e477, vec3<f32>(_e480, _e483, _e486))) * _e490), 0.1f, 1f);
            let _e493 = texelMetres;
            let _e494 = cosSlope;
            let _e495 = cosSlope;
            let _e501 = cosSlope;
            let _e503 = cascadeDepth;
            receiverSlope = (((_e493 * sqrt(max((1f - (_e494 * _e495)), 0f))) / _e501) / _e503);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e505 = attempt;
            attempt = (_e505 + 1i);
        }
    }
    let _e507 = found;
    if !(_e507) {
        return 1f;
    }
    let _e509 = cascade;
    if (_e509 == 0i) {
        let _e513 = frag_info.shadow_bias[0u];
        local_13 = _e513;
    } else {
        let _e514 = cascade;
        if (_e514 == 1i) {
            let _e518 = frag_info.shadow_bias[1u];
            local_14 = _e518;
        } else {
            let _e521 = frag_info.shadow_bias[2u];
            local_14 = _e521;
        }
        let _e522 = local_14;
        local_13 = _e522;
    }
    let _e523 = local_13;
    bias = _e523;
    let _e526 = frag_info.shadow_params[1u];
    storage_ = _e526;
    let _e527 = storage_;
    let _e529 = storage_;
    if ((_e527 > 0.5f) && (_e529 < 1.5f)) {
        let _e532 = bias;
        let _e534 = projected[2u];
        param_55 = _e534;
        let _e535 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e532, _e535);
    }
    let _e539 = frag_info.shadow_params[0u];
    let _e542 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e539, _e542);
    let _e544 = cascade;
    let _e546 = cascadeCount;
    let _e550 = texel_1;
    tileLo = (vec2<f32>((f32(_e544) / f32(_e546)), 0f) + (_e550 * 0.5f));
    let _e553 = cascade;
    let _e556 = cascadeCount;
    let _e560 = texel_1;
    tileHi = (vec2<f32>((f32((_e553 + 1i)) / f32(_e556)), 1f) - (_e560 * 0.5f));
    let _e565 = frag_info.shadow_bias[3u];
    if (_e565 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e567 = y;
            if (_e567 <= 1i) {
                x = -1i;
                loop {
                    let _e569 = x;
                    if (_e569 <= 1i) {
                        let _e571 = uv_4;
                        let _e572 = x;
                        let _e574 = y;
                        let _e577 = texel_1;
                        let _e580 = tileLo;
                        let _e581 = tileHi;
                        let _e583 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e571 + (vec2<f32>(f32(_e572), f32(_e574)) * _e577)), _e580, _e581), 0f);
                        let _e584 = stored_4;
                        stored_4 = (_e584 + _e583);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e586 = x;
                        x = (_e586 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e588 = y;
                y = (_e588 + 1i);
            }
        }
        let _e590 = stored_4;
        stored_4 = (_e590 * 0.11111111f);
        let _e593 = stored_4[1u];
        let _e596 = stored_4[2u];
        let _e599 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e593), (1f - _e596), _e599), vec3(0f), vec3(4f));
        let _e604 = through;
        let _e605 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e604, vec3(clamp(_e605, 0f, 1f)));
    }
    let _e611 = frag_info.ambient_ground[3u];
    softness = _e611;
    lit_1 = 0f;
    let _e612 = softness;
    if (_e612 < 0f) {
        let _e614 = uv_4;
        let _e615 = tileLo;
        let _e616 = tileHi;
        let _e618 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e614, _e615, _e616), 0f);
        moments_2 = _e618;
        let _e620 = projected[2u];
        let _e621 = bias;
        let _e623 = softness;
        let _e627 = moments_2;
        param_56 = _e627;
        param_57 = (_e620 - _e621);
        param_58 = clamp((-(_e623) - 1f), 0f, 0.95f);
        let _e628 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e628;
    } else {
        let _e629 = softness;
        if (_e629 <= 0f) {
            y_1 = -1i;
            loop {
                let _e631 = y_1;
                if (_e631 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e633 = x_1;
                        if (_e633 <= 1i) {
                            let _e635 = uv_4;
                            let _e636 = x_1;
                            let _e638 = y_1;
                            let _e641 = texel_1;
                            let _e644 = tileLo;
                            let _e645 = tileHi;
                            let _e647 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e635 + (vec2<f32>(f32(_e636), f32(_e638)) * _e641)), _e644, _e645), 0f);
                            param_59 = _e647.x;
                            let _e649 = storage_;
                            param_60 = _e649;
                            let _e650 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e650;
                            let _e652 = projected[2u];
                            let _e653 = bias;
                            let _e655 = occluder;
                            let _e658 = lit_1;
                            lit_1 = (_e658 + select(1f, 0f, ((_e652 - _e653) > _e655)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e660 = x_1;
                            x_1 = (_e660 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e662 = y_1;
                    y_1 = (_e662 + 1i);
                }
            }
            let _e664 = lit_1;
            lit_1 = (_e664 * 0.11111111f);
        } else {
            let _e666 = softness;
            spread = tan(min(_e666, 0.5f));
            let _e669 = ShadowNoise_u0028_();
            turn_1 = (_e669 * 6.2831855f);
            let _e671 = spread;
            let _e673 = projected[2u];
            let _e675 = cascadeDepth;
            let _e677 = cascadeTexel;
            searchRadius = clamp((((_e671 * _e673) * _e675) / _e677), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e680 = i_5;
                if (_e680 < 16i) {
                    let _e682 = i_5;
                    param_61 = _e682;
                    param_62 = 16i;
                    let _e683 = turn_1;
                    param_63 = _e683;
                    let _e684 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e684;
                    let _e685 = bias;
                    let _e686 = disc;
                    let _e688 = searchRadius;
                    let _e692 = receiverSlope;
                    tapBias = (_e685 + (max(((length(_e686) * _e688) - 1.5f), 0f) * _e692));
                    let _e695 = uv_4;
                    let _e696 = disc;
                    let _e697 = texel_1;
                    let _e699 = searchRadius;
                    let _e702 = tileLo;
                    let _e703 = tileHi;
                    let _e705 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e695 + ((_e696 * _e697) * _e699)), _e702, _e703), 0f);
                    param_64 = _e705.x;
                    let _e707 = storage_;
                    param_65 = _e707;
                    let _e708 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e708;
                    let _e710 = projected[2u];
                    let _e711 = tapBias;
                    let _e713 = occluder_1;
                    if ((_e710 - _e711) > _e713) {
                        let _e715 = occluder_1;
                        let _e716 = blockerSum;
                        blockerSum = (_e716 + _e715);
                        let _e718 = blockerCount;
                        blockerCount = (_e718 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e720 = i_5;
                    i_5 = (_e720 + 1i);
                }
            }
            let _e722 = blockerCount;
            if (_e722 <= 0f) {
                return 1f;
            }
            let _e725 = projected[2u];
            let _e726 = blockerSum;
            let _e727 = blockerCount;
            let _e731 = cascadeDepth;
            gap = (max((_e725 - (_e726 / _e727)), 0f) * _e731);
            let _e733 = spread;
            let _e734 = gap;
            let _e736 = cascadeTexel;
            radius_2 = clamp(((_e733 * _e734) / _e736), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e739 = i_6;
                if (_e739 < 16i) {
                    let _e741 = turn_1;
                    let _e743 = i_6;
                    param_66 = _e743;
                    param_67 = 16i;
                    param_68 = (_e741 + 1f);
                    let _e744 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e744;
                    let _e745 = bias;
                    let _e746 = disc_1;
                    let _e748 = radius_2;
                    let _e752 = receiverSlope;
                    tapBias_1 = (_e745 + (max(((length(_e746) * _e748) - 1.5f), 0f) * _e752));
                    let _e755 = uv_4;
                    let _e756 = disc_1;
                    let _e757 = texel_1;
                    let _e759 = radius_2;
                    let _e762 = tileLo;
                    let _e763 = tileHi;
                    let _e765 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e755 + ((_e756 * _e757) * _e759)), _e762, _e763), 0f);
                    param_69 = _e765.x;
                    let _e767 = storage_;
                    param_70 = _e767;
                    let _e768 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e768;
                    let _e770 = projected[2u];
                    let _e771 = tapBias_1;
                    let _e773 = occluder_2;
                    let _e776 = lit_1;
                    lit_1 = (_e776 + select(1f, 0f, ((_e770 - _e771) > _e773)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e778 = i_6;
                    i_6 = (_e778 + 1i);
                }
            }
            let _e780 = lit_1;
            lit_1 = (_e780 * 0.0625f);
        }
    }
    let _e782 = lit_1;
    let _e783 = strength_1;
    return mix(1f, _e782, clamp(_e783, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e188 = (*s_3);
    param_71 = _e188;
    let _e189 = (*light_2);
    param_72 = _e189;
    let _e190 = (*index);
    param_73 = _e190;
    let _e191 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e191;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e183 = (*index_1);
    return (_e183 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e187 = (*distance_1);
    let _e188 = (*distance_1);
    attenuation = (1f / max((_e187 * _e188), 0.0001f));
    let _e192 = (*range_4);
    if (_e192 > 0f) {
        let _e194 = (*distance_1);
        let _e195 = (*range_4);
        ratio = (_e194 / _e195);
        let _e197 = ratio;
        let _e198 = ratio;
        let _e200 = ratio;
        let _e202 = ratio;
        window = clamp((1f - (((_e197 * _e198) * _e200) * _e202)), 0f, 1f);
        let _e206 = window;
        let _e207 = window;
        let _e209 = attenuation;
        attenuation = (_e209 * (_e206 * _e207));
    }
    let _e211 = attenuation;
    return _e211;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_15: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e199 = (*halfWidth);
    let _e200 = (*halfHeight);
    n_2 = cross(_e199, _e200);
    let _e202 = n_2;
    nLen = length(_e202);
    let _e204 = nLen;
    if (_e204 < 0.000000000001f) {
        let _e206 = (*centre);
        return _e206;
    }
    let _e207 = nLen;
    let _e208 = n_2;
    n_2 = (_e208 / vec3(_e207));
    let _e211 = (*centre);
    let _e212 = (*world_2);
    toPlane = (_e211 - _e212);
    let _e214 = (*mirror);
    let _e215 = n_2;
    denom = dot(_e214, _e215);
    let _e217 = denom;
    if (abs(_e217) < 0.00001f) {
        let _e220 = toPlane;
        let _e221 = n_2;
        let _e222 = toPlane;
        let _e223 = n_2;
        onPlane = (_e220 - (_e221 * dot(_e222, _e223)));
    } else {
        let _e227 = toPlane;
        let _e228 = n_2;
        let _e230 = denom;
        t_1 = (dot(_e227, _e228) / _e230);
        let _e232 = t_1;
        if (_e232 > 0f) {
            let _e234 = (*mirror);
            let _e235 = t_1;
            local_15 = (_e234 * _e235);
        } else {
            let _e237 = toPlane;
            let _e238 = n_2;
            let _e239 = toPlane;
            let _e240 = n_2;
            local_15 = (_e237 - (_e238 * dot(_e239, _e240)));
        }
        let _e244 = local_15;
        onPlane = _e244;
    }
    let _e245 = onPlane;
    let _e246 = toPlane;
    offset_2 = (_e245 - _e246);
    let _e248 = (*halfWidth);
    let _e249 = (*halfWidth);
    wLen2_ = max(dot(_e248, _e249), 0.000000000001f);
    let _e252 = (*halfHeight);
    let _e253 = (*halfHeight);
    hLen2_ = max(dot(_e252, _e253), 0.000000000001f);
    let _e256 = offset_2;
    let _e257 = (*halfWidth);
    let _e259 = wLen2_;
    u = clamp((dot(_e256, _e257) / _e259), -1f, 1f);
    let _e262 = offset_2;
    let _e263 = (*halfHeight);
    let _e265 = hLen2_;
    v = clamp((dot(_e262, _e263) / _e265), -1f, 1f);
    let _e268 = (*centre);
    let _e269 = (*halfWidth);
    let _e270 = u;
    let _e273 = (*halfHeight);
    let _e274 = v;
    return ((_e268 + (_e269 * _e270)) + (_e273 * _e274));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_16: f32;

    let _e191 = (*a_1);
    let _e192 = (*a_1);
    ua = (_e191 / vec3(max(length(_e192), 0.000000000001f)));
    let _e197 = (*b);
    let _e198 = (*b);
    ub = (_e197 / vec3(max(length(_e198), 0.000000000001f)));
    let _e203 = ua;
    let _e204 = ub;
    angle_1 = acos(clamp(dot(_e203, _e204), -1f, 1f));
    let _e208 = ua;
    let _e209 = ub;
    axis = cross(_e208, _e209);
    let _e211 = axis;
    len = length(_e211);
    let _e213 = len;
    if (_e213 > 0.000001f) {
        let _e215 = angle_1;
        let _e216 = axis;
        let _e217 = (*n_3);
        let _e220 = len;
        local_16 = ((_e215 * dot(_e216, _e217)) / _e220);
    } else {
        local_16 = 0f;
    }
    let _e222 = local_16;
    return _e222;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_17: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_18: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_19: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e205 = i_7;
        if (_e205 < 4i) {
            let _e207 = i_7;
            let _e209 = (*corners)[_e207];
            a_2 = _e209;
            let _e210 = i_7;
            if (_e210 == 3i) {
                local_17 = 0i;
            } else {
                let _e212 = i_7;
                local_17 = (_e212 + 1i);
            }
            let _e214 = local_17;
            let _e216 = (*corners)[_e214];
            b_1 = _e216;
            let _e217 = a_2;
            let _e218 = (*n_4);
            ha = dot(_e217, _e218);
            let _e220 = b_1;
            let _e221 = (*n_4);
            hb = dot(_e220, _e221);
            let _e223 = ha;
            let _e224 = hb;
            d_3 = (_e223 - _e224);
            let _e226 = a_2;
            let _e227 = b_1;
            let _e228 = a_2;
            let _e230 = d_3;
            if (abs(_e230) > 0.000000000001f) {
                let _e233 = ha;
                let _e234 = d_3;
                local_18 = (_e233 / _e234);
            } else {
                local_18 = 0f;
            }
            let _e236 = local_18;
            q = (_e226 + ((_e227 - _e228) * _e236));
            let _e239 = ha;
            aAbove = (_e239 > 0f);
            let _e241 = hb;
            bAbove = (_e241 > 0f);
            let _e243 = aAbove;
            let _e244 = bAbove;
            if (_e243 || _e244) {
                let _e246 = aAbove;
                let _e247 = a_2;
                let _e248 = q;
                let _e251 = bAbove;
                let _e252 = b_1;
                let _e253 = q;
                param_74 = select(_e248, _e247, vec3(_e246));
                param_75 = select(_e253, _e252, vec3(_e251));
                let _e256 = (*n_4);
                param_76 = _e256;
                let _e257 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_19 = _e257;
            } else {
                local_19 = 0f;
            }
            let _e258 = local_19;
            let _e259 = total;
            total = (_e259 + _e258);
            let _e261 = aAbove;
            let _e262 = bAbove;
            let _e265 = q;
            let _e266 = exit;
            exit = select(_e266, _e265, vec3((_e261 && !(_e262))));
            let _e269 = aAbove;
            let _e271 = bAbove;
            let _e273 = q;
            let _e274 = entry;
            entry = select(_e274, _e273, vec3((!(_e269) && _e271)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e277 = i_7;
            i_7 = (_e277 + 1i);
        }
    }
    let _e279 = exit;
    param_77 = _e279;
    let _e280 = entry;
    param_78 = _e280;
    let _e281 = (*n_4);
    param_79 = _e281;
    let _e282 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e283 = total;
    total = (_e283 + _e282);
    let _e285 = total;
    return max((-(_e285) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_20: f32;
    var local_21: f32;
    var local_22: f32;

    let _e188 = (*slot_1);
    let _e189 = (*slot_1);
    lane = (_e188 - ((_e189 / 4i) * 4i));
    let _e193 = lane;
    if (_e193 == 0i) {
        let _e196 = (*four)[0u];
        local_20 = _e196;
    } else {
        let _e197 = lane;
        if (_e197 == 1i) {
            let _e200 = (*four)[1u];
            local_21 = _e200;
        } else {
            let _e201 = lane;
            if (_e201 == 2i) {
                let _e204 = (*four)[2u];
                local_22 = _e204;
            } else {
                let _e206 = (*four)[3u];
                local_22 = _e206;
            }
            let _e207 = local_22;
            local_21 = _e207;
        }
        let _e208 = local_21;
        local_20 = _e208;
    }
    let _e209 = local_20;
    return _e209;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e185 = (*slot_2);
    let _e189 = light_list_info.scales[(_e185 / 4i)];
    param_80 = _e189;
    let _e190 = (*slot_2);
    param_81 = _e190;
    let _e191 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e191;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e187 = light_list_info.slot_rows[0i];
    let _e188 = (*row);
    a_3 = abs((_e187 - vec4(_e188)));
    let _e194 = light_list_info.slot_rows[1i];
    let _e195 = (*row);
    b_2 = abs((_e194 - vec4(_e195)));
    let _e200 = a_3[0u];
    let _e202 = a_3[1u];
    let _e205 = a_3[2u];
    let _e207 = a_3[3u];
    let _e211 = b_2[0u];
    let _e213 = b_2[1u];
    let _e216 = b_2[2u];
    let _e218 = b_2[3u];
    return (min(min(min(_e200, _e202), min(_e205, _e207)), min(min(_e211, _e213), min(_e216, _e218))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e185 = (*slot_3);
    let _e189 = light_list_info.indices[(_e185 / 4i)];
    param_82 = _e189;
    let _e190 = (*slot_3);
    param_83 = _e190;
    let _e191 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e191;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e184 = (*texel_2);
    let _e188 = light_list_info.list[1u];
    let _e190 = (*row_1);
    let _e194 = light_list_info.list[2u];
    let _e197 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e184 + 0.5f) * _e188), ((_e190 + 0.5f) * _e194)), 0f);
    return _e197;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e192 = g_cluster_offset;
    let _e193 = (*slot_4);
    entry_1 = (_e192 + f32(_e193));
    let _e196 = entry_1;
    row_2 = floor((_e196 / 16f));
    let _e199 = entry_1;
    let _e200 = row_2;
    within = (_e199 - (_e200 * 16f));
    let _e203 = within;
    texel_3 = floor((_e203 / 4f));
    let _e208 = light_list_info.cluster_depth[3u];
    let _e209 = row_2;
    let _e211 = texel_3;
    param_84 = _e211;
    param_85 = (_e208 + _e209);
    let _e212 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e212;
    let _e213 = within;
    let _e214 = texel_3;
    let _e219 = four_1;
    param_86 = _e219;
    param_87 = i32(((_e213 - (_e214 * 4f)) + 0.5f));
    let _e220 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e220;
}

fn Clustered_u0028_() -> bool {
    let _e184 = light_list_info.cluster_grid[3u];
    return (_e184 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_23: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_24: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_25: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_26: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_27: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp_1: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e236 = (*index_2);
    if (_e236 < 8i) {
        let _e238 = (*index_2);
        let _e241 = frag_info.light_position[_e238];
        position = _e241;
        let _e242 = (*index_2);
        let _e245 = frag_info.light_color[_e242];
        color_1 = _e245;
        let _e246 = (*index_2);
        let _e249 = frag_info.light_direction[_e246];
        direction = _e249;
        let _e250 = (*index_2);
        let _e253 = frag_info.light_cone[_e250];
        cone = _e253;
    } else {
        let _e254 = (*index_2);
        slot_5 = (_e254 - 8i);
        let _e256 = Clustered_u0028_();
        clustered = _e256;
        let _e257 = clustered;
        if _e257 {
            let _e258 = slot_5;
            param_88 = _e258;
            let _e259 = ClusterRow_u0028_i1_u003b((&param_88));
            local_23 = _e259;
        } else {
            let _e260 = slot_5;
            param_89 = _e260;
            let _e261 = LightListRow_u0028_i1_u003b((&param_89));
            local_23 = _e261;
        }
        let _e262 = local_23;
        listRow = _e262;
        let _e263 = listRow;
        let _e267 = light_list_info.list[2u];
        v_1 = ((_e263 + 0.5f) * _e267);
        let _e271 = light_list_info.list[1u];
        u_1 = _e271;
        let _e272 = u_1;
        let _e274 = v_1;
        let _e276 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e272), _e274), 0f);
        position = _e276;
        let _e277 = u_1;
        let _e279 = v_1;
        let _e281 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e277), _e279), 0f);
        color_1 = _e281;
        let _e282 = u_1;
        let _e284 = v_1;
        let _e286 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e282), _e284), 0f);
        direction = _e286;
        let _e287 = u_1;
        let _e289 = v_1;
        let _e291 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e287), _e289), 0f);
        cone = _e291;
        let _e292 = clustered;
        if _e292 {
            let _e293 = listRow;
            param_90 = _e293;
            let _e294 = InSlots_u0028_f1_u003b((&param_90));
            local_24 = select(1f, 0f, _e294);
        } else {
            let _e296 = slot_5;
            param_91 = _e296;
            let _e297 = LightListScale_u0028_i1_u003b((&param_91));
            local_24 = _e297;
        }
        let _e298 = local_24;
        let _e300 = color_1[3u];
        color_1[3u] = (_e300 * _e298);
    }
    let _e304 = position[3u];
    type_39 = _e304;
    let _e305 = type_39;
    if (_e305 > 15.5f) {
        let _e308 = (*s_4).n;
        light_3.l = _e308;
        let _e311 = (*s_4).n;
        light_3.h = _e311;
        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 _e317 = light_3;
        return _e317;
    }
    let _e318 = type_39;
    if (_e318 > 2.5f) {
        let _e320 = direction;
        halfWidth_1 = _e320.xyz;
        let _e322 = cone;
        halfHeight_1 = _e322.xyz;
        let _e324 = position;
        let _e326 = v_world_position_1;
        toCentre = (_e324.xyz - _e326);
        let _e328 = toCentre;
        let _e329 = halfWidth_1;
        let _e331 = halfHeight_1;
        corners_1[0i] = ((_e328 - _e329) - _e331);
        let _e334 = toCentre;
        let _e335 = halfWidth_1;
        let _e337 = halfHeight_1;
        corners_1[1i] = ((_e334 + _e335) - _e337);
        let _e340 = toCentre;
        let _e341 = halfWidth_1;
        let _e343 = halfHeight_1;
        corners_1[2i] = ((_e340 + _e341) + _e343);
        let _e346 = toCentre;
        let _e347 = halfWidth_1;
        let _e349 = halfHeight_1;
        corners_1[3i] = ((_e346 - _e347) + _e349);
        let _e352 = toCentre;
        let _e353 = halfWidth_1;
        let _e354 = halfHeight_1;
        behind = (dot(_e352, cross(_e353, _e354)) >= 0f);
        let _e358 = behind;
        if _e358 {
            local_25 = 0f;
        } else {
            let _e359 = corners_1;
            param_92 = _e359;
            let _e361 = (*s_4).n;
            param_93 = _e361;
            let _e362 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_25 = _e362;
        }
        let _e363 = local_25;
        formFactor = _e363;
        let _e364 = halfWidth_1;
        let _e365 = halfHeight_1;
        area = (length(cross(_e364, _e365)) * 4f);
        let _e369 = area;
        if (_e369 > 0.000000001f) {
            let _e371 = area;
            local_26 = (1f / _e371);
        } else {
            local_26 = 0f;
        }
        let _e373 = local_26;
        radiance = _e373;
        let _e374 = toCentre;
        distance_2 = length(_e374);
        let _e377 = direction[3u];
        if (_e377 > 0f) {
            let _e379 = distance_2;
            let _e381 = direction[3u];
            ratio_1 = (_e379 / _e381);
            let _e383 = ratio_1;
            let _e384 = ratio_1;
            let _e386 = ratio_1;
            let _e388 = ratio_1;
            window_1 = clamp((1f - (((_e383 * _e384) * _e386) * _e388)), 0f, 1f);
            let _e392 = window_1;
            let _e393 = window_1;
            let _e395 = radiance;
            radiance = (_e395 * (_e392 * _e393));
        }
        let _e398 = (*s_4).v;
        let _e401 = (*s_4).n;
        mirror_1 = reflect(-(_e398), _e401);
        let _e403 = position;
        param_94 = _e403.xyz;
        let _e405 = halfWidth_1;
        param_95 = _e405;
        let _e406 = halfHeight_1;
        param_96 = _e406;
        let _e407 = v_world_position_1;
        param_97 = _e407;
        let _e408 = mirror_1;
        param_98 = _e408;
        let _e409 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e409;
        let _e410 = representative;
        let _e411 = v_world_position_1;
        toPoint = (_e410 - _e411);
        let _e413 = toPoint;
        pointDistance = length(_e413);
        let _e415 = pointDistance;
        if (_e415 > 0.000001f) {
            let _e417 = toPoint;
            let _e418 = pointDistance;
            local_27 = (_e417 / vec3(_e418));
        } else {
            let _e422 = (*s_4).n;
            local_27 = _e422;
        }
        let _e423 = local_27;
        light_3.l = _e423;
        let _e426 = light_3.l;
        let _e428 = (*s_4).v;
        light_3.h = normalize((_e426 + _e428));
        let _e432 = formFactor;
        light_3.n_dot_l = _e432;
        let _e435 = (*s_4).n;
        let _e437 = light_3.h;
        light_3.n_dot_h = max(dot(_e435, _e437), 0f);
        let _e442 = (*s_4).v;
        let _e444 = light_3.h;
        light_3.v_dot_h = max(dot(_e442, _e444), 0f);
        let _e448 = color_1;
        let _e451 = color_1[3u];
        let _e453 = radiance;
        light_3.radiance = ((_e448.xyz * _e451) * _e453);
        let _e456 = light_3;
        return _e456;
    }
    let _e457 = direction;
    aim = normalize(_e457.xyz);
    attenuation_1 = 1f;
    let _e460 = type_39;
    if (_e460 < 0.5f) {
        let _e462 = aim;
        light_3.l = -(_e462);
    } else {
        let _e465 = position;
        let _e467 = v_world_position_1;
        toLight_1 = (_e465.xyz - _e467);
        let _e469 = toLight_1;
        distance_3 = length(_e469);
        let _e471 = distance_3;
        if (_e471 < 0.000001f) {
            let _e474 = (*s_4).n;
            light_3.l = _e474;
            let _e477 = (*s_4).n;
            light_3.h = _e477;
            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 _e483 = light_3;
            return _e483;
        }
        let _e484 = toLight_1;
        let _e485 = distance_3;
        light_3.l = (_e484 / vec3(_e485));
        let _e489 = distance_3;
        param_99 = _e489;
        let _e491 = direction[3u];
        param_100 = _e491;
        let _e492 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e492;
        let _e493 = type_39;
        if (_e493 > 1.5f) {
            let _e495 = aim;
            let _e497 = light_3.l;
            cosAngle = dot(_e495, -(_e497));
            let _e500 = cosAngle;
            let _e502 = cone[1u];
            let _e505 = cone[0u];
            let _e507 = cone[1u];
            ramp_1 = clamp(((_e500 - _e502) / (_e505 - _e507)), 0f, 1f);
            let _e511 = ramp_1;
            let _e512 = ramp_1;
            let _e514 = attenuation_1;
            attenuation_1 = (_e514 * (_e511 * _e512));
        }
    }
    let _e517 = light_3.l;
    let _e519 = (*s_4).v;
    light_3.h = normalize((_e517 + _e519));
    let _e524 = (*s_4).n;
    let _e526 = light_3.l;
    light_3.n_dot_l = max(dot(_e524, _e526), 0f);
    let _e531 = (*s_4).n;
    let _e533 = light_3.h;
    light_3.n_dot_h = max(dot(_e531, _e533), 0f);
    let _e538 = (*s_4).v;
    let _e540 = light_3.h;
    light_3.v_dot_h = max(dot(_e538, _e540), 0f);
    let _e544 = color_1;
    let _e547 = color_1[3u];
    let _e549 = attenuation_1;
    light_3.radiance = ((_e544.xyz * _e547) * _e549);
    let _e552 = light_3;
    return _e552;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_28: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e197 = light_list_info.cluster_view_projection;
    let _e198 = (*world_3);
    clip_1 = (_e197 * vec4<f32>(_e198.x, _e198.y, _e198.z, 1f));
    let _e204 = clip_1;
    let _e207 = clip_1[3u];
    ndc_1 = (_e204.xy / vec2(max(_e207, 0.000001f)));
    let _e212 = light_list_info.cluster_grid;
    grid = _e212.xyz;
    let _e216 = light_list_info.cluster_depth[0u];
    near_1 = _e216;
    let _e218 = ndc_1[0u];
    let _e222 = grid[0u];
    let _e226 = grid[0u];
    tx = clamp(floor((((_e218 * 0.5f) + 0.5f) * _e222)), 0f, (_e226 - 1f));
    let _e230 = ndc_1[1u];
    let _e234 = grid[1u];
    let _e238 = grid[1u];
    ty = clamp(floor((((_e230 * 0.5f) + 0.5f) * _e234)), 0f, (_e238 - 1f));
    let _e242 = clip_1[3u];
    let _e243 = near_1;
    if (_e242 <= _e243) {
        local_28 = 0f;
    } else {
        let _e246 = clip_1[3u];
        let _e247 = near_1;
        let _e252 = light_list_info.cluster_depth[1u];
        let _e256 = grid[2u];
        local_28 = clamp(floor((log((_e246 / _e247)) * _e252)), 0f, (_e256 - 1f));
    }
    let _e259 = local_28;
    tz = _e259;
    let _e260 = tx;
    let _e261 = ty;
    let _e263 = grid[0u];
    let _e266 = tz;
    let _e268 = grid[0u];
    let _e271 = grid[1u];
    cell = ((_e260 + (_e261 * _e263)) + ((_e266 * _e268) * _e271));
    let _e274 = cell;
    row_3 = floor((_e274 / 4f));
    let _e277 = cell;
    let _e278 = row_3;
    let _e283 = light_list_info.cluster_depth[2u];
    let _e284 = row_3;
    param_101 = (_e277 - (_e278 * 4f));
    param_102 = (_e283 + _e284);
    let _e286 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e286;
    let _e288 = header[0u];
    g_cluster_offset = _e288;
    let _e290 = header[1u];
    g_cluster_count = _e290;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e186 = light_list_info.list[0u];
    tail = _e186;
    let _e187 = Clustered_u0028_();
    if _e187 {
        let _e188 = v_world_position_1;
        param_103 = _e188;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e189 = g_cluster_count;
        tail = _e189;
    }
    let _e192 = frag_info.frame_params[1u];
    let _e196 = tail;
    return (clamp(i32((_e192 + 0.5f)), 0i, 8i) + clamp(i32((_e196 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_29: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e200 = LightCount_u0028_();
    count_1 = _e200;
    i_8 = 0i;
    loop {
        let _e201 = i_8;
        if (_e201 < 32i) {
            let _e203 = i_8;
            let _e204 = count_1;
            if (_e203 >= _e204) {
                break;
            }
            let _e206 = i_8;
            param_104 = _e206;
            let _e207 = (*s_5);
            param_105 = _e207;
            let _e208 = 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((&param_104), (&param_105));
            light_4 = _e208;
            let _e210 = light_4.n_dot_l;
            if (_e210 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e212 = i_8;
            param_106 = _e212;
            let _e213 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e213 {
                let _e214 = (*s_5);
                param_107 = _e214;
                let _e215 = light_4;
                param_108 = _e215;
                let _e216 = i_8;
                param_109 = _e216;
                let _e217 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e218 = v_world_position_1;
                param_110 = _e218;
                let _e220 = (*s_5).n;
                param_111 = _e220;
                let _e221 = i_8;
                param_112 = _e221;
                let _e222 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_29 = (_e217 * _e222);
            } else {
                local_29 = 1f;
            }
            let _e224 = local_29;
            visibility = _e224;
            let _e225 = visibility;
            if (_e225 <= 0f) {
                continue;
            }
            let _e227 = (*s_5);
            param_113 = _e227;
            let _e228 = light_4;
            param_114 = _e228;
            let _e229 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e231 = light_4.radiance;
            let _e234 = light_4.n_dot_l;
            let _e236 = visibility;
            let _e238 = light_transmittance;
            let _e240 = total_1;
            total_1 = (_e240 + ((((_e229 * _e231) * _e234) * _e236) * _e238));
            continue;
        } else {
            break;
        }
        continuing {
            let _e242 = i_8;
            i_8 = (_e242 + 1i);
        }
    }
    let _e244 = total_1;
    return _e244;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_30: f32;
    var local_31: f32;

    let _e186 = OcclusionTarget_u0028_();
    target_ = _e186;
    let _e187 = target_;
    let _e189 = target_;
    if ((_e187 > 0.5f) && (_e189 < 1.5f)) {
        local_30 = 1f;
    } else {
        let _e193 = (*s_6).occlusion;
        local_30 = _e193;
    }
    let _e194 = local_30;
    local_31 = _e194;
    let _e195 = local_31;
    return _e195;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e183 = v_lightmap_uv_1;
    let _e184 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e183);
    texel_4 = _e184;
    let _e185 = texel_4;
    let _e188 = texel_4[3u];
    return ((_e185.xyz * _e188) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e184 = frag_info.target_origin[1u];
    return _e184;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e184 = v_texcoord_1;
    let _e185 = MaterialLodBias_u0028_();
    let _e186 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e184, _e185);
    orm = _e186.xyz;
    let _e189 = (*s_7).metallic;
    let _e191 = orm[2u];
    (*s_7).metallic = clamp((_e189 * _e191), 0f, 1f);
    let _e196 = (*s_7).roughness;
    let _e198 = orm[1u];
    (*s_7).roughness = clamp((_e196 * _e198), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e183 = (*srgb);
    let _e186 = (*srgb);
    let _e191 = (*srgb);
    return mix((_e183 / vec3(12.92f)), pow(((_e186 + 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), _e191));
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_115: vec3<f32>;

    let _e185 = v_texcoord_1;
    let _e186 = MaterialLodBias_u0028_();
    let _e187 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e185, _e186);
    param_115 = _e187.xyz;
    let _e189 = SrgbToLinear_u0028_vf3_u003b((&param_115));
    emissive = _e189;
    let _e190 = emissive;
    let _e192 = frag_info.emissive;
    let _e197 = frag_info.material2_[3u];
    (*s_8).emissive = ((_e190 * _e192.xyz) * _e197);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e185 = v_texcoord_1;
    let _e186 = MaterialLodBias_u0028_();
    let _e187 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e185, _e186);
    occlusion = _e187.x;
    let _e191 = frag_info.material2_[2u];
    let _e192 = OcclusionTarget_u0028_();
    strength_2 = (_e191 - (2f * _e192));
    let _e195 = occlusion;
    let _e196 = strength_2;
    (*s_9).occlusion = mix(1f, _e195, clamp(_e196, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e187 = v_texcoord_1;
    let _e188 = MaterialLodBias_u0028_();
    let _e189 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e187, _e188);
    sampledTexel = _e189;
    let _e190 = v_tangent_1;
    t_2 = _e190.xyz;
    let _e192 = t_2;
    let _e194 = (*s_10).n;
    let _e196 = (*s_10).n;
    let _e197 = t_2;
    t_2 = (_e192 - (_e194 * dot(_e196, _e197)));
    let _e201 = t_2;
    let _e202 = t_2;
    if (dot(_e201, _e202) < 0.000000000001f) {
        return;
    }
    let _e205 = t_2;
    t_2 = normalize(_e205);
    let _e208 = (*s_10).n;
    let _e209 = t_2;
    let _e212 = v_tangent_1[3u];
    b_3 = (cross(_e208, _e209) * _e212);
    let _e214 = gl_FrontFacing_1;
    if !(_e214) {
        let _e216 = t_2;
        t_2 = -(_e216);
    }
    let _e218 = sampledTexel;
    sampled = ((_e218.xyz * 2f) - vec3(1f));
    let _e225 = frag_info.emissive[3u];
    if (_e225 > 0.5f) {
        let _e227 = sampled;
        let _e229 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e227.xy, _e229.xy)), 0f));
    }
    let _e238 = frag_info.material2_[1u];
    let _e239 = sampled;
    let _e241 = (_e239.xy * _e238);
    sampled[0u] = _e241.x;
    sampled[1u] = _e241.y;
    let _e246 = t_2;
    let _e248 = sampled[0u];
    let _e250 = b_3;
    let _e252 = sampled[1u];
    let _e256 = (*s_10).n;
    let _e258 = sampled[2u];
    (*s_10).n = normalize((((_e246 * _e248) + (_e250 * _e252)) + (_e256 * _e258)));
    let _e264 = (*s_10).n;
    let _e266 = (*s_10).v;
    (*s_10).n_dot_v = max(dot(_e264, _e266), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e183 = (*texel_5);
    let _e187 = irradiance_info.atlas;
    let _e190 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e183 + vec2(0.5f)) * _e187.xy), 0f);
    return _e190;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_116: vec2<f32>;
    var b_4: vec4<f32>;
    var param_117: vec2<f32>;
    var c: vec4<f32>;
    var param_118: vec2<f32>;
    var d_4: vec4<f32>;
    var param_119: vec2<f32>;

    let _e196 = (*uv_5);
    let _e197 = (*interior);
    at_1 = ((vec2(1f) + (_e196 * _e197)) - vec2(0.5f));
    let _e203 = at_1;
    low = floor(_e203);
    let _e205 = at_1;
    let _e206 = low;
    f = (_e205 - _e206);
    let _e208 = (*corner);
    let _e209 = low;
    param_116 = (_e208 + _e209);
    let _e211 = AtlasTexel_u0028_vf2_u003b((&param_116));
    a_4 = _e211;
    let _e212 = (*corner);
    let _e213 = low;
    param_117 = ((_e212 + _e213) + vec2<f32>(1f, 0f));
    let _e216 = AtlasTexel_u0028_vf2_u003b((&param_117));
    b_4 = _e216;
    let _e217 = (*corner);
    let _e218 = low;
    param_118 = ((_e217 + _e218) + vec2<f32>(0f, 1f));
    let _e221 = AtlasTexel_u0028_vf2_u003b((&param_118));
    c = _e221;
    let _e222 = (*corner);
    let _e223 = low;
    param_119 = ((_e222 + _e223) + vec2<f32>(1f, 1f));
    let _e226 = AtlasTexel_u0028_vf2_u003b((&param_119));
    d_4 = _e226;
    let _e227 = a_4;
    let _e228 = b_4;
    let _e230 = f[0u];
    let _e233 = c;
    let _e234 = d_4;
    let _e236 = f[0u];
    let _e240 = f[1u];
    return mix(mix(_e227, _e228, vec4(_e230)), mix(_e233, _e234, vec4(_e236)), vec4(_e240));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e187 = (*direction_1)[0u];
    let _e190 = (*direction_1)[1u];
    let _e194 = (*direction_1)[2u];
    sum_1 = ((abs(_e187) + abs(_e190)) + abs(_e194));
    let _e197 = sum_1;
    if (_e197 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e199 = (*direction_1);
    let _e200 = sum_1;
    n_5 = (_e199 / vec3(_e200));
    let _e203 = n_5;
    xy = _e203.xy;
    let _e206 = n_5[2u];
    if (_e206 < 0f) {
        let _e209 = n_5[1u];
        let _e213 = n_5[0u];
        let _e218 = n_5[0u];
        let _e222 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e209)) * select(-1f, 1f, (_e213 >= 0f))), ((1f - abs(_e218)) * select(-1f, 1f, (_e222 >= 0f))));
    }
    let _e227 = xy;
    return ((_e227 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_120: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_121: vec3<f32>;
    var param_122: vec2<f32>;
    var param_123: f32;
    var param_124: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_125: vec3<f32>;
    var param_126: vec2<f32>;
    var param_127: f32;
    var param_128: vec2<f32>;
    var local_32: vec3<f32>;

    let _e229 = irradiance_info.origin;
    origin_2 = _e229.xyz;
    let _e232 = irradiance_info.spacing;
    spacing = _e232.xyz;
    let _e235 = irradiance_info.counts;
    counts = _e235.xyz;
    let _e239 = irradiance_info.tiles[0u];
    irradianceTile = _e239;
    let _e242 = irradiance_info.tiles[1u];
    depthTile = _e242;
    let _e245 = irradiance_info.tiles[2u];
    columns = _e245;
    let _e248 = irradiance_info.tiles[3u];
    momentsTop = _e248;
    let _e249 = (*normal_1);
    unit = normalize(_e249);
    let _e251 = (*world_4);
    let _e252 = unit;
    let _e255 = irradiance_info.spacing[3u];
    let _e258 = (*view);
    let _e261 = irradiance_info.counts[3u];
    biased = ((_e251 + (_e252 * _e255)) + (_e258 * _e261));
    let _e264 = biased;
    let _e265 = origin_2;
    let _e267 = spacing;
    grid_1 = ((_e264 - _e265) / _e267);
    let _e269 = grid_1;
    let _e271 = counts;
    base = clamp(floor(_e269), vec3<f32>(0f, 0f, 0f), (_e271 - vec3(2f)));
    let _e275 = grid_1;
    let _e276 = base;
    f_1 = clamp((_e275 - _e276), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e279 = corner_1;
        if (_e279 < 8i) {
            let _e281 = corner_1;
            let _e284 = corner_1;
            let _e289 = corner_1;
            offset_3 = vec3<f32>(f32((_e281 & 1i)), f32(((_e284 >> bitcast<u32>(1i)) & 1i)), f32(((_e289 >> bitcast<u32>(2i)) & 1i)));
            let _e295 = base;
            let _e296 = offset_3;
            cell_1 = (_e295 + _e296);
            let _e299 = cell_1[2u];
            let _e301 = counts[1u];
            let _e304 = cell_1[1u];
            let _e307 = counts[0u];
            let _e310 = cell_1[0u];
            probe = ((((_e299 * _e301) + _e304) * _e307) + _e310);
            let _e312 = probe;
            let _e313 = columns;
            let _e318 = probe;
            let _e319 = columns;
            tile_4 = vec2<f32>((_e312 - (floor((_e312 / _e313)) * _e313)), floor((_e318 / _e319)));
            let _e323 = tile_4;
            let _e324 = irradianceTile;
            irradianceCorner = (_e323 * (_e324 + 2f));
            let _e328 = tile_4[0u];
            let _e329 = depthTile;
            let _e332 = momentsTop;
            let _e334 = tile_4[1u];
            let _e335 = depthTile;
            momentCorner = vec2<f32>((_e328 * (_e329 + 2f)), (_e332 + (_e334 * (_e335 + 2f))));
            let _e340 = irradianceCorner;
            param_120 = (_e340 + vec2(1f));
            let _e343 = AtlasTexel_u0028_vf2_u003b((&param_120));
            if (_e343.w < 0.5f) {
                continue;
            }
            let _e346 = f_1;
            let _e348 = f_1;
            let _e349 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e346), _e348, _e349);
            let _e352 = trilinear[0u];
            let _e354 = trilinear[1u];
            let _e357 = trilinear[2u];
            weight_2 = max(((_e352 * _e354) * _e357), 0.001f);
            let _e360 = origin_2;
            let _e361 = spacing;
            let _e362 = cell_1;
            probePosition = (_e360 + (_e361 * _e362));
            let _e365 = probePosition;
            let _e366 = biased;
            toProbe = (_e365 - _e366);
            let _e368 = toProbe;
            distance_4 = length(_e368);
            let _e370 = distance_4;
            if (_e370 > 0.000001f) {
                let _e372 = toProbe;
                let _e373 = distance_4;
                direction_2 = (_e372 / vec3(_e373));
                let _e376 = unit;
                let _e377 = probePosition;
                let _e378 = (*world_4);
                facing = ((dot(_e376, normalize((_e377 - _e378))) * 0.5f) + 0.5f);
                let _e384 = facing;
                let _e385 = facing;
                probeWeight = ((_e384 * _e385) + 0.2f);
                let _e388 = direction_2;
                param_121 = -(_e388);
                let _e390 = ProbeOctahedral_u0028_vf3_u003b((&param_121));
                let _e391 = momentCorner;
                param_122 = _e391;
                let _e392 = depthTile;
                param_123 = _e392;
                param_124 = _e390;
                let _e393 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_122), (&param_123), (&param_124));
                moments_3 = _e393.xy;
                chebyshev = 1f;
                let _e395 = distance_4;
                let _e397 = moments_3[0u];
                if (_e395 > _e397) {
                    let _e400 = moments_3[1u];
                    let _e402 = moments_3[0u];
                    let _e404 = moments_3[0u];
                    variance_1 = max((_e400 - (_e402 * _e404)), 0.000001f);
                    let _e408 = distance_4;
                    let _e410 = moments_3[0u];
                    difference = (_e408 - _e410);
                    let _e412 = variance_1;
                    let _e413 = variance_1;
                    let _e414 = difference;
                    let _e415 = difference;
                    chebyshev = (_e412 / (_e413 + (_e414 * _e415)));
                    let _e419 = chebyshev;
                    let _e420 = chebyshev;
                    let _e422 = chebyshev;
                    chebyshev = ((_e419 * _e420) * _e422);
                }
                let _e424 = probeWeight;
                let _e425 = chebyshev;
                probeWeight = max((_e424 * max(_e425, 0.05f)), 0.000001f);
                let _e429 = probeWeight;
                if (_e429 < 0.2f) {
                    let _e431 = probeWeight;
                    let _e432 = probeWeight;
                    let _e435 = probeWeight;
                    probeWeight = (_e435 * ((_e431 * _e432) * 25f));
                }
                let _e437 = probeWeight;
                let _e438 = weight_2;
                weight_2 = (_e438 * _e437);
            }
            let _e440 = unit;
            param_125 = _e440;
            let _e441 = ProbeOctahedral_u0028_vf3_u003b((&param_125));
            let _e442 = irradianceCorner;
            param_126 = _e442;
            let _e443 = irradianceTile;
            param_127 = _e443;
            param_128 = _e441;
            let _e444 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_126), (&param_127), (&param_128));
            let _e446 = weight_2;
            let _e448 = total_2;
            total_2 = (_e448 + (_e444.xyz * _e446));
            let _e450 = weight_2;
            let _e451 = weights;
            weights = (_e451 + _e450);
            continue;
        } else {
            break;
        }
        continuing {
            let _e453 = corner_1;
            corner_1 = (_e453 + 1i);
        }
    }
    let _e455 = weights;
    if (_e455 > 0f) {
        let _e457 = total_2;
        let _e458 = weights;
        local_32 = (_e457 / vec3(_e458));
    } else {
        local_32 = vec3<f32>(0f, 0f, 0f);
    }
    let _e461 = local_32;
    return _e461;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e184 = irradiance_info.origin[3u];
    return (_e184 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;
    var param_132: Surface;
    var param_133: Surface;
    var param_134: Surface;

    let _e189 = IrradianceEnabled_u0028_();
    if _e189 {
        let _e190 = v_world_position_1;
        param_129 = _e190;
        let _e192 = (*s_11).n;
        param_130 = _e192;
        let _e194 = (*s_11).v;
        param_131 = _e194;
        let _e195 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
        let _e198 = frag_info.material[2u];
        (*s_11).ambient = (_e195 * _e198);
    }
    let _e201 = (*s_11);
    param_132 = _e201;
    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((&param_132));
    let _e202 = param_132;
    (*s_11) = _e202;
    let _e203 = (*s_11);
    param_133 = _e203;
    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((&param_133));
    let _e204 = param_133;
    (*s_11) = _e204;
    let _e205 = (*s_11);
    param_134 = _e205;
    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((&param_134));
    let _e206 = param_134;
    (*s_11) = _e206;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_33: vec3<f32>;

    let _e183 = Orthographic_u0028_();
    if _e183 {
        let _e185 = fog_info.forward;
        local_33 = -(_e185.xyz);
    } else {
        let _e189 = fog_info.eye;
        let _e191 = v_world_position_1;
        local_33 = normalize((_e189.xyz - _e191));
    }
    let _e194 = local_33;
    return _e194;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var p3_: vec3<f32>;

    let _e188 = (*cutoff);
    key = (-2f - _e188);
    let _e190 = key;
    let _e193 = key;
    let _e195 = floor((_e193 / 128f));
    let _e200 = key;
    origin_3 = vec3<f32>(floor((_e190 / 16384f)), (_e195 - (floor((_e195 / 128f)) * 128f)), (_e200 - (floor((_e200 / 128f)) * 128f)));
    let _e206 = (*scenePosition);
    let _e209 = origin_3;
    let _e210 = (floor((_e206 * 16f)) + _e209);
    let _e211 = vec3(128f);
    cell_2 = (_e210 - (floor((_e210 / _e211)) * _e211));
    let _e216 = cell_2;
    p3_ = fract((_e216 * 0.1031f));
    let _e219 = p3_;
    let _e220 = p3_;
    let _e225 = p3_;
    p3_ = (_e225 + vec3(dot(_e219, (_e220.zyx + vec3(31.32f)))));
    let _e229 = p3_[0u];
    let _e231 = p3_[1u];
    let _e234 = p3_[2u];
    return fract(((_e229 + _e231) * _e234));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_12: Surface;
    var param_135: vec3<f32>;
    var param_136: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_137: vec3<f32>;
    var param_138: f32;

    let _e190 = v_texcoord_1;
    let _e191 = MaterialLodBias_u0028_();
    let _e192 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e190, _e191);
    texel_6 = _e192;
    let _e193 = texel_6;
    param_135 = _e193.xyz;
    let _e195 = SrgbToLinear_u0028_vf3_u003b((&param_135));
    let _e197 = frag_info.base_color;
    param_136 = _e197.xyz;
    let _e199 = SrgbToLinear_u0028_vf3_u003b((&param_136));
    let _e201 = v_color_1;
    s_12.albedo = ((_e195 * _e199) * _e201.xyz);
    let _e206 = texel_6[3u];
    let _e209 = frag_info.base_color[3u];
    let _e212 = v_color_1[3u];
    s_12.alpha = ((_e206 * _e209) * _e212);
    let _e216 = s_12.albedo;
    g_albedo = _e216;
    let _e219 = frag_info.material2_[0u];
    cutoff_1 = _e219;
    let _e220 = cutoff_1;
    if (_e220 > 1f) {
        let _e222 = cutoff_1;
        edge = (_e222 - 1f);
        let _e225 = s_12.alpha;
        let _e226 = edge;
        let _e229 = s_12.alpha;
        let _e230 = fwidth(_e229);
        s_12.alpha = clamp((((_e225 - _e226) / max(_e230, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e236 = cutoff_1;
        if (_e236 >= 0f) {
            let _e239 = s_12.alpha;
            let _e240 = cutoff_1;
            if (_e239 < _e240) {
                discard;
            }
            s_12.alpha = 1f;
        } else {
            let _e243 = cutoff_1;
            if (_e243 < -1.5f) {
                let _e246 = s_12.alpha;
                let _e247 = v_world_position_1;
                param_137 = _e247;
                let _e248 = cutoff_1;
                param_138 = _e248;
                let _e249 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_137), (&param_138));
                if (_e246 < _e249) {
                    discard;
                }
            }
        }
    }
    let _e251 = cutoff_1;
    let _e253 = cutoff_1;
    g_premultiply = ((_e251 < 0f) && (_e253 > -0.75f));
    let _e256 = v_normal_1;
    s_12.n = normalize(_e256);
    let _e259 = gl_FrontFacing_1;
    if !(_e259) {
        let _e262 = s_12.n;
        s_12.n = -(_e262);
    }
    let _e265 = TowardsEye_u0028_();
    s_12.v = _e265;
    let _e268 = s_12.n;
    let _e270 = s_12.v;
    s_12.n_dot_v = max(dot(_e268, _e270), 0.0001f);
    let _e276 = frag_info.material[0u];
    s_12.metallic = clamp(_e276, 0f, 1f);
    let _e281 = frag_info.material[1u];
    s_12.roughness = clamp(_e281, 0.02f, 1f);
    let _e285 = frag_info.ambient_ground;
    let _e288 = frag_info.ambient_sky;
    let _e292 = s_12.n[1u];
    let _e299 = frag_info.material[2u];
    s_12.ambient = (mix(_e285.xyz, _e288.xyz, vec3(((_e292 * 0.5f) + 0.5f))) * _e299);
    let _e304 = frag_info.frame_params[0u];
    s_12.exposure = max(_e304, 0f);
    s_12.occlusion = 1f;
    s_12.emissive = vec3<f32>(0f, 0f, 0f);
    let _e309 = s_12;
    return _e309;
}

fn main_1() {
    var s_13: Surface;
    var param_139: Surface;
    var param_140: Surface;
    var rim: f32;
    var ambient: vec3<f32>;
    var param_141: Surface;
    var lit_2: vec3<f32>;
    var param_142: Surface;
    var param_143: Surface;
    var param_144: vec3<f32>;
    var param_145: f32;
    var param_146: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e194 = ReadSurface_u0028_();
    s_13 = _e194;
    let _e195 = s_13;
    param_139 = _e195;
    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((&param_139));
    let _e196 = param_139;
    s_13 = _e196;
    let _e197 = s_13;
    param_140 = _e197;
    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((&param_140));
    let _e198 = param_140;
    s_13 = _e198;
    let _e200 = s_13.n_dot_v;
    let _e205 = frag_info.material[3u];
    rim = (pow((1f - _e200), 3f) * _e205);
    let _e208 = s_13.albedo;
    let _e210 = s_13.ambient;
    let _e211 = SampleLightmap_u0028_();
    let _e214 = s_13;
    param_141 = _e214;
    let _e215 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    ambient = ((_e208 * (_e210 + _e211)) * _e215);
    let _e217 = s_13;
    param_142 = _e217;
    let _e218 = 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((&param_142));
    let _e219 = s_13;
    param_143 = _e219;
    let _e220 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_143));
    let _e222 = ambient;
    let _e224 = rim;
    let _e229 = s_13.emissive;
    lit_2 = ((((_e218 * _e220) + _e222) + vec3((_e224 * 0.35f))) + _e229);
    let _e231 = lit_2;
    param_144 = _e231;
    let _e233 = s_13.alpha;
    param_145 = _e233;
    let _e235 = s_13.roughness;
    param_146 = _e235;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_144), (&param_145), (&param_146));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'UnlitOpaque': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e71 = v_world_position_1;
    let _e73 = fog_info.eye;
    let _e77 = fog_info.forward;
    return dot((_e71 - _e73.xyz), _e77.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e76 = ViewDepth_u0028_();
    z = abs(_e76);
    let _e78 = z;
    near = (_e78 / 5f);
    let _e80 = z;
    far = (_e80 / 200f);
    let _e82 = far;
    let _e83 = far;
    let _e85 = far;
    far3_ = ((_e82 * _e83) * _e85);
    let _e87 = (*alpha);
    let _e88 = near;
    let _e89 = near;
    let _e92 = far3_;
    let _e93 = far3_;
    return (_e87 * clamp((10f / ((0.00001f + (_e88 * _e89)) + (_e92 * _e93))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e80 = fog_info.forward[3u];
    mode = _e80;
    let _e81 = mode;
    if (_e81 > 0.5f) {
        let _e84 = frag_color[3u];
        alpha_1 = _e84;
        let _e85 = alpha_1;
        param = _e85;
        let _e86 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e86;
        let _e87 = frag_color;
        let _e89 = weight;
        let _e90 = (_e87.xyz * _e89);
        let _e91 = alpha_1;
        let _e92 = weight;
        accumulate = vec4<f32>(_e90.x, _e90.y, _e90.z, (_e91 * _e92));
        let _e98 = mode;
        let _e100 = mode;
        revealage = ((_e98 > 1.5f) && (_e100 < 2.5f));
        let _e103 = revealage;
        if _e103 {
            let _e104 = alpha_1;
            local = vec4(_e104);
        } else {
            let _e106 = accumulate;
            local = _e106;
        }
        let _e107 = local;
        frag_color = _e107;
        let _e108 = mode;
        if (_e108 > 2.5f) {
            let _e110 = alpha_1;
            frag_surface = vec4(_e110);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e74 = (*n)[0u];
    let _e77 = (*n)[1u];
    let _e81 = (*n)[2u];
    let _e84 = (*n);
    (*n) = (_e84 / vec3(((abs(_e74) + abs(_e77)) + abs(_e81))));
    let _e87 = (*n);
    e = _e87.xy;
    let _e90 = (*n)[2u];
    if (_e90 < 0f) {
        let _e92 = (*n);
        let _e98 = (*n)[0u];
        let _e102 = (*n)[1u];
        e = ((vec2(1f) - abs(_e92.yx)) * vec2<f32>(select(-1f, 1f, (_e98 >= 0f)), select(-1f, 1f, (_e102 >= 0f))));
    }
    let _e107 = e;
    return ((_e107 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e72 = (*linear);
    let _e74 = (*linear);
    let _e78 = (*linear);
    return mix((_e72 * 12.92f), ((pow(_e74, 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), _e78));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e75 = g_albedo;
    param_1 = clamp(_e75, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e77 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e77.x, _e77.y, _e77.z, 1f);
    let _e82 = g_debug_surface_on;
    if _e82 {
        let _e83 = g_debug_surface;
        let _e84 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e83.x, _e83.y, _e83.z, _e84);
        return;
    }
    let _e89 = v_normal_1;
    geometric = normalize(_e89);
    let _e91 = gl_FrontFacing_1;
    if !(_e91) {
        let _e93 = geometric;
        geometric = -(_e93);
    }
    let _e95 = geometric;
    param_2 = _e95;
    let _e96 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e97 = (*roughness);
    let _e99 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e96.x, _e96.y, clamp(_e97, 0f, 1f), _e99);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e73 = fog_info.projection[0u];
    return (_e73 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e72 = Orthographic_u0028_();
    if _e72 {
        let _e73 = ViewDepth_u0028_();
        local_1 = max(_e73, 0f);
    } else {
        let _e75 = v_world_position_1;
        let _e77 = fog_info.eye;
        local_1 = distance(_e75, _e77.xyz);
    }
    let _e80 = local_1;
    return _e80;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e79 = fog_info.fog[3u];
    density = _e79;
    let _e80 = density;
    if (_e80 <= 0f) {
        let _e82 = (*color);
        return _e82;
    }
    let _e83 = EyeDistance_u0028_();
    d = _e83;
    let _e86 = fog_info.eye[3u];
    falloff = _e86;
    let _e87 = falloff;
    if (_e87 > 0f) {
        let _e89 = falloff;
        let _e91 = v_world_position_1[1u];
        let _e94 = fog_info.eye[1u];
        k = (_e89 * (_e91 - _e94));
        let _e97 = k;
        if (abs(_e97) > 0.001f) {
            let _e100 = k;
            let _e104 = k;
            local_2 = ((1f - exp(-(_e100))) / _e104);
        } else {
            let _e106 = k;
            local_2 = (1f - (0.5f * _e106));
        }
        let _e109 = local_2;
        let _e110 = density;
        density = (_e110 * _e109);
    }
    let _e113 = fog_info.fog;
    let _e115 = (*color);
    let _e116 = density;
    let _e118 = d;
    return mix(_e113.xyz, _e115, vec3(clamp(exp((-(_e116) * _e118)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e77 = g_premultiply;
    let _e78 = (*alpha_2);
    weight_1 = select(1f, _e78, _e77);
    let _e80 = (*linearColor);
    param_3 = _e80;
    let _e81 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e82 = weight_1;
    let _e83 = (_e81 * _e82);
    let _e84 = (*alpha_2);
    let _e85 = g_pass_through;
    frag_color = vec4<f32>(_e83.x, _e83.y, _e83.z, (_e84 * (1f - _e85)));
    let _e92 = (*roughness_1);
    param_4 = _e92;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
    var param_5: vec3<f32>;
    var param_6: f32;
    var param_7: f32;

    let _e76 = (*linearColor_1);
    param_5 = _e76;
    let _e77 = (*alpha_3);
    param_6 = _e77;
    param_7 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_3: vec3<f32>;

    let _e72 = Orthographic_u0028_();
    if _e72 {
        let _e74 = fog_info.forward;
        local_3 = -(_e74.xyz);
    } else {
        let _e78 = fog_info.eye;
        let _e80 = v_world_position_1;
        local_3 = normalize((_e78.xyz - _e80));
    }
    let _e83 = local_3;
    return _e83;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e72 = (*srgb);
    let _e75 = (*srgb);
    let _e80 = (*srgb);
    return mix((_e72 / vec3(12.92f)), pow(((_e75 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e80));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e73 = frag_info.target_origin[1u];
    return _e73;
}

fn ReadSurface_u0028_() -> Surface {
    var texel: vec4<f32>;
    var s: Surface;
    var param_8: vec3<f32>;
    var param_9: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e77 = v_texcoord_1;
    let _e78 = MaterialLodBias_u0028_();
    let _e79 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e77, _e78);
    texel = _e79;
    let _e80 = texel;
    param_8 = _e80.xyz;
    let _e82 = SrgbToLinear_u0028_vf3_u003b((&param_8));
    let _e84 = frag_info.base_color;
    param_9 = _e84.xyz;
    let _e86 = SrgbToLinear_u0028_vf3_u003b((&param_9));
    let _e88 = v_color_1;
    s.albedo = ((_e82 * _e86) * _e88.xyz);
    let _e93 = texel[3u];
    let _e96 = frag_info.base_color[3u];
    let _e99 = v_color_1[3u];
    s.alpha = ((_e93 * _e96) * _e99);
    let _e103 = s.albedo;
    g_albedo = _e103;
    let _e106 = frag_info.material2_[0u];
    cutoff = _e106;
    let _e107 = cutoff;
    if (_e107 > 1f) {
        let _e109 = cutoff;
        edge = (_e109 - 1f);
        let _e112 = s.alpha;
        let _e113 = edge;
        let _e116 = s.alpha;
        let _e117 = fwidth(_e116);
        s.alpha = clamp((((_e112 - _e113) / max(_e117, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e123 = cutoff;
        if (_e123 >= 0f) {
            s.alpha = 1f;
        }
    }
    let _e126 = cutoff;
    let _e128 = cutoff;
    g_premultiply = ((_e126 < 0f) && (_e128 > -0.75f));
    let _e131 = v_normal_1;
    s.n = normalize(_e131);
    let _e134 = gl_FrontFacing_1;
    if !(_e134) {
        let _e137 = s.n;
        s.n = -(_e137);
    }
    let _e140 = TowardsEye_u0028_();
    s.v = _e140;
    let _e143 = s.n;
    let _e145 = s.v;
    s.n_dot_v = max(dot(_e143, _e145), 0.0001f);
    let _e151 = frag_info.material[0u];
    s.metallic = clamp(_e151, 0f, 1f);
    let _e156 = frag_info.material[1u];
    s.roughness = clamp(_e156, 0.02f, 1f);
    let _e160 = frag_info.ambient_ground;
    let _e163 = frag_info.ambient_sky;
    let _e167 = s.n[1u];
    let _e174 = frag_info.material[2u];
    s.ambient = (mix(_e160.xyz, _e163.xyz, vec3(((_e167 * 0.5f) + 0.5f))) * _e174);
    let _e179 = frag_info.frame_params[0u];
    s.exposure = max(_e179, 0f);
    s.occlusion = 1f;
    s.emissive = vec3<f32>(0f, 0f, 0f);
    let _e184 = s;
    return _e184;
}

fn main_1() {
    var s_1: Surface;
    var param_10: vec3<f32>;
    var param_11: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e74 = ReadSurface_u0028_();
    s_1 = _e74;
    g_albedo = vec3<f32>(0f, 0f, 0f);
    let _e76 = s_1.albedo;
    param_10 = _e76;
    let _e78 = s_1.alpha;
    param_11 = _e78;
    WriteSurface_u0028_vf3_u003b_f1_u003b((&param_10), (&param_11));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e17 = frag_albedo;
    let _e18 = frag_surface;
    let _e19 = frag_color;
    return FragmentOutput(_e17, _e18, _e19);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LambertOpaque': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(21)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_texture_smp: sampler;
@group(1) @binding(19)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(17)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(15)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(23)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e172 = v_world_position_1;
    let _e174 = fog_info.eye;
    let _e178 = fog_info.forward;
    return dot((_e172 - _e174.xyz), _e178.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e177 = ViewDepth_u0028_();
    z = abs(_e177);
    let _e179 = z;
    near = (_e179 / 5f);
    let _e181 = z;
    far = (_e181 / 200f);
    let _e183 = far;
    let _e184 = far;
    let _e186 = far;
    far3_ = ((_e183 * _e184) * _e186);
    let _e188 = (*alpha);
    let _e189 = near;
    let _e190 = near;
    let _e193 = far3_;
    let _e194 = far3_;
    return (_e188 * clamp((10f / ((0.00001f + (_e189 * _e190)) + (_e193 * _e194))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e181 = fog_info.forward[3u];
    mode = _e181;
    let _e182 = mode;
    if (_e182 > 0.5f) {
        let _e185 = frag_color[3u];
        alpha_1 = _e185;
        let _e186 = alpha_1;
        param = _e186;
        let _e187 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e187;
        let _e188 = frag_color;
        let _e190 = weight;
        let _e191 = (_e188.xyz * _e190);
        let _e192 = alpha_1;
        let _e193 = weight;
        accumulate = vec4<f32>(_e191.x, _e191.y, _e191.z, (_e192 * _e193));
        let _e199 = mode;
        let _e201 = mode;
        revealage = ((_e199 > 1.5f) && (_e201 < 2.5f));
        let _e204 = revealage;
        if _e204 {
            let _e205 = alpha_1;
            local = vec4(_e205);
        } else {
            let _e207 = accumulate;
            local = _e207;
        }
        let _e208 = local;
        frag_color = _e208;
        let _e209 = mode;
        if (_e209 > 2.5f) {
            let _e211 = alpha_1;
            frag_surface = vec4(_e211);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e175 = (*n)[0u];
    let _e178 = (*n)[1u];
    let _e182 = (*n)[2u];
    let _e185 = (*n);
    (*n) = (_e185 / vec3(((abs(_e175) + abs(_e178)) + abs(_e182))));
    let _e188 = (*n);
    e = _e188.xy;
    let _e191 = (*n)[2u];
    if (_e191 < 0f) {
        let _e193 = (*n);
        let _e199 = (*n)[0u];
        let _e203 = (*n)[1u];
        e = ((vec2(1f) - abs(_e193.yx)) * vec2<f32>(select(-1f, 1f, (_e199 >= 0f)), select(-1f, 1f, (_e203 >= 0f))));
    }
    let _e208 = e;
    return ((_e208 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e173 = (*linear);
    let _e175 = (*linear);
    let _e179 = (*linear);
    return mix((_e173 * 12.92f), ((pow(_e175, 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), _e179));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e176 = g_albedo;
    param_1 = clamp(_e176, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e178 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e178.x, _e178.y, _e178.z, 1f);
    let _e183 = g_debug_surface_on;
    if _e183 {
        let _e184 = g_debug_surface;
        let _e185 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e184.x, _e184.y, _e184.z, _e185);
        return;
    }
    let _e190 = v_normal_1;
    geometric = normalize(_e190);
    let _e192 = gl_FrontFacing_1;
    if !(_e192) {
        let _e194 = geometric;
        geometric = -(_e194);
    }
    let _e196 = geometric;
    param_2 = _e196;
    let _e197 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e198 = (*roughness);
    let _e200 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e197.x, _e197.y, clamp(_e198, 0f, 1f), _e200);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e174 = fog_info.projection[0u];
    return (_e174 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e173 = Orthographic_u0028_();
    if _e173 {
        let _e174 = ViewDepth_u0028_();
        local_1 = max(_e174, 0f);
    } else {
        let _e176 = v_world_position_1;
        let _e178 = fog_info.eye;
        local_1 = distance(_e176, _e178.xyz);
    }
    let _e181 = local_1;
    return _e181;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e180 = fog_info.fog[3u];
    density = _e180;
    let _e181 = density;
    if (_e181 <= 0f) {
        let _e183 = (*color);
        return _e183;
    }
    let _e184 = EyeDistance_u0028_();
    d = _e184;
    let _e187 = fog_info.eye[3u];
    falloff = _e187;
    let _e188 = falloff;
    if (_e188 > 0f) {
        let _e190 = falloff;
        let _e192 = v_world_position_1[1u];
        let _e195 = fog_info.eye[1u];
        k = (_e190 * (_e192 - _e195));
        let _e198 = k;
        if (abs(_e198) > 0.001f) {
            let _e201 = k;
            let _e205 = k;
            local_2 = ((1f - exp(-(_e201))) / _e205);
        } else {
            let _e207 = k;
            local_2 = (1f - (0.5f * _e207));
        }
        let _e210 = local_2;
        let _e211 = density;
        density = (_e211 * _e210);
    }
    let _e214 = fog_info.fog;
    let _e216 = (*color);
    let _e217 = density;
    let _e219 = d;
    return mix(_e214.xyz, _e216, vec3(clamp(exp((-(_e217) * _e219)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e178 = g_premultiply;
    let _e179 = (*alpha_2);
    weight_1 = select(1f, _e179, _e178);
    let _e181 = (*linearColor);
    param_3 = _e181;
    let _e182 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e183 = weight_1;
    let _e184 = (_e182 * _e183);
    let _e185 = (*alpha_2);
    let _e186 = g_pass_through;
    frag_color = vec4<f32>(_e184.x, _e184.y, _e184.z, (_e185 * (1f - _e186)));
    let _e193 = (*roughness_1);
    param_4 = _e193;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_3: f32;

    let _e175 = frag_info.material2_[2u];
    local_3 = floor((_e175 * 0.5f));
    let _e178 = local_3;
    return _e178;
}

fn DirectOcclusion_u0028_struct_u002d_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: ptr<function, Surface>) -> f32 {
    var local_4: f32;
    var local_5: f32;

    let _e175 = OcclusionTarget_u0028_();
    if (_e175 > 1.5f) {
        local_4 = 1f;
    } else {
        let _e178 = (*s).occlusion;
        local_4 = _e178;
    }
    let _e179 = local_4;
    local_5 = _e179;
    let _e180 = local_5;
    return _e180;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    let _e175 = (*s_1).albedo;
    return _e175;
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e173 = (*i);
    if (_e173 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e175 = (*i);
    if (_e175 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e177 = (*i);
    if (_e177 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e179 = (*i);
    if (_e179 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e181 = (*i);
    if (_e181 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e183 = (*i);
    if (_e183 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e185 = (*i);
    if (_e185 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e178 = (*i_1);
    param_5 = _e178;
    let _e179 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e179;
    let _e181 = p[0u];
    let _e182 = (*ca);
    let _e185 = p[1u];
    let _e186 = (*sa);
    let _e190 = p[0u];
    let _e191 = (*sa);
    let _e194 = p[1u];
    let _e195 = (*ca);
    let _e199 = (*radius);
    return (vec2<f32>(((_e181 * _e182) - (_e185 * _e186)), ((_e190 * _e191) + (_e194 * _e195))) * _e199);
}

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_6: vec2<f32>;
    var atlas: vec2<f32>;

    let _e181 = point_shadow.params[0u];
    inset = _e181;
    let _e182 = (*uv);
    let _e183 = (*offset);
    let _e185 = inset;
    let _e186 = inset;
    local_6 = clamp((_e182 + _e183), vec2(_e185), vec2((1f - _e186)));
    let _e191 = local_6;
    let _e192 = (*tile);
    atlas = ((_e191 + _e192) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e197 = point_shadow.params3_[0u];
    if (_e197 > 0.5f) {
        let _e200 = atlas[1u];
        atlas[1u] = (1f - _e200);
    }
    let _e203 = atlas;
    let _e204 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e203, 0f);
    let _e206 = atlas;
    let _e207 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e206, 0f);
    let _e210 = (*range);
    return (min(_e204.x, _e207.x) * _e210);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e182 = (*uv_1);
    param_6 = _e182;
    let _e183 = (*offset_1);
    param_7 = _e183;
    let _e184 = (*tile_1);
    param_8 = _e184;
    let _e185 = (*range_1);
    param_9 = _e185;
    let _e186 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e186;
    let _e187 = stored;
    let _e188 = (*range_1);
    if (_e187 >= (_e188 * 0.999f)) {
        return 1f;
    }
    let _e191 = (*receiver);
    let _e192 = stored;
    return select(1f, 0f, (_e191 > _e192));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e203 = point_shadow.params2_[1u];
    lightRadius = _e203;
    let _e206 = point_shadow.params2_[0u];
    minRadius = _e206;
    let _e209 = point_shadow.params2_[2u];
    maxRadius = _e209;
    let _e210 = lightRadius;
    if (_e210 <= 0f) {
        let _e212 = (*uv_2);
        param_10 = _e212;
        param_11 = vec2<f32>(0f, 0f);
        let _e213 = (*tile_2);
        param_12 = _e213;
        let _e214 = (*range_2);
        param_13 = _e214;
        let _e215 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e215;
        let _e216 = minRadius;
        return _e216;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e217 = i_2;
        if (_e217 < 8i) {
            let _e219 = i_2;
            param_14 = _e219;
            let _e220 = (*ca_1);
            param_15 = _e220;
            let _e221 = (*sa_1);
            param_16 = _e221;
            let _e222 = maxRadius;
            param_17 = _e222;
            let _e223 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e224 = (*uv_2);
            param_18 = _e224;
            param_19 = _e223;
            let _e225 = (*tile_2);
            param_20 = _e225;
            let _e226 = (*range_2);
            param_21 = _e226;
            let _e227 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e227;
            let _e228 = stored_1;
            let _e229 = (*range_2);
            if (_e228 >= (_e229 * 0.999f)) {
                continue;
            }
            let _e232 = stored_1;
            let _e233 = (*receiver_1);
            if (_e232 >= _e233) {
                continue;
            }
            let _e235 = stored_1;
            let _e236 = sum;
            sum = (_e236 + _e235);
            let _e238 = count;
            count = (_e238 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e240 = i_2;
            i_2 = (_e240 + 1i);
        }
    }
    let _e242 = count;
    if (_e242 < 0.5f) {
        return -1f;
    }
    let _e244 = sum;
    let _e245 = count;
    blocker = max((_e244 / _e245), 0.0001f);
    let _e248 = blocker;
    (*blockerOut) = _e248;
    let _e249 = lightRadius;
    let _e250 = (*receiver_1);
    let _e251 = blocker;
    let _e255 = blocker;
    world = ((_e249 * max((_e250 - _e251), 0f)) / _e255);
    let _e257 = world;
    let _e258 = (*receiver_1);
    let _e260 = (*tanHalf);
    let _e263 = minRadius;
    let _e264 = maxRadius;
    return clamp((_e257 / ((2f * _e258) * _e260)), _e263, _e264);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_7: vec2<f32>;

    let _e174 = (*rows);
    if (_e174 > 0f) {
        let _e177 = gl_FragCoord_1[0u];
        let _e178 = (*rows);
        let _e180 = gl_FragCoord_1[1u];
        local_7 = vec2<f32>(_e177, (_e178 - _e180));
    } else {
        let _e183 = gl_FragCoord_1;
        local_7 = _e183.xy;
    }
    let _e185 = local_7;
    return _e185;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_8: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2239_: bool;
    var phi_2300_: bool;

    let _e226 = (*lightIndex);
    let _e230 = point_shadow.slots[_e226][0u];
    slot = i32((_e230 + 0.5f));
    let _e233 = (*lightIndex);
    let _e237 = point_shadow.slots[_e233][0u];
    if (_e237 < 0f) {
        return 1f;
    }
    let _e241 = point_shadow.params[2u];
    strength = _e241;
    let _e242 = strength;
    if (_e242 <= 0f) {
        return 1f;
    }
    let _e244 = slot;
    let _e247 = point_shadow.lights[_e244];
    let _e249 = (*world_1);
    toLight = (_e247.xyz - _e249);
    let _e251 = toLight;
    toLightLength = max(length(_e251), 0.000001f);
    let _e254 = (*normal);
    let _e255 = toLight;
    let _e256 = toLightLength;
    nDotL = max(dot(_e254, (_e255 / vec3(_e256))), 0.15f);
    let _e261 = nDotL;
    let _e262 = nDotL;
    let _e267 = nDotL;
    let _e268 = nDotL;
    slope = min((sqrt(max((1f - (_e261 * _e262)), 0f)) / (_e267 * _e268)), 8f);
    let _e272 = toLightLength;
    let _e274 = (*lightIndex);
    let _e278 = point_shadow.slots[_e274][2u];
    let _e283 = point_shadow.params3_[1u];
    texel = (((2f * _e272) * max(_e278, 0.0001f)) * _e283);
    let _e285 = (*world_1);
    let _e286 = (*normal);
    let _e287 = texel;
    let _e291 = point_shadow.params[3u];
    let _e293 = slope;
    origin = (_e285 + (((_e286 * _e287) * _e291) * (1f + _e293)));
    let _e297 = origin;
    let _e298 = slot;
    let _e301 = point_shadow.lights[_e298];
    toFragment = (_e297 - _e301.xyz);
    let _e304 = toFragment;
    distance_ = length(_e304);
    let _e306 = slot;
    let _e310 = point_shadow.lights[_e306][3u];
    range_3 = max(_e310, 0.0001f);
    let _e312 = distance_;
    let _e313 = range_3;
    if (_e312 >= _e313) {
        return 1f;
    }
    face = 0i;
    let _e315 = (*lightIndex);
    let _e319 = point_shadow.slots[_e315][1u];
    if (_e319 < 0.5f) {
        let _e321 = toFragment;
        a = abs(_e321);
        let _e324 = a[0u];
        let _e326 = a[1u];
        let _e327 = (_e324 >= _e326);
        phi_2239_ = _e327;
        if _e327 {
            let _e329 = a[0u];
            let _e331 = a[2u];
            phi_2239_ = (_e329 >= _e331);
        }
        let _e334 = phi_2239_;
        if _e334 {
            let _e336 = toFragment[0u];
            face = select(1i, 0i, (_e336 > 0f));
        } else {
            let _e340 = a[1u];
            let _e342 = a[2u];
            if (_e340 >= _e342) {
                let _e345 = toFragment[1u];
                face = select(3i, 2i, (_e345 > 0f));
            } else {
                let _e349 = toFragment[2u];
                face = select(5i, 4i, (_e349 > 0f));
            }
        }
    }
    let _e352 = slot;
    let _e354 = face;
    let _e358 = point_shadow.faces[((_e352 * 6i) + _e354)];
    let _e359 = origin;
    clip = (_e358 * vec4<f32>(_e359.x, _e359.y, _e359.z, 1f));
    let _e366 = clip[3u];
    if (_e366 <= 0f) {
        return 1f;
    }
    let _e368 = clip;
    let _e371 = clip[3u];
    ndc = (_e368.xy / vec2(_e371));
    let _e375 = ndc[0u];
    let _e377 = (abs(_e375) > 1f);
    phi_2300_ = _e377;
    if !(_e377) {
        let _e380 = ndc[1u];
        phi_2300_ = (abs(_e380) > 1f);
    }
    let _e384 = phi_2300_;
    if _e384 {
        return 1f;
    }
    let _e386 = ndc[0u];
    let _e390 = ndc[1u];
    uv_3 = vec2<f32>(((_e386 * 0.5f) + 0.5f), (0.5f - (_e390 * 0.5f)));
    let _e394 = face;
    let _e396 = slot;
    tile_3 = vec2<f32>(f32(_e394), f32(_e396));
    let _e399 = distance_;
    let _e402 = point_shadow.params[1u];
    receiver_2 = (_e399 - _e402);
    let _e406 = frag_info.target_origin[0u];
    param_22 = _e406;
    let _e407 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e407, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e412 = noise;
    angle = (_e412 * 6.2831855f);
    let _e414 = angle;
    ca_2 = cos(_e414);
    let _e416 = angle;
    sa_2 = sin(_e416);
    let _e418 = (*lightIndex);
    let _e422 = point_shadow.slots[_e418][2u];
    tanHalf_1 = max(_e422, 0.0001f);
    blocker_1 = -1f;
    let _e424 = uv_3;
    param_23 = _e424;
    let _e425 = tile_3;
    param_24 = _e425;
    let _e426 = range_3;
    param_25 = _e426;
    let _e427 = receiver_2;
    param_26 = _e427;
    let _e428 = ca_2;
    param_27 = _e428;
    let _e429 = sa_2;
    param_28 = _e429;
    let _e430 = tanHalf_1;
    param_29 = _e430;
    let _e431 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e432 = param_30;
    blocker_1 = _e432;
    radius_1 = _e431;
    let _e435 = point_shadow.params2_[3u];
    if (_e435 > 0.5f) {
        g_debug_surface_on = true;
        let _e437 = radius_1;
        if (_e437 < 0f) {
            local_8 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e439 = radius_1;
            let _e442 = point_shadow.params2_[2u];
            let _e446 = blocker_1;
            let _e447 = range_3;
            local_8 = vec3<f32>(clamp((_e439 / max(_e442, 0.000001f)), 0f, 1f), clamp((_e446 / _e447), 0f, 1f), 0f);
        }
        let _e451 = local_8;
        g_debug_surface = _e451;
    }
    let _e452 = radius_1;
    if (_e452 < 0f) {
        return 1f;
    }
    let _e454 = uv_3;
    param_31 = _e454;
    param_32 = vec2<f32>(0f, 0f);
    let _e455 = tile_3;
    param_33 = _e455;
    let _e456 = range_3;
    param_34 = _e456;
    let _e457 = receiver_2;
    param_35 = _e457;
    let _e458 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e458;
    let _e459 = radius_1;
    if (_e459 > 0f) {
        i_3 = 0i;
        loop {
            let _e461 = i_3;
            if (_e461 < 8i) {
                let _e463 = i_3;
                param_36 = _e463;
                let _e464 = ca_2;
                param_37 = _e464;
                let _e465 = sa_2;
                param_38 = _e465;
                let _e466 = radius_1;
                param_39 = _e466;
                let _e467 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e468 = uv_3;
                param_40 = _e468;
                param_41 = _e467;
                let _e469 = tile_3;
                param_42 = _e469;
                let _e470 = range_3;
                param_43 = _e470;
                let _e471 = receiver_2;
                param_44 = _e471;
                let _e472 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e473 = lit;
                lit = (_e473 + _e472);
                continue;
            } else {
                break;
            }
            continuing {
                let _e475 = i_3;
                i_3 = (_e475 + 1i);
            }
        }
        let _e477 = lit;
        lit = (_e477 * 0.11111111f);
    }
    let _e479 = lit;
    let _e480 = strength;
    return mix(1f, _e479, clamp(_e480, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e177 = (*i_4);
    let _e180 = (*n_1);
    r = sqrt(((f32(_e177) + 0.5f) / f32(_e180)));
    let _e184 = (*i_4);
    let _e187 = (*turn);
    theta = ((f32(_e184) * 2.3999631f) + _e187);
    let _e189 = r;
    let _e190 = theta;
    let _e192 = theta;
    return (vec2<f32>(cos(_e190), sin(_e192)) * _e189);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e176 = frag_info.target_origin[0u];
    param_45 = _e176;
    let _e177 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e180 = frag_info.target_origin[3u];
    at = (_e177 + vec2((5.588238f * max(_e180, 0f))));
    let _e185 = at;
    return fract((52.982918f * fract(dot(_e185, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_9: f32;

    let _e175 = (*mode_1);
    if (_e175 > 0.5f) {
        let _e177 = (*stored_2);
        local_9 = (1f - _e177);
    } else {
        let _e179 = (*stored_2);
        local_9 = _e179;
    }
    let _e180 = local_9;
    return _e180;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e181 = (*moments)[1u];
    let _e183 = (*moments)[0u];
    let _e185 = (*moments)[0u];
    let _e188 = (*minVariance);
    variance = max((_e181 - (_e183 * _e185)), _e188);
    let _e190 = (*t);
    let _e192 = (*moments)[0u];
    d_1 = (_e190 - _e192);
    let _e194 = variance;
    let _e195 = variance;
    let _e196 = d_1;
    let _e197 = d_1;
    pMax = (_e194 / (_e195 + (_e196 * _e197)));
    let _e201 = pMax;
    let _e202 = (*bleed);
    let _e204 = (*bleed);
    reduced = clamp(((_e201 - _e202) / max((1f - _e204), 0.0001f)), 0f, 1f);
    let _e209 = (*t);
    let _e211 = (*moments)[0u];
    let _e213 = reduced;
    return select(_e213, 1f, (_e209 <= _e211));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e174 = (*depth);
    d_2 = ((2f * clamp(_e174, 0f, 1f)) - 1f);
    let _e178 = d_2;
    let _e181 = d_2;
    return vec2<f32>(exp((40f * _e178)), -(exp((-5f * _e181))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e188 = (*depth_1);
    param_46 = _e188;
    let _e189 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e189;
    let _e190 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e190);
    let _e193 = scale[0u];
    let _e195 = scale[0u];
    let _e197 = (*moments_1);
    param_47 = _e197.xy;
    let _e200 = warped[0u];
    param_48 = _e200;
    param_49 = (_e193 * _e195);
    let _e201 = (*bleed_1);
    param_50 = _e201;
    let _e202 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e202;
    let _e204 = scale[1u];
    let _e206 = scale[1u];
    let _e208 = (*moments_1);
    param_51 = _e208.zw;
    let _e211 = warped[1u];
    param_52 = _e211;
    param_53 = (_e204 * _e206);
    let _e212 = (*bleed_1);
    param_54 = _e212;
    let _e213 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e213;
    let _e214 = positive;
    let _e215 = negative;
    return min(_e214, _e215);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e174 = (*depth_2);
    stored_3 = max((1f - _e174), 0.000061035156f);
    let _e177 = stored_3;
    return exp2((floor(log2(_e177)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_10: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_11: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_13: f32;
    var local_14: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_3412_: bool;
    var phi_3423_: bool;
    var phi_3584_: bool;
    var phi_3591_: bool;
    var phi_3598_: bool;

    let _e253 = frag_info.shadow_params[3u];
    strength_1 = _e253;
    let _e254 = strength_1;
    if (_e254 <= 0f) {
        return 1f;
    }
    let _e256 = (*lightIndex_1);
    let _e259 = frag_info.frame_params[2u];
    if (_e256 != i32(floor((_e259 + 0.5f)))) {
        return 1f;
    }
    let _e266 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e266 + 0.5f));
    let _e269 = Orthographic_u0028_();
    if _e269 {
        let _e270 = ViewDepth_u0028_();
        local_10 = _e270;
    } else {
        let _e271 = v_world_position_1;
        let _e273 = frag_info.camera_position;
        local_10 = length((_e271 - _e273.xyz));
    }
    let _e277 = local_10;
    viewDistance = _e277;
    cascade = 0i;
    let _e278 = cascadeCount;
    let _e279 = (_e278 > 1i);
    phi_3412_ = _e279;
    if _e279 {
        let _e280 = viewDistance;
        let _e283 = frag_info.shadow_cascades[0u];
        phi_3412_ = (_e280 > _e283);
    }
    let _e286 = phi_3412_;
    if _e286 {
        cascade = 1i;
    }
    let _e287 = cascadeCount;
    let _e288 = (_e287 > 2i);
    phi_3423_ = _e288;
    if _e288 {
        let _e289 = viewDistance;
        let _e292 = frag_info.shadow_cascades[1u];
        phi_3423_ = (_e289 > _e292);
    }
    let _e295 = phi_3423_;
    if _e295 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e296 = attempt;
        if (_e296 < 3i) {
            let _e298 = cascade;
            let _e299 = attempt;
            which = (_e298 + _e299);
            let _e301 = which;
            let _e302 = cascadeCount;
            if (_e301 >= _e302) {
                break;
            }
            let _e304 = which;
            if (_e304 == 0i) {
                let _e307 = frag_info.shadow_matrix;
                local_11 = _e307;
            } else {
                let _e308 = which;
                if (_e308 == 1i) {
                    let _e311 = frag_info.shadow_matrix_far;
                    local_12 = _e311;
                } else {
                    let _e313 = frag_info.shadow_matrix_farthest;
                    local_12 = _e313;
                }
                let _e314 = local_12;
                local_11 = _e314;
            }
            let _e315 = local_11;
            matrix = _e315;
            let _e318 = matrix[0][0u];
            let _e321 = matrix[1][0u];
            let _e324 = matrix[2][0u];
            axisX = vec3<f32>(_e318, _e321, _e324);
            let _e328 = matrix[0][1u];
            let _e331 = matrix[1][1u];
            let _e334 = matrix[2][1u];
            axisY = vec3<f32>(_e328, _e331, _e334);
            let _e336 = axisX;
            rowX = max(length(_e336), 0.000001f);
            let _e339 = axisY;
            rowY = max(length(_e339), 0.000001f);
            let _e344 = frag_info.shadow_cascades[3u];
            let _e346 = rowX;
            texelMetres = ((2f * _e344) / _e346);
            let _e350 = frag_info.shadow_cascades[3u];
            let _e353 = (*s_2).n;
            let _e354 = axisX;
            let _e357 = rowX;
            let _e358 = rowX;
            let _e362 = (*s_2).n;
            let _e363 = axisY;
            let _e366 = rowY;
            let _e367 = rowY;
            reach = ((3f * _e350) * ((abs(dot(_e353, _e354)) / (_e357 * _e358)) + (abs(dot(_e362, _e363)) / (_e366 * _e367))));
            let _e374 = frag_info.shadow_params[2u];
            let _e375 = texelMetres;
            flatOffset = min(_e374, _e375);
            let _e377 = v_world_position_1;
            let _e379 = (*s_2).n;
            let _e380 = flatOffset;
            let _e381 = reach;
            origin_1 = (_e377 + (_e379 * (_e380 + _e381)));
            let _e385 = matrix;
            let _e386 = origin_1;
            lightSpace = (_e385 * vec4<f32>(_e386.x, _e386.y, _e386.z, 1f));
            let _e393 = lightSpace[3u];
            if (_e393 <= 0f) {
                continue;
            }
            let _e395 = lightSpace;
            let _e398 = lightSpace[3u];
            candidate = (_e395.xyz / vec3(_e398));
            let _e402 = candidate[0u];
            let _e406 = candidate[1u];
            inTile = vec2<f32>(((_e402 * 0.5f) + 0.5f), (0.5f - (_e406 * 0.5f)));
            let _e411 = inTile[0u];
            let _e412 = (_e411 < 0f);
            phi_3584_ = _e412;
            if !(_e412) {
                let _e415 = inTile[0u];
                phi_3584_ = (_e415 > 1f);
            }
            let _e418 = phi_3584_;
            phi_3591_ = _e418;
            if !(_e418) {
                let _e421 = inTile[1u];
                phi_3591_ = (_e421 < 0f);
            }
            let _e424 = phi_3591_;
            phi_3598_ = _e424;
            if !(_e424) {
                let _e427 = inTile[1u];
                phi_3598_ = (_e427 > 1f);
            }
            let _e430 = phi_3598_;
            if _e430 {
                continue;
            }
            let _e432 = candidate[2u];
            if (_e432 > 1f) {
                let _e434 = which;
                let _e435 = cascadeCount;
                if (_e434 < (_e435 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e440 = inTile[0u];
            let _e441 = which;
            let _e444 = cascadeCount;
            let _e448 = inTile[1u];
            uv_4 = vec2<f32>(((_e440 + f32(_e441)) / f32(_e444)), _e448);
            let _e450 = candidate;
            projected = _e450;
            let _e451 = which;
            cascade = _e451;
            let _e452 = texelMetres;
            cascadeTexel = _e452;
            let _e455 = matrix[0][2u];
            let _e458 = matrix[1][2u];
            let _e461 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e455, _e458, _e461)), 0.000001f));
            let _e467 = (*s_2).n;
            let _e470 = matrix[0][2u];
            let _e473 = matrix[1][2u];
            let _e476 = matrix[2][2u];
            let _e480 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e467, vec3<f32>(_e470, _e473, _e476))) * _e480), 0.1f, 1f);
            let _e483 = texelMetres;
            let _e484 = cosSlope;
            let _e485 = cosSlope;
            let _e491 = cosSlope;
            let _e493 = cascadeDepth;
            receiverSlope = (((_e483 * sqrt(max((1f - (_e484 * _e485)), 0f))) / _e491) / _e493);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e495 = attempt;
            attempt = (_e495 + 1i);
        }
    }
    let _e497 = found;
    if !(_e497) {
        return 1f;
    }
    let _e499 = cascade;
    if (_e499 == 0i) {
        let _e503 = frag_info.shadow_bias[0u];
        local_13 = _e503;
    } else {
        let _e504 = cascade;
        if (_e504 == 1i) {
            let _e508 = frag_info.shadow_bias[1u];
            local_14 = _e508;
        } else {
            let _e511 = frag_info.shadow_bias[2u];
            local_14 = _e511;
        }
        let _e512 = local_14;
        local_13 = _e512;
    }
    let _e513 = local_13;
    bias = _e513;
    let _e516 = frag_info.shadow_params[1u];
    storage_ = _e516;
    let _e517 = storage_;
    let _e519 = storage_;
    if ((_e517 > 0.5f) && (_e519 < 1.5f)) {
        let _e522 = bias;
        let _e524 = projected[2u];
        param_55 = _e524;
        let _e525 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e522, _e525);
    }
    let _e529 = frag_info.shadow_params[0u];
    let _e532 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e529, _e532);
    let _e534 = cascade;
    let _e536 = cascadeCount;
    let _e540 = texel_1;
    tileLo = (vec2<f32>((f32(_e534) / f32(_e536)), 0f) + (_e540 * 0.5f));
    let _e543 = cascade;
    let _e546 = cascadeCount;
    let _e550 = texel_1;
    tileHi = (vec2<f32>((f32((_e543 + 1i)) / f32(_e546)), 1f) - (_e550 * 0.5f));
    let _e555 = frag_info.shadow_bias[3u];
    if (_e555 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e557 = y;
            if (_e557 <= 1i) {
                x = -1i;
                loop {
                    let _e559 = x;
                    if (_e559 <= 1i) {
                        let _e561 = uv_4;
                        let _e562 = x;
                        let _e564 = y;
                        let _e567 = texel_1;
                        let _e570 = tileLo;
                        let _e571 = tileHi;
                        let _e573 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e561 + (vec2<f32>(f32(_e562), f32(_e564)) * _e567)), _e570, _e571), 0f);
                        let _e574 = stored_4;
                        stored_4 = (_e574 + _e573);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e576 = x;
                        x = (_e576 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e578 = y;
                y = (_e578 + 1i);
            }
        }
        let _e580 = stored_4;
        stored_4 = (_e580 * 0.11111111f);
        let _e583 = stored_4[1u];
        let _e586 = stored_4[2u];
        let _e589 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e583), (1f - _e586), _e589), vec3(0f), vec3(4f));
        let _e594 = through;
        let _e595 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e594, vec3(clamp(_e595, 0f, 1f)));
    }
    let _e601 = frag_info.ambient_ground[3u];
    softness = _e601;
    lit_1 = 0f;
    let _e602 = softness;
    if (_e602 < 0f) {
        let _e604 = uv_4;
        let _e605 = tileLo;
        let _e606 = tileHi;
        let _e608 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e604, _e605, _e606), 0f);
        moments_2 = _e608;
        let _e610 = projected[2u];
        let _e611 = bias;
        let _e613 = softness;
        let _e617 = moments_2;
        param_56 = _e617;
        param_57 = (_e610 - _e611);
        param_58 = clamp((-(_e613) - 1f), 0f, 0.95f);
        let _e618 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e618;
    } else {
        let _e619 = softness;
        if (_e619 <= 0f) {
            y_1 = -1i;
            loop {
                let _e621 = y_1;
                if (_e621 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e623 = x_1;
                        if (_e623 <= 1i) {
                            let _e625 = uv_4;
                            let _e626 = x_1;
                            let _e628 = y_1;
                            let _e631 = texel_1;
                            let _e634 = tileLo;
                            let _e635 = tileHi;
                            let _e637 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e625 + (vec2<f32>(f32(_e626), f32(_e628)) * _e631)), _e634, _e635), 0f);
                            param_59 = _e637.x;
                            let _e639 = storage_;
                            param_60 = _e639;
                            let _e640 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e640;
                            let _e642 = projected[2u];
                            let _e643 = bias;
                            let _e645 = occluder;
                            let _e648 = lit_1;
                            lit_1 = (_e648 + select(1f, 0f, ((_e642 - _e643) > _e645)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e650 = x_1;
                            x_1 = (_e650 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e652 = y_1;
                    y_1 = (_e652 + 1i);
                }
            }
            let _e654 = lit_1;
            lit_1 = (_e654 * 0.11111111f);
        } else {
            let _e656 = softness;
            spread = tan(min(_e656, 0.5f));
            let _e659 = ShadowNoise_u0028_();
            turn_1 = (_e659 * 6.2831855f);
            let _e661 = spread;
            let _e663 = projected[2u];
            let _e665 = cascadeDepth;
            let _e667 = cascadeTexel;
            searchRadius = clamp((((_e661 * _e663) * _e665) / _e667), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e670 = i_5;
                if (_e670 < 16i) {
                    let _e672 = i_5;
                    param_61 = _e672;
                    param_62 = 16i;
                    let _e673 = turn_1;
                    param_63 = _e673;
                    let _e674 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e674;
                    let _e675 = bias;
                    let _e676 = disc;
                    let _e678 = searchRadius;
                    let _e682 = receiverSlope;
                    tapBias = (_e675 + (max(((length(_e676) * _e678) - 1.5f), 0f) * _e682));
                    let _e685 = uv_4;
                    let _e686 = disc;
                    let _e687 = texel_1;
                    let _e689 = searchRadius;
                    let _e692 = tileLo;
                    let _e693 = tileHi;
                    let _e695 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e685 + ((_e686 * _e687) * _e689)), _e692, _e693), 0f);
                    param_64 = _e695.x;
                    let _e697 = storage_;
                    param_65 = _e697;
                    let _e698 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e698;
                    let _e700 = projected[2u];
                    let _e701 = tapBias;
                    let _e703 = occluder_1;
                    if ((_e700 - _e701) > _e703) {
                        let _e705 = occluder_1;
                        let _e706 = blockerSum;
                        blockerSum = (_e706 + _e705);
                        let _e708 = blockerCount;
                        blockerCount = (_e708 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e710 = i_5;
                    i_5 = (_e710 + 1i);
                }
            }
            let _e712 = blockerCount;
            if (_e712 <= 0f) {
                return 1f;
            }
            let _e715 = projected[2u];
            let _e716 = blockerSum;
            let _e717 = blockerCount;
            let _e721 = cascadeDepth;
            gap = (max((_e715 - (_e716 / _e717)), 0f) * _e721);
            let _e723 = spread;
            let _e724 = gap;
            let _e726 = cascadeTexel;
            radius_2 = clamp(((_e723 * _e724) / _e726), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e729 = i_6;
                if (_e729 < 16i) {
                    let _e731 = turn_1;
                    let _e733 = i_6;
                    param_66 = _e733;
                    param_67 = 16i;
                    param_68 = (_e731 + 1f);
                    let _e734 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e734;
                    let _e735 = bias;
                    let _e736 = disc_1;
                    let _e738 = radius_2;
                    let _e742 = receiverSlope;
                    tapBias_1 = (_e735 + (max(((length(_e736) * _e738) - 1.5f), 0f) * _e742));
                    let _e745 = uv_4;
                    let _e746 = disc_1;
                    let _e747 = texel_1;
                    let _e749 = radius_2;
                    let _e752 = tileLo;
                    let _e753 = tileHi;
                    let _e755 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e745 + ((_e746 * _e747) * _e749)), _e752, _e753), 0f);
                    param_69 = _e755.x;
                    let _e757 = storage_;
                    param_70 = _e757;
                    let _e758 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e758;
                    let _e760 = projected[2u];
                    let _e761 = tapBias_1;
                    let _e763 = occluder_2;
                    let _e766 = lit_1;
                    lit_1 = (_e766 + select(1f, 0f, ((_e760 - _e761) > _e763)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e768 = i_6;
                    i_6 = (_e768 + 1i);
                }
            }
            let _e770 = lit_1;
            lit_1 = (_e770 * 0.0625f);
        }
    }
    let _e772 = lit_1;
    let _e773 = strength_1;
    return mix(1f, _e772, clamp(_e773, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e178 = (*s_3);
    param_71 = _e178;
    let _e179 = (*light_2);
    param_72 = _e179;
    let _e180 = (*index);
    param_73 = _e180;
    let _e181 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e181;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e173 = (*index_1);
    return (_e173 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e177 = (*distance_1);
    let _e178 = (*distance_1);
    attenuation = (1f / max((_e177 * _e178), 0.0001f));
    let _e182 = (*range_4);
    if (_e182 > 0f) {
        let _e184 = (*distance_1);
        let _e185 = (*range_4);
        ratio = (_e184 / _e185);
        let _e187 = ratio;
        let _e188 = ratio;
        let _e190 = ratio;
        let _e192 = ratio;
        window = clamp((1f - (((_e187 * _e188) * _e190) * _e192)), 0f, 1f);
        let _e196 = window;
        let _e197 = window;
        let _e199 = attenuation;
        attenuation = (_e199 * (_e196 * _e197));
    }
    let _e201 = attenuation;
    return _e201;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_15: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e189 = (*halfWidth);
    let _e190 = (*halfHeight);
    n_2 = cross(_e189, _e190);
    let _e192 = n_2;
    nLen = length(_e192);
    let _e194 = nLen;
    if (_e194 < 0.000000000001f) {
        let _e196 = (*centre);
        return _e196;
    }
    let _e197 = nLen;
    let _e198 = n_2;
    n_2 = (_e198 / vec3(_e197));
    let _e201 = (*centre);
    let _e202 = (*world_2);
    toPlane = (_e201 - _e202);
    let _e204 = (*mirror);
    let _e205 = n_2;
    denom = dot(_e204, _e205);
    let _e207 = denom;
    if (abs(_e207) < 0.00001f) {
        let _e210 = toPlane;
        let _e211 = n_2;
        let _e212 = toPlane;
        let _e213 = n_2;
        onPlane = (_e210 - (_e211 * dot(_e212, _e213)));
    } else {
        let _e217 = toPlane;
        let _e218 = n_2;
        let _e220 = denom;
        t_1 = (dot(_e217, _e218) / _e220);
        let _e222 = t_1;
        if (_e222 > 0f) {
            let _e224 = (*mirror);
            let _e225 = t_1;
            local_15 = (_e224 * _e225);
        } else {
            let _e227 = toPlane;
            let _e228 = n_2;
            let _e229 = toPlane;
            let _e230 = n_2;
            local_15 = (_e227 - (_e228 * dot(_e229, _e230)));
        }
        let _e234 = local_15;
        onPlane = _e234;
    }
    let _e235 = onPlane;
    let _e236 = toPlane;
    offset_2 = (_e235 - _e236);
    let _e238 = (*halfWidth);
    let _e239 = (*halfWidth);
    wLen2_ = max(dot(_e238, _e239), 0.000000000001f);
    let _e242 = (*halfHeight);
    let _e243 = (*halfHeight);
    hLen2_ = max(dot(_e242, _e243), 0.000000000001f);
    let _e246 = offset_2;
    let _e247 = (*halfWidth);
    let _e249 = wLen2_;
    u = clamp((dot(_e246, _e247) / _e249), -1f, 1f);
    let _e252 = offset_2;
    let _e253 = (*halfHeight);
    let _e255 = hLen2_;
    v = clamp((dot(_e252, _e253) / _e255), -1f, 1f);
    let _e258 = (*centre);
    let _e259 = (*halfWidth);
    let _e260 = u;
    let _e263 = (*halfHeight);
    let _e264 = v;
    return ((_e258 + (_e259 * _e260)) + (_e263 * _e264));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_16: f32;

    let _e181 = (*a_1);
    let _e182 = (*a_1);
    ua = (_e181 / vec3(max(length(_e182), 0.000000000001f)));
    let _e187 = (*b);
    let _e188 = (*b);
    ub = (_e187 / vec3(max(length(_e188), 0.000000000001f)));
    let _e193 = ua;
    let _e194 = ub;
    angle_1 = acos(clamp(dot(_e193, _e194), -1f, 1f));
    let _e198 = ua;
    let _e199 = ub;
    axis = cross(_e198, _e199);
    let _e201 = axis;
    len = length(_e201);
    let _e203 = len;
    if (_e203 > 0.000001f) {
        let _e205 = angle_1;
        let _e206 = axis;
        let _e207 = (*n_3);
        let _e210 = len;
        local_16 = ((_e205 * dot(_e206, _e207)) / _e210);
    } else {
        local_16 = 0f;
    }
    let _e212 = local_16;
    return _e212;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_17: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_18: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_19: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e195 = i_7;
        if (_e195 < 4i) {
            let _e197 = i_7;
            let _e199 = (*corners)[_e197];
            a_2 = _e199;
            let _e200 = i_7;
            if (_e200 == 3i) {
                local_17 = 0i;
            } else {
                let _e202 = i_7;
                local_17 = (_e202 + 1i);
            }
            let _e204 = local_17;
            let _e206 = (*corners)[_e204];
            b_1 = _e206;
            let _e207 = a_2;
            let _e208 = (*n_4);
            ha = dot(_e207, _e208);
            let _e210 = b_1;
            let _e211 = (*n_4);
            hb = dot(_e210, _e211);
            let _e213 = ha;
            let _e214 = hb;
            d_3 = (_e213 - _e214);
            let _e216 = a_2;
            let _e217 = b_1;
            let _e218 = a_2;
            let _e220 = d_3;
            if (abs(_e220) > 0.000000000001f) {
                let _e223 = ha;
                let _e224 = d_3;
                local_18 = (_e223 / _e224);
            } else {
                local_18 = 0f;
            }
            let _e226 = local_18;
            q = (_e216 + ((_e217 - _e218) * _e226));
            let _e229 = ha;
            aAbove = (_e229 > 0f);
            let _e231 = hb;
            bAbove = (_e231 > 0f);
            let _e233 = aAbove;
            let _e234 = bAbove;
            if (_e233 || _e234) {
                let _e236 = aAbove;
                let _e237 = a_2;
                let _e238 = q;
                let _e241 = bAbove;
                let _e242 = b_1;
                let _e243 = q;
                param_74 = select(_e238, _e237, vec3(_e236));
                param_75 = select(_e243, _e242, vec3(_e241));
                let _e246 = (*n_4);
                param_76 = _e246;
                let _e247 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_19 = _e247;
            } else {
                local_19 = 0f;
            }
            let _e248 = local_19;
            let _e249 = total;
            total = (_e249 + _e248);
            let _e251 = aAbove;
            let _e252 = bAbove;
            let _e255 = q;
            let _e256 = exit;
            exit = select(_e256, _e255, vec3((_e251 && !(_e252))));
            let _e259 = aAbove;
            let _e261 = bAbove;
            let _e263 = q;
            let _e264 = entry;
            entry = select(_e264, _e263, vec3((!(_e259) && _e261)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e267 = i_7;
            i_7 = (_e267 + 1i);
        }
    }
    let _e269 = exit;
    param_77 = _e269;
    let _e270 = entry;
    param_78 = _e270;
    let _e271 = (*n_4);
    param_79 = _e271;
    let _e272 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e273 = total;
    total = (_e273 + _e272);
    let _e275 = total;
    return max((-(_e275) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_20: f32;
    var local_21: f32;
    var local_22: f32;

    let _e178 = (*slot_1);
    let _e179 = (*slot_1);
    lane = (_e178 - ((_e179 / 4i) * 4i));
    let _e183 = lane;
    if (_e183 == 0i) {
        let _e186 = (*four)[0u];
        local_20 = _e186;
    } else {
        let _e187 = lane;
        if (_e187 == 1i) {
            let _e190 = (*four)[1u];
            local_21 = _e190;
        } else {
            let _e191 = lane;
            if (_e191 == 2i) {
                let _e194 = (*four)[2u];
                local_22 = _e194;
            } else {
                let _e196 = (*four)[3u];
                local_22 = _e196;
            }
            let _e197 = local_22;
            local_21 = _e197;
        }
        let _e198 = local_21;
        local_20 = _e198;
    }
    let _e199 = local_20;
    return _e199;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e175 = (*slot_2);
    let _e179 = light_list_info.scales[(_e175 / 4i)];
    param_80 = _e179;
    let _e180 = (*slot_2);
    param_81 = _e180;
    let _e181 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e181;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e177 = light_list_info.slot_rows[0i];
    let _e178 = (*row);
    a_3 = abs((_e177 - vec4(_e178)));
    let _e184 = light_list_info.slot_rows[1i];
    let _e185 = (*row);
    b_2 = abs((_e184 - vec4(_e185)));
    let _e190 = a_3[0u];
    let _e192 = a_3[1u];
    let _e195 = a_3[2u];
    let _e197 = a_3[3u];
    let _e201 = b_2[0u];
    let _e203 = b_2[1u];
    let _e206 = b_2[2u];
    let _e208 = b_2[3u];
    return (min(min(min(_e190, _e192), min(_e195, _e197)), min(min(_e201, _e203), min(_e206, _e208))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e175 = (*slot_3);
    let _e179 = light_list_info.indices[(_e175 / 4i)];
    param_82 = _e179;
    let _e180 = (*slot_3);
    param_83 = _e180;
    let _e181 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e181;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e174 = (*texel_2);
    let _e178 = light_list_info.list[1u];
    let _e180 = (*row_1);
    let _e184 = light_list_info.list[2u];
    let _e187 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e174 + 0.5f) * _e178), ((_e180 + 0.5f) * _e184)), 0f);
    return _e187;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e182 = g_cluster_offset;
    let _e183 = (*slot_4);
    entry_1 = (_e182 + f32(_e183));
    let _e186 = entry_1;
    row_2 = floor((_e186 / 16f));
    let _e189 = entry_1;
    let _e190 = row_2;
    within = (_e189 - (_e190 * 16f));
    let _e193 = within;
    texel_3 = floor((_e193 / 4f));
    let _e198 = light_list_info.cluster_depth[3u];
    let _e199 = row_2;
    let _e201 = texel_3;
    param_84 = _e201;
    param_85 = (_e198 + _e199);
    let _e202 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e202;
    let _e203 = within;
    let _e204 = texel_3;
    let _e209 = four_1;
    param_86 = _e209;
    param_87 = i32(((_e203 - (_e204 * 4f)) + 0.5f));
    let _e210 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e210;
}

fn Clustered_u0028_() -> bool {
    let _e174 = light_list_info.cluster_grid[3u];
    return (_e174 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_23: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_24: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_25: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_26: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_27: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e226 = (*index_2);
    if (_e226 < 8i) {
        let _e228 = (*index_2);
        let _e231 = frag_info.light_position[_e228];
        position = _e231;
        let _e232 = (*index_2);
        let _e235 = frag_info.light_color[_e232];
        color_1 = _e235;
        let _e236 = (*index_2);
        let _e239 = frag_info.light_direction[_e236];
        direction = _e239;
        let _e240 = (*index_2);
        let _e243 = frag_info.light_cone[_e240];
        cone = _e243;
    } else {
        let _e244 = (*index_2);
        slot_5 = (_e244 - 8i);
        let _e246 = Clustered_u0028_();
        clustered = _e246;
        let _e247 = clustered;
        if _e247 {
            let _e248 = slot_5;
            param_88 = _e248;
            let _e249 = ClusterRow_u0028_i1_u003b((&param_88));
            local_23 = _e249;
        } else {
            let _e250 = slot_5;
            param_89 = _e250;
            let _e251 = LightListRow_u0028_i1_u003b((&param_89));
            local_23 = _e251;
        }
        let _e252 = local_23;
        listRow = _e252;
        let _e253 = listRow;
        let _e257 = light_list_info.list[2u];
        v_1 = ((_e253 + 0.5f) * _e257);
        let _e261 = light_list_info.list[1u];
        u_1 = _e261;
        let _e262 = u_1;
        let _e264 = v_1;
        let _e266 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e262), _e264), 0f);
        position = _e266;
        let _e267 = u_1;
        let _e269 = v_1;
        let _e271 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e267), _e269), 0f);
        color_1 = _e271;
        let _e272 = u_1;
        let _e274 = v_1;
        let _e276 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e272), _e274), 0f);
        direction = _e276;
        let _e277 = u_1;
        let _e279 = v_1;
        let _e281 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e277), _e279), 0f);
        cone = _e281;
        let _e282 = clustered;
        if _e282 {
            let _e283 = listRow;
            param_90 = _e283;
            let _e284 = InSlots_u0028_f1_u003b((&param_90));
            local_24 = select(1f, 0f, _e284);
        } else {
            let _e286 = slot_5;
            param_91 = _e286;
            let _e287 = LightListScale_u0028_i1_u003b((&param_91));
            local_24 = _e287;
        }
        let _e288 = local_24;
        let _e290 = color_1[3u];
        color_1[3u] = (_e290 * _e288);
    }
    let _e294 = position[3u];
    type_39 = _e294;
    let _e295 = type_39;
    if (_e295 > 15.5f) {
        let _e298 = (*s_4).n;
        light_3.l = _e298;
        let _e301 = (*s_4).n;
        light_3.h = _e301;
        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 _e307 = light_3;
        return _e307;
    }
    let _e308 = type_39;
    if (_e308 > 2.5f) {
        let _e310 = direction;
        halfWidth_1 = _e310.xyz;
        let _e312 = cone;
        halfHeight_1 = _e312.xyz;
        let _e314 = position;
        let _e316 = v_world_position_1;
        toCentre = (_e314.xyz - _e316);
        let _e318 = toCentre;
        let _e319 = halfWidth_1;
        let _e321 = halfHeight_1;
        corners_1[0i] = ((_e318 - _e319) - _e321);
        let _e324 = toCentre;
        let _e325 = halfWidth_1;
        let _e327 = halfHeight_1;
        corners_1[1i] = ((_e324 + _e325) - _e327);
        let _e330 = toCentre;
        let _e331 = halfWidth_1;
        let _e333 = halfHeight_1;
        corners_1[2i] = ((_e330 + _e331) + _e333);
        let _e336 = toCentre;
        let _e337 = halfWidth_1;
        let _e339 = halfHeight_1;
        corners_1[3i] = ((_e336 - _e337) + _e339);
        let _e342 = toCentre;
        let _e343 = halfWidth_1;
        let _e344 = halfHeight_1;
        behind = (dot(_e342, cross(_e343, _e344)) >= 0f);
        let _e348 = behind;
        if _e348 {
            local_25 = 0f;
        } else {
            let _e349 = corners_1;
            param_92 = _e349;
            let _e351 = (*s_4).n;
            param_93 = _e351;
            let _e352 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_25 = _e352;
        }
        let _e353 = local_25;
        formFactor = _e353;
        let _e354 = halfWidth_1;
        let _e355 = halfHeight_1;
        area = (length(cross(_e354, _e355)) * 4f);
        let _e359 = area;
        if (_e359 > 0.000000001f) {
            let _e361 = area;
            local_26 = (1f / _e361);
        } else {
            local_26 = 0f;
        }
        let _e363 = local_26;
        radiance = _e363;
        let _e364 = toCentre;
        distance_2 = length(_e364);
        let _e367 = direction[3u];
        if (_e367 > 0f) {
            let _e369 = distance_2;
            let _e371 = direction[3u];
            ratio_1 = (_e369 / _e371);
            let _e373 = ratio_1;
            let _e374 = ratio_1;
            let _e376 = ratio_1;
            let _e378 = ratio_1;
            window_1 = clamp((1f - (((_e373 * _e374) * _e376) * _e378)), 0f, 1f);
            let _e382 = window_1;
            let _e383 = window_1;
            let _e385 = radiance;
            radiance = (_e385 * (_e382 * _e383));
        }
        let _e388 = (*s_4).v;
        let _e391 = (*s_4).n;
        mirror_1 = reflect(-(_e388), _e391);
        let _e393 = position;
        param_94 = _e393.xyz;
        let _e395 = halfWidth_1;
        param_95 = _e395;
        let _e396 = halfHeight_1;
        param_96 = _e396;
        let _e397 = v_world_position_1;
        param_97 = _e397;
        let _e398 = mirror_1;
        param_98 = _e398;
        let _e399 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e399;
        let _e400 = representative;
        let _e401 = v_world_position_1;
        toPoint = (_e400 - _e401);
        let _e403 = toPoint;
        pointDistance = length(_e403);
        let _e405 = pointDistance;
        if (_e405 > 0.000001f) {
            let _e407 = toPoint;
            let _e408 = pointDistance;
            local_27 = (_e407 / vec3(_e408));
        } else {
            let _e412 = (*s_4).n;
            local_27 = _e412;
        }
        let _e413 = local_27;
        light_3.l = _e413;
        let _e416 = light_3.l;
        let _e418 = (*s_4).v;
        light_3.h = normalize((_e416 + _e418));
        let _e422 = formFactor;
        light_3.n_dot_l = _e422;
        let _e425 = (*s_4).n;
        let _e427 = light_3.h;
        light_3.n_dot_h = max(dot(_e425, _e427), 0f);
        let _e432 = (*s_4).v;
        let _e434 = light_3.h;
        light_3.v_dot_h = max(dot(_e432, _e434), 0f);
        let _e438 = color_1;
        let _e441 = color_1[3u];
        let _e443 = radiance;
        light_3.radiance = ((_e438.xyz * _e441) * _e443);
        let _e446 = light_3;
        return _e446;
    }
    let _e447 = direction;
    aim = normalize(_e447.xyz);
    attenuation_1 = 1f;
    let _e450 = type_39;
    if (_e450 < 0.5f) {
        let _e452 = aim;
        light_3.l = -(_e452);
    } else {
        let _e455 = position;
        let _e457 = v_world_position_1;
        toLight_1 = (_e455.xyz - _e457);
        let _e459 = toLight_1;
        distance_3 = length(_e459);
        let _e461 = distance_3;
        if (_e461 < 0.000001f) {
            let _e464 = (*s_4).n;
            light_3.l = _e464;
            let _e467 = (*s_4).n;
            light_3.h = _e467;
            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 _e473 = light_3;
            return _e473;
        }
        let _e474 = toLight_1;
        let _e475 = distance_3;
        light_3.l = (_e474 / vec3(_e475));
        let _e479 = distance_3;
        param_99 = _e479;
        let _e481 = direction[3u];
        param_100 = _e481;
        let _e482 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e482;
        let _e483 = type_39;
        if (_e483 > 1.5f) {
            let _e485 = aim;
            let _e487 = light_3.l;
            cosAngle = dot(_e485, -(_e487));
            let _e490 = cosAngle;
            let _e492 = cone[1u];
            let _e495 = cone[0u];
            let _e497 = cone[1u];
            ramp = clamp(((_e490 - _e492) / (_e495 - _e497)), 0f, 1f);
            let _e501 = ramp;
            let _e502 = ramp;
            let _e504 = attenuation_1;
            attenuation_1 = (_e504 * (_e501 * _e502));
        }
    }
    let _e507 = light_3.l;
    let _e509 = (*s_4).v;
    light_3.h = normalize((_e507 + _e509));
    let _e514 = (*s_4).n;
    let _e516 = light_3.l;
    light_3.n_dot_l = max(dot(_e514, _e516), 0f);
    let _e521 = (*s_4).n;
    let _e523 = light_3.h;
    light_3.n_dot_h = max(dot(_e521, _e523), 0f);
    let _e528 = (*s_4).v;
    let _e530 = light_3.h;
    light_3.v_dot_h = max(dot(_e528, _e530), 0f);
    let _e534 = color_1;
    let _e537 = color_1[3u];
    let _e539 = attenuation_1;
    light_3.radiance = ((_e534.xyz * _e537) * _e539);
    let _e542 = light_3;
    return _e542;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_28: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e187 = light_list_info.cluster_view_projection;
    let _e188 = (*world_3);
    clip_1 = (_e187 * vec4<f32>(_e188.x, _e188.y, _e188.z, 1f));
    let _e194 = clip_1;
    let _e197 = clip_1[3u];
    ndc_1 = (_e194.xy / vec2(max(_e197, 0.000001f)));
    let _e202 = light_list_info.cluster_grid;
    grid = _e202.xyz;
    let _e206 = light_list_info.cluster_depth[0u];
    near_1 = _e206;
    let _e208 = ndc_1[0u];
    let _e212 = grid[0u];
    let _e216 = grid[0u];
    tx = clamp(floor((((_e208 * 0.5f) + 0.5f) * _e212)), 0f, (_e216 - 1f));
    let _e220 = ndc_1[1u];
    let _e224 = grid[1u];
    let _e228 = grid[1u];
    ty = clamp(floor((((_e220 * 0.5f) + 0.5f) * _e224)), 0f, (_e228 - 1f));
    let _e232 = clip_1[3u];
    let _e233 = near_1;
    if (_e232 <= _e233) {
        local_28 = 0f;
    } else {
        let _e236 = clip_1[3u];
        let _e237 = near_1;
        let _e242 = light_list_info.cluster_depth[1u];
        let _e246 = grid[2u];
        local_28 = clamp(floor((log((_e236 / _e237)) * _e242)), 0f, (_e246 - 1f));
    }
    let _e249 = local_28;
    tz = _e249;
    let _e250 = tx;
    let _e251 = ty;
    let _e253 = grid[0u];
    let _e256 = tz;
    let _e258 = grid[0u];
    let _e261 = grid[1u];
    cell = ((_e250 + (_e251 * _e253)) + ((_e256 * _e258) * _e261));
    let _e264 = cell;
    row_3 = floor((_e264 / 4f));
    let _e267 = cell;
    let _e268 = row_3;
    let _e273 = light_list_info.cluster_depth[2u];
    let _e274 = row_3;
    param_101 = (_e267 - (_e268 * 4f));
    param_102 = (_e273 + _e274);
    let _e276 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e276;
    let _e278 = header[0u];
    g_cluster_offset = _e278;
    let _e280 = header[1u];
    g_cluster_count = _e280;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e176 = light_list_info.list[0u];
    tail = _e176;
    let _e177 = Clustered_u0028_();
    if _e177 {
        let _e178 = v_world_position_1;
        param_103 = _e178;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e179 = g_cluster_count;
        tail = _e179;
    }
    let _e182 = frag_info.frame_params[1u];
    let _e186 = tail;
    return (clamp(i32((_e182 + 0.5f)), 0i, 8i) + clamp(i32((_e186 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_29: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e190 = LightCount_u0028_();
    count_1 = _e190;
    i_8 = 0i;
    loop {
        let _e191 = i_8;
        if (_e191 < 32i) {
            let _e193 = i_8;
            let _e194 = count_1;
            if (_e193 >= _e194) {
                break;
            }
            let _e196 = i_8;
            param_104 = _e196;
            let _e197 = (*s_5);
            param_105 = _e197;
            let _e198 = 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((&param_104), (&param_105));
            light_4 = _e198;
            let _e200 = light_4.n_dot_l;
            if (_e200 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e202 = i_8;
            param_106 = _e202;
            let _e203 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e203 {
                let _e204 = (*s_5);
                param_107 = _e204;
                let _e205 = light_4;
                param_108 = _e205;
                let _e206 = i_8;
                param_109 = _e206;
                let _e207 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e208 = v_world_position_1;
                param_110 = _e208;
                let _e210 = (*s_5).n;
                param_111 = _e210;
                let _e211 = i_8;
                param_112 = _e211;
                let _e212 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_29 = (_e207 * _e212);
            } else {
                local_29 = 1f;
            }
            let _e214 = local_29;
            visibility = _e214;
            let _e215 = visibility;
            if (_e215 <= 0f) {
                continue;
            }
            let _e217 = (*s_5);
            param_113 = _e217;
            let _e218 = light_4;
            param_114 = _e218;
            let _e219 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e221 = light_4.radiance;
            let _e224 = light_4.n_dot_l;
            let _e226 = visibility;
            let _e228 = light_transmittance;
            let _e230 = total_1;
            total_1 = (_e230 + ((((_e219 * _e221) * _e224) * _e226) * _e228));
            continue;
        } else {
            break;
        }
        continuing {
            let _e232 = i_8;
            i_8 = (_e232 + 1i);
        }
    }
    let _e234 = total_1;
    return _e234;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_30: f32;
    var local_31: f32;

    let _e176 = OcclusionTarget_u0028_();
    target_ = _e176;
    let _e177 = target_;
    let _e179 = target_;
    if ((_e177 > 0.5f) && (_e179 < 1.5f)) {
        local_30 = 1f;
    } else {
        let _e183 = (*s_6).occlusion;
        local_30 = _e183;
    }
    let _e184 = local_30;
    local_31 = _e184;
    let _e185 = local_31;
    return _e185;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e173 = v_lightmap_uv_1;
    let _e174 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e173);
    texel_4 = _e174;
    let _e175 = texel_4;
    let _e178 = texel_4[3u];
    return ((_e175.xyz * _e178) * 8f);
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e173 = (*srgb);
    let _e176 = (*srgb);
    let _e181 = (*srgb);
    return mix((_e173 / vec3(12.92f)), pow(((_e176 + 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), _e181));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e174 = frag_info.target_origin[1u];
    return _e174;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_115: vec3<f32>;

    let _e175 = v_texcoord_1;
    let _e176 = MaterialLodBias_u0028_();
    let _e177 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e175, _e176);
    param_115 = _e177.xyz;
    let _e179 = SrgbToLinear_u0028_vf3_u003b((&param_115));
    emissive = _e179;
    let _e180 = emissive;
    let _e182 = frag_info.emissive;
    let _e187 = frag_info.material2_[3u];
    (*s_7).emissive = ((_e180 * _e182.xyz) * _e187);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e175 = v_texcoord_1;
    let _e176 = MaterialLodBias_u0028_();
    let _e177 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e175, _e176);
    occlusion = _e177.x;
    let _e181 = frag_info.material2_[2u];
    let _e182 = OcclusionTarget_u0028_();
    strength_2 = (_e181 - (2f * _e182));
    let _e185 = occlusion;
    let _e186 = strength_2;
    (*s_8).occlusion = mix(1f, _e185, clamp(_e186, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e177 = v_texcoord_1;
    let _e178 = MaterialLodBias_u0028_();
    let _e179 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e177, _e178);
    sampledTexel = _e179;
    let _e180 = v_tangent_1;
    t_2 = _e180.xyz;
    let _e182 = t_2;
    let _e184 = (*s_9).n;
    let _e186 = (*s_9).n;
    let _e187 = t_2;
    t_2 = (_e182 - (_e184 * dot(_e186, _e187)));
    let _e191 = t_2;
    let _e192 = t_2;
    if (dot(_e191, _e192) < 0.000000000001f) {
        return;
    }
    let _e195 = t_2;
    t_2 = normalize(_e195);
    let _e198 = (*s_9).n;
    let _e199 = t_2;
    let _e202 = v_tangent_1[3u];
    b_3 = (cross(_e198, _e199) * _e202);
    let _e204 = gl_FrontFacing_1;
    if !(_e204) {
        let _e206 = t_2;
        t_2 = -(_e206);
    }
    let _e208 = sampledTexel;
    sampled = ((_e208.xyz * 2f) - vec3(1f));
    let _e215 = frag_info.emissive[3u];
    if (_e215 > 0.5f) {
        let _e217 = sampled;
        let _e219 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e217.xy, _e219.xy)), 0f));
    }
    let _e228 = frag_info.material2_[1u];
    let _e229 = sampled;
    let _e231 = (_e229.xy * _e228);
    sampled[0u] = _e231.x;
    sampled[1u] = _e231.y;
    let _e236 = t_2;
    let _e238 = sampled[0u];
    let _e240 = b_3;
    let _e242 = sampled[1u];
    let _e246 = (*s_9).n;
    let _e248 = sampled[2u];
    (*s_9).n = normalize((((_e236 * _e238) + (_e240 * _e242)) + (_e246 * _e248)));
    let _e254 = (*s_9).n;
    let _e256 = (*s_9).v;
    (*s_9).n_dot_v = max(dot(_e254, _e256), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e173 = (*texel_5);
    let _e177 = irradiance_info.atlas;
    let _e180 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e173 + vec2(0.5f)) * _e177.xy), 0f);
    return _e180;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_116: vec2<f32>;
    var b_4: vec4<f32>;
    var param_117: vec2<f32>;
    var c: vec4<f32>;
    var param_118: vec2<f32>;
    var d_4: vec4<f32>;
    var param_119: vec2<f32>;

    let _e186 = (*uv_5);
    let _e187 = (*interior);
    at_1 = ((vec2(1f) + (_e186 * _e187)) - vec2(0.5f));
    let _e193 = at_1;
    low = floor(_e193);
    let _e195 = at_1;
    let _e196 = low;
    f = (_e195 - _e196);
    let _e198 = (*corner);
    let _e199 = low;
    param_116 = (_e198 + _e199);
    let _e201 = AtlasTexel_u0028_vf2_u003b((&param_116));
    a_4 = _e201;
    let _e202 = (*corner);
    let _e203 = low;
    param_117 = ((_e202 + _e203) + vec2<f32>(1f, 0f));
    let _e206 = AtlasTexel_u0028_vf2_u003b((&param_117));
    b_4 = _e206;
    let _e207 = (*corner);
    let _e208 = low;
    param_118 = ((_e207 + _e208) + vec2<f32>(0f, 1f));
    let _e211 = AtlasTexel_u0028_vf2_u003b((&param_118));
    c = _e211;
    let _e212 = (*corner);
    let _e213 = low;
    param_119 = ((_e212 + _e213) + vec2<f32>(1f, 1f));
    let _e216 = AtlasTexel_u0028_vf2_u003b((&param_119));
    d_4 = _e216;
    let _e217 = a_4;
    let _e218 = b_4;
    let _e220 = f[0u];
    let _e223 = c;
    let _e224 = d_4;
    let _e226 = f[0u];
    let _e230 = f[1u];
    return mix(mix(_e217, _e218, vec4(_e220)), mix(_e223, _e224, vec4(_e226)), vec4(_e230));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e177 = (*direction_1)[0u];
    let _e180 = (*direction_1)[1u];
    let _e184 = (*direction_1)[2u];
    sum_1 = ((abs(_e177) + abs(_e180)) + abs(_e184));
    let _e187 = sum_1;
    if (_e187 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e189 = (*direction_1);
    let _e190 = sum_1;
    n_5 = (_e189 / vec3(_e190));
    let _e193 = n_5;
    xy = _e193.xy;
    let _e196 = n_5[2u];
    if (_e196 < 0f) {
        let _e199 = n_5[1u];
        let _e203 = n_5[0u];
        let _e208 = n_5[0u];
        let _e212 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e199)) * select(-1f, 1f, (_e203 >= 0f))), ((1f - abs(_e208)) * select(-1f, 1f, (_e212 >= 0f))));
    }
    let _e217 = xy;
    return ((_e217 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_120: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_121: vec3<f32>;
    var param_122: vec2<f32>;
    var param_123: f32;
    var param_124: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_125: vec3<f32>;
    var param_126: vec2<f32>;
    var param_127: f32;
    var param_128: vec2<f32>;
    var local_32: vec3<f32>;

    let _e219 = irradiance_info.origin;
    origin_2 = _e219.xyz;
    let _e222 = irradiance_info.spacing;
    spacing = _e222.xyz;
    let _e225 = irradiance_info.counts;
    counts = _e225.xyz;
    let _e229 = irradiance_info.tiles[0u];
    irradianceTile = _e229;
    let _e232 = irradiance_info.tiles[1u];
    depthTile = _e232;
    let _e235 = irradiance_info.tiles[2u];
    columns = _e235;
    let _e238 = irradiance_info.tiles[3u];
    momentsTop = _e238;
    let _e239 = (*normal_1);
    unit = normalize(_e239);
    let _e241 = (*world_4);
    let _e242 = unit;
    let _e245 = irradiance_info.spacing[3u];
    let _e248 = (*view);
    let _e251 = irradiance_info.counts[3u];
    biased = ((_e241 + (_e242 * _e245)) + (_e248 * _e251));
    let _e254 = biased;
    let _e255 = origin_2;
    let _e257 = spacing;
    grid_1 = ((_e254 - _e255) / _e257);
    let _e259 = grid_1;
    let _e261 = counts;
    base = clamp(floor(_e259), vec3<f32>(0f, 0f, 0f), (_e261 - vec3(2f)));
    let _e265 = grid_1;
    let _e266 = base;
    f_1 = clamp((_e265 - _e266), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e269 = corner_1;
        if (_e269 < 8i) {
            let _e271 = corner_1;
            let _e274 = corner_1;
            let _e279 = corner_1;
            offset_3 = vec3<f32>(f32((_e271 & 1i)), f32(((_e274 >> bitcast<u32>(1i)) & 1i)), f32(((_e279 >> bitcast<u32>(2i)) & 1i)));
            let _e285 = base;
            let _e286 = offset_3;
            cell_1 = (_e285 + _e286);
            let _e289 = cell_1[2u];
            let _e291 = counts[1u];
            let _e294 = cell_1[1u];
            let _e297 = counts[0u];
            let _e300 = cell_1[0u];
            probe = ((((_e289 * _e291) + _e294) * _e297) + _e300);
            let _e302 = probe;
            let _e303 = columns;
            let _e308 = probe;
            let _e309 = columns;
            tile_4 = vec2<f32>((_e302 - (floor((_e302 / _e303)) * _e303)), floor((_e308 / _e309)));
            let _e313 = tile_4;
            let _e314 = irradianceTile;
            irradianceCorner = (_e313 * (_e314 + 2f));
            let _e318 = tile_4[0u];
            let _e319 = depthTile;
            let _e322 = momentsTop;
            let _e324 = tile_4[1u];
            let _e325 = depthTile;
            momentCorner = vec2<f32>((_e318 * (_e319 + 2f)), (_e322 + (_e324 * (_e325 + 2f))));
            let _e330 = irradianceCorner;
            param_120 = (_e330 + vec2(1f));
            let _e333 = AtlasTexel_u0028_vf2_u003b((&param_120));
            if (_e333.w < 0.5f) {
                continue;
            }
            let _e336 = f_1;
            let _e338 = f_1;
            let _e339 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e336), _e338, _e339);
            let _e342 = trilinear[0u];
            let _e344 = trilinear[1u];
            let _e347 = trilinear[2u];
            weight_2 = max(((_e342 * _e344) * _e347), 0.001f);
            let _e350 = origin_2;
            let _e351 = spacing;
            let _e352 = cell_1;
            probePosition = (_e350 + (_e351 * _e352));
            let _e355 = probePosition;
            let _e356 = biased;
            toProbe = (_e355 - _e356);
            let _e358 = toProbe;
            distance_4 = length(_e358);
            let _e360 = distance_4;
            if (_e360 > 0.000001f) {
                let _e362 = toProbe;
                let _e363 = distance_4;
                direction_2 = (_e362 / vec3(_e363));
                let _e366 = unit;
                let _e367 = probePosition;
                let _e368 = (*world_4);
                facing = ((dot(_e366, normalize((_e367 - _e368))) * 0.5f) + 0.5f);
                let _e374 = facing;
                let _e375 = facing;
                probeWeight = ((_e374 * _e375) + 0.2f);
                let _e378 = direction_2;
                param_121 = -(_e378);
                let _e380 = ProbeOctahedral_u0028_vf3_u003b((&param_121));
                let _e381 = momentCorner;
                param_122 = _e381;
                let _e382 = depthTile;
                param_123 = _e382;
                param_124 = _e380;
                let _e383 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_122), (&param_123), (&param_124));
                moments_3 = _e383.xy;
                chebyshev = 1f;
                let _e385 = distance_4;
                let _e387 = moments_3[0u];
                if (_e385 > _e387) {
                    let _e390 = moments_3[1u];
                    let _e392 = moments_3[0u];
                    let _e394 = moments_3[0u];
                    variance_1 = max((_e390 - (_e392 * _e394)), 0.000001f);
                    let _e398 = distance_4;
                    let _e400 = moments_3[0u];
                    difference = (_e398 - _e400);
                    let _e402 = variance_1;
                    let _e403 = variance_1;
                    let _e404 = difference;
                    let _e405 = difference;
                    chebyshev = (_e402 / (_e403 + (_e404 * _e405)));
                    let _e409 = chebyshev;
                    let _e410 = chebyshev;
                    let _e412 = chebyshev;
                    chebyshev = ((_e409 * _e410) * _e412);
                }
                let _e414 = probeWeight;
                let _e415 = chebyshev;
                probeWeight = max((_e414 * max(_e415, 0.05f)), 0.000001f);
                let _e419 = probeWeight;
                if (_e419 < 0.2f) {
                    let _e421 = probeWeight;
                    let _e422 = probeWeight;
                    let _e425 = probeWeight;
                    probeWeight = (_e425 * ((_e421 * _e422) * 25f));
                }
                let _e427 = probeWeight;
                let _e428 = weight_2;
                weight_2 = (_e428 * _e427);
            }
            let _e430 = unit;
            param_125 = _e430;
            let _e431 = ProbeOctahedral_u0028_vf3_u003b((&param_125));
            let _e432 = irradianceCorner;
            param_126 = _e432;
            let _e433 = irradianceTile;
            param_127 = _e433;
            param_128 = _e431;
            let _e434 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_126), (&param_127), (&param_128));
            let _e436 = weight_2;
            let _e438 = total_2;
            total_2 = (_e438 + (_e434.xyz * _e436));
            let _e440 = weight_2;
            let _e441 = weights;
            weights = (_e441 + _e440);
            continue;
        } else {
            break;
        }
        continuing {
            let _e443 = corner_1;
            corner_1 = (_e443 + 1i);
        }
    }
    let _e445 = weights;
    if (_e445 > 0f) {
        let _e447 = total_2;
        let _e448 = weights;
        local_32 = (_e447 / vec3(_e448));
    } else {
        local_32 = vec3<f32>(0f, 0f, 0f);
    }
    let _e451 = local_32;
    return _e451;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e174 = irradiance_info.origin[3u];
    return (_e174 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;
    var param_132: Surface;
    var param_133: Surface;
    var param_134: Surface;

    let _e179 = IrradianceEnabled_u0028_();
    if _e179 {
        let _e180 = v_world_position_1;
        param_129 = _e180;
        let _e182 = (*s_10).n;
        param_130 = _e182;
        let _e184 = (*s_10).v;
        param_131 = _e184;
        let _e185 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
        let _e188 = frag_info.material[2u];
        (*s_10).ambient = (_e185 * _e188);
    }
    let _e191 = (*s_10);
    param_132 = _e191;
    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((&param_132));
    let _e192 = param_132;
    (*s_10) = _e192;
    let _e193 = (*s_10);
    param_133 = _e193;
    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((&param_133));
    let _e194 = param_133;
    (*s_10) = _e194;
    let _e195 = (*s_10);
    param_134 = _e195;
    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((&param_134));
    let _e196 = param_134;
    (*s_10) = _e196;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_33: vec3<f32>;

    let _e173 = Orthographic_u0028_();
    if _e173 {
        let _e175 = fog_info.forward;
        local_33 = -(_e175.xyz);
    } else {
        let _e179 = fog_info.eye;
        let _e181 = v_world_position_1;
        local_33 = normalize((_e179.xyz - _e181));
    }
    let _e184 = local_33;
    return _e184;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_11: Surface;
    var param_135: vec3<f32>;
    var param_136: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e178 = v_texcoord_1;
    let _e179 = MaterialLodBias_u0028_();
    let _e180 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e178, _e179);
    texel_6 = _e180;
    let _e181 = texel_6;
    param_135 = _e181.xyz;
    let _e183 = SrgbToLinear_u0028_vf3_u003b((&param_135));
    let _e185 = frag_info.base_color;
    param_136 = _e185.xyz;
    let _e187 = SrgbToLinear_u0028_vf3_u003b((&param_136));
    let _e189 = v_color_1;
    s_11.albedo = ((_e183 * _e187) * _e189.xyz);
    let _e194 = texel_6[3u];
    let _e197 = frag_info.base_color[3u];
    let _e200 = v_color_1[3u];
    s_11.alpha = ((_e194 * _e197) * _e200);
    let _e204 = s_11.albedo;
    g_albedo = _e204;
    let _e207 = frag_info.material2_[0u];
    cutoff = _e207;
    let _e208 = cutoff;
    if (_e208 > 1f) {
        let _e210 = cutoff;
        edge = (_e210 - 1f);
        let _e213 = s_11.alpha;
        let _e214 = edge;
        let _e217 = s_11.alpha;
        let _e218 = fwidth(_e217);
        s_11.alpha = clamp((((_e213 - _e214) / max(_e218, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e224 = cutoff;
        if (_e224 >= 0f) {
            s_11.alpha = 1f;
        }
    }
    let _e227 = cutoff;
    let _e229 = cutoff;
    g_premultiply = ((_e227 < 0f) && (_e229 > -0.75f));
    let _e232 = v_normal_1;
    s_11.n = normalize(_e232);
    let _e235 = gl_FrontFacing_1;
    if !(_e235) {
        let _e238 = s_11.n;
        s_11.n = -(_e238);
    }
    let _e241 = TowardsEye_u0028_();
    s_11.v = _e241;
    let _e244 = s_11.n;
    let _e246 = s_11.v;
    s_11.n_dot_v = max(dot(_e244, _e246), 0.0001f);
    let _e252 = frag_info.material[0u];
    s_11.metallic = clamp(_e252, 0f, 1f);
    let _e257 = frag_info.material[1u];
    s_11.roughness = clamp(_e257, 0.02f, 1f);
    let _e261 = frag_info.ambient_ground;
    let _e264 = frag_info.ambient_sky;
    let _e268 = s_11.n[1u];
    let _e275 = frag_info.material[2u];
    s_11.ambient = (mix(_e261.xyz, _e264.xyz, vec3(((_e268 * 0.5f) + 0.5f))) * _e275);
    let _e280 = frag_info.frame_params[0u];
    s_11.exposure = max(_e280, 0f);
    s_11.occlusion = 1f;
    s_11.emissive = vec3<f32>(0f, 0f, 0f);
    let _e285 = s_11;
    return _e285;
}

fn main_1() {
    var s_12: Surface;
    var param_137: Surface;
    var ambient: vec3<f32>;
    var param_138: Surface;
    var lit_2: vec3<f32>;
    var param_139: Surface;
    var param_140: Surface;
    var param_141: vec3<f32>;
    var param_142: f32;
    var param_143: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e182 = ReadSurface_u0028_();
    s_12 = _e182;
    let _e183 = s_12;
    param_137 = _e183;
    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((&param_137));
    let _e184 = param_137;
    s_12 = _e184;
    let _e186 = s_12.albedo;
    let _e188 = s_12.ambient;
    let _e189 = SampleLightmap_u0028_();
    let _e192 = s_12;
    param_138 = _e192;
    let _e193 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_138));
    ambient = ((_e186 * (_e188 + _e189)) * _e193);
    let _e195 = s_12;
    param_139 = _e195;
    let _e196 = 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((&param_139));
    let _e197 = s_12;
    param_140 = _e197;
    let _e198 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_140));
    let _e200 = ambient;
    let _e203 = s_12.emissive;
    lit_2 = (((_e196 * _e198) + _e200) + _e203);
    let _e205 = lit_2;
    param_141 = _e205;
    let _e207 = s_12.alpha;
    param_142 = _e207;
    let _e209 = s_12.roughness;
    param_143 = _e209;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_141), (&param_142), (&param_143));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'BlinnPhongOpaque': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e175 = v_world_position_1;
    let _e177 = fog_info.eye;
    let _e181 = fog_info.forward;
    return dot((_e175 - _e177.xyz), _e181.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e180 = ViewDepth_u0028_();
    z = abs(_e180);
    let _e182 = z;
    near = (_e182 / 5f);
    let _e184 = z;
    far = (_e184 / 200f);
    let _e186 = far;
    let _e187 = far;
    let _e189 = far;
    far3_ = ((_e186 * _e187) * _e189);
    let _e191 = (*alpha);
    let _e192 = near;
    let _e193 = near;
    let _e196 = far3_;
    let _e197 = far3_;
    return (_e191 * clamp((10f / ((0.00001f + (_e192 * _e193)) + (_e196 * _e197))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e184 = fog_info.forward[3u];
    mode = _e184;
    let _e185 = mode;
    if (_e185 > 0.5f) {
        let _e188 = frag_color[3u];
        alpha_1 = _e188;
        let _e189 = alpha_1;
        param = _e189;
        let _e190 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e190;
        let _e191 = frag_color;
        let _e193 = weight;
        let _e194 = (_e191.xyz * _e193);
        let _e195 = alpha_1;
        let _e196 = weight;
        accumulate = vec4<f32>(_e194.x, _e194.y, _e194.z, (_e195 * _e196));
        let _e202 = mode;
        let _e204 = mode;
        revealage = ((_e202 > 1.5f) && (_e204 < 2.5f));
        let _e207 = revealage;
        if _e207 {
            let _e208 = alpha_1;
            local = vec4(_e208);
        } else {
            let _e210 = accumulate;
            local = _e210;
        }
        let _e211 = local;
        frag_color = _e211;
        let _e212 = mode;
        if (_e212 > 2.5f) {
            let _e214 = alpha_1;
            frag_surface = vec4(_e214);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e178 = (*n)[0u];
    let _e181 = (*n)[1u];
    let _e185 = (*n)[2u];
    let _e188 = (*n);
    (*n) = (_e188 / vec3(((abs(_e178) + abs(_e181)) + abs(_e185))));
    let _e191 = (*n);
    e = _e191.xy;
    let _e194 = (*n)[2u];
    if (_e194 < 0f) {
        let _e196 = (*n);
        let _e202 = (*n)[0u];
        let _e206 = (*n)[1u];
        e = ((vec2(1f) - abs(_e196.yx)) * vec2<f32>(select(-1f, 1f, (_e202 >= 0f)), select(-1f, 1f, (_e206 >= 0f))));
    }
    let _e211 = e;
    return ((_e211 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e176 = (*linear);
    let _e178 = (*linear);
    let _e182 = (*linear);
    return mix((_e176 * 12.92f), ((pow(_e178, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e182));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e179 = g_albedo;
    param_1 = clamp(_e179, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e181 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e181.x, _e181.y, _e181.z, 1f);
    let _e186 = g_debug_surface_on;
    if _e186 {
        let _e187 = g_debug_surface;
        let _e188 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e187.x, _e187.y, _e187.z, _e188);
        return;
    }
    let _e193 = v_normal_1;
    geometric = normalize(_e193);
    let _e195 = gl_FrontFacing_1;
    if !(_e195) {
        let _e197 = geometric;
        geometric = -(_e197);
    }
    let _e199 = geometric;
    param_2 = _e199;
    let _e200 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e201 = (*roughness);
    let _e203 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e200.x, _e200.y, clamp(_e201, 0f, 1f), _e203);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e177 = fog_info.projection[0u];
    return (_e177 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e176 = Orthographic_u0028_();
    if _e176 {
        let _e177 = ViewDepth_u0028_();
        local_1 = max(_e177, 0f);
    } else {
        let _e179 = v_world_position_1;
        let _e181 = fog_info.eye;
        local_1 = distance(_e179, _e181.xyz);
    }
    let _e184 = local_1;
    return _e184;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e183 = fog_info.fog[3u];
    density = _e183;
    let _e184 = density;
    if (_e184 <= 0f) {
        let _e186 = (*color);
        return _e186;
    }
    let _e187 = EyeDistance_u0028_();
    d = _e187;
    let _e190 = fog_info.eye[3u];
    falloff = _e190;
    let _e191 = falloff;
    if (_e191 > 0f) {
        let _e193 = falloff;
        let _e195 = v_world_position_1[1u];
        let _e198 = fog_info.eye[1u];
        k = (_e193 * (_e195 - _e198));
        let _e201 = k;
        if (abs(_e201) > 0.001f) {
            let _e204 = k;
            let _e208 = k;
            local_2 = ((1f - exp(-(_e204))) / _e208);
        } else {
            let _e210 = k;
            local_2 = (1f - (0.5f * _e210));
        }
        let _e213 = local_2;
        let _e214 = density;
        density = (_e214 * _e213);
    }
    let _e217 = fog_info.fog;
    let _e219 = (*color);
    let _e220 = density;
    let _e222 = d;
    return mix(_e217.xyz, _e219, vec3(clamp(exp((-(_e220) * _e222)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e181 = g_premultiply;
    let _e182 = (*alpha_2);
    weight_1 = select(1f, _e182, _e181);
    let _e184 = (*linearColor);
    param_3 = _e184;
    let _e185 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e186 = weight_1;
    let _e187 = (_e185 * _e186);
    let _e188 = (*alpha_2);
    let _e189 = g_pass_through;
    frag_color = vec4<f32>(_e187.x, _e187.y, _e187.z, (_e188 * (1f - _e189)));
    let _e196 = (*roughness_1);
    param_4 = _e196;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_3: f32;

    let _e178 = frag_info.material2_[2u];
    local_3 = floor((_e178 * 0.5f));
    let _e181 = local_3;
    return _e181;
}

fn DirectOcclusion_u0028_struct_u002d_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: ptr<function, Surface>) -> f32 {
    var local_4: f32;
    var local_5: f32;

    let _e178 = OcclusionTarget_u0028_();
    if (_e178 > 1.5f) {
        local_4 = 1f;
    } else {
        let _e181 = (*s).occlusion;
        local_4 = _e181;
    }
    let _e182 = local_4;
    local_5 = _e182;
    let _e183 = local_5;
    return _e183;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var shininess: f32;
    var specular: f32;

    let _e180 = (*s_1).roughness;
    shininess = mix(256f, 4f, _e180);
    let _e183 = (*light).n_dot_h;
    let _e184 = shininess;
    let _e188 = frag_info.material[3u];
    specular = (pow(_e183, _e184) * _e188);
    let _e191 = (*s_1).albedo;
    let _e192 = specular;
    return (_e191 + vec3(_e192));
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e176 = (*i);
    if (_e176 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e178 = (*i);
    if (_e178 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e180 = (*i);
    if (_e180 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e182 = (*i);
    if (_e182 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e184 = (*i);
    if (_e184 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e186 = (*i);
    if (_e186 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e188 = (*i);
    if (_e188 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e181 = (*i_1);
    param_5 = _e181;
    let _e182 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e182;
    let _e184 = p[0u];
    let _e185 = (*ca);
    let _e188 = p[1u];
    let _e189 = (*sa);
    let _e193 = p[0u];
    let _e194 = (*sa);
    let _e197 = p[1u];
    let _e198 = (*ca);
    let _e202 = (*radius);
    return (vec2<f32>(((_e184 * _e185) - (_e188 * _e189)), ((_e193 * _e194) + (_e197 * _e198))) * _e202);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_6: vec2<f32>;
    var atlas: vec2<f32>;

    let _e184 = point_shadow.params[0u];
    inset = _e184;
    let _e185 = (*uv);
    let _e186 = (*offset);
    let _e188 = inset;
    let _e189 = inset;
    local_6 = clamp((_e185 + _e186), vec2(_e188), vec2((1f - _e189)));
    let _e194 = local_6;
    let _e195 = (*tile);
    atlas = ((_e194 + _e195) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e200 = point_shadow.params3_[0u];
    if (_e200 > 0.5f) {
        let _e203 = atlas[1u];
        atlas[1u] = (1f - _e203);
    }
    let _e206 = atlas;
    let _e207 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e206, 0f);
    let _e209 = atlas;
    let _e210 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e209, 0f);
    let _e213 = (*range);
    return (min(_e207.x, _e210.x) * _e213);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e185 = (*uv_1);
    param_6 = _e185;
    let _e186 = (*offset_1);
    param_7 = _e186;
    let _e187 = (*tile_1);
    param_8 = _e187;
    let _e188 = (*range_1);
    param_9 = _e188;
    let _e189 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e189;
    let _e190 = stored;
    let _e191 = (*range_1);
    if (_e190 >= (_e191 * 0.999f)) {
        return 1f;
    }
    let _e194 = (*receiver);
    let _e195 = stored;
    return select(1f, 0f, (_e194 > _e195));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e206 = point_shadow.params2_[1u];
    lightRadius = _e206;
    let _e209 = point_shadow.params2_[0u];
    minRadius = _e209;
    let _e212 = point_shadow.params2_[2u];
    maxRadius = _e212;
    let _e213 = lightRadius;
    if (_e213 <= 0f) {
        let _e215 = (*uv_2);
        param_10 = _e215;
        param_11 = vec2<f32>(0f, 0f);
        let _e216 = (*tile_2);
        param_12 = _e216;
        let _e217 = (*range_2);
        param_13 = _e217;
        let _e218 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e218;
        let _e219 = minRadius;
        return _e219;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e220 = i_2;
        if (_e220 < 8i) {
            let _e222 = i_2;
            param_14 = _e222;
            let _e223 = (*ca_1);
            param_15 = _e223;
            let _e224 = (*sa_1);
            param_16 = _e224;
            let _e225 = maxRadius;
            param_17 = _e225;
            let _e226 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e227 = (*uv_2);
            param_18 = _e227;
            param_19 = _e226;
            let _e228 = (*tile_2);
            param_20 = _e228;
            let _e229 = (*range_2);
            param_21 = _e229;
            let _e230 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e230;
            let _e231 = stored_1;
            let _e232 = (*range_2);
            if (_e231 >= (_e232 * 0.999f)) {
                continue;
            }
            let _e235 = stored_1;
            let _e236 = (*receiver_1);
            if (_e235 >= _e236) {
                continue;
            }
            let _e238 = stored_1;
            let _e239 = sum;
            sum = (_e239 + _e238);
            let _e241 = count;
            count = (_e241 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e243 = i_2;
            i_2 = (_e243 + 1i);
        }
    }
    let _e245 = count;
    if (_e245 < 0.5f) {
        return -1f;
    }
    let _e247 = sum;
    let _e248 = count;
    blocker = max((_e247 / _e248), 0.0001f);
    let _e251 = blocker;
    (*blockerOut) = _e251;
    let _e252 = lightRadius;
    let _e253 = (*receiver_1);
    let _e254 = blocker;
    let _e258 = blocker;
    world = ((_e252 * max((_e253 - _e254), 0f)) / _e258);
    let _e260 = world;
    let _e261 = (*receiver_1);
    let _e263 = (*tanHalf);
    let _e266 = minRadius;
    let _e267 = maxRadius;
    return clamp((_e260 / ((2f * _e261) * _e263)), _e266, _e267);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_7: vec2<f32>;

    let _e177 = (*rows);
    if (_e177 > 0f) {
        let _e180 = gl_FragCoord_1[0u];
        let _e181 = (*rows);
        let _e183 = gl_FragCoord_1[1u];
        local_7 = vec2<f32>(_e180, (_e181 - _e183));
    } else {
        let _e186 = gl_FragCoord_1;
        local_7 = _e186.xy;
    }
    let _e188 = local_7;
    return _e188;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_8: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2242_: bool;
    var phi_2303_: bool;

    let _e229 = (*lightIndex);
    let _e233 = point_shadow.slots[_e229][0u];
    slot = i32((_e233 + 0.5f));
    let _e236 = (*lightIndex);
    let _e240 = point_shadow.slots[_e236][0u];
    if (_e240 < 0f) {
        return 1f;
    }
    let _e244 = point_shadow.params[2u];
    strength = _e244;
    let _e245 = strength;
    if (_e245 <= 0f) {
        return 1f;
    }
    let _e247 = slot;
    let _e250 = point_shadow.lights[_e247];
    let _e252 = (*world_1);
    toLight = (_e250.xyz - _e252);
    let _e254 = toLight;
    toLightLength = max(length(_e254), 0.000001f);
    let _e257 = (*normal);
    let _e258 = toLight;
    let _e259 = toLightLength;
    nDotL = max(dot(_e257, (_e258 / vec3(_e259))), 0.15f);
    let _e264 = nDotL;
    let _e265 = nDotL;
    let _e270 = nDotL;
    let _e271 = nDotL;
    slope = min((sqrt(max((1f - (_e264 * _e265)), 0f)) / (_e270 * _e271)), 8f);
    let _e275 = toLightLength;
    let _e277 = (*lightIndex);
    let _e281 = point_shadow.slots[_e277][2u];
    let _e286 = point_shadow.params3_[1u];
    texel = (((2f * _e275) * max(_e281, 0.0001f)) * _e286);
    let _e288 = (*world_1);
    let _e289 = (*normal);
    let _e290 = texel;
    let _e294 = point_shadow.params[3u];
    let _e296 = slope;
    origin = (_e288 + (((_e289 * _e290) * _e294) * (1f + _e296)));
    let _e300 = origin;
    let _e301 = slot;
    let _e304 = point_shadow.lights[_e301];
    toFragment = (_e300 - _e304.xyz);
    let _e307 = toFragment;
    distance_ = length(_e307);
    let _e309 = slot;
    let _e313 = point_shadow.lights[_e309][3u];
    range_3 = max(_e313, 0.0001f);
    let _e315 = distance_;
    let _e316 = range_3;
    if (_e315 >= _e316) {
        return 1f;
    }
    face = 0i;
    let _e318 = (*lightIndex);
    let _e322 = point_shadow.slots[_e318][1u];
    if (_e322 < 0.5f) {
        let _e324 = toFragment;
        a = abs(_e324);
        let _e327 = a[0u];
        let _e329 = a[1u];
        let _e330 = (_e327 >= _e329);
        phi_2242_ = _e330;
        if _e330 {
            let _e332 = a[0u];
            let _e334 = a[2u];
            phi_2242_ = (_e332 >= _e334);
        }
        let _e337 = phi_2242_;
        if _e337 {
            let _e339 = toFragment[0u];
            face = select(1i, 0i, (_e339 > 0f));
        } else {
            let _e343 = a[1u];
            let _e345 = a[2u];
            if (_e343 >= _e345) {
                let _e348 = toFragment[1u];
                face = select(3i, 2i, (_e348 > 0f));
            } else {
                let _e352 = toFragment[2u];
                face = select(5i, 4i, (_e352 > 0f));
            }
        }
    }
    let _e355 = slot;
    let _e357 = face;
    let _e361 = point_shadow.faces[((_e355 * 6i) + _e357)];
    let _e362 = origin;
    clip = (_e361 * vec4<f32>(_e362.x, _e362.y, _e362.z, 1f));
    let _e369 = clip[3u];
    if (_e369 <= 0f) {
        return 1f;
    }
    let _e371 = clip;
    let _e374 = clip[3u];
    ndc = (_e371.xy / vec2(_e374));
    let _e378 = ndc[0u];
    let _e380 = (abs(_e378) > 1f);
    phi_2303_ = _e380;
    if !(_e380) {
        let _e383 = ndc[1u];
        phi_2303_ = (abs(_e383) > 1f);
    }
    let _e387 = phi_2303_;
    if _e387 {
        return 1f;
    }
    let _e389 = ndc[0u];
    let _e393 = ndc[1u];
    uv_3 = vec2<f32>(((_e389 * 0.5f) + 0.5f), (0.5f - (_e393 * 0.5f)));
    let _e397 = face;
    let _e399 = slot;
    tile_3 = vec2<f32>(f32(_e397), f32(_e399));
    let _e402 = distance_;
    let _e405 = point_shadow.params[1u];
    receiver_2 = (_e402 - _e405);
    let _e409 = frag_info.target_origin[0u];
    param_22 = _e409;
    let _e410 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e410, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e415 = noise;
    angle = (_e415 * 6.2831855f);
    let _e417 = angle;
    ca_2 = cos(_e417);
    let _e419 = angle;
    sa_2 = sin(_e419);
    let _e421 = (*lightIndex);
    let _e425 = point_shadow.slots[_e421][2u];
    tanHalf_1 = max(_e425, 0.0001f);
    blocker_1 = -1f;
    let _e427 = uv_3;
    param_23 = _e427;
    let _e428 = tile_3;
    param_24 = _e428;
    let _e429 = range_3;
    param_25 = _e429;
    let _e430 = receiver_2;
    param_26 = _e430;
    let _e431 = ca_2;
    param_27 = _e431;
    let _e432 = sa_2;
    param_28 = _e432;
    let _e433 = tanHalf_1;
    param_29 = _e433;
    let _e434 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e435 = param_30;
    blocker_1 = _e435;
    radius_1 = _e434;
    let _e438 = point_shadow.params2_[3u];
    if (_e438 > 0.5f) {
        g_debug_surface_on = true;
        let _e440 = radius_1;
        if (_e440 < 0f) {
            local_8 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e442 = radius_1;
            let _e445 = point_shadow.params2_[2u];
            let _e449 = blocker_1;
            let _e450 = range_3;
            local_8 = vec3<f32>(clamp((_e442 / max(_e445, 0.000001f)), 0f, 1f), clamp((_e449 / _e450), 0f, 1f), 0f);
        }
        let _e454 = local_8;
        g_debug_surface = _e454;
    }
    let _e455 = radius_1;
    if (_e455 < 0f) {
        return 1f;
    }
    let _e457 = uv_3;
    param_31 = _e457;
    param_32 = vec2<f32>(0f, 0f);
    let _e458 = tile_3;
    param_33 = _e458;
    let _e459 = range_3;
    param_34 = _e459;
    let _e460 = receiver_2;
    param_35 = _e460;
    let _e461 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e461;
    let _e462 = radius_1;
    if (_e462 > 0f) {
        i_3 = 0i;
        loop {
            let _e464 = i_3;
            if (_e464 < 8i) {
                let _e466 = i_3;
                param_36 = _e466;
                let _e467 = ca_2;
                param_37 = _e467;
                let _e468 = sa_2;
                param_38 = _e468;
                let _e469 = radius_1;
                param_39 = _e469;
                let _e470 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e471 = uv_3;
                param_40 = _e471;
                param_41 = _e470;
                let _e472 = tile_3;
                param_42 = _e472;
                let _e473 = range_3;
                param_43 = _e473;
                let _e474 = receiver_2;
                param_44 = _e474;
                let _e475 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e476 = lit;
                lit = (_e476 + _e475);
                continue;
            } else {
                break;
            }
            continuing {
                let _e478 = i_3;
                i_3 = (_e478 + 1i);
            }
        }
        let _e480 = lit;
        lit = (_e480 * 0.11111111f);
    }
    let _e482 = lit;
    let _e483 = strength;
    return mix(1f, _e482, clamp(_e483, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e180 = (*i_4);
    let _e183 = (*n_1);
    r = sqrt(((f32(_e180) + 0.5f) / f32(_e183)));
    let _e187 = (*i_4);
    let _e190 = (*turn);
    theta = ((f32(_e187) * 2.3999631f) + _e190);
    let _e192 = r;
    let _e193 = theta;
    let _e195 = theta;
    return (vec2<f32>(cos(_e193), sin(_e195)) * _e192);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e179 = frag_info.target_origin[0u];
    param_45 = _e179;
    let _e180 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e183 = frag_info.target_origin[3u];
    at = (_e180 + vec2((5.588238f * max(_e183, 0f))));
    let _e188 = at;
    return fract((52.982918f * fract(dot(_e188, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_9: f32;

    let _e178 = (*mode_1);
    if (_e178 > 0.5f) {
        let _e180 = (*stored_2);
        local_9 = (1f - _e180);
    } else {
        let _e182 = (*stored_2);
        local_9 = _e182;
    }
    let _e183 = local_9;
    return _e183;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e184 = (*moments)[1u];
    let _e186 = (*moments)[0u];
    let _e188 = (*moments)[0u];
    let _e191 = (*minVariance);
    variance = max((_e184 - (_e186 * _e188)), _e191);
    let _e193 = (*t);
    let _e195 = (*moments)[0u];
    d_1 = (_e193 - _e195);
    let _e197 = variance;
    let _e198 = variance;
    let _e199 = d_1;
    let _e200 = d_1;
    pMax = (_e197 / (_e198 + (_e199 * _e200)));
    let _e204 = pMax;
    let _e205 = (*bleed);
    let _e207 = (*bleed);
    reduced = clamp(((_e204 - _e205) / max((1f - _e207), 0.0001f)), 0f, 1f);
    let _e212 = (*t);
    let _e214 = (*moments)[0u];
    let _e216 = reduced;
    return select(_e216, 1f, (_e212 <= _e214));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e177 = (*depth);
    d_2 = ((2f * clamp(_e177, 0f, 1f)) - 1f);
    let _e181 = d_2;
    let _e184 = d_2;
    return vec2<f32>(exp((40f * _e181)), -(exp((-5f * _e184))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e191 = (*depth_1);
    param_46 = _e191;
    let _e192 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e192;
    let _e193 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e193);
    let _e196 = scale[0u];
    let _e198 = scale[0u];
    let _e200 = (*moments_1);
    param_47 = _e200.xy;
    let _e203 = warped[0u];
    param_48 = _e203;
    param_49 = (_e196 * _e198);
    let _e204 = (*bleed_1);
    param_50 = _e204;
    let _e205 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e205;
    let _e207 = scale[1u];
    let _e209 = scale[1u];
    let _e211 = (*moments_1);
    param_51 = _e211.zw;
    let _e214 = warped[1u];
    param_52 = _e214;
    param_53 = (_e207 * _e209);
    let _e215 = (*bleed_1);
    param_54 = _e215;
    let _e216 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e216;
    let _e217 = positive;
    let _e218 = negative;
    return min(_e217, _e218);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e177 = (*depth_2);
    stored_3 = max((1f - _e177), 0.000061035156f);
    let _e180 = stored_3;
    return exp2((floor(log2(_e180)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_10: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_11: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_13: f32;
    var local_14: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_3439_: bool;
    var phi_3450_: bool;
    var phi_3611_: bool;
    var phi_3618_: bool;
    var phi_3625_: bool;

    let _e256 = frag_info.shadow_params[3u];
    strength_1 = _e256;
    let _e257 = strength_1;
    if (_e257 <= 0f) {
        return 1f;
    }
    let _e259 = (*lightIndex_1);
    let _e262 = frag_info.frame_params[2u];
    if (_e259 != i32(floor((_e262 + 0.5f)))) {
        return 1f;
    }
    let _e269 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e269 + 0.5f));
    let _e272 = Orthographic_u0028_();
    if _e272 {
        let _e273 = ViewDepth_u0028_();
        local_10 = _e273;
    } else {
        let _e274 = v_world_position_1;
        let _e276 = frag_info.camera_position;
        local_10 = length((_e274 - _e276.xyz));
    }
    let _e280 = local_10;
    viewDistance = _e280;
    cascade = 0i;
    let _e281 = cascadeCount;
    let _e282 = (_e281 > 1i);
    phi_3439_ = _e282;
    if _e282 {
        let _e283 = viewDistance;
        let _e286 = frag_info.shadow_cascades[0u];
        phi_3439_ = (_e283 > _e286);
    }
    let _e289 = phi_3439_;
    if _e289 {
        cascade = 1i;
    }
    let _e290 = cascadeCount;
    let _e291 = (_e290 > 2i);
    phi_3450_ = _e291;
    if _e291 {
        let _e292 = viewDistance;
        let _e295 = frag_info.shadow_cascades[1u];
        phi_3450_ = (_e292 > _e295);
    }
    let _e298 = phi_3450_;
    if _e298 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e299 = attempt;
        if (_e299 < 3i) {
            let _e301 = cascade;
            let _e302 = attempt;
            which = (_e301 + _e302);
            let _e304 = which;
            let _e305 = cascadeCount;
            if (_e304 >= _e305) {
                break;
            }
            let _e307 = which;
            if (_e307 == 0i) {
                let _e310 = frag_info.shadow_matrix;
                local_11 = _e310;
            } else {
                let _e311 = which;
                if (_e311 == 1i) {
                    let _e314 = frag_info.shadow_matrix_far;
                    local_12 = _e314;
                } else {
                    let _e316 = frag_info.shadow_matrix_farthest;
                    local_12 = _e316;
                }
                let _e317 = local_12;
                local_11 = _e317;
            }
            let _e318 = local_11;
            matrix = _e318;
            let _e321 = matrix[0][0u];
            let _e324 = matrix[1][0u];
            let _e327 = matrix[2][0u];
            axisX = vec3<f32>(_e321, _e324, _e327);
            let _e331 = matrix[0][1u];
            let _e334 = matrix[1][1u];
            let _e337 = matrix[2][1u];
            axisY = vec3<f32>(_e331, _e334, _e337);
            let _e339 = axisX;
            rowX = max(length(_e339), 0.000001f);
            let _e342 = axisY;
            rowY = max(length(_e342), 0.000001f);
            let _e347 = frag_info.shadow_cascades[3u];
            let _e349 = rowX;
            texelMetres = ((2f * _e347) / _e349);
            let _e353 = frag_info.shadow_cascades[3u];
            let _e356 = (*s_2).n;
            let _e357 = axisX;
            let _e360 = rowX;
            let _e361 = rowX;
            let _e365 = (*s_2).n;
            let _e366 = axisY;
            let _e369 = rowY;
            let _e370 = rowY;
            reach = ((3f * _e353) * ((abs(dot(_e356, _e357)) / (_e360 * _e361)) + (abs(dot(_e365, _e366)) / (_e369 * _e370))));
            let _e377 = frag_info.shadow_params[2u];
            let _e378 = texelMetres;
            flatOffset = min(_e377, _e378);
            let _e380 = v_world_position_1;
            let _e382 = (*s_2).n;
            let _e383 = flatOffset;
            let _e384 = reach;
            origin_1 = (_e380 + (_e382 * (_e383 + _e384)));
            let _e388 = matrix;
            let _e389 = origin_1;
            lightSpace = (_e388 * vec4<f32>(_e389.x, _e389.y, _e389.z, 1f));
            let _e396 = lightSpace[3u];
            if (_e396 <= 0f) {
                continue;
            }
            let _e398 = lightSpace;
            let _e401 = lightSpace[3u];
            candidate = (_e398.xyz / vec3(_e401));
            let _e405 = candidate[0u];
            let _e409 = candidate[1u];
            inTile = vec2<f32>(((_e405 * 0.5f) + 0.5f), (0.5f - (_e409 * 0.5f)));
            let _e414 = inTile[0u];
            let _e415 = (_e414 < 0f);
            phi_3611_ = _e415;
            if !(_e415) {
                let _e418 = inTile[0u];
                phi_3611_ = (_e418 > 1f);
            }
            let _e421 = phi_3611_;
            phi_3618_ = _e421;
            if !(_e421) {
                let _e424 = inTile[1u];
                phi_3618_ = (_e424 < 0f);
            }
            let _e427 = phi_3618_;
            phi_3625_ = _e427;
            if !(_e427) {
                let _e430 = inTile[1u];
                phi_3625_ = (_e430 > 1f);
            }
            let _e433 = phi_3625_;
            if _e433 {
                continue;
            }
            let _e435 = candidate[2u];
            if (_e435 > 1f) {
                let _e437 = which;
                let _e438 = cascadeCount;
                if (_e437 < (_e438 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e443 = inTile[0u];
            let _e444 = which;
            let _e447 = cascadeCount;
            let _e451 = inTile[1u];
            uv_4 = vec2<f32>(((_e443 + f32(_e444)) / f32(_e447)), _e451);
            let _e453 = candidate;
            projected = _e453;
            let _e454 = which;
            cascade = _e454;
            let _e455 = texelMetres;
            cascadeTexel = _e455;
            let _e458 = matrix[0][2u];
            let _e461 = matrix[1][2u];
            let _e464 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e458, _e461, _e464)), 0.000001f));
            let _e470 = (*s_2).n;
            let _e473 = matrix[0][2u];
            let _e476 = matrix[1][2u];
            let _e479 = matrix[2][2u];
            let _e483 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e470, vec3<f32>(_e473, _e476, _e479))) * _e483), 0.1f, 1f);
            let _e486 = texelMetres;
            let _e487 = cosSlope;
            let _e488 = cosSlope;
            let _e494 = cosSlope;
            let _e496 = cascadeDepth;
            receiverSlope = (((_e486 * sqrt(max((1f - (_e487 * _e488)), 0f))) / _e494) / _e496);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e498 = attempt;
            attempt = (_e498 + 1i);
        }
    }
    let _e500 = found;
    if !(_e500) {
        return 1f;
    }
    let _e502 = cascade;
    if (_e502 == 0i) {
        let _e506 = frag_info.shadow_bias[0u];
        local_13 = _e506;
    } else {
        let _e507 = cascade;
        if (_e507 == 1i) {
            let _e511 = frag_info.shadow_bias[1u];
            local_14 = _e511;
        } else {
            let _e514 = frag_info.shadow_bias[2u];
            local_14 = _e514;
        }
        let _e515 = local_14;
        local_13 = _e515;
    }
    let _e516 = local_13;
    bias = _e516;
    let _e519 = frag_info.shadow_params[1u];
    storage_ = _e519;
    let _e520 = storage_;
    let _e522 = storage_;
    if ((_e520 > 0.5f) && (_e522 < 1.5f)) {
        let _e525 = bias;
        let _e527 = projected[2u];
        param_55 = _e527;
        let _e528 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e525, _e528);
    }
    let _e532 = frag_info.shadow_params[0u];
    let _e535 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e532, _e535);
    let _e537 = cascade;
    let _e539 = cascadeCount;
    let _e543 = texel_1;
    tileLo = (vec2<f32>((f32(_e537) / f32(_e539)), 0f) + (_e543 * 0.5f));
    let _e546 = cascade;
    let _e549 = cascadeCount;
    let _e553 = texel_1;
    tileHi = (vec2<f32>((f32((_e546 + 1i)) / f32(_e549)), 1f) - (_e553 * 0.5f));
    let _e558 = frag_info.shadow_bias[3u];
    if (_e558 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e560 = y;
            if (_e560 <= 1i) {
                x = -1i;
                loop {
                    let _e562 = x;
                    if (_e562 <= 1i) {
                        let _e564 = uv_4;
                        let _e565 = x;
                        let _e567 = y;
                        let _e570 = texel_1;
                        let _e573 = tileLo;
                        let _e574 = tileHi;
                        let _e576 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e564 + (vec2<f32>(f32(_e565), f32(_e567)) * _e570)), _e573, _e574), 0f);
                        let _e577 = stored_4;
                        stored_4 = (_e577 + _e576);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e579 = x;
                        x = (_e579 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e581 = y;
                y = (_e581 + 1i);
            }
        }
        let _e583 = stored_4;
        stored_4 = (_e583 * 0.11111111f);
        let _e586 = stored_4[1u];
        let _e589 = stored_4[2u];
        let _e592 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e586), (1f - _e589), _e592), vec3(0f), vec3(4f));
        let _e597 = through;
        let _e598 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e597, vec3(clamp(_e598, 0f, 1f)));
    }
    let _e604 = frag_info.ambient_ground[3u];
    softness = _e604;
    lit_1 = 0f;
    let _e605 = softness;
    if (_e605 < 0f) {
        let _e607 = uv_4;
        let _e608 = tileLo;
        let _e609 = tileHi;
        let _e611 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e607, _e608, _e609), 0f);
        moments_2 = _e611;
        let _e613 = projected[2u];
        let _e614 = bias;
        let _e616 = softness;
        let _e620 = moments_2;
        param_56 = _e620;
        param_57 = (_e613 - _e614);
        param_58 = clamp((-(_e616) - 1f), 0f, 0.95f);
        let _e621 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e621;
    } else {
        let _e622 = softness;
        if (_e622 <= 0f) {
            y_1 = -1i;
            loop {
                let _e624 = y_1;
                if (_e624 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e626 = x_1;
                        if (_e626 <= 1i) {
                            let _e628 = uv_4;
                            let _e629 = x_1;
                            let _e631 = y_1;
                            let _e634 = texel_1;
                            let _e637 = tileLo;
                            let _e638 = tileHi;
                            let _e640 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e628 + (vec2<f32>(f32(_e629), f32(_e631)) * _e634)), _e637, _e638), 0f);
                            param_59 = _e640.x;
                            let _e642 = storage_;
                            param_60 = _e642;
                            let _e643 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e643;
                            let _e645 = projected[2u];
                            let _e646 = bias;
                            let _e648 = occluder;
                            let _e651 = lit_1;
                            lit_1 = (_e651 + select(1f, 0f, ((_e645 - _e646) > _e648)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e653 = x_1;
                            x_1 = (_e653 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e655 = y_1;
                    y_1 = (_e655 + 1i);
                }
            }
            let _e657 = lit_1;
            lit_1 = (_e657 * 0.11111111f);
        } else {
            let _e659 = softness;
            spread = tan(min(_e659, 0.5f));
            let _e662 = ShadowNoise_u0028_();
            turn_1 = (_e662 * 6.2831855f);
            let _e664 = spread;
            let _e666 = projected[2u];
            let _e668 = cascadeDepth;
            let _e670 = cascadeTexel;
            searchRadius = clamp((((_e664 * _e666) * _e668) / _e670), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e673 = i_5;
                if (_e673 < 16i) {
                    let _e675 = i_5;
                    param_61 = _e675;
                    param_62 = 16i;
                    let _e676 = turn_1;
                    param_63 = _e676;
                    let _e677 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e677;
                    let _e678 = bias;
                    let _e679 = disc;
                    let _e681 = searchRadius;
                    let _e685 = receiverSlope;
                    tapBias = (_e678 + (max(((length(_e679) * _e681) - 1.5f), 0f) * _e685));
                    let _e688 = uv_4;
                    let _e689 = disc;
                    let _e690 = texel_1;
                    let _e692 = searchRadius;
                    let _e695 = tileLo;
                    let _e696 = tileHi;
                    let _e698 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e688 + ((_e689 * _e690) * _e692)), _e695, _e696), 0f);
                    param_64 = _e698.x;
                    let _e700 = storage_;
                    param_65 = _e700;
                    let _e701 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e701;
                    let _e703 = projected[2u];
                    let _e704 = tapBias;
                    let _e706 = occluder_1;
                    if ((_e703 - _e704) > _e706) {
                        let _e708 = occluder_1;
                        let _e709 = blockerSum;
                        blockerSum = (_e709 + _e708);
                        let _e711 = blockerCount;
                        blockerCount = (_e711 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e713 = i_5;
                    i_5 = (_e713 + 1i);
                }
            }
            let _e715 = blockerCount;
            if (_e715 <= 0f) {
                return 1f;
            }
            let _e718 = projected[2u];
            let _e719 = blockerSum;
            let _e720 = blockerCount;
            let _e724 = cascadeDepth;
            gap = (max((_e718 - (_e719 / _e720)), 0f) * _e724);
            let _e726 = spread;
            let _e727 = gap;
            let _e729 = cascadeTexel;
            radius_2 = clamp(((_e726 * _e727) / _e729), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e732 = i_6;
                if (_e732 < 16i) {
                    let _e734 = turn_1;
                    let _e736 = i_6;
                    param_66 = _e736;
                    param_67 = 16i;
                    param_68 = (_e734 + 1f);
                    let _e737 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e737;
                    let _e738 = bias;
                    let _e739 = disc_1;
                    let _e741 = radius_2;
                    let _e745 = receiverSlope;
                    tapBias_1 = (_e738 + (max(((length(_e739) * _e741) - 1.5f), 0f) * _e745));
                    let _e748 = uv_4;
                    let _e749 = disc_1;
                    let _e750 = texel_1;
                    let _e752 = radius_2;
                    let _e755 = tileLo;
                    let _e756 = tileHi;
                    let _e758 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e748 + ((_e749 * _e750) * _e752)), _e755, _e756), 0f);
                    param_69 = _e758.x;
                    let _e760 = storage_;
                    param_70 = _e760;
                    let _e761 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e761;
                    let _e763 = projected[2u];
                    let _e764 = tapBias_1;
                    let _e766 = occluder_2;
                    let _e769 = lit_1;
                    lit_1 = (_e769 + select(1f, 0f, ((_e763 - _e764) > _e766)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e771 = i_6;
                    i_6 = (_e771 + 1i);
                }
            }
            let _e773 = lit_1;
            lit_1 = (_e773 * 0.0625f);
        }
    }
    let _e775 = lit_1;
    let _e776 = strength_1;
    return mix(1f, _e775, clamp(_e776, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e181 = (*s_3);
    param_71 = _e181;
    let _e182 = (*light_2);
    param_72 = _e182;
    let _e183 = (*index);
    param_73 = _e183;
    let _e184 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e184;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e176 = (*index_1);
    return (_e176 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e180 = (*distance_1);
    let _e181 = (*distance_1);
    attenuation = (1f / max((_e180 * _e181), 0.0001f));
    let _e185 = (*range_4);
    if (_e185 > 0f) {
        let _e187 = (*distance_1);
        let _e188 = (*range_4);
        ratio = (_e187 / _e188);
        let _e190 = ratio;
        let _e191 = ratio;
        let _e193 = ratio;
        let _e195 = ratio;
        window = clamp((1f - (((_e190 * _e191) * _e193) * _e195)), 0f, 1f);
        let _e199 = window;
        let _e200 = window;
        let _e202 = attenuation;
        attenuation = (_e202 * (_e199 * _e200));
    }
    let _e204 = attenuation;
    return _e204;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_15: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e192 = (*halfWidth);
    let _e193 = (*halfHeight);
    n_2 = cross(_e192, _e193);
    let _e195 = n_2;
    nLen = length(_e195);
    let _e197 = nLen;
    if (_e197 < 0.000000000001f) {
        let _e199 = (*centre);
        return _e199;
    }
    let _e200 = nLen;
    let _e201 = n_2;
    n_2 = (_e201 / vec3(_e200));
    let _e204 = (*centre);
    let _e205 = (*world_2);
    toPlane = (_e204 - _e205);
    let _e207 = (*mirror);
    let _e208 = n_2;
    denom = dot(_e207, _e208);
    let _e210 = denom;
    if (abs(_e210) < 0.00001f) {
        let _e213 = toPlane;
        let _e214 = n_2;
        let _e215 = toPlane;
        let _e216 = n_2;
        onPlane = (_e213 - (_e214 * dot(_e215, _e216)));
    } else {
        let _e220 = toPlane;
        let _e221 = n_2;
        let _e223 = denom;
        t_1 = (dot(_e220, _e221) / _e223);
        let _e225 = t_1;
        if (_e225 > 0f) {
            let _e227 = (*mirror);
            let _e228 = t_1;
            local_15 = (_e227 * _e228);
        } else {
            let _e230 = toPlane;
            let _e231 = n_2;
            let _e232 = toPlane;
            let _e233 = n_2;
            local_15 = (_e230 - (_e231 * dot(_e232, _e233)));
        }
        let _e237 = local_15;
        onPlane = _e237;
    }
    let _e238 = onPlane;
    let _e239 = toPlane;
    offset_2 = (_e238 - _e239);
    let _e241 = (*halfWidth);
    let _e242 = (*halfWidth);
    wLen2_ = max(dot(_e241, _e242), 0.000000000001f);
    let _e245 = (*halfHeight);
    let _e246 = (*halfHeight);
    hLen2_ = max(dot(_e245, _e246), 0.000000000001f);
    let _e249 = offset_2;
    let _e250 = (*halfWidth);
    let _e252 = wLen2_;
    u = clamp((dot(_e249, _e250) / _e252), -1f, 1f);
    let _e255 = offset_2;
    let _e256 = (*halfHeight);
    let _e258 = hLen2_;
    v = clamp((dot(_e255, _e256) / _e258), -1f, 1f);
    let _e261 = (*centre);
    let _e262 = (*halfWidth);
    let _e263 = u;
    let _e266 = (*halfHeight);
    let _e267 = v;
    return ((_e261 + (_e262 * _e263)) + (_e266 * _e267));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_16: f32;

    let _e184 = (*a_1);
    let _e185 = (*a_1);
    ua = (_e184 / vec3(max(length(_e185), 0.000000000001f)));
    let _e190 = (*b);
    let _e191 = (*b);
    ub = (_e190 / vec3(max(length(_e191), 0.000000000001f)));
    let _e196 = ua;
    let _e197 = ub;
    angle_1 = acos(clamp(dot(_e196, _e197), -1f, 1f));
    let _e201 = ua;
    let _e202 = ub;
    axis = cross(_e201, _e202);
    let _e204 = axis;
    len = length(_e204);
    let _e206 = len;
    if (_e206 > 0.000001f) {
        let _e208 = angle_1;
        let _e209 = axis;
        let _e210 = (*n_3);
        let _e213 = len;
        local_16 = ((_e208 * dot(_e209, _e210)) / _e213);
    } else {
        local_16 = 0f;
    }
    let _e215 = local_16;
    return _e215;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_17: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_18: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_19: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e198 = i_7;
        if (_e198 < 4i) {
            let _e200 = i_7;
            let _e202 = (*corners)[_e200];
            a_2 = _e202;
            let _e203 = i_7;
            if (_e203 == 3i) {
                local_17 = 0i;
            } else {
                let _e205 = i_7;
                local_17 = (_e205 + 1i);
            }
            let _e207 = local_17;
            let _e209 = (*corners)[_e207];
            b_1 = _e209;
            let _e210 = a_2;
            let _e211 = (*n_4);
            ha = dot(_e210, _e211);
            let _e213 = b_1;
            let _e214 = (*n_4);
            hb = dot(_e213, _e214);
            let _e216 = ha;
            let _e217 = hb;
            d_3 = (_e216 - _e217);
            let _e219 = a_2;
            let _e220 = b_1;
            let _e221 = a_2;
            let _e223 = d_3;
            if (abs(_e223) > 0.000000000001f) {
                let _e226 = ha;
                let _e227 = d_3;
                local_18 = (_e226 / _e227);
            } else {
                local_18 = 0f;
            }
            let _e229 = local_18;
            q = (_e219 + ((_e220 - _e221) * _e229));
            let _e232 = ha;
            aAbove = (_e232 > 0f);
            let _e234 = hb;
            bAbove = (_e234 > 0f);
            let _e236 = aAbove;
            let _e237 = bAbove;
            if (_e236 || _e237) {
                let _e239 = aAbove;
                let _e240 = a_2;
                let _e241 = q;
                let _e244 = bAbove;
                let _e245 = b_1;
                let _e246 = q;
                param_74 = select(_e241, _e240, vec3(_e239));
                param_75 = select(_e246, _e245, vec3(_e244));
                let _e249 = (*n_4);
                param_76 = _e249;
                let _e250 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_19 = _e250;
            } else {
                local_19 = 0f;
            }
            let _e251 = local_19;
            let _e252 = total;
            total = (_e252 + _e251);
            let _e254 = aAbove;
            let _e255 = bAbove;
            let _e258 = q;
            let _e259 = exit;
            exit = select(_e259, _e258, vec3((_e254 && !(_e255))));
            let _e262 = aAbove;
            let _e264 = bAbove;
            let _e266 = q;
            let _e267 = entry;
            entry = select(_e267, _e266, vec3((!(_e262) && _e264)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e270 = i_7;
            i_7 = (_e270 + 1i);
        }
    }
    let _e272 = exit;
    param_77 = _e272;
    let _e273 = entry;
    param_78 = _e273;
    let _e274 = (*n_4);
    param_79 = _e274;
    let _e275 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e276 = total;
    total = (_e276 + _e275);
    let _e278 = total;
    return max((-(_e278) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_20: f32;
    var local_21: f32;
    var local_22: f32;

    let _e181 = (*slot_1);
    let _e182 = (*slot_1);
    lane = (_e181 - ((_e182 / 4i) * 4i));
    let _e186 = lane;
    if (_e186 == 0i) {
        let _e189 = (*four)[0u];
        local_20 = _e189;
    } else {
        let _e190 = lane;
        if (_e190 == 1i) {
            let _e193 = (*four)[1u];
            local_21 = _e193;
        } else {
            let _e194 = lane;
            if (_e194 == 2i) {
                let _e197 = (*four)[2u];
                local_22 = _e197;
            } else {
                let _e199 = (*four)[3u];
                local_22 = _e199;
            }
            let _e200 = local_22;
            local_21 = _e200;
        }
        let _e201 = local_21;
        local_20 = _e201;
    }
    let _e202 = local_20;
    return _e202;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e178 = (*slot_2);
    let _e182 = light_list_info.scales[(_e178 / 4i)];
    param_80 = _e182;
    let _e183 = (*slot_2);
    param_81 = _e183;
    let _e184 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e184;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e180 = light_list_info.slot_rows[0i];
    let _e181 = (*row);
    a_3 = abs((_e180 - vec4(_e181)));
    let _e187 = light_list_info.slot_rows[1i];
    let _e188 = (*row);
    b_2 = abs((_e187 - vec4(_e188)));
    let _e193 = a_3[0u];
    let _e195 = a_3[1u];
    let _e198 = a_3[2u];
    let _e200 = a_3[3u];
    let _e204 = b_2[0u];
    let _e206 = b_2[1u];
    let _e209 = b_2[2u];
    let _e211 = b_2[3u];
    return (min(min(min(_e193, _e195), min(_e198, _e200)), min(min(_e204, _e206), min(_e209, _e211))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e178 = (*slot_3);
    let _e182 = light_list_info.indices[(_e178 / 4i)];
    param_82 = _e182;
    let _e183 = (*slot_3);
    param_83 = _e183;
    let _e184 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e184;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e177 = (*texel_2);
    let _e181 = light_list_info.list[1u];
    let _e183 = (*row_1);
    let _e187 = light_list_info.list[2u];
    let _e190 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e177 + 0.5f) * _e181), ((_e183 + 0.5f) * _e187)), 0f);
    return _e190;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e185 = g_cluster_offset;
    let _e186 = (*slot_4);
    entry_1 = (_e185 + f32(_e186));
    let _e189 = entry_1;
    row_2 = floor((_e189 / 16f));
    let _e192 = entry_1;
    let _e193 = row_2;
    within = (_e192 - (_e193 * 16f));
    let _e196 = within;
    texel_3 = floor((_e196 / 4f));
    let _e201 = light_list_info.cluster_depth[3u];
    let _e202 = row_2;
    let _e204 = texel_3;
    param_84 = _e204;
    param_85 = (_e201 + _e202);
    let _e205 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e205;
    let _e206 = within;
    let _e207 = texel_3;
    let _e212 = four_1;
    param_86 = _e212;
    param_87 = i32(((_e206 - (_e207 * 4f)) + 0.5f));
    let _e213 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e213;
}

fn Clustered_u0028_() -> bool {
    let _e177 = light_list_info.cluster_grid[3u];
    return (_e177 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_23: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_24: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_25: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_26: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_27: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e229 = (*index_2);
    if (_e229 < 8i) {
        let _e231 = (*index_2);
        let _e234 = frag_info.light_position[_e231];
        position = _e234;
        let _e235 = (*index_2);
        let _e238 = frag_info.light_color[_e235];
        color_1 = _e238;
        let _e239 = (*index_2);
        let _e242 = frag_info.light_direction[_e239];
        direction = _e242;
        let _e243 = (*index_2);
        let _e246 = frag_info.light_cone[_e243];
        cone = _e246;
    } else {
        let _e247 = (*index_2);
        slot_5 = (_e247 - 8i);
        let _e249 = Clustered_u0028_();
        clustered = _e249;
        let _e250 = clustered;
        if _e250 {
            let _e251 = slot_5;
            param_88 = _e251;
            let _e252 = ClusterRow_u0028_i1_u003b((&param_88));
            local_23 = _e252;
        } else {
            let _e253 = slot_5;
            param_89 = _e253;
            let _e254 = LightListRow_u0028_i1_u003b((&param_89));
            local_23 = _e254;
        }
        let _e255 = local_23;
        listRow = _e255;
        let _e256 = listRow;
        let _e260 = light_list_info.list[2u];
        v_1 = ((_e256 + 0.5f) * _e260);
        let _e264 = light_list_info.list[1u];
        u_1 = _e264;
        let _e265 = u_1;
        let _e267 = v_1;
        let _e269 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e265), _e267), 0f);
        position = _e269;
        let _e270 = u_1;
        let _e272 = v_1;
        let _e274 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e270), _e272), 0f);
        color_1 = _e274;
        let _e275 = u_1;
        let _e277 = v_1;
        let _e279 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e275), _e277), 0f);
        direction = _e279;
        let _e280 = u_1;
        let _e282 = v_1;
        let _e284 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e280), _e282), 0f);
        cone = _e284;
        let _e285 = clustered;
        if _e285 {
            let _e286 = listRow;
            param_90 = _e286;
            let _e287 = InSlots_u0028_f1_u003b((&param_90));
            local_24 = select(1f, 0f, _e287);
        } else {
            let _e289 = slot_5;
            param_91 = _e289;
            let _e290 = LightListScale_u0028_i1_u003b((&param_91));
            local_24 = _e290;
        }
        let _e291 = local_24;
        let _e293 = color_1[3u];
        color_1[3u] = (_e293 * _e291);
    }
    let _e297 = position[3u];
    type_39 = _e297;
    let _e298 = type_39;
    if (_e298 > 15.5f) {
        let _e301 = (*s_4).n;
        light_3.l = _e301;
        let _e304 = (*s_4).n;
        light_3.h = _e304;
        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 _e310 = light_3;
        return _e310;
    }
    let _e311 = type_39;
    if (_e311 > 2.5f) {
        let _e313 = direction;
        halfWidth_1 = _e313.xyz;
        let _e315 = cone;
        halfHeight_1 = _e315.xyz;
        let _e317 = position;
        let _e319 = v_world_position_1;
        toCentre = (_e317.xyz - _e319);
        let _e321 = toCentre;
        let _e322 = halfWidth_1;
        let _e324 = halfHeight_1;
        corners_1[0i] = ((_e321 - _e322) - _e324);
        let _e327 = toCentre;
        let _e328 = halfWidth_1;
        let _e330 = halfHeight_1;
        corners_1[1i] = ((_e327 + _e328) - _e330);
        let _e333 = toCentre;
        let _e334 = halfWidth_1;
        let _e336 = halfHeight_1;
        corners_1[2i] = ((_e333 + _e334) + _e336);
        let _e339 = toCentre;
        let _e340 = halfWidth_1;
        let _e342 = halfHeight_1;
        corners_1[3i] = ((_e339 - _e340) + _e342);
        let _e345 = toCentre;
        let _e346 = halfWidth_1;
        let _e347 = halfHeight_1;
        behind = (dot(_e345, cross(_e346, _e347)) >= 0f);
        let _e351 = behind;
        if _e351 {
            local_25 = 0f;
        } else {
            let _e352 = corners_1;
            param_92 = _e352;
            let _e354 = (*s_4).n;
            param_93 = _e354;
            let _e355 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_25 = _e355;
        }
        let _e356 = local_25;
        formFactor = _e356;
        let _e357 = halfWidth_1;
        let _e358 = halfHeight_1;
        area = (length(cross(_e357, _e358)) * 4f);
        let _e362 = area;
        if (_e362 > 0.000000001f) {
            let _e364 = area;
            local_26 = (1f / _e364);
        } else {
            local_26 = 0f;
        }
        let _e366 = local_26;
        radiance = _e366;
        let _e367 = toCentre;
        distance_2 = length(_e367);
        let _e370 = direction[3u];
        if (_e370 > 0f) {
            let _e372 = distance_2;
            let _e374 = direction[3u];
            ratio_1 = (_e372 / _e374);
            let _e376 = ratio_1;
            let _e377 = ratio_1;
            let _e379 = ratio_1;
            let _e381 = ratio_1;
            window_1 = clamp((1f - (((_e376 * _e377) * _e379) * _e381)), 0f, 1f);
            let _e385 = window_1;
            let _e386 = window_1;
            let _e388 = radiance;
            radiance = (_e388 * (_e385 * _e386));
        }
        let _e391 = (*s_4).v;
        let _e394 = (*s_4).n;
        mirror_1 = reflect(-(_e391), _e394);
        let _e396 = position;
        param_94 = _e396.xyz;
        let _e398 = halfWidth_1;
        param_95 = _e398;
        let _e399 = halfHeight_1;
        param_96 = _e399;
        let _e400 = v_world_position_1;
        param_97 = _e400;
        let _e401 = mirror_1;
        param_98 = _e401;
        let _e402 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e402;
        let _e403 = representative;
        let _e404 = v_world_position_1;
        toPoint = (_e403 - _e404);
        let _e406 = toPoint;
        pointDistance = length(_e406);
        let _e408 = pointDistance;
        if (_e408 > 0.000001f) {
            let _e410 = toPoint;
            let _e411 = pointDistance;
            local_27 = (_e410 / vec3(_e411));
        } else {
            let _e415 = (*s_4).n;
            local_27 = _e415;
        }
        let _e416 = local_27;
        light_3.l = _e416;
        let _e419 = light_3.l;
        let _e421 = (*s_4).v;
        light_3.h = normalize((_e419 + _e421));
        let _e425 = formFactor;
        light_3.n_dot_l = _e425;
        let _e428 = (*s_4).n;
        let _e430 = light_3.h;
        light_3.n_dot_h = max(dot(_e428, _e430), 0f);
        let _e435 = (*s_4).v;
        let _e437 = light_3.h;
        light_3.v_dot_h = max(dot(_e435, _e437), 0f);
        let _e441 = color_1;
        let _e444 = color_1[3u];
        let _e446 = radiance;
        light_3.radiance = ((_e441.xyz * _e444) * _e446);
        let _e449 = light_3;
        return _e449;
    }
    let _e450 = direction;
    aim = normalize(_e450.xyz);
    attenuation_1 = 1f;
    let _e453 = type_39;
    if (_e453 < 0.5f) {
        let _e455 = aim;
        light_3.l = -(_e455);
    } else {
        let _e458 = position;
        let _e460 = v_world_position_1;
        toLight_1 = (_e458.xyz - _e460);
        let _e462 = toLight_1;
        distance_3 = length(_e462);
        let _e464 = distance_3;
        if (_e464 < 0.000001f) {
            let _e467 = (*s_4).n;
            light_3.l = _e467;
            let _e470 = (*s_4).n;
            light_3.h = _e470;
            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 _e476 = light_3;
            return _e476;
        }
        let _e477 = toLight_1;
        let _e478 = distance_3;
        light_3.l = (_e477 / vec3(_e478));
        let _e482 = distance_3;
        param_99 = _e482;
        let _e484 = direction[3u];
        param_100 = _e484;
        let _e485 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e485;
        let _e486 = type_39;
        if (_e486 > 1.5f) {
            let _e488 = aim;
            let _e490 = light_3.l;
            cosAngle = dot(_e488, -(_e490));
            let _e493 = cosAngle;
            let _e495 = cone[1u];
            let _e498 = cone[0u];
            let _e500 = cone[1u];
            ramp = clamp(((_e493 - _e495) / (_e498 - _e500)), 0f, 1f);
            let _e504 = ramp;
            let _e505 = ramp;
            let _e507 = attenuation_1;
            attenuation_1 = (_e507 * (_e504 * _e505));
        }
    }
    let _e510 = light_3.l;
    let _e512 = (*s_4).v;
    light_3.h = normalize((_e510 + _e512));
    let _e517 = (*s_4).n;
    let _e519 = light_3.l;
    light_3.n_dot_l = max(dot(_e517, _e519), 0f);
    let _e524 = (*s_4).n;
    let _e526 = light_3.h;
    light_3.n_dot_h = max(dot(_e524, _e526), 0f);
    let _e531 = (*s_4).v;
    let _e533 = light_3.h;
    light_3.v_dot_h = max(dot(_e531, _e533), 0f);
    let _e537 = color_1;
    let _e540 = color_1[3u];
    let _e542 = attenuation_1;
    light_3.radiance = ((_e537.xyz * _e540) * _e542);
    let _e545 = light_3;
    return _e545;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_28: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e190 = light_list_info.cluster_view_projection;
    let _e191 = (*world_3);
    clip_1 = (_e190 * vec4<f32>(_e191.x, _e191.y, _e191.z, 1f));
    let _e197 = clip_1;
    let _e200 = clip_1[3u];
    ndc_1 = (_e197.xy / vec2(max(_e200, 0.000001f)));
    let _e205 = light_list_info.cluster_grid;
    grid = _e205.xyz;
    let _e209 = light_list_info.cluster_depth[0u];
    near_1 = _e209;
    let _e211 = ndc_1[0u];
    let _e215 = grid[0u];
    let _e219 = grid[0u];
    tx = clamp(floor((((_e211 * 0.5f) + 0.5f) * _e215)), 0f, (_e219 - 1f));
    let _e223 = ndc_1[1u];
    let _e227 = grid[1u];
    let _e231 = grid[1u];
    ty = clamp(floor((((_e223 * 0.5f) + 0.5f) * _e227)), 0f, (_e231 - 1f));
    let _e235 = clip_1[3u];
    let _e236 = near_1;
    if (_e235 <= _e236) {
        local_28 = 0f;
    } else {
        let _e239 = clip_1[3u];
        let _e240 = near_1;
        let _e245 = light_list_info.cluster_depth[1u];
        let _e249 = grid[2u];
        local_28 = clamp(floor((log((_e239 / _e240)) * _e245)), 0f, (_e249 - 1f));
    }
    let _e252 = local_28;
    tz = _e252;
    let _e253 = tx;
    let _e254 = ty;
    let _e256 = grid[0u];
    let _e259 = tz;
    let _e261 = grid[0u];
    let _e264 = grid[1u];
    cell = ((_e253 + (_e254 * _e256)) + ((_e259 * _e261) * _e264));
    let _e267 = cell;
    row_3 = floor((_e267 / 4f));
    let _e270 = cell;
    let _e271 = row_3;
    let _e276 = light_list_info.cluster_depth[2u];
    let _e277 = row_3;
    param_101 = (_e270 - (_e271 * 4f));
    param_102 = (_e276 + _e277);
    let _e279 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e279;
    let _e281 = header[0u];
    g_cluster_offset = _e281;
    let _e283 = header[1u];
    g_cluster_count = _e283;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e179 = light_list_info.list[0u];
    tail = _e179;
    let _e180 = Clustered_u0028_();
    if _e180 {
        let _e181 = v_world_position_1;
        param_103 = _e181;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e182 = g_cluster_count;
        tail = _e182;
    }
    let _e185 = frag_info.frame_params[1u];
    let _e189 = tail;
    return (clamp(i32((_e185 + 0.5f)), 0i, 8i) + clamp(i32((_e189 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_29: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e193 = LightCount_u0028_();
    count_1 = _e193;
    i_8 = 0i;
    loop {
        let _e194 = i_8;
        if (_e194 < 32i) {
            let _e196 = i_8;
            let _e197 = count_1;
            if (_e196 >= _e197) {
                break;
            }
            let _e199 = i_8;
            param_104 = _e199;
            let _e200 = (*s_5);
            param_105 = _e200;
            let _e201 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_104), (&param_105));
            light_4 = _e201;
            let _e203 = light_4.n_dot_l;
            if (_e203 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e205 = i_8;
            param_106 = _e205;
            let _e206 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e206 {
                let _e207 = (*s_5);
                param_107 = _e207;
                let _e208 = light_4;
                param_108 = _e208;
                let _e209 = i_8;
                param_109 = _e209;
                let _e210 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e211 = v_world_position_1;
                param_110 = _e211;
                let _e213 = (*s_5).n;
                param_111 = _e213;
                let _e214 = i_8;
                param_112 = _e214;
                let _e215 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_29 = (_e210 * _e215);
            } else {
                local_29 = 1f;
            }
            let _e217 = local_29;
            visibility = _e217;
            let _e218 = visibility;
            if (_e218 <= 0f) {
                continue;
            }
            let _e220 = (*s_5);
            param_113 = _e220;
            let _e221 = light_4;
            param_114 = _e221;
            let _e222 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e224 = light_4.radiance;
            let _e227 = light_4.n_dot_l;
            let _e229 = visibility;
            let _e231 = light_transmittance;
            let _e233 = total_1;
            total_1 = (_e233 + ((((_e222 * _e224) * _e227) * _e229) * _e231));
            continue;
        } else {
            break;
        }
        continuing {
            let _e235 = i_8;
            i_8 = (_e235 + 1i);
        }
    }
    let _e237 = total_1;
    return _e237;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_30: f32;
    var local_31: f32;

    let _e179 = OcclusionTarget_u0028_();
    target_ = _e179;
    let _e180 = target_;
    let _e182 = target_;
    if ((_e180 > 0.5f) && (_e182 < 1.5f)) {
        local_30 = 1f;
    } else {
        let _e186 = (*s_6).occlusion;
        local_30 = _e186;
    }
    let _e187 = local_30;
    local_31 = _e187;
    let _e188 = local_31;
    return _e188;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e176 = v_lightmap_uv_1;
    let _e177 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e176);
    texel_4 = _e177;
    let _e178 = texel_4;
    let _e181 = texel_4[3u];
    return ((_e178.xyz * _e181) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e177 = frag_info.target_origin[1u];
    return _e177;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e177 = v_texcoord_1;
    let _e178 = MaterialLodBias_u0028_();
    let _e179 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e177, _e178);
    orm = _e179.xyz;
    let _e182 = (*s_7).metallic;
    let _e184 = orm[2u];
    (*s_7).metallic = clamp((_e182 * _e184), 0f, 1f);
    let _e189 = (*s_7).roughness;
    let _e191 = orm[1u];
    (*s_7).roughness = clamp((_e189 * _e191), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e176 = (*srgb);
    let _e179 = (*srgb);
    let _e184 = (*srgb);
    return mix((_e176 / vec3(12.92f)), pow(((_e179 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e184));
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_115: vec3<f32>;

    let _e178 = v_texcoord_1;
    let _e179 = MaterialLodBias_u0028_();
    let _e180 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e178, _e179);
    param_115 = _e180.xyz;
    let _e182 = SrgbToLinear_u0028_vf3_u003b((&param_115));
    emissive = _e182;
    let _e183 = emissive;
    let _e185 = frag_info.emissive;
    let _e190 = frag_info.material2_[3u];
    (*s_8).emissive = ((_e183 * _e185.xyz) * _e190);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e178 = v_texcoord_1;
    let _e179 = MaterialLodBias_u0028_();
    let _e180 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e178, _e179);
    occlusion = _e180.x;
    let _e184 = frag_info.material2_[2u];
    let _e185 = OcclusionTarget_u0028_();
    strength_2 = (_e184 - (2f * _e185));
    let _e188 = occlusion;
    let _e189 = strength_2;
    (*s_9).occlusion = mix(1f, _e188, clamp(_e189, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e180 = v_texcoord_1;
    let _e181 = MaterialLodBias_u0028_();
    let _e182 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e180, _e181);
    sampledTexel = _e182;
    let _e183 = v_tangent_1;
    t_2 = _e183.xyz;
    let _e185 = t_2;
    let _e187 = (*s_10).n;
    let _e189 = (*s_10).n;
    let _e190 = t_2;
    t_2 = (_e185 - (_e187 * dot(_e189, _e190)));
    let _e194 = t_2;
    let _e195 = t_2;
    if (dot(_e194, _e195) < 0.000000000001f) {
        return;
    }
    let _e198 = t_2;
    t_2 = normalize(_e198);
    let _e201 = (*s_10).n;
    let _e202 = t_2;
    let _e205 = v_tangent_1[3u];
    b_3 = (cross(_e201, _e202) * _e205);
    let _e207 = gl_FrontFacing_1;
    if !(_e207) {
        let _e209 = t_2;
        t_2 = -(_e209);
    }
    let _e211 = sampledTexel;
    sampled = ((_e211.xyz * 2f) - vec3(1f));
    let _e218 = frag_info.emissive[3u];
    if (_e218 > 0.5f) {
        let _e220 = sampled;
        let _e222 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e220.xy, _e222.xy)), 0f));
    }
    let _e231 = frag_info.material2_[1u];
    let _e232 = sampled;
    let _e234 = (_e232.xy * _e231);
    sampled[0u] = _e234.x;
    sampled[1u] = _e234.y;
    let _e239 = t_2;
    let _e241 = sampled[0u];
    let _e243 = b_3;
    let _e245 = sampled[1u];
    let _e249 = (*s_10).n;
    let _e251 = sampled[2u];
    (*s_10).n = normalize((((_e239 * _e241) + (_e243 * _e245)) + (_e249 * _e251)));
    let _e257 = (*s_10).n;
    let _e259 = (*s_10).v;
    (*s_10).n_dot_v = max(dot(_e257, _e259), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e176 = (*texel_5);
    let _e180 = irradiance_info.atlas;
    let _e183 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e176 + vec2(0.5f)) * _e180.xy), 0f);
    return _e183;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_116: vec2<f32>;
    var b_4: vec4<f32>;
    var param_117: vec2<f32>;
    var c: vec4<f32>;
    var param_118: vec2<f32>;
    var d_4: vec4<f32>;
    var param_119: vec2<f32>;

    let _e189 = (*uv_5);
    let _e190 = (*interior);
    at_1 = ((vec2(1f) + (_e189 * _e190)) - vec2(0.5f));
    let _e196 = at_1;
    low = floor(_e196);
    let _e198 = at_1;
    let _e199 = low;
    f = (_e198 - _e199);
    let _e201 = (*corner);
    let _e202 = low;
    param_116 = (_e201 + _e202);
    let _e204 = AtlasTexel_u0028_vf2_u003b((&param_116));
    a_4 = _e204;
    let _e205 = (*corner);
    let _e206 = low;
    param_117 = ((_e205 + _e206) + vec2<f32>(1f, 0f));
    let _e209 = AtlasTexel_u0028_vf2_u003b((&param_117));
    b_4 = _e209;
    let _e210 = (*corner);
    let _e211 = low;
    param_118 = ((_e210 + _e211) + vec2<f32>(0f, 1f));
    let _e214 = AtlasTexel_u0028_vf2_u003b((&param_118));
    c = _e214;
    let _e215 = (*corner);
    let _e216 = low;
    param_119 = ((_e215 + _e216) + vec2<f32>(1f, 1f));
    let _e219 = AtlasTexel_u0028_vf2_u003b((&param_119));
    d_4 = _e219;
    let _e220 = a_4;
    let _e221 = b_4;
    let _e223 = f[0u];
    let _e226 = c;
    let _e227 = d_4;
    let _e229 = f[0u];
    let _e233 = f[1u];
    return mix(mix(_e220, _e221, vec4(_e223)), mix(_e226, _e227, vec4(_e229)), vec4(_e233));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e180 = (*direction_1)[0u];
    let _e183 = (*direction_1)[1u];
    let _e187 = (*direction_1)[2u];
    sum_1 = ((abs(_e180) + abs(_e183)) + abs(_e187));
    let _e190 = sum_1;
    if (_e190 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e192 = (*direction_1);
    let _e193 = sum_1;
    n_5 = (_e192 / vec3(_e193));
    let _e196 = n_5;
    xy = _e196.xy;
    let _e199 = n_5[2u];
    if (_e199 < 0f) {
        let _e202 = n_5[1u];
        let _e206 = n_5[0u];
        let _e211 = n_5[0u];
        let _e215 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e202)) * select(-1f, 1f, (_e206 >= 0f))), ((1f - abs(_e211)) * select(-1f, 1f, (_e215 >= 0f))));
    }
    let _e220 = xy;
    return ((_e220 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_120: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_121: vec3<f32>;
    var param_122: vec2<f32>;
    var param_123: f32;
    var param_124: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_125: vec3<f32>;
    var param_126: vec2<f32>;
    var param_127: f32;
    var param_128: vec2<f32>;
    var local_32: vec3<f32>;

    let _e222 = irradiance_info.origin;
    origin_2 = _e222.xyz;
    let _e225 = irradiance_info.spacing;
    spacing = _e225.xyz;
    let _e228 = irradiance_info.counts;
    counts = _e228.xyz;
    let _e232 = irradiance_info.tiles[0u];
    irradianceTile = _e232;
    let _e235 = irradiance_info.tiles[1u];
    depthTile = _e235;
    let _e238 = irradiance_info.tiles[2u];
    columns = _e238;
    let _e241 = irradiance_info.tiles[3u];
    momentsTop = _e241;
    let _e242 = (*normal_1);
    unit = normalize(_e242);
    let _e244 = (*world_4);
    let _e245 = unit;
    let _e248 = irradiance_info.spacing[3u];
    let _e251 = (*view);
    let _e254 = irradiance_info.counts[3u];
    biased = ((_e244 + (_e245 * _e248)) + (_e251 * _e254));
    let _e257 = biased;
    let _e258 = origin_2;
    let _e260 = spacing;
    grid_1 = ((_e257 - _e258) / _e260);
    let _e262 = grid_1;
    let _e264 = counts;
    base = clamp(floor(_e262), vec3<f32>(0f, 0f, 0f), (_e264 - vec3(2f)));
    let _e268 = grid_1;
    let _e269 = base;
    f_1 = clamp((_e268 - _e269), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e272 = corner_1;
        if (_e272 < 8i) {
            let _e274 = corner_1;
            let _e277 = corner_1;
            let _e282 = corner_1;
            offset_3 = vec3<f32>(f32((_e274 & 1i)), f32(((_e277 >> bitcast<u32>(1i)) & 1i)), f32(((_e282 >> bitcast<u32>(2i)) & 1i)));
            let _e288 = base;
            let _e289 = offset_3;
            cell_1 = (_e288 + _e289);
            let _e292 = cell_1[2u];
            let _e294 = counts[1u];
            let _e297 = cell_1[1u];
            let _e300 = counts[0u];
            let _e303 = cell_1[0u];
            probe = ((((_e292 * _e294) + _e297) * _e300) + _e303);
            let _e305 = probe;
            let _e306 = columns;
            let _e311 = probe;
            let _e312 = columns;
            tile_4 = vec2<f32>((_e305 - (floor((_e305 / _e306)) * _e306)), floor((_e311 / _e312)));
            let _e316 = tile_4;
            let _e317 = irradianceTile;
            irradianceCorner = (_e316 * (_e317 + 2f));
            let _e321 = tile_4[0u];
            let _e322 = depthTile;
            let _e325 = momentsTop;
            let _e327 = tile_4[1u];
            let _e328 = depthTile;
            momentCorner = vec2<f32>((_e321 * (_e322 + 2f)), (_e325 + (_e327 * (_e328 + 2f))));
            let _e333 = irradianceCorner;
            param_120 = (_e333 + vec2(1f));
            let _e336 = AtlasTexel_u0028_vf2_u003b((&param_120));
            if (_e336.w < 0.5f) {
                continue;
            }
            let _e339 = f_1;
            let _e341 = f_1;
            let _e342 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e339), _e341, _e342);
            let _e345 = trilinear[0u];
            let _e347 = trilinear[1u];
            let _e350 = trilinear[2u];
            weight_2 = max(((_e345 * _e347) * _e350), 0.001f);
            let _e353 = origin_2;
            let _e354 = spacing;
            let _e355 = cell_1;
            probePosition = (_e353 + (_e354 * _e355));
            let _e358 = probePosition;
            let _e359 = biased;
            toProbe = (_e358 - _e359);
            let _e361 = toProbe;
            distance_4 = length(_e361);
            let _e363 = distance_4;
            if (_e363 > 0.000001f) {
                let _e365 = toProbe;
                let _e366 = distance_4;
                direction_2 = (_e365 / vec3(_e366));
                let _e369 = unit;
                let _e370 = probePosition;
                let _e371 = (*world_4);
                facing = ((dot(_e369, normalize((_e370 - _e371))) * 0.5f) + 0.5f);
                let _e377 = facing;
                let _e378 = facing;
                probeWeight = ((_e377 * _e378) + 0.2f);
                let _e381 = direction_2;
                param_121 = -(_e381);
                let _e383 = ProbeOctahedral_u0028_vf3_u003b((&param_121));
                let _e384 = momentCorner;
                param_122 = _e384;
                let _e385 = depthTile;
                param_123 = _e385;
                param_124 = _e383;
                let _e386 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_122), (&param_123), (&param_124));
                moments_3 = _e386.xy;
                chebyshev = 1f;
                let _e388 = distance_4;
                let _e390 = moments_3[0u];
                if (_e388 > _e390) {
                    let _e393 = moments_3[1u];
                    let _e395 = moments_3[0u];
                    let _e397 = moments_3[0u];
                    variance_1 = max((_e393 - (_e395 * _e397)), 0.000001f);
                    let _e401 = distance_4;
                    let _e403 = moments_3[0u];
                    difference = (_e401 - _e403);
                    let _e405 = variance_1;
                    let _e406 = variance_1;
                    let _e407 = difference;
                    let _e408 = difference;
                    chebyshev = (_e405 / (_e406 + (_e407 * _e408)));
                    let _e412 = chebyshev;
                    let _e413 = chebyshev;
                    let _e415 = chebyshev;
                    chebyshev = ((_e412 * _e413) * _e415);
                }
                let _e417 = probeWeight;
                let _e418 = chebyshev;
                probeWeight = max((_e417 * max(_e418, 0.05f)), 0.000001f);
                let _e422 = probeWeight;
                if (_e422 < 0.2f) {
                    let _e424 = probeWeight;
                    let _e425 = probeWeight;
                    let _e428 = probeWeight;
                    probeWeight = (_e428 * ((_e424 * _e425) * 25f));
                }
                let _e430 = probeWeight;
                let _e431 = weight_2;
                weight_2 = (_e431 * _e430);
            }
            let _e433 = unit;
            param_125 = _e433;
            let _e434 = ProbeOctahedral_u0028_vf3_u003b((&param_125));
            let _e435 = irradianceCorner;
            param_126 = _e435;
            let _e436 = irradianceTile;
            param_127 = _e436;
            param_128 = _e434;
            let _e437 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_126), (&param_127), (&param_128));
            let _e439 = weight_2;
            let _e441 = total_2;
            total_2 = (_e441 + (_e437.xyz * _e439));
            let _e443 = weight_2;
            let _e444 = weights;
            weights = (_e444 + _e443);
            continue;
        } else {
            break;
        }
        continuing {
            let _e446 = corner_1;
            corner_1 = (_e446 + 1i);
        }
    }
    let _e448 = weights;
    if (_e448 > 0f) {
        let _e450 = total_2;
        let _e451 = weights;
        local_32 = (_e450 / vec3(_e451));
    } else {
        local_32 = vec3<f32>(0f, 0f, 0f);
    }
    let _e454 = local_32;
    return _e454;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e177 = irradiance_info.origin[3u];
    return (_e177 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;
    var param_132: Surface;
    var param_133: Surface;
    var param_134: Surface;

    let _e182 = IrradianceEnabled_u0028_();
    if _e182 {
        let _e183 = v_world_position_1;
        param_129 = _e183;
        let _e185 = (*s_11).n;
        param_130 = _e185;
        let _e187 = (*s_11).v;
        param_131 = _e187;
        let _e188 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
        let _e191 = frag_info.material[2u];
        (*s_11).ambient = (_e188 * _e191);
    }
    let _e194 = (*s_11);
    param_132 = _e194;
    ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_132));
    let _e195 = param_132;
    (*s_11) = _e195;
    let _e196 = (*s_11);
    param_133 = _e196;
    ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_133));
    let _e197 = param_133;
    (*s_11) = _e197;
    let _e198 = (*s_11);
    param_134 = _e198;
    ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_134));
    let _e199 = param_134;
    (*s_11) = _e199;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_33: vec3<f32>;

    let _e176 = Orthographic_u0028_();
    if _e176 {
        let _e178 = fog_info.forward;
        local_33 = -(_e178.xyz);
    } else {
        let _e182 = fog_info.eye;
        let _e184 = v_world_position_1;
        local_33 = normalize((_e182.xyz - _e184));
    }
    let _e187 = local_33;
    return _e187;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_12: Surface;
    var param_135: vec3<f32>;
    var param_136: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e181 = v_texcoord_1;
    let _e182 = MaterialLodBias_u0028_();
    let _e183 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e181, _e182);
    texel_6 = _e183;
    let _e184 = texel_6;
    param_135 = _e184.xyz;
    let _e186 = SrgbToLinear_u0028_vf3_u003b((&param_135));
    let _e188 = frag_info.base_color;
    param_136 = _e188.xyz;
    let _e190 = SrgbToLinear_u0028_vf3_u003b((&param_136));
    let _e192 = v_color_1;
    s_12.albedo = ((_e186 * _e190) * _e192.xyz);
    let _e197 = texel_6[3u];
    let _e200 = frag_info.base_color[3u];
    let _e203 = v_color_1[3u];
    s_12.alpha = ((_e197 * _e200) * _e203);
    let _e207 = s_12.albedo;
    g_albedo = _e207;
    let _e210 = frag_info.material2_[0u];
    cutoff = _e210;
    let _e211 = cutoff;
    if (_e211 > 1f) {
        let _e213 = cutoff;
        edge = (_e213 - 1f);
        let _e216 = s_12.alpha;
        let _e217 = edge;
        let _e220 = s_12.alpha;
        let _e221 = fwidth(_e220);
        s_12.alpha = clamp((((_e216 - _e217) / max(_e221, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e227 = cutoff;
        if (_e227 >= 0f) {
            s_12.alpha = 1f;
        }
    }
    let _e230 = cutoff;
    let _e232 = cutoff;
    g_premultiply = ((_e230 < 0f) && (_e232 > -0.75f));
    let _e235 = v_normal_1;
    s_12.n = normalize(_e235);
    let _e238 = gl_FrontFacing_1;
    if !(_e238) {
        let _e241 = s_12.n;
        s_12.n = -(_e241);
    }
    let _e244 = TowardsEye_u0028_();
    s_12.v = _e244;
    let _e247 = s_12.n;
    let _e249 = s_12.v;
    s_12.n_dot_v = max(dot(_e247, _e249), 0.0001f);
    let _e255 = frag_info.material[0u];
    s_12.metallic = clamp(_e255, 0f, 1f);
    let _e260 = frag_info.material[1u];
    s_12.roughness = clamp(_e260, 0.02f, 1f);
    let _e264 = frag_info.ambient_ground;
    let _e267 = frag_info.ambient_sky;
    let _e271 = s_12.n[1u];
    let _e278 = frag_info.material[2u];
    s_12.ambient = (mix(_e264.xyz, _e267.xyz, vec3(((_e271 * 0.5f) + 0.5f))) * _e278);
    let _e283 = frag_info.frame_params[0u];
    s_12.exposure = max(_e283, 0f);
    s_12.occlusion = 1f;
    s_12.emissive = vec3<f32>(0f, 0f, 0f);
    let _e288 = s_12;
    return _e288;
}

fn main_1() {
    var s_13: Surface;
    var param_137: Surface;
    var param_138: Surface;
    var ambient: vec3<f32>;
    var param_139: Surface;
    var lit_2: vec3<f32>;
    var param_140: Surface;
    var param_141: Surface;
    var param_142: vec3<f32>;
    var param_143: f32;
    var param_144: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e186 = ReadSurface_u0028_();
    s_13 = _e186;
    let _e187 = s_13;
    param_137 = _e187;
    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((&param_137));
    let _e188 = param_137;
    s_13 = _e188;
    let _e189 = s_13;
    param_138 = _e189;
    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((&param_138));
    let _e190 = param_138;
    s_13 = _e190;
    let _e192 = s_13.albedo;
    let _e194 = s_13.ambient;
    let _e195 = SampleLightmap_u0028_();
    let _e198 = s_13;
    param_139 = _e198;
    let _e199 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_139));
    ambient = ((_e192 * (_e194 + _e195)) * _e199);
    let _e201 = s_13;
    param_140 = _e201;
    let _e202 = 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((&param_140));
    let _e203 = s_13;
    param_141 = _e203;
    let _e204 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    let _e206 = ambient;
    let _e209 = s_13.emissive;
    lit_2 = (((_e202 * _e204) + _e206) + _e209);
    let _e211 = lit_2;
    param_142 = _e211;
    let _e213 = s_13.alpha;
    param_143 = _e213;
    let _e215 = s_13.roughness;
    param_144 = _e215;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_142), (&param_143), (&param_144));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrOpaque': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(13)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(17)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var ltc_texture_smp: sampler;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(27)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(28)
var point_shadow_texture_smp: sampler;
@group(1) @binding(25)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(11)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var irradiance_texture_smp: sampler;
@group(1) @binding(15)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(23)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(21)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(29)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(30)
var shadow_texture_smp: sampler;
@group(1) @binding(9)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(10)
var environment_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e194 = v_world_position_1;
    let _e196 = fog_info.eye;
    let _e200 = fog_info.forward;
    return dot((_e194 - _e196.xyz), _e200.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e199 = ViewDepth_u0028_();
    z = abs(_e199);
    let _e201 = z;
    near = (_e201 / 5f);
    let _e203 = z;
    far = (_e203 / 200f);
    let _e205 = far;
    let _e206 = far;
    let _e208 = far;
    far3_ = ((_e205 * _e206) * _e208);
    let _e210 = (*alpha);
    let _e211 = near;
    let _e212 = near;
    let _e215 = far3_;
    let _e216 = far3_;
    return (_e210 * clamp((10f / ((0.00001f + (_e211 * _e212)) + (_e215 * _e216))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e203 = fog_info.forward[3u];
    mode = _e203;
    let _e204 = mode;
    if (_e204 > 0.5f) {
        let _e207 = frag_color[3u];
        alpha_1 = _e207;
        let _e208 = alpha_1;
        param = _e208;
        let _e209 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e209;
        let _e210 = frag_color;
        let _e212 = weight;
        let _e213 = (_e210.xyz * _e212);
        let _e214 = alpha_1;
        let _e215 = weight;
        accumulate = vec4<f32>(_e213.x, _e213.y, _e213.z, (_e214 * _e215));
        let _e221 = mode;
        let _e223 = mode;
        revealage = ((_e221 > 1.5f) && (_e223 < 2.5f));
        let _e226 = revealage;
        if _e226 {
            let _e227 = alpha_1;
            local = vec4(_e227);
        } else {
            let _e229 = accumulate;
            local = _e229;
        }
        let _e230 = local;
        frag_color = _e230;
        let _e231 = mode;
        if (_e231 > 2.5f) {
            let _e233 = alpha_1;
            frag_surface = vec4(_e233);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e197 = (*n)[0u];
    let _e200 = (*n)[1u];
    let _e204 = (*n)[2u];
    let _e207 = (*n);
    (*n) = (_e207 / vec3(((abs(_e197) + abs(_e200)) + abs(_e204))));
    let _e210 = (*n);
    e = _e210.xy;
    let _e213 = (*n)[2u];
    if (_e213 < 0f) {
        let _e215 = (*n);
        let _e221 = (*n)[0u];
        let _e225 = (*n)[1u];
        e = ((vec2(1f) - abs(_e215.yx)) * vec2<f32>(select(-1f, 1f, (_e221 >= 0f)), select(-1f, 1f, (_e225 >= 0f))));
    }
    let _e230 = e;
    return ((_e230 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e195 = (*linear);
    let _e197 = (*linear);
    let _e201 = (*linear);
    return mix((_e195 * 12.92f), ((pow(_e197, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e201));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e198 = g_albedo;
    param_1 = clamp(_e198, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e200 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e200.x, _e200.y, _e200.z, 1f);
    let _e205 = g_debug_surface_on;
    if _e205 {
        let _e206 = g_debug_surface;
        let _e207 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e206.x, _e206.y, _e206.z, _e207);
        return;
    }
    let _e212 = v_normal_1;
    geometric = normalize(_e212);
    let _e214 = gl_FrontFacing_1;
    if !(_e214) {
        let _e216 = geometric;
        geometric = -(_e216);
    }
    let _e218 = geometric;
    param_2 = _e218;
    let _e219 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e220 = (*roughness);
    let _e222 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e219.x, _e219.y, clamp(_e220, 0f, 1f), _e222);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e196 = fog_info.projection[0u];
    return (_e196 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e195 = Orthographic_u0028_();
    if _e195 {
        let _e196 = ViewDepth_u0028_();
        local_1 = max(_e196, 0f);
    } else {
        let _e198 = v_world_position_1;
        let _e200 = fog_info.eye;
        local_1 = distance(_e198, _e200.xyz);
    }
    let _e203 = local_1;
    return _e203;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e202 = fog_info.fog[3u];
    density = _e202;
    let _e203 = density;
    if (_e203 <= 0f) {
        let _e205 = (*color);
        return _e205;
    }
    let _e206 = EyeDistance_u0028_();
    d = _e206;
    let _e209 = fog_info.eye[3u];
    falloff = _e209;
    let _e210 = falloff;
    if (_e210 > 0f) {
        let _e212 = falloff;
        let _e214 = v_world_position_1[1u];
        let _e217 = fog_info.eye[1u];
        k = (_e212 * (_e214 - _e217));
        let _e220 = k;
        if (abs(_e220) > 0.001f) {
            let _e223 = k;
            let _e227 = k;
            local_2 = ((1f - exp(-(_e223))) / _e227);
        } else {
            let _e229 = k;
            local_2 = (1f - (0.5f * _e229));
        }
        let _e232 = local_2;
        let _e233 = density;
        density = (_e233 * _e232);
    }
    let _e236 = fog_info.fog;
    let _e238 = (*color);
    let _e239 = density;
    let _e241 = d;
    return mix(_e236.xyz, _e238, vec3(clamp(exp((-(_e239) * _e241)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e200 = g_premultiply;
    let _e201 = (*alpha_2);
    weight_1 = select(1f, _e201, _e200);
    let _e203 = (*linearColor);
    param_3 = _e203;
    let _e204 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e205 = weight_1;
    let _e206 = (_e204 * _e205);
    let _e207 = (*alpha_2);
    let _e208 = g_pass_through;
    frag_color = vec4<f32>(_e206.x, _e206.y, _e206.z, (_e207 * (1f - _e208)));
    let _e215 = (*roughness_1);
    param_4 = _e215;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m: f32;
    var g: f32;

    let _e198 = (*mu);
    m = (1f - _e198);
    let _e200 = m;
    let _e201 = m;
    let _e202 = m;
    let _e203 = m;
    g = (_e200 * (0.05710853f + (_e201 * (0.49188188f + (_e202 * (-0.33218145f + (_e203 * 0.071443f)))))));
    let _e211 = (*r);
    let _e212 = g;
    let _e215 = (*r);
    return ((1f + (_e211 * _e212)) / (1f + (0.2877934f * _e215)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e196 = (*rho);
    let _e197 = (*rho);
    let _e199 = (*average);
    let _e201 = (*rho);
    let _e202 = (*average);
    return (((_e196 * _e197) * _e199) / (vec3<f32>(1f, 1f, 1f) - (_e201 * (1f - _e202))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e195 = (*r_1);
    let _e198 = (*r_1);
    return ((1f + (0.07248821f * _e195)) / (1f + (0.2877934f * _e198)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s: f32;
    var s_over_t: f32;
    var local_3: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_5: f32;
    var multi: vec3<f32>;
    var param_6: vec3<f32>;
    var param_7: f32;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;
    var param_11: f32;

    let _e213 = (*l_dot_v);
    let _e214 = (*mu_i);
    let _e215 = (*mu_o);
    s = (_e213 - (_e214 * _e215));
    let _e218 = s;
    if (_e218 > 0f) {
        let _e220 = s;
        let _e221 = (*mu_i);
        let _e222 = (*mu_o);
        local_3 = (_e220 / max(_e221, _e222));
    } else {
        let _e225 = s;
        local_3 = _e225;
    }
    let _e226 = local_3;
    s_over_t = _e226;
    let _e227 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e227)));
    let _e231 = (*rho_1);
    let _e232 = af;
    let _e233 = (*r_2);
    let _e234 = s_over_t;
    single = (_e231 * (_e232 * (1f + (_e233 * _e234))));
    let _e239 = (*r_2);
    param_5 = _e239;
    let _e240 = FonAverage_u0028_f1_u003b((&param_5));
    average_1 = _e240;
    let _e241 = (*rho_1);
    param_6 = _e241;
    let _e242 = average_1;
    param_7 = _e242;
    let _e243 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_6), (&param_7));
    let _e244 = (*mu_o);
    param_8 = _e244;
    let _e245 = (*r_2);
    param_9 = _e245;
    let _e246 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_8), (&param_9));
    let _e249 = (*mu_i);
    param_10 = _e249;
    let _e250 = (*r_2);
    param_11 = _e250;
    let _e251 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_10), (&param_11));
    let _e255 = average_1;
    multi = (_e243 * ((max((1f - _e246), 0.0000001f) * max((1f - _e251), 0.0000001f)) / max((1f - _e255), 0.0000001f)));
    let _e260 = single;
    let _e261 = multi;
    return ((_e260 + _e261) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e196 = frag_info.ambient_sky[3u];
    return (_e196 > 0.5f);
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e198 = (*x);
    let _e199 = (*y);
    inTable = ((vec2<f32>(_e198, _e199) * 0.984375f) + vec2(0.0078125f));
    let _e205 = inTable[0u];
    let _e207 = inTable[1u];
    let _e208 = (*table);
    return vec2<f32>(_e205, ((_e207 + _e208) * 0.5f));
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_12: f32;
    var param_13: f32;
    var param_14: f32;

    let _e200 = (*roughness_2);
    let _e202 = (*n_dot_v);
    param_12 = clamp(_e200, 0f, 1f);
    param_13 = sqrt(clamp((1f - _e202), 0f, 1f));
    param_14 = 1f;
    let _e206 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_12), (&param_13), (&param_14));
    let _e207 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e206, 0f);
    dfg = _e207.xy;
    let _e210 = dfg[0u];
    let _e212 = dfg[1u];
    let _e215 = dfg[1u];
    return vec2<f32>((_e210 - _e212), _e215);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_1: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_15: f32;
    var param_16: f32;
    var ess: f32;

    let _e201 = (*s_1).roughness;
    param_15 = max(_e201, 0.045f);
    let _e204 = (*s_1).n_dot_v;
    param_16 = _e204;
    let _e205 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_15), (&param_16));
    ab = _e205;
    let _e207 = ab[0u];
    let _e209 = ab[1u];
    ess = max((_e207 + _e209), 0.0001f);
    let _e212 = (*f0_);
    let _e213 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e212 * ((1f / _e213) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e196 = frag_info.target_origin[2u];
    return (_e196 > 0.5f);
}

fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f: f32;

    let _e197 = (*v_dot_h);
    f = pow((1f - _e197), 5f);
    let _e200 = (*f0_1);
    let _e201 = (*f0_1);
    let _e203 = f;
    return (_e200 + ((vec3<f32>(1f, 1f, 1f) - _e201) * _e203));
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e200 = (*alpha_3);
    let _e201 = (*alpha_3);
    a2_ = (_e200 * _e201);
    let _e203 = (*n_dot_l);
    let _e204 = (*n_dot_v_1);
    let _e205 = (*n_dot_v_1);
    let _e207 = a2_;
    let _e210 = a2_;
    lambda_v = (_e203 * sqrt((((_e204 * _e205) * (1f - _e207)) + _e210)));
    let _e214 = (*n_dot_v_1);
    let _e215 = (*n_dot_l);
    let _e216 = (*n_dot_l);
    let _e218 = a2_;
    let _e221 = a2_;
    lambda_l = (_e214 * sqrt((((_e215 * _e216) * (1f - _e218)) + _e221)));
    let _e225 = lambda_v;
    let _e226 = lambda_l;
    return (0.5f / max((_e225 + _e226), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_1: f32;

    let _e198 = (*n_dot_h);
    let _e199 = (*alpha_4);
    a = (_e198 * _e199);
    let _e201 = (*alpha_4);
    let _e202 = (*n_dot_h);
    let _e203 = (*n_dot_h);
    let _e206 = a;
    let _e207 = a;
    k_1 = (_e201 / max(((1f - (_e202 * _e203)) + (_e206 * _e207)), 0.0000001f));
    let _e212 = k_1;
    let _e213 = k_1;
    return ((_e212 * _e213) * 0.31830987f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var lobe: f32;
    var alpha_5: f32;
    var f0_2: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_1: f32;
    var param_17: f32;
    var param_18: f32;
    var vis: f32;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;
    var f_1: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: f32;
    var specular: vec3<f32>;
    var param_24: vec3<f32>;
    var param_25: Surface;
    var diffuse: vec3<f32>;
    var param_26: vec3<f32>;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;

    let _e220 = (*s_2).roughness;
    lobe = max(_e220, 0.045f);
    let _e222 = lobe;
    let _e223 = lobe;
    alpha_5 = (_e222 * _e223);
    let _e226 = (*s_2).albedo;
    let _e228 = (*s_2).metallic;
    f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e226, vec3(_e228));
    let _e232 = (*s_2).albedo;
    let _e234 = (*s_2).metallic;
    diffuseColor = (_e232 * (1f - _e234));
    let _e238 = (*light).n_dot_h;
    param_17 = _e238;
    let _e239 = alpha_5;
    param_18 = _e239;
    let _e240 = D_GGX_u0028_f1_u003b_f1_u003b((&param_17), (&param_18));
    d_1 = _e240;
    let _e242 = (*s_2).n_dot_v;
    param_19 = _e242;
    let _e244 = (*light).n_dot_l;
    param_20 = _e244;
    let _e245 = alpha_5;
    param_21 = _e245;
    let _e246 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21));
    vis = _e246;
    let _e247 = f0_2;
    param_22 = _e247;
    let _e249 = (*light).v_dot_h;
    param_23 = _e249;
    let _e250 = F_Schlick_u0028_vf3_u003b_f1_u003b((&param_22), (&param_23));
    f_1 = _e250;
    let _e251 = d_1;
    let _e252 = vis;
    let _e254 = f_1;
    let _e258 = frag_info.material[3u];
    specular = ((_e254 * (_e251 * _e252)) * _e258);
    let _e261 = (*light).integrated;
    if (_e261 > 0.5f) {
        let _e265 = (*light).ltc[0u];
        let _e266 = f0_2;
        let _e269 = (*light).ltc[1u];
        let _e271 = f0_2;
        let _e276 = (*light).ltc[2u];
        let _e282 = frag_info.material[3u];
        let _e285 = (*light).n_dot_l;
        specular = (((((_e266 * _e269) + ((vec3(1f) - _e271) * _e276)) * _e265) * _e282) / vec3(max(_e285, 0.000001f)));
    }
    let _e289 = EnergyCompensation_u0028_();
    if _e289 {
        let _e290 = f0_2;
        param_24 = _e290;
        let _e291 = (*s_2);
        param_25 = _e291;
        let _e292 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_24), (&param_25));
        let _e293 = specular;
        specular = (_e293 * _e292);
    }
    let _e295 = diffuseColor;
    let _e296 = f_1;
    diffuse = ((_e295 * (vec3<f32>(1f, 1f, 1f) - _e296)) / vec3(3.1415927f));
    let _e301 = EonDiffuse_u0028_();
    if _e301 {
        let _e303 = (*s_2).n;
        let _e305 = (*light).l;
        let _e309 = (*light).l;
        let _e311 = (*s_2).v;
        let _e313 = diffuseColor;
        param_26 = _e313;
        let _e315 = (*s_2).roughness;
        param_27 = _e315;
        param_28 = clamp(dot(_e303, _e305), 0.0001f, 1f);
        let _e317 = (*s_2).n_dot_v;
        param_29 = _e317;
        param_30 = dot(_e309, _e311);
        let _e318 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
        let _e319 = f_1;
        diffuse = (_e318 * (vec3<f32>(1f, 1f, 1f) - _e319));
    }
    let _e322 = diffuse;
    let _e323 = specular;
    return ((_e322 + _e323) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e195 = (*i);
    if (_e195 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e197 = (*i);
    if (_e197 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e199 = (*i);
    if (_e199 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e201 = (*i);
    if (_e201 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e203 = (*i);
    if (_e203 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e205 = (*i);
    if (_e205 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e207 = (*i);
    if (_e207 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_31: i32;

    let _e200 = (*i_1);
    param_31 = _e200;
    let _e201 = PointShadowDiskTap_u0028_i1_u003b((&param_31));
    p = _e201;
    let _e203 = p[0u];
    let _e204 = (*ca);
    let _e207 = p[1u];
    let _e208 = (*sa);
    let _e212 = p[0u];
    let _e213 = (*sa);
    let _e216 = p[1u];
    let _e217 = (*ca);
    let _e221 = (*radius);
    return (vec2<f32>(((_e203 * _e204) - (_e207 * _e208)), ((_e212 * _e213) + (_e216 * _e217))) * _e221);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_4: vec2<f32>;
    var atlas: vec2<f32>;

    let _e203 = point_shadow.params[0u];
    inset = _e203;
    let _e204 = (*uv);
    let _e205 = (*offset);
    let _e207 = inset;
    let _e208 = inset;
    local_4 = clamp((_e204 + _e205), vec2(_e207), vec2((1f - _e208)));
    let _e213 = local_4;
    let _e214 = (*tile);
    atlas = ((_e213 + _e214) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e219 = point_shadow.params3_[0u];
    if (_e219 > 0.5f) {
        let _e222 = atlas[1u];
        atlas[1u] = (1f - _e222);
    }
    let _e225 = atlas;
    let _e226 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e225, 0f);
    let _e228 = atlas;
    let _e229 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e228, 0f);
    let _e232 = (*range);
    return (min(_e226.x, _e229.x) * _e232);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: vec2<f32>;
    var param_35: f32;

    let _e204 = (*uv_1);
    param_32 = _e204;
    let _e205 = (*offset_1);
    param_33 = _e205;
    let _e206 = (*tile_1);
    param_34 = _e206;
    let _e207 = (*range_1);
    param_35 = _e207;
    let _e208 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35));
    stored = _e208;
    let _e209 = stored;
    let _e210 = (*range_1);
    if (_e209 >= (_e210 * 0.999f)) {
        return 1f;
    }
    let _e213 = (*receiver);
    let _e214 = stored;
    return select(1f, 0f, (_e213 > _e214));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_36: vec2<f32>;
    var param_37: vec2<f32>;
    var param_38: vec2<f32>;
    var param_39: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_40: i32;
    var param_41: f32;
    var param_42: f32;
    var param_43: f32;
    var param_44: vec2<f32>;
    var param_45: vec2<f32>;
    var param_46: vec2<f32>;
    var param_47: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e225 = point_shadow.params2_[1u];
    lightRadius = _e225;
    let _e228 = point_shadow.params2_[0u];
    minRadius = _e228;
    let _e231 = point_shadow.params2_[2u];
    maxRadius = _e231;
    let _e232 = lightRadius;
    if (_e232 <= 0f) {
        let _e234 = (*uv_2);
        param_36 = _e234;
        param_37 = vec2<f32>(0f, 0f);
        let _e235 = (*tile_2);
        param_38 = _e235;
        let _e236 = (*range_2);
        param_39 = _e236;
        let _e237 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
        (*blockerOut) = _e237;
        let _e238 = minRadius;
        return _e238;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e239 = i_2;
        if (_e239 < 8i) {
            let _e241 = i_2;
            param_40 = _e241;
            let _e242 = (*ca_1);
            param_41 = _e242;
            let _e243 = (*sa_1);
            param_42 = _e243;
            let _e244 = maxRadius;
            param_43 = _e244;
            let _e245 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43));
            let _e246 = (*uv_2);
            param_44 = _e246;
            param_45 = _e245;
            let _e247 = (*tile_2);
            param_46 = _e247;
            let _e248 = (*range_2);
            param_47 = _e248;
            let _e249 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_44), (&param_45), (&param_46), (&param_47));
            stored_1 = _e249;
            let _e250 = stored_1;
            let _e251 = (*range_2);
            if (_e250 >= (_e251 * 0.999f)) {
                continue;
            }
            let _e254 = stored_1;
            let _e255 = (*receiver_1);
            if (_e254 >= _e255) {
                continue;
            }
            let _e257 = stored_1;
            let _e258 = sum;
            sum = (_e258 + _e257);
            let _e260 = count;
            count = (_e260 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e262 = i_2;
            i_2 = (_e262 + 1i);
        }
    }
    let _e264 = count;
    if (_e264 < 0.5f) {
        return -1f;
    }
    let _e266 = sum;
    let _e267 = count;
    blocker = max((_e266 / _e267), 0.0001f);
    let _e270 = blocker;
    (*blockerOut) = _e270;
    let _e271 = lightRadius;
    let _e272 = (*receiver_1);
    let _e273 = blocker;
    let _e277 = blocker;
    world = ((_e271 * max((_e272 - _e273), 0f)) / _e277);
    let _e279 = world;
    let _e280 = (*receiver_1);
    let _e282 = (*tanHalf);
    let _e285 = minRadius;
    let _e286 = maxRadius;
    return clamp((_e279 / ((2f * _e280) * _e282)), _e285, _e286);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_5: vec2<f32>;

    let _e196 = (*rows);
    if (_e196 > 0f) {
        let _e199 = gl_FragCoord_1[0u];
        let _e200 = (*rows);
        let _e202 = gl_FragCoord_1[1u];
        local_5 = vec2<f32>(_e199, (_e200 - _e202));
    } else {
        let _e205 = gl_FragCoord_1;
        local_5 = _e205.xy;
    }
    let _e207 = local_5;
    return _e207;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_1: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_48: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: f32;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;
    var param_55: f32;
    var param_56: f32;
    var local_6: vec3<f32>;
    var lit: f32;
    var param_57: vec2<f32>;
    var param_58: vec2<f32>;
    var param_59: vec2<f32>;
    var param_60: f32;
    var param_61: f32;
    var i_3: i32;
    var param_62: i32;
    var param_63: f32;
    var param_64: f32;
    var param_65: f32;
    var param_66: vec2<f32>;
    var param_67: vec2<f32>;
    var param_68: vec2<f32>;
    var param_69: f32;
    var param_70: f32;
    var phi_2583_: bool;
    var phi_2644_: bool;

    let _e248 = (*lightIndex);
    let _e252 = point_shadow.slots[_e248][0u];
    slot = i32((_e252 + 0.5f));
    let _e255 = (*lightIndex);
    let _e259 = point_shadow.slots[_e255][0u];
    if (_e259 < 0f) {
        return 1f;
    }
    let _e263 = point_shadow.params[2u];
    strength = _e263;
    let _e264 = strength;
    if (_e264 <= 0f) {
        return 1f;
    }
    let _e266 = slot;
    let _e269 = point_shadow.lights[_e266];
    let _e271 = (*world_1);
    toLight = (_e269.xyz - _e271);
    let _e273 = toLight;
    toLightLength = max(length(_e273), 0.000001f);
    let _e276 = (*normal);
    let _e277 = toLight;
    let _e278 = toLightLength;
    nDotL = max(dot(_e276, (_e277 / vec3(_e278))), 0.15f);
    let _e283 = nDotL;
    let _e284 = nDotL;
    let _e289 = nDotL;
    let _e290 = nDotL;
    slope = min((sqrt(max((1f - (_e283 * _e284)), 0f)) / (_e289 * _e290)), 8f);
    let _e294 = toLightLength;
    let _e296 = (*lightIndex);
    let _e300 = point_shadow.slots[_e296][2u];
    let _e305 = point_shadow.params3_[1u];
    texel = (((2f * _e294) * max(_e300, 0.0001f)) * _e305);
    let _e307 = (*world_1);
    let _e308 = (*normal);
    let _e309 = texel;
    let _e313 = point_shadow.params[3u];
    let _e315 = slope;
    origin = (_e307 + (((_e308 * _e309) * _e313) * (1f + _e315)));
    let _e319 = origin;
    let _e320 = slot;
    let _e323 = point_shadow.lights[_e320];
    toFragment = (_e319 - _e323.xyz);
    let _e326 = toFragment;
    distance_ = length(_e326);
    let _e328 = slot;
    let _e332 = point_shadow.lights[_e328][3u];
    range_3 = max(_e332, 0.0001f);
    let _e334 = distance_;
    let _e335 = range_3;
    if (_e334 >= _e335) {
        return 1f;
    }
    face = 0i;
    let _e337 = (*lightIndex);
    let _e341 = point_shadow.slots[_e337][1u];
    if (_e341 < 0.5f) {
        let _e343 = toFragment;
        a_1 = abs(_e343);
        let _e346 = a_1[0u];
        let _e348 = a_1[1u];
        let _e349 = (_e346 >= _e348);
        phi_2583_ = _e349;
        if _e349 {
            let _e351 = a_1[0u];
            let _e353 = a_1[2u];
            phi_2583_ = (_e351 >= _e353);
        }
        let _e356 = phi_2583_;
        if _e356 {
            let _e358 = toFragment[0u];
            face = select(1i, 0i, (_e358 > 0f));
        } else {
            let _e362 = a_1[1u];
            let _e364 = a_1[2u];
            if (_e362 >= _e364) {
                let _e367 = toFragment[1u];
                face = select(3i, 2i, (_e367 > 0f));
            } else {
                let _e371 = toFragment[2u];
                face = select(5i, 4i, (_e371 > 0f));
            }
        }
    }
    let _e374 = slot;
    let _e376 = face;
    let _e380 = point_shadow.faces[((_e374 * 6i) + _e376)];
    let _e381 = origin;
    clip = (_e380 * vec4<f32>(_e381.x, _e381.y, _e381.z, 1f));
    let _e388 = clip[3u];
    if (_e388 <= 0f) {
        return 1f;
    }
    let _e390 = clip;
    let _e393 = clip[3u];
    ndc = (_e390.xy / vec2(_e393));
    let _e397 = ndc[0u];
    let _e399 = (abs(_e397) > 1f);
    phi_2644_ = _e399;
    if !(_e399) {
        let _e402 = ndc[1u];
        phi_2644_ = (abs(_e402) > 1f);
    }
    let _e406 = phi_2644_;
    if _e406 {
        return 1f;
    }
    let _e408 = ndc[0u];
    let _e412 = ndc[1u];
    uv_3 = vec2<f32>(((_e408 * 0.5f) + 0.5f), (0.5f - (_e412 * 0.5f)));
    let _e416 = face;
    let _e418 = slot;
    tile_3 = vec2<f32>(f32(_e416), f32(_e418));
    let _e421 = distance_;
    let _e424 = point_shadow.params[1u];
    receiver_2 = (_e421 - _e424);
    let _e428 = frag_info.target_origin[0u];
    param_48 = _e428;
    let _e429 = FragCoordFromTop_u0028_f1_u003b((&param_48));
    noise = fract((52.982918f * fract(dot(_e429, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e434 = noise;
    angle = (_e434 * 6.2831855f);
    let _e436 = angle;
    ca_2 = cos(_e436);
    let _e438 = angle;
    sa_2 = sin(_e438);
    let _e440 = (*lightIndex);
    let _e444 = point_shadow.slots[_e440][2u];
    tanHalf_1 = max(_e444, 0.0001f);
    blocker_1 = -1f;
    let _e446 = uv_3;
    param_49 = _e446;
    let _e447 = tile_3;
    param_50 = _e447;
    let _e448 = range_3;
    param_51 = _e448;
    let _e449 = receiver_2;
    param_52 = _e449;
    let _e450 = ca_2;
    param_53 = _e450;
    let _e451 = sa_2;
    param_54 = _e451;
    let _e452 = tanHalf_1;
    param_55 = _e452;
    let _e453 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53), (&param_54), (&param_55), (&param_56));
    let _e454 = param_56;
    blocker_1 = _e454;
    radius_1 = _e453;
    let _e457 = point_shadow.params2_[3u];
    if (_e457 > 0.5f) {
        g_debug_surface_on = true;
        let _e459 = radius_1;
        if (_e459 < 0f) {
            local_6 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e461 = radius_1;
            let _e464 = point_shadow.params2_[2u];
            let _e468 = blocker_1;
            let _e469 = range_3;
            local_6 = vec3<f32>(clamp((_e461 / max(_e464, 0.000001f)), 0f, 1f), clamp((_e468 / _e469), 0f, 1f), 0f);
        }
        let _e473 = local_6;
        g_debug_surface = _e473;
    }
    let _e474 = radius_1;
    if (_e474 < 0f) {
        return 1f;
    }
    let _e476 = uv_3;
    param_57 = _e476;
    param_58 = vec2<f32>(0f, 0f);
    let _e477 = tile_3;
    param_59 = _e477;
    let _e478 = range_3;
    param_60 = _e478;
    let _e479 = receiver_2;
    param_61 = _e479;
    let _e480 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60), (&param_61));
    lit = _e480;
    let _e481 = radius_1;
    if (_e481 > 0f) {
        i_3 = 0i;
        loop {
            let _e483 = i_3;
            if (_e483 < 8i) {
                let _e485 = i_3;
                param_62 = _e485;
                let _e486 = ca_2;
                param_63 = _e486;
                let _e487 = sa_2;
                param_64 = _e487;
                let _e488 = radius_1;
                param_65 = _e488;
                let _e489 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_62), (&param_63), (&param_64), (&param_65));
                let _e490 = uv_3;
                param_66 = _e490;
                param_67 = _e489;
                let _e491 = tile_3;
                param_68 = _e491;
                let _e492 = range_3;
                param_69 = _e492;
                let _e493 = receiver_2;
                param_70 = _e493;
                let _e494 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_66), (&param_67), (&param_68), (&param_69), (&param_70));
                let _e495 = lit;
                lit = (_e495 + _e494);
                continue;
            } else {
                break;
            }
            continuing {
                let _e497 = i_3;
                i_3 = (_e497 + 1i);
            }
        }
        let _e499 = lit;
        lit = (_e499 * 0.11111111f);
    }
    let _e501 = lit;
    let _e502 = strength;
    return mix(1f, _e501, clamp(_e502, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e199 = (*i_4);
    let _e202 = (*n_1);
    r_3 = sqrt(((f32(_e199) + 0.5f) / f32(_e202)));
    let _e206 = (*i_4);
    let _e209 = (*turn);
    theta = ((f32(_e206) * 2.3999631f) + _e209);
    let _e211 = r_3;
    let _e212 = theta;
    let _e214 = theta;
    return (vec2<f32>(cos(_e212), sin(_e214)) * _e211);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_71: f32;

    let _e198 = frag_info.target_origin[0u];
    param_71 = _e198;
    let _e199 = FragCoordFromTop_u0028_f1_u003b((&param_71));
    let _e202 = frag_info.target_origin[3u];
    at = (_e199 + vec2((5.588238f * max(_e202, 0f))));
    let _e207 = at;
    return fract((52.982918f * fract(dot(_e207, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_7: f32;

    let _e197 = (*mode_1);
    if (_e197 > 0.5f) {
        let _e199 = (*stored_2);
        local_7 = (1f - _e199);
    } else {
        let _e201 = (*stored_2);
        local_7 = _e201;
    }
    let _e202 = local_7;
    return _e202;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_2: f32;
    var pMax: f32;
    var reduced: f32;

    let _e203 = (*moments)[1u];
    let _e205 = (*moments)[0u];
    let _e207 = (*moments)[0u];
    let _e210 = (*minVariance);
    variance = max((_e203 - (_e205 * _e207)), _e210);
    let _e212 = (*t);
    let _e214 = (*moments)[0u];
    d_2 = (_e212 - _e214);
    let _e216 = variance;
    let _e217 = variance;
    let _e218 = d_2;
    let _e219 = d_2;
    pMax = (_e216 / (_e217 + (_e218 * _e219)));
    let _e223 = pMax;
    let _e224 = (*bleed);
    let _e226 = (*bleed);
    reduced = clamp(((_e223 - _e224) / max((1f - _e226), 0.0001f)), 0f, 1f);
    let _e231 = (*t);
    let _e233 = (*moments)[0u];
    let _e235 = reduced;
    return select(_e235, 1f, (_e231 <= _e233));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_3: f32;

    let _e196 = (*depth);
    d_3 = ((2f * clamp(_e196, 0f, 1f)) - 1f);
    let _e200 = d_3;
    let _e203 = d_3;
    return vec2<f32>(exp((40f * _e200)), -(exp((-5f * _e203))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_72: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_73: vec2<f32>;
    var param_74: f32;
    var param_75: f32;
    var param_76: f32;
    var negative: f32;
    var param_77: vec2<f32>;
    var param_78: f32;
    var param_79: f32;
    var param_80: f32;

    let _e210 = (*depth_1);
    param_72 = _e210;
    let _e211 = EvsmWarp_u0028_f1_u003b((&param_72));
    warped = _e211;
    let _e212 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e212);
    let _e215 = scale[0u];
    let _e217 = scale[0u];
    let _e219 = (*moments_1);
    param_73 = _e219.xy;
    let _e222 = warped[0u];
    param_74 = _e222;
    param_75 = (_e215 * _e217);
    let _e223 = (*bleed_1);
    param_76 = _e223;
    let _e224 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_73), (&param_74), (&param_75), (&param_76));
    positive = _e224;
    let _e226 = scale[1u];
    let _e228 = scale[1u];
    let _e230 = (*moments_1);
    param_77 = _e230.zw;
    let _e233 = warped[1u];
    param_78 = _e233;
    param_79 = (_e226 * _e228);
    let _e234 = (*bleed_1);
    param_80 = _e234;
    let _e235 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_77), (&param_78), (&param_79), (&param_80));
    negative = _e235;
    let _e236 = positive;
    let _e237 = negative;
    return min(_e236, _e237);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e196 = (*depth_2);
    stored_3 = max((1f - _e196), 0.000061035156f);
    let _e199 = stored_3;
    return exp2((floor(log2(_e199)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_8: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_9: mat4x4<f32>;
    var local_10: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_11: f32;
    var local_12: f32;
    var storage_: f32;
    var param_81: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_82: vec4<f32>;
    var param_83: f32;
    var param_84: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_85: f32;
    var param_86: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_87: i32;
    var param_88: i32;
    var param_89: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_90: f32;
    var param_91: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_92: i32;
    var param_93: i32;
    var param_94: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_95: f32;
    var param_96: f32;
    var phi_3778_: bool;
    var phi_3789_: bool;
    var phi_3950_: bool;
    var phi_3957_: bool;
    var phi_3964_: bool;

    let _e275 = frag_info.shadow_params[3u];
    strength_1 = _e275;
    let _e276 = strength_1;
    if (_e276 <= 0f) {
        return 1f;
    }
    let _e278 = (*lightIndex_1);
    let _e281 = frag_info.frame_params[2u];
    if (_e278 != i32(floor((_e281 + 0.5f)))) {
        return 1f;
    }
    let _e288 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e288 + 0.5f));
    let _e291 = Orthographic_u0028_();
    if _e291 {
        let _e292 = ViewDepth_u0028_();
        local_8 = _e292;
    } else {
        let _e293 = v_world_position_1;
        let _e295 = frag_info.camera_position;
        local_8 = length((_e293 - _e295.xyz));
    }
    let _e299 = local_8;
    viewDistance = _e299;
    cascade = 0i;
    let _e300 = cascadeCount;
    let _e301 = (_e300 > 1i);
    phi_3778_ = _e301;
    if _e301 {
        let _e302 = viewDistance;
        let _e305 = frag_info.shadow_cascades[0u];
        phi_3778_ = (_e302 > _e305);
    }
    let _e308 = phi_3778_;
    if _e308 {
        cascade = 1i;
    }
    let _e309 = cascadeCount;
    let _e310 = (_e309 > 2i);
    phi_3789_ = _e310;
    if _e310 {
        let _e311 = viewDistance;
        let _e314 = frag_info.shadow_cascades[1u];
        phi_3789_ = (_e311 > _e314);
    }
    let _e317 = phi_3789_;
    if _e317 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e318 = attempt;
        if (_e318 < 3i) {
            let _e320 = cascade;
            let _e321 = attempt;
            which = (_e320 + _e321);
            let _e323 = which;
            let _e324 = cascadeCount;
            if (_e323 >= _e324) {
                break;
            }
            let _e326 = which;
            if (_e326 == 0i) {
                let _e329 = frag_info.shadow_matrix;
                local_9 = _e329;
            } else {
                let _e330 = which;
                if (_e330 == 1i) {
                    let _e333 = frag_info.shadow_matrix_far;
                    local_10 = _e333;
                } else {
                    let _e335 = frag_info.shadow_matrix_farthest;
                    local_10 = _e335;
                }
                let _e336 = local_10;
                local_9 = _e336;
            }
            let _e337 = local_9;
            matrix = _e337;
            let _e340 = matrix[0][0u];
            let _e343 = matrix[1][0u];
            let _e346 = matrix[2][0u];
            axisX = vec3<f32>(_e340, _e343, _e346);
            let _e350 = matrix[0][1u];
            let _e353 = matrix[1][1u];
            let _e356 = matrix[2][1u];
            axisY = vec3<f32>(_e350, _e353, _e356);
            let _e358 = axisX;
            rowX = max(length(_e358), 0.000001f);
            let _e361 = axisY;
            rowY = max(length(_e361), 0.000001f);
            let _e366 = frag_info.shadow_cascades[3u];
            let _e368 = rowX;
            texelMetres = ((2f * _e366) / _e368);
            let _e372 = frag_info.shadow_cascades[3u];
            let _e375 = (*s_3).n;
            let _e376 = axisX;
            let _e379 = rowX;
            let _e380 = rowX;
            let _e384 = (*s_3).n;
            let _e385 = axisY;
            let _e388 = rowY;
            let _e389 = rowY;
            reach = ((3f * _e372) * ((abs(dot(_e375, _e376)) / (_e379 * _e380)) + (abs(dot(_e384, _e385)) / (_e388 * _e389))));
            let _e396 = frag_info.shadow_params[2u];
            let _e397 = texelMetres;
            flatOffset = min(_e396, _e397);
            let _e399 = v_world_position_1;
            let _e401 = (*s_3).n;
            let _e402 = flatOffset;
            let _e403 = reach;
            origin_1 = (_e399 + (_e401 * (_e402 + _e403)));
            let _e407 = matrix;
            let _e408 = origin_1;
            lightSpace = (_e407 * vec4<f32>(_e408.x, _e408.y, _e408.z, 1f));
            let _e415 = lightSpace[3u];
            if (_e415 <= 0f) {
                continue;
            }
            let _e417 = lightSpace;
            let _e420 = lightSpace[3u];
            candidate = (_e417.xyz / vec3(_e420));
            let _e424 = candidate[0u];
            let _e428 = candidate[1u];
            inTile = vec2<f32>(((_e424 * 0.5f) + 0.5f), (0.5f - (_e428 * 0.5f)));
            let _e433 = inTile[0u];
            let _e434 = (_e433 < 0f);
            phi_3950_ = _e434;
            if !(_e434) {
                let _e437 = inTile[0u];
                phi_3950_ = (_e437 > 1f);
            }
            let _e440 = phi_3950_;
            phi_3957_ = _e440;
            if !(_e440) {
                let _e443 = inTile[1u];
                phi_3957_ = (_e443 < 0f);
            }
            let _e446 = phi_3957_;
            phi_3964_ = _e446;
            if !(_e446) {
                let _e449 = inTile[1u];
                phi_3964_ = (_e449 > 1f);
            }
            let _e452 = phi_3964_;
            if _e452 {
                continue;
            }
            let _e454 = candidate[2u];
            if (_e454 > 1f) {
                let _e456 = which;
                let _e457 = cascadeCount;
                if (_e456 < (_e457 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e462 = inTile[0u];
            let _e463 = which;
            let _e466 = cascadeCount;
            let _e470 = inTile[1u];
            uv_4 = vec2<f32>(((_e462 + f32(_e463)) / f32(_e466)), _e470);
            let _e472 = candidate;
            projected = _e472;
            let _e473 = which;
            cascade = _e473;
            let _e474 = texelMetres;
            cascadeTexel = _e474;
            let _e477 = matrix[0][2u];
            let _e480 = matrix[1][2u];
            let _e483 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e477, _e480, _e483)), 0.000001f));
            let _e489 = (*s_3).n;
            let _e492 = matrix[0][2u];
            let _e495 = matrix[1][2u];
            let _e498 = matrix[2][2u];
            let _e502 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e489, vec3<f32>(_e492, _e495, _e498))) * _e502), 0.1f, 1f);
            let _e505 = texelMetres;
            let _e506 = cosSlope;
            let _e507 = cosSlope;
            let _e513 = cosSlope;
            let _e515 = cascadeDepth;
            receiverSlope = (((_e505 * sqrt(max((1f - (_e506 * _e507)), 0f))) / _e513) / _e515);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e517 = attempt;
            attempt = (_e517 + 1i);
        }
    }
    let _e519 = found;
    if !(_e519) {
        return 1f;
    }
    let _e521 = cascade;
    if (_e521 == 0i) {
        let _e525 = frag_info.shadow_bias[0u];
        local_11 = _e525;
    } else {
        let _e526 = cascade;
        if (_e526 == 1i) {
            let _e530 = frag_info.shadow_bias[1u];
            local_12 = _e530;
        } else {
            let _e533 = frag_info.shadow_bias[2u];
            local_12 = _e533;
        }
        let _e534 = local_12;
        local_11 = _e534;
    }
    let _e535 = local_11;
    bias = _e535;
    let _e538 = frag_info.shadow_params[1u];
    storage_ = _e538;
    let _e539 = storage_;
    let _e541 = storage_;
    if ((_e539 > 0.5f) && (_e541 < 1.5f)) {
        let _e544 = bias;
        let _e546 = projected[2u];
        param_81 = _e546;
        let _e547 = ShadowStoredStep_u0028_f1_u003b((&param_81));
        bias = max(_e544, _e547);
    }
    let _e551 = frag_info.shadow_params[0u];
    let _e554 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e551, _e554);
    let _e556 = cascade;
    let _e558 = cascadeCount;
    let _e562 = texel_1;
    tileLo = (vec2<f32>((f32(_e556) / f32(_e558)), 0f) + (_e562 * 0.5f));
    let _e565 = cascade;
    let _e568 = cascadeCount;
    let _e572 = texel_1;
    tileHi = (vec2<f32>((f32((_e565 + 1i)) / f32(_e568)), 1f) - (_e572 * 0.5f));
    let _e577 = frag_info.shadow_bias[3u];
    if (_e577 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e579 = y_1;
            if (_e579 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e581 = x_1;
                    if (_e581 <= 1i) {
                        let _e583 = uv_4;
                        let _e584 = x_1;
                        let _e586 = y_1;
                        let _e589 = texel_1;
                        let _e592 = tileLo;
                        let _e593 = tileHi;
                        let _e595 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e583 + (vec2<f32>(f32(_e584), f32(_e586)) * _e589)), _e592, _e593), 0f);
                        let _e596 = stored_4;
                        stored_4 = (_e596 + _e595);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e598 = x_1;
                        x_1 = (_e598 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e600 = y_1;
                y_1 = (_e600 + 1i);
            }
        }
        let _e602 = stored_4;
        stored_4 = (_e602 * 0.11111111f);
        let _e605 = stored_4[1u];
        let _e608 = stored_4[2u];
        let _e611 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e605), (1f - _e608), _e611), vec3(0f), vec3(4f));
        let _e616 = through;
        let _e617 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e616, vec3(clamp(_e617, 0f, 1f)));
    }
    let _e623 = frag_info.ambient_ground[3u];
    softness = _e623;
    lit_1 = 0f;
    let _e624 = softness;
    if (_e624 < 0f) {
        let _e626 = uv_4;
        let _e627 = tileLo;
        let _e628 = tileHi;
        let _e630 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e626, _e627, _e628), 0f);
        moments_2 = _e630;
        let _e632 = projected[2u];
        let _e633 = bias;
        let _e635 = softness;
        let _e639 = moments_2;
        param_82 = _e639;
        param_83 = (_e632 - _e633);
        param_84 = clamp((-(_e635) - 1f), 0f, 0.95f);
        let _e640 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_82), (&param_83), (&param_84));
        lit_1 = _e640;
    } else {
        let _e641 = softness;
        if (_e641 <= 0f) {
            y_2 = -1i;
            loop {
                let _e643 = y_2;
                if (_e643 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e645 = x_2;
                        if (_e645 <= 1i) {
                            let _e647 = uv_4;
                            let _e648 = x_2;
                            let _e650 = y_2;
                            let _e653 = texel_1;
                            let _e656 = tileLo;
                            let _e657 = tileHi;
                            let _e659 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e647 + (vec2<f32>(f32(_e648), f32(_e650)) * _e653)), _e656, _e657), 0f);
                            param_85 = _e659.x;
                            let _e661 = storage_;
                            param_86 = _e661;
                            let _e662 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_85), (&param_86));
                            occluder = _e662;
                            let _e664 = projected[2u];
                            let _e665 = bias;
                            let _e667 = occluder;
                            let _e670 = lit_1;
                            lit_1 = (_e670 + select(1f, 0f, ((_e664 - _e665) > _e667)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e672 = x_2;
                            x_2 = (_e672 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e674 = y_2;
                    y_2 = (_e674 + 1i);
                }
            }
            let _e676 = lit_1;
            lit_1 = (_e676 * 0.11111111f);
        } else {
            let _e678 = softness;
            spread = tan(min(_e678, 0.5f));
            let _e681 = ShadowNoise_u0028_();
            turn_1 = (_e681 * 6.2831855f);
            let _e683 = spread;
            let _e685 = projected[2u];
            let _e687 = cascadeDepth;
            let _e689 = cascadeTexel;
            searchRadius = clamp((((_e683 * _e685) * _e687) / _e689), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e692 = i_5;
                if (_e692 < 16i) {
                    let _e694 = i_5;
                    param_87 = _e694;
                    param_88 = 16i;
                    let _e695 = turn_1;
                    param_89 = _e695;
                    let _e696 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_87), (&param_88), (&param_89));
                    disc = _e696;
                    let _e697 = bias;
                    let _e698 = disc;
                    let _e700 = searchRadius;
                    let _e704 = receiverSlope;
                    tapBias = (_e697 + (max(((length(_e698) * _e700) - 1.5f), 0f) * _e704));
                    let _e707 = uv_4;
                    let _e708 = disc;
                    let _e709 = texel_1;
                    let _e711 = searchRadius;
                    let _e714 = tileLo;
                    let _e715 = tileHi;
                    let _e717 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e707 + ((_e708 * _e709) * _e711)), _e714, _e715), 0f);
                    param_90 = _e717.x;
                    let _e719 = storage_;
                    param_91 = _e719;
                    let _e720 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_90), (&param_91));
                    occluder_1 = _e720;
                    let _e722 = projected[2u];
                    let _e723 = tapBias;
                    let _e725 = occluder_1;
                    if ((_e722 - _e723) > _e725) {
                        let _e727 = occluder_1;
                        let _e728 = blockerSum;
                        blockerSum = (_e728 + _e727);
                        let _e730 = blockerCount;
                        blockerCount = (_e730 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e732 = i_5;
                    i_5 = (_e732 + 1i);
                }
            }
            let _e734 = blockerCount;
            if (_e734 <= 0f) {
                return 1f;
            }
            let _e737 = projected[2u];
            let _e738 = blockerSum;
            let _e739 = blockerCount;
            let _e743 = cascadeDepth;
            gap = (max((_e737 - (_e738 / _e739)), 0f) * _e743);
            let _e745 = spread;
            let _e746 = gap;
            let _e748 = cascadeTexel;
            radius_2 = clamp(((_e745 * _e746) / _e748), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e751 = i_6;
                if (_e751 < 16i) {
                    let _e753 = turn_1;
                    let _e755 = i_6;
                    param_92 = _e755;
                    param_93 = 16i;
                    param_94 = (_e753 + 1f);
                    let _e756 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_92), (&param_93), (&param_94));
                    disc_1 = _e756;
                    let _e757 = bias;
                    let _e758 = disc_1;
                    let _e760 = radius_2;
                    let _e764 = receiverSlope;
                    tapBias_1 = (_e757 + (max(((length(_e758) * _e760) - 1.5f), 0f) * _e764));
                    let _e767 = uv_4;
                    let _e768 = disc_1;
                    let _e769 = texel_1;
                    let _e771 = radius_2;
                    let _e774 = tileLo;
                    let _e775 = tileHi;
                    let _e777 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e767 + ((_e768 * _e769) * _e771)), _e774, _e775), 0f);
                    param_95 = _e777.x;
                    let _e779 = storage_;
                    param_96 = _e779;
                    let _e780 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_95), (&param_96));
                    occluder_2 = _e780;
                    let _e782 = projected[2u];
                    let _e783 = tapBias_1;
                    let _e785 = occluder_2;
                    let _e788 = lit_1;
                    lit_1 = (_e788 + select(1f, 0f, ((_e782 - _e783) > _e785)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e790 = i_6;
                    i_6 = (_e790 + 1i);
                }
            }
            let _e792 = lit_1;
            lit_1 = (_e792 * 0.0625f);
        }
    }
    let _e794 = lit_1;
    let _e795 = strength_1;
    return mix(1f, _e794, clamp(_e795, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_97: Surface;
    var param_98: LightSample;
    var param_99: i32;

    let _e200 = (*s_4);
    param_97 = _e200;
    let _e201 = (*light_2);
    param_98 = _e201;
    let _e202 = (*index);
    param_99 = _e202;
    let _e203 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_97), (&param_98), (&param_99));
    return _e203;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e195 = (*index_1);
    return (_e195 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e199 = (*distance_1);
    let _e200 = (*distance_1);
    attenuation = (1f / max((_e199 * _e200), 0.0001f));
    let _e204 = (*range_4);
    if (_e204 > 0f) {
        let _e206 = (*distance_1);
        let _e207 = (*range_4);
        ratio = (_e206 / _e207);
        let _e209 = ratio;
        let _e210 = ratio;
        let _e212 = ratio;
        let _e214 = ratio;
        window = clamp((1f - (((_e209 * _e210) * _e212) * _e214)), 0f, 1f);
        let _e218 = window;
        let _e219 = window;
        let _e221 = attenuation;
        attenuation = (_e221 * (_e218 * _e219));
    }
    let _e223 = attenuation;
    return _e223;
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle_1: f32;
    var local_13: vec3<f32>;

    let _e200 = (*a_2);
    let _e201 = (*b);
    axis = cross(_e200, _e201);
    let _e203 = axis;
    len = length(_e203);
    let _e205 = (*a_2);
    let _e206 = (*b);
    angle_1 = acos(clamp(dot(_e205, _e206), -1f, 1f));
    let _e210 = len;
    if (_e210 > 0.000001f) {
        let _e212 = axis;
        let _e213 = angle_1;
        let _e214 = len;
        local_13 = (_e212 * (_e213 / (_e214 * 6.2831855f)));
    } else {
        local_13 = vec3<f32>(0f, 0f, 0f);
    }
    let _e218 = local_13;
    return _e218;
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_3: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv_5: vec2<f32>;
    var inverse: vec4<f32>;
    var param_100: f32;
    var param_101: f32;
    var param_102: f32;
    var fit: vec4<f32>;
    var param_103: f32;
    var param_104: f32;
    var param_105: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_14: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i_7: i32;
    var p_1: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f_2: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var param_108: vec3<f32>;
    var param_109: vec3<f32>;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: vec3<f32>;
    var param_113: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_15: f32;
    var sphere: f32;
    var param_114: f32;
    var param_115: f32;
    var param_116: f32;

    let _e232 = (*roughness_3);
    let _e234 = (*n_2);
    let _e235 = (*v);
    uv_5 = vec2<f32>(clamp(_e232, 0f, 1f), sqrt(clamp((1f - dot(_e234, _e235)), 0f, 1f)));
    let _e242 = uv_5[0u];
    param_100 = _e242;
    let _e244 = uv_5[1u];
    param_101 = _e244;
    param_102 = 0f;
    let _e245 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_100), (&param_101), (&param_102));
    let _e246 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e245, 0f);
    inverse = _e246;
    let _e248 = uv_5[0u];
    param_103 = _e248;
    let _e250 = uv_5[1u];
    param_104 = _e250;
    param_105 = 1f;
    let _e251 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_103), (&param_104), (&param_105));
    let _e252 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e251, 0f);
    fit = _e252;
    let _e253 = (*v);
    let _e254 = (*n_2);
    let _e255 = (*v);
    let _e256 = (*n_2);
    along = (_e253 - (_e254 * dot(_e255, _e256)));
    let _e260 = along;
    alongLength = length(_e260);
    let _e262 = alongLength;
    if (_e262 > 0.00001f) {
        let _e264 = along;
        let _e265 = alongLength;
        local_14 = (_e264 / vec3(_e265));
    } else {
        let _e268 = (*n_2);
        let _e270 = (*n_2)[2u];
        local_14 = normalize(cross(_e268, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e270) < 0.999f)))));
    }
    let _e277 = local_14;
    t1_ = _e277;
    let _e278 = (*n_2);
    let _e279 = t1_;
    t2_ = cross(_e278, _e279);
    let _e282 = inverse[0u];
    let _e284 = inverse[1u];
    let _e285 = vec3<f32>(_e282, 0f, _e284);
    let _e287 = inverse[2u];
    let _e289 = inverse[3u];
    let _e290 = vec3<f32>(_e287, 0f, _e289);
    minv = mat3x3<f32>(vec3<f32>(_e285.x, _e285.y, _e285.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e290.x, _e290.y, _e290.z));
    i_7 = 0i;
    loop {
        let _e304 = i_7;
        if (_e304 < 4i) {
            let _e306 = i_7;
            let _e308 = (*corners)[_e306];
            p_1 = _e308;
            let _e309 = i_7;
            let _e310 = minv;
            let _e311 = p_1;
            let _e312 = t1_;
            let _e314 = p_1;
            let _e315 = t2_;
            let _e317 = p_1;
            let _e318 = (*n_2);
            l[_e309] = normalize((_e310 * vec3<f32>(dot(_e311, _e312), dot(_e314, _e315), dot(_e317, _e318))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e324 = i_7;
            i_7 = (_e324 + 1i);
        }
    }
    let _e327 = l[0i];
    param_106 = _e327;
    let _e329 = l[1i];
    param_107 = _e329;
    let _e330 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_106), (&param_107));
    let _e332 = l[1i];
    param_108 = _e332;
    let _e334 = l[2i];
    param_109 = _e334;
    let _e335 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_108), (&param_109));
    let _e338 = l[2i];
    param_110 = _e338;
    let _e340 = l[3i];
    param_111 = _e340;
    let _e341 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_110), (&param_111));
    let _e344 = l[3i];
    param_112 = _e344;
    let _e346 = l[0i];
    param_113 = _e346;
    let _e347 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_112), (&param_113));
    f_2 = -((((_e330 + _e335) + _e341) + _e347));
    let _e350 = f_2;
    len_1 = length(_e350);
    let _e352 = len_1;
    if (_e352 > 0.000000001f) {
        let _e355 = f_2[2u];
        let _e356 = len_1;
        local_15 = (_e355 / _e356);
    } else {
        local_15 = 0f;
    }
    let _e358 = local_15;
    z_1 = _e358;
    let _e359 = z_1;
    let _e362 = len_1;
    param_114 = ((_e359 * 0.5f) + 0.5f);
    param_115 = clamp(_e362, 0f, 1f);
    param_116 = 1f;
    let _e364 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_114), (&param_115), (&param_116));
    let _e365 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e364, 0f);
    sphere = _e365.w;
    let _e367 = len_1;
    let _e368 = sphere;
    let _e372 = fit[0u];
    let _e374 = fit[1u];
    return vec3<f32>(max((_e367 * _e368), 0f), _e372, _e374);
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_16: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e211 = (*halfWidth);
    let _e212 = (*halfHeight);
    n_3 = cross(_e211, _e212);
    let _e214 = n_3;
    nLen = length(_e214);
    let _e216 = nLen;
    if (_e216 < 0.000000000001f) {
        let _e218 = (*centre);
        return _e218;
    }
    let _e219 = nLen;
    let _e220 = n_3;
    n_3 = (_e220 / vec3(_e219));
    let _e223 = (*centre);
    let _e224 = (*world_2);
    toPlane = (_e223 - _e224);
    let _e226 = (*mirror);
    let _e227 = n_3;
    denom = dot(_e226, _e227);
    let _e229 = denom;
    if (abs(_e229) < 0.00001f) {
        let _e232 = toPlane;
        let _e233 = n_3;
        let _e234 = toPlane;
        let _e235 = n_3;
        onPlane = (_e232 - (_e233 * dot(_e234, _e235)));
    } else {
        let _e239 = toPlane;
        let _e240 = n_3;
        let _e242 = denom;
        t_1 = (dot(_e239, _e240) / _e242);
        let _e244 = t_1;
        if (_e244 > 0f) {
            let _e246 = (*mirror);
            let _e247 = t_1;
            local_16 = (_e246 * _e247);
        } else {
            let _e249 = toPlane;
            let _e250 = n_3;
            let _e251 = toPlane;
            let _e252 = n_3;
            local_16 = (_e249 - (_e250 * dot(_e251, _e252)));
        }
        let _e256 = local_16;
        onPlane = _e256;
    }
    let _e257 = onPlane;
    let _e258 = toPlane;
    offset_2 = (_e257 - _e258);
    let _e260 = (*halfWidth);
    let _e261 = (*halfWidth);
    wLen2_ = max(dot(_e260, _e261), 0.000000000001f);
    let _e264 = (*halfHeight);
    let _e265 = (*halfHeight);
    hLen2_ = max(dot(_e264, _e265), 0.000000000001f);
    let _e268 = offset_2;
    let _e269 = (*halfWidth);
    let _e271 = wLen2_;
    u = clamp((dot(_e268, _e269) / _e271), -1f, 1f);
    let _e274 = offset_2;
    let _e275 = (*halfHeight);
    let _e277 = hLen2_;
    v_1 = clamp((dot(_e274, _e275) / _e277), -1f, 1f);
    let _e280 = (*centre);
    let _e281 = (*halfWidth);
    let _e282 = u;
    let _e285 = (*halfHeight);
    let _e286 = v_1;
    return ((_e280 + (_e281 * _e282)) + (_e285 * _e286));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_17: f32;

    let _e203 = (*a_3);
    let _e204 = (*a_3);
    ua = (_e203 / vec3(max(length(_e204), 0.000000000001f)));
    let _e209 = (*b_1);
    let _e210 = (*b_1);
    ub = (_e209 / vec3(max(length(_e210), 0.000000000001f)));
    let _e215 = ua;
    let _e216 = ub;
    angle_2 = acos(clamp(dot(_e215, _e216), -1f, 1f));
    let _e220 = ua;
    let _e221 = ub;
    axis_1 = cross(_e220, _e221);
    let _e223 = axis_1;
    len_2 = length(_e223);
    let _e225 = len_2;
    if (_e225 > 0.000001f) {
        let _e227 = angle_2;
        let _e228 = axis_1;
        let _e229 = (*n_4);
        let _e232 = len_2;
        local_17 = ((_e227 * dot(_e228, _e229)) / _e232);
    } else {
        local_17 = 0f;
    }
    let _e234 = local_17;
    return _e234;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_18: i32;
    var ha: f32;
    var hb: f32;
    var d_4: f32;
    var q: vec3<f32>;
    var local_19: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_20: f32;
    var param_117: vec3<f32>;
    var param_118: vec3<f32>;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: vec3<f32>;
    var param_122: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e217 = i_8;
        if (_e217 < 4i) {
            let _e219 = i_8;
            let _e221 = (*corners_1)[_e219];
            a_4 = _e221;
            let _e222 = i_8;
            if (_e222 == 3i) {
                local_18 = 0i;
            } else {
                let _e224 = i_8;
                local_18 = (_e224 + 1i);
            }
            let _e226 = local_18;
            let _e228 = (*corners_1)[_e226];
            b_2 = _e228;
            let _e229 = a_4;
            let _e230 = (*n_5);
            ha = dot(_e229, _e230);
            let _e232 = b_2;
            let _e233 = (*n_5);
            hb = dot(_e232, _e233);
            let _e235 = ha;
            let _e236 = hb;
            d_4 = (_e235 - _e236);
            let _e238 = a_4;
            let _e239 = b_2;
            let _e240 = a_4;
            let _e242 = d_4;
            if (abs(_e242) > 0.000000000001f) {
                let _e245 = ha;
                let _e246 = d_4;
                local_19 = (_e245 / _e246);
            } else {
                local_19 = 0f;
            }
            let _e248 = local_19;
            q = (_e238 + ((_e239 - _e240) * _e248));
            let _e251 = ha;
            aAbove = (_e251 > 0f);
            let _e253 = hb;
            bAbove = (_e253 > 0f);
            let _e255 = aAbove;
            let _e256 = bAbove;
            if (_e255 || _e256) {
                let _e258 = aAbove;
                let _e259 = a_4;
                let _e260 = q;
                let _e263 = bAbove;
                let _e264 = b_2;
                let _e265 = q;
                param_117 = select(_e260, _e259, vec3(_e258));
                param_118 = select(_e265, _e264, vec3(_e263));
                let _e268 = (*n_5);
                param_119 = _e268;
                let _e269 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_117), (&param_118), (&param_119));
                local_20 = _e269;
            } else {
                local_20 = 0f;
            }
            let _e270 = local_20;
            let _e271 = total;
            total = (_e271 + _e270);
            let _e273 = aAbove;
            let _e274 = bAbove;
            let _e277 = q;
            let _e278 = exit;
            exit = select(_e278, _e277, vec3((_e273 && !(_e274))));
            let _e281 = aAbove;
            let _e283 = bAbove;
            let _e285 = q;
            let _e286 = entry;
            entry = select(_e286, _e285, vec3((!(_e281) && _e283)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e289 = i_8;
            i_8 = (_e289 + 1i);
        }
    }
    let _e291 = exit;
    param_120 = _e291;
    let _e292 = entry;
    param_121 = _e292;
    let _e293 = (*n_5);
    param_122 = _e293;
    let _e294 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_120), (&param_121), (&param_122));
    let _e295 = total;
    total = (_e295 + _e294);
    let _e297 = total;
    return max((-(_e297) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_21: f32;
    var local_22: f32;
    var local_23: f32;

    let _e200 = (*slot_1);
    let _e201 = (*slot_1);
    lane = (_e200 - ((_e201 / 4i) * 4i));
    let _e205 = lane;
    if (_e205 == 0i) {
        let _e208 = (*four)[0u];
        local_21 = _e208;
    } else {
        let _e209 = lane;
        if (_e209 == 1i) {
            let _e212 = (*four)[1u];
            local_22 = _e212;
        } else {
            let _e213 = lane;
            if (_e213 == 2i) {
                let _e216 = (*four)[2u];
                local_23 = _e216;
            } else {
                let _e218 = (*four)[3u];
                local_23 = _e218;
            }
            let _e219 = local_23;
            local_22 = _e219;
        }
        let _e220 = local_22;
        local_21 = _e220;
    }
    let _e221 = local_21;
    return _e221;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_123: vec4<f32>;
    var param_124: i32;

    let _e197 = (*slot_2);
    let _e201 = light_list_info.scales[(_e197 / 4i)];
    param_123 = _e201;
    let _e202 = (*slot_2);
    param_124 = _e202;
    let _e203 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_123), (&param_124));
    return _e203;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e199 = light_list_info.slot_rows[0i];
    let _e200 = (*row);
    a_5 = abs((_e199 - vec4(_e200)));
    let _e206 = light_list_info.slot_rows[1i];
    let _e207 = (*row);
    b_3 = abs((_e206 - vec4(_e207)));
    let _e212 = a_5[0u];
    let _e214 = a_5[1u];
    let _e217 = a_5[2u];
    let _e219 = a_5[3u];
    let _e223 = b_3[0u];
    let _e225 = b_3[1u];
    let _e228 = b_3[2u];
    let _e230 = b_3[3u];
    return (min(min(min(_e212, _e214), min(_e217, _e219)), min(min(_e223, _e225), min(_e228, _e230))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_125: vec4<f32>;
    var param_126: i32;

    let _e197 = (*slot_3);
    let _e201 = light_list_info.indices[(_e197 / 4i)];
    param_125 = _e201;
    let _e202 = (*slot_3);
    param_126 = _e202;
    let _e203 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_125), (&param_126));
    return _e203;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e196 = (*texel_2);
    let _e200 = light_list_info.list[1u];
    let _e202 = (*row_1);
    let _e206 = light_list_info.list[2u];
    let _e209 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e196 + 0.5f) * _e200), ((_e202 + 0.5f) * _e206)), 0f);
    return _e209;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_127: f32;
    var param_128: f32;
    var param_129: vec4<f32>;
    var param_130: i32;

    let _e204 = g_cluster_offset;
    let _e205 = (*slot_4);
    entry_1 = (_e204 + f32(_e205));
    let _e208 = entry_1;
    row_2 = floor((_e208 / 16f));
    let _e211 = entry_1;
    let _e212 = row_2;
    within = (_e211 - (_e212 * 16f));
    let _e215 = within;
    texel_3 = floor((_e215 / 4f));
    let _e220 = light_list_info.cluster_depth[3u];
    let _e221 = row_2;
    let _e223 = texel_3;
    param_127 = _e223;
    param_128 = (_e220 + _e221);
    let _e224 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_127), (&param_128));
    four_1 = _e224;
    let _e225 = within;
    let _e226 = texel_3;
    let _e231 = four_1;
    param_129 = _e231;
    param_130 = i32(((_e225 - (_e226 * 4f)) + 0.5f));
    let _e232 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_129), (&param_130));
    return _e232;
}

fn Clustered_u0028_() -> bool {
    let _e196 = light_list_info.cluster_grid[3u];
    return (_e196 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_24: f32;
    var param_131: i32;
    var param_132: i32;
    var v_2: f32;
    var u_1: f32;
    var local_25: f32;
    var param_133: f32;
    var param_134: i32;
    var type_42: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_26: f32;
    var param_135: array<vec3<f32>, 4>;
    var param_136: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_27: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_137: vec3<f32>;
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_28: vec3<f32>;
    var param_142: vec3<f32>;
    var param_143: vec3<f32>;
    var param_144: f32;
    var param_145: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_146: f32;
    var param_147: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e252 = (*index_2);
    if (_e252 < 8i) {
        let _e254 = (*index_2);
        let _e257 = frag_info.light_position[_e254];
        position = _e257;
        let _e258 = (*index_2);
        let _e261 = frag_info.light_color[_e258];
        color_1 = _e261;
        let _e262 = (*index_2);
        let _e265 = frag_info.light_direction[_e262];
        direction = _e265;
        let _e266 = (*index_2);
        let _e269 = frag_info.light_cone[_e266];
        cone = _e269;
    } else {
        let _e270 = (*index_2);
        slot_5 = (_e270 - 8i);
        let _e272 = Clustered_u0028_();
        clustered = _e272;
        let _e273 = clustered;
        if _e273 {
            let _e274 = slot_5;
            param_131 = _e274;
            let _e275 = ClusterRow_u0028_i1_u003b((&param_131));
            local_24 = _e275;
        } else {
            let _e276 = slot_5;
            param_132 = _e276;
            let _e277 = LightListRow_u0028_i1_u003b((&param_132));
            local_24 = _e277;
        }
        let _e278 = local_24;
        listRow = _e278;
        let _e279 = listRow;
        let _e283 = light_list_info.list[2u];
        v_2 = ((_e279 + 0.5f) * _e283);
        let _e287 = light_list_info.list[1u];
        u_1 = _e287;
        let _e288 = u_1;
        let _e290 = v_2;
        let _e292 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e288), _e290), 0f);
        position = _e292;
        let _e293 = u_1;
        let _e295 = v_2;
        let _e297 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e293), _e295), 0f);
        color_1 = _e297;
        let _e298 = u_1;
        let _e300 = v_2;
        let _e302 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e298), _e300), 0f);
        direction = _e302;
        let _e303 = u_1;
        let _e305 = v_2;
        let _e307 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e303), _e305), 0f);
        cone = _e307;
        let _e308 = clustered;
        if _e308 {
            let _e309 = listRow;
            param_133 = _e309;
            let _e310 = InSlots_u0028_f1_u003b((&param_133));
            local_25 = select(1f, 0f, _e310);
        } else {
            let _e312 = slot_5;
            param_134 = _e312;
            let _e313 = LightListScale_u0028_i1_u003b((&param_134));
            local_25 = _e313;
        }
        let _e314 = local_25;
        let _e316 = color_1[3u];
        color_1[3u] = (_e316 * _e314);
    }
    let _e320 = position[3u];
    type_42 = _e320;
    let _e321 = type_42;
    if (_e321 > 15.5f) {
        let _e324 = (*s_5).n;
        light_3.l = _e324;
        let _e327 = (*s_5).n;
        light_3.h = _e327;
        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 _e333 = light_3;
        return _e333;
    }
    let _e334 = type_42;
    if (_e334 > 2.5f) {
        let _e336 = direction;
        halfWidth_1 = _e336.xyz;
        let _e338 = cone;
        halfHeight_1 = _e338.xyz;
        let _e340 = position;
        let _e342 = v_world_position_1;
        toCentre = (_e340.xyz - _e342);
        let _e344 = toCentre;
        let _e345 = halfWidth_1;
        let _e347 = halfHeight_1;
        corners_2[0i] = ((_e344 - _e345) - _e347);
        let _e350 = toCentre;
        let _e351 = halfWidth_1;
        let _e353 = halfHeight_1;
        corners_2[1i] = ((_e350 + _e351) - _e353);
        let _e356 = toCentre;
        let _e357 = halfWidth_1;
        let _e359 = halfHeight_1;
        corners_2[2i] = ((_e356 + _e357) + _e359);
        let _e362 = toCentre;
        let _e363 = halfWidth_1;
        let _e365 = halfHeight_1;
        corners_2[3i] = ((_e362 - _e363) + _e365);
        let _e368 = toCentre;
        let _e369 = halfWidth_1;
        let _e370 = halfHeight_1;
        behind = (dot(_e368, cross(_e369, _e370)) >= 0f);
        let _e374 = behind;
        if _e374 {
            local_26 = 0f;
        } else {
            let _e375 = corners_2;
            param_135 = _e375;
            let _e377 = (*s_5).n;
            param_136 = _e377;
            let _e378 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_135), (&param_136));
            local_26 = _e378;
        }
        let _e379 = local_26;
        formFactor = _e379;
        let _e380 = halfWidth_1;
        let _e381 = halfHeight_1;
        area = (length(cross(_e380, _e381)) * 4f);
        let _e385 = area;
        if (_e385 > 0.000000001f) {
            let _e387 = area;
            local_27 = (1f / _e387);
        } else {
            local_27 = 0f;
        }
        let _e389 = local_27;
        radiance = _e389;
        let _e390 = toCentre;
        distance_2 = length(_e390);
        let _e393 = direction[3u];
        if (_e393 > 0f) {
            let _e395 = distance_2;
            let _e397 = direction[3u];
            ratio_1 = (_e395 / _e397);
            let _e399 = ratio_1;
            let _e400 = ratio_1;
            let _e402 = ratio_1;
            let _e404 = ratio_1;
            window_1 = clamp((1f - (((_e399 * _e400) * _e402) * _e404)), 0f, 1f);
            let _e408 = window_1;
            let _e409 = window_1;
            let _e411 = radiance;
            radiance = (_e411 * (_e408 * _e409));
        }
        let _e414 = (*s_5).v;
        let _e417 = (*s_5).n;
        mirror_1 = reflect(-(_e414), _e417);
        let _e419 = position;
        param_137 = _e419.xyz;
        let _e421 = halfWidth_1;
        param_138 = _e421;
        let _e422 = halfHeight_1;
        param_139 = _e422;
        let _e423 = v_world_position_1;
        param_140 = _e423;
        let _e424 = mirror_1;
        param_141 = _e424;
        let _e425 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_137), (&param_138), (&param_139), (&param_140), (&param_141));
        representative = _e425;
        let _e426 = representative;
        let _e427 = v_world_position_1;
        toPoint = (_e426 - _e427);
        let _e429 = toPoint;
        pointDistance = length(_e429);
        let _e431 = pointDistance;
        if (_e431 > 0.000001f) {
            let _e433 = toPoint;
            let _e434 = pointDistance;
            local_28 = (_e433 / vec3(_e434));
        } else {
            let _e438 = (*s_5).n;
            local_28 = _e438;
        }
        let _e439 = local_28;
        light_3.l = _e439;
        let _e442 = light_3.l;
        let _e444 = (*s_5).v;
        light_3.h = normalize((_e442 + _e444));
        let _e448 = formFactor;
        light_3.n_dot_l = _e448;
        let _e451 = (*s_5).n;
        let _e453 = light_3.h;
        light_3.n_dot_h = max(dot(_e451, _e453), 0f);
        let _e458 = (*s_5).v;
        let _e460 = light_3.h;
        light_3.v_dot_h = max(dot(_e458, _e460), 0f);
        let _e464 = color_1;
        let _e467 = color_1[3u];
        let _e469 = radiance;
        light_3.radiance = ((_e464.xyz * _e467) * _e469);
        light_3.integrated = 1f;
        let _e474 = (*s_5).n;
        param_142 = _e474;
        let _e476 = (*s_5).v;
        param_143 = _e476;
        let _e478 = (*s_5).roughness;
        param_144 = _e478;
        let _e479 = corners_2;
        param_145 = _e479;
        let _e480 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_142), (&param_143), (&param_144), (&param_145));
        light_3.ltc = _e480;
        let _e482 = light_3;
        return _e482;
    }
    let _e483 = direction;
    aim = normalize(_e483.xyz);
    attenuation_1 = 1f;
    let _e486 = type_42;
    if (_e486 < 0.5f) {
        let _e488 = aim;
        light_3.l = -(_e488);
    } else {
        let _e491 = position;
        let _e493 = v_world_position_1;
        toLight_1 = (_e491.xyz - _e493);
        let _e495 = toLight_1;
        distance_3 = length(_e495);
        let _e497 = distance_3;
        if (_e497 < 0.000001f) {
            let _e500 = (*s_5).n;
            light_3.l = _e500;
            let _e503 = (*s_5).n;
            light_3.h = _e503;
            light_3.radiance = vec3<f32>(0f, 0f, 0f);
            light_3.n_dot_l = 0f;
            light_3.n_dot_h = 0f;
            light_3.v_dot_h = 0f;
            let _e509 = light_3;
            return _e509;
        }
        let _e510 = toLight_1;
        let _e511 = distance_3;
        light_3.l = (_e510 / vec3(_e511));
        let _e515 = distance_3;
        param_146 = _e515;
        let _e517 = direction[3u];
        param_147 = _e517;
        let _e518 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_146), (&param_147));
        attenuation_1 = _e518;
        let _e519 = type_42;
        if (_e519 > 1.5f) {
            let _e521 = aim;
            let _e523 = light_3.l;
            cosAngle = dot(_e521, -(_e523));
            let _e526 = cosAngle;
            let _e528 = cone[1u];
            let _e531 = cone[0u];
            let _e533 = cone[1u];
            ramp = clamp(((_e526 - _e528) / (_e531 - _e533)), 0f, 1f);
            let _e537 = ramp;
            let _e538 = ramp;
            let _e540 = attenuation_1;
            attenuation_1 = (_e540 * (_e537 * _e538));
        }
    }
    let _e543 = light_3.l;
    let _e545 = (*s_5).v;
    light_3.h = normalize((_e543 + _e545));
    let _e550 = (*s_5).n;
    let _e552 = light_3.l;
    light_3.n_dot_l = max(dot(_e550, _e552), 0f);
    let _e557 = (*s_5).n;
    let _e559 = light_3.h;
    light_3.n_dot_h = max(dot(_e557, _e559), 0f);
    let _e564 = (*s_5).v;
    let _e566 = light_3.h;
    light_3.v_dot_h = max(dot(_e564, _e566), 0f);
    let _e570 = color_1;
    let _e573 = color_1[3u];
    let _e575 = attenuation_1;
    light_3.radiance = ((_e570.xyz * _e573) * _e575);
    let _e578 = light_3;
    return _e578;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_29: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_148: f32;
    var param_149: f32;

    let _e209 = light_list_info.cluster_view_projection;
    let _e210 = (*world_3);
    clip_1 = (_e209 * vec4<f32>(_e210.x, _e210.y, _e210.z, 1f));
    let _e216 = clip_1;
    let _e219 = clip_1[3u];
    ndc_1 = (_e216.xy / vec2(max(_e219, 0.000001f)));
    let _e224 = light_list_info.cluster_grid;
    grid = _e224.xyz;
    let _e228 = light_list_info.cluster_depth[0u];
    near_1 = _e228;
    let _e230 = ndc_1[0u];
    let _e234 = grid[0u];
    let _e238 = grid[0u];
    tx = clamp(floor((((_e230 * 0.5f) + 0.5f) * _e234)), 0f, (_e238 - 1f));
    let _e242 = ndc_1[1u];
    let _e246 = grid[1u];
    let _e250 = grid[1u];
    ty = clamp(floor((((_e242 * 0.5f) + 0.5f) * _e246)), 0f, (_e250 - 1f));
    let _e254 = clip_1[3u];
    let _e255 = near_1;
    if (_e254 <= _e255) {
        local_29 = 0f;
    } else {
        let _e258 = clip_1[3u];
        let _e259 = near_1;
        let _e264 = light_list_info.cluster_depth[1u];
        let _e268 = grid[2u];
        local_29 = clamp(floor((log((_e258 / _e259)) * _e264)), 0f, (_e268 - 1f));
    }
    let _e271 = local_29;
    tz = _e271;
    let _e272 = tx;
    let _e273 = ty;
    let _e275 = grid[0u];
    let _e278 = tz;
    let _e280 = grid[0u];
    let _e283 = grid[1u];
    cell = ((_e272 + (_e273 * _e275)) + ((_e278 * _e280) * _e283));
    let _e286 = cell;
    row_3 = floor((_e286 / 4f));
    let _e289 = cell;
    let _e290 = row_3;
    let _e295 = light_list_info.cluster_depth[2u];
    let _e296 = row_3;
    param_148 = (_e289 - (_e290 * 4f));
    param_149 = (_e295 + _e296);
    let _e298 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_148), (&param_149));
    header = _e298;
    let _e300 = header[0u];
    g_cluster_offset = _e300;
    let _e302 = header[1u];
    g_cluster_count = _e302;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_150: vec3<f32>;

    let _e198 = light_list_info.list[0u];
    tail = _e198;
    let _e199 = Clustered_u0028_();
    if _e199 {
        let _e200 = v_world_position_1;
        param_150 = _e200;
        FindCluster_u0028_vf3_u003b((&param_150));
        let _e201 = g_cluster_count;
        tail = _e201;
    }
    let _e204 = frag_info.frame_params[1u];
    let _e208 = tail;
    return (clamp(i32((_e204 + 0.5f)), 0i, 8i) + clamp(i32((_e208 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_4: LightSample;
    var param_151: i32;
    var param_152: Surface;
    var visibility: f32;
    var param_153: i32;
    var local_30: f32;
    var param_154: Surface;
    var param_155: LightSample;
    var param_156: i32;
    var param_157: vec3<f32>;
    var param_158: vec3<f32>;
    var param_159: i32;
    var param_160: Surface;
    var param_161: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e212 = LightCount_u0028_();
    count_1 = _e212;
    i_9 = 0i;
    loop {
        let _e213 = i_9;
        if (_e213 < 32i) {
            let _e215 = i_9;
            let _e216 = count_1;
            if (_e215 >= _e216) {
                break;
            }
            let _e218 = i_9;
            param_151 = _e218;
            let _e219 = (*s_6);
            param_152 = _e219;
            let _e220 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_151), (&param_152));
            light_4 = _e220;
            let _e222 = light_4.n_dot_l;
            if (_e222 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e224 = i_9;
            param_153 = _e224;
            let _e225 = LightHasShadow_u0028_i1_u003b((&param_153));
            if _e225 {
                let _e226 = (*s_6);
                param_154 = _e226;
                let _e227 = light_4;
                param_155 = _e227;
                let _e228 = i_9;
                param_156 = _e228;
                let _e229 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_154), (&param_155), (&param_156));
                let _e230 = v_world_position_1;
                param_157 = _e230;
                let _e232 = (*s_6).n;
                param_158 = _e232;
                let _e233 = i_9;
                param_159 = _e233;
                let _e234 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_157), (&param_158), (&param_159));
                local_30 = (_e229 * _e234);
            } else {
                local_30 = 1f;
            }
            let _e236 = local_30;
            visibility = _e236;
            let _e237 = visibility;
            if (_e237 <= 0f) {
                continue;
            }
            let _e239 = (*s_6);
            param_160 = _e239;
            let _e240 = light_4;
            param_161 = _e240;
            let _e241 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_160), (&param_161));
            let _e243 = light_4.radiance;
            let _e246 = light_4.n_dot_l;
            let _e248 = visibility;
            let _e250 = light_transmittance;
            let _e252 = total_1;
            total_1 = (_e252 + ((((_e241 * _e243) * _e246) * _e248) * _e250));
            continue;
        } else {
            break;
        }
        continuing {
            let _e254 = i_9;
            i_9 = (_e254 + 1i);
        }
    }
    let _e256 = total_1;
    return _e256;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e195 = v_lightmap_uv_1;
    let _e196 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e195);
    texel_4 = _e196;
    let _e197 = texel_4;
    let _e200 = texel_4[3u];
    return ((_e197.xyz * _e200) * 8f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_31: f32;

    let _e197 = frag_info.material2_[2u];
    local_31 = floor((_e197 * 0.5f));
    let _e200 = local_31;
    return _e200;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_32: f32;
    var local_33: f32;

    let _e198 = OcclusionTarget_u0028_();
    target_ = _e198;
    let _e199 = target_;
    let _e201 = target_;
    if ((_e199 > 0.5f) && (_e201 < 1.5f)) {
        local_32 = 1f;
    } else {
        let _e205 = (*s_7).occlusion;
        local_32 = _e205;
    }
    let _e206 = local_32;
    local_33 = _e206;
    let _e207 = local_33;
    return _e207;
}

fn DirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var local_34: f32;
    var local_35: f32;

    let _e197 = OcclusionTarget_u0028_();
    if (_e197 > 1.5f) {
        local_34 = 1f;
    } else {
        let _e200 = (*s_8).occlusion;
        local_34 = _e200;
    }
    let _e201 = local_34;
    local_35 = _e201;
    let _e202 = local_35;
    return _e202;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_162: f32;
    var param_163: f32;
    var param_164: f32;
    var param_165: vec3<f32>;
    var param_166: f32;

    let _e203 = (*mu_1);
    param_162 = _e203;
    let _e204 = (*r_4);
    param_163 = _e204;
    let _e205 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_162), (&param_163));
    e_1 = _e205;
    let _e206 = (*rho_2);
    let _e207 = e_1;
    let _e209 = (*r_4);
    param_164 = _e209;
    let _e210 = FonAverage_u0028_f1_u003b((&param_164));
    let _e211 = (*rho_2);
    param_165 = _e211;
    param_166 = _e210;
    let _e212 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_165), (&param_166));
    let _e213 = e_1;
    return ((_e206 * _e207) + (_e212 * (1f - _e213)));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e196 = frag_info.target_origin[1u];
    return _e196;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e196 = v_texcoord_1;
    let _e197 = MaterialLodBias_u0028_();
    let _e198 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e196, _e197);
    orm = _e198.xyz;
    let _e201 = (*s_9).metallic;
    let _e203 = orm[2u];
    (*s_9).metallic = clamp((_e201 * _e203), 0f, 1f);
    let _e208 = (*s_9).roughness;
    let _e210 = orm[1u];
    (*s_9).roughness = clamp((_e208 * _e210), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e195 = (*srgb);
    let _e198 = (*srgb);
    let _e203 = (*srgb);
    return mix((_e195 / vec3(12.92f)), pow(((_e198 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e203));
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_167: vec3<f32>;

    let _e197 = v_texcoord_1;
    let _e198 = MaterialLodBias_u0028_();
    let _e199 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e197, _e198);
    param_167 = _e199.xyz;
    let _e201 = SrgbToLinear_u0028_vf3_u003b((&param_167));
    emissive = _e201;
    let _e202 = emissive;
    let _e204 = frag_info.emissive;
    let _e209 = frag_info.material2_[3u];
    (*s_10).emissive = ((_e202 * _e204.xyz) * _e209);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e197 = v_texcoord_1;
    let _e198 = MaterialLodBias_u0028_();
    let _e199 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e197, _e198);
    occlusion = _e199.x;
    let _e203 = frag_info.material2_[2u];
    let _e204 = OcclusionTarget_u0028_();
    strength_2 = (_e203 - (2f * _e204));
    let _e207 = occlusion;
    let _e208 = strength_2;
    (*s_11).occlusion = mix(1f, _e207, clamp(_e208, 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_12: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_4: vec3<f32>;
    var sampled: vec3<f32>;

    let _e199 = v_texcoord_1;
    let _e200 = MaterialLodBias_u0028_();
    let _e201 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e199, _e200);
    sampledTexel = _e201;
    let _e202 = v_tangent_1;
    t_2 = _e202.xyz;
    let _e204 = t_2;
    let _e206 = (*s_12).n;
    let _e208 = (*s_12).n;
    let _e209 = t_2;
    t_2 = (_e204 - (_e206 * dot(_e208, _e209)));
    let _e213 = t_2;
    let _e214 = t_2;
    if (dot(_e213, _e214) < 0.000000000001f) {
        return;
    }
    let _e217 = t_2;
    t_2 = normalize(_e217);
    let _e220 = (*s_12).n;
    let _e221 = t_2;
    let _e224 = v_tangent_1[3u];
    b_4 = (cross(_e220, _e221) * _e224);
    let _e226 = gl_FrontFacing_1;
    if !(_e226) {
        let _e228 = t_2;
        t_2 = -(_e228);
    }
    let _e230 = sampledTexel;
    sampled = ((_e230.xyz * 2f) - vec3(1f));
    let _e237 = frag_info.emissive[3u];
    if (_e237 > 0.5f) {
        let _e239 = sampled;
        let _e241 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e239.xy, _e241.xy)), 0f));
    }
    let _e250 = frag_info.material2_[1u];
    let _e251 = sampled;
    let _e253 = (_e251.xy * _e250);
    sampled[0u] = _e253.x;
    sampled[1u] = _e253.y;
    let _e258 = t_2;
    let _e260 = sampled[0u];
    let _e262 = b_4;
    let _e264 = sampled[1u];
    let _e268 = (*s_12).n;
    let _e270 = sampled[2u];
    (*s_12).n = normalize((((_e258 * _e260) + (_e262 * _e264)) + (_e268 * _e270)));
    let _e276 = (*s_12).n;
    let _e278 = (*s_12).v;
    (*s_12).n_dot_v = max(dot(_e276, _e278), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e195 = (*texel_5);
    let _e199 = irradiance_info.atlas;
    let _e202 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e195 + vec2(0.5f)) * _e199.xy), 0f);
    return _e202;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f_3: vec2<f32>;
    var a_6: vec4<f32>;
    var param_168: vec2<f32>;
    var b_5: vec4<f32>;
    var param_169: vec2<f32>;
    var c: vec4<f32>;
    var param_170: vec2<f32>;
    var d_5: vec4<f32>;
    var param_171: vec2<f32>;

    let _e208 = (*uv_6);
    let _e209 = (*interior);
    at_1 = ((vec2(1f) + (_e208 * _e209)) - vec2(0.5f));
    let _e215 = at_1;
    low = floor(_e215);
    let _e217 = at_1;
    let _e218 = low;
    f_3 = (_e217 - _e218);
    let _e220 = (*corner);
    let _e221 = low;
    param_168 = (_e220 + _e221);
    let _e223 = AtlasTexel_u0028_vf2_u003b((&param_168));
    a_6 = _e223;
    let _e224 = (*corner);
    let _e225 = low;
    param_169 = ((_e224 + _e225) + vec2<f32>(1f, 0f));
    let _e228 = AtlasTexel_u0028_vf2_u003b((&param_169));
    b_5 = _e228;
    let _e229 = (*corner);
    let _e230 = low;
    param_170 = ((_e229 + _e230) + vec2<f32>(0f, 1f));
    let _e233 = AtlasTexel_u0028_vf2_u003b((&param_170));
    c = _e233;
    let _e234 = (*corner);
    let _e235 = low;
    param_171 = ((_e234 + _e235) + vec2<f32>(1f, 1f));
    let _e238 = AtlasTexel_u0028_vf2_u003b((&param_171));
    d_5 = _e238;
    let _e239 = a_6;
    let _e240 = b_5;
    let _e242 = f_3[0u];
    let _e245 = c;
    let _e246 = d_5;
    let _e248 = f_3[0u];
    let _e252 = f_3[1u];
    return mix(mix(_e239, _e240, vec4(_e242)), mix(_e245, _e246, vec4(_e248)), vec4(_e252));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e199 = (*direction_1)[0u];
    let _e202 = (*direction_1)[1u];
    let _e206 = (*direction_1)[2u];
    sum_1 = ((abs(_e199) + abs(_e202)) + abs(_e206));
    let _e209 = sum_1;
    if (_e209 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e211 = (*direction_1);
    let _e212 = sum_1;
    n_6 = (_e211 / vec3(_e212));
    let _e215 = n_6;
    xy = _e215.xy;
    let _e218 = n_6[2u];
    if (_e218 < 0f) {
        let _e221 = n_6[1u];
        let _e225 = n_6[0u];
        let _e230 = n_6[0u];
        let _e234 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e221)) * select(-1f, 1f, (_e225 >= 0f))), ((1f - abs(_e230)) * select(-1f, 1f, (_e234 >= 0f))));
    }
    let _e239 = xy;
    return ((_e239 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_4: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_172: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_173: vec3<f32>;
    var param_174: vec2<f32>;
    var param_175: f32;
    var param_176: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_177: vec3<f32>;
    var param_178: vec2<f32>;
    var param_179: f32;
    var param_180: vec2<f32>;
    var local_36: vec3<f32>;

    let _e241 = irradiance_info.origin;
    origin_2 = _e241.xyz;
    let _e244 = irradiance_info.spacing;
    spacing = _e244.xyz;
    let _e247 = irradiance_info.counts;
    counts = _e247.xyz;
    let _e251 = irradiance_info.tiles[0u];
    irradianceTile = _e251;
    let _e254 = irradiance_info.tiles[1u];
    depthTile = _e254;
    let _e257 = irradiance_info.tiles[2u];
    columns = _e257;
    let _e260 = irradiance_info.tiles[3u];
    momentsTop = _e260;
    let _e261 = (*normal_1);
    unit = normalize(_e261);
    let _e263 = (*world_4);
    let _e264 = unit;
    let _e267 = irradiance_info.spacing[3u];
    let _e270 = (*view);
    let _e273 = irradiance_info.counts[3u];
    biased = ((_e263 + (_e264 * _e267)) + (_e270 * _e273));
    let _e276 = biased;
    let _e277 = origin_2;
    let _e279 = spacing;
    grid_1 = ((_e276 - _e277) / _e279);
    let _e281 = grid_1;
    let _e283 = counts;
    base = clamp(floor(_e281), vec3<f32>(0f, 0f, 0f), (_e283 - vec3(2f)));
    let _e287 = grid_1;
    let _e288 = base;
    f_4 = clamp((_e287 - _e288), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e291 = corner_1;
        if (_e291 < 8i) {
            let _e293 = corner_1;
            let _e296 = corner_1;
            let _e301 = corner_1;
            offset_3 = vec3<f32>(f32((_e293 & 1i)), f32(((_e296 >> bitcast<u32>(1i)) & 1i)), f32(((_e301 >> bitcast<u32>(2i)) & 1i)));
            let _e307 = base;
            let _e308 = offset_3;
            cell_1 = (_e307 + _e308);
            let _e311 = cell_1[2u];
            let _e313 = counts[1u];
            let _e316 = cell_1[1u];
            let _e319 = counts[0u];
            let _e322 = cell_1[0u];
            probe = ((((_e311 * _e313) + _e316) * _e319) + _e322);
            let _e324 = probe;
            let _e325 = columns;
            let _e330 = probe;
            let _e331 = columns;
            tile_4 = vec2<f32>((_e324 - (floor((_e324 / _e325)) * _e325)), floor((_e330 / _e331)));
            let _e335 = tile_4;
            let _e336 = irradianceTile;
            irradianceCorner = (_e335 * (_e336 + 2f));
            let _e340 = tile_4[0u];
            let _e341 = depthTile;
            let _e344 = momentsTop;
            let _e346 = tile_4[1u];
            let _e347 = depthTile;
            momentCorner = vec2<f32>((_e340 * (_e341 + 2f)), (_e344 + (_e346 * (_e347 + 2f))));
            let _e352 = irradianceCorner;
            param_172 = (_e352 + vec2(1f));
            let _e355 = AtlasTexel_u0028_vf2_u003b((&param_172));
            if (_e355.w < 0.5f) {
                continue;
            }
            let _e358 = f_4;
            let _e360 = f_4;
            let _e361 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e358), _e360, _e361);
            let _e364 = trilinear[0u];
            let _e366 = trilinear[1u];
            let _e369 = trilinear[2u];
            weight_2 = max(((_e364 * _e366) * _e369), 0.001f);
            let _e372 = origin_2;
            let _e373 = spacing;
            let _e374 = cell_1;
            probePosition = (_e372 + (_e373 * _e374));
            let _e377 = probePosition;
            let _e378 = biased;
            toProbe = (_e377 - _e378);
            let _e380 = toProbe;
            distance_4 = length(_e380);
            let _e382 = distance_4;
            if (_e382 > 0.000001f) {
                let _e384 = toProbe;
                let _e385 = distance_4;
                direction_2 = (_e384 / vec3(_e385));
                let _e388 = unit;
                let _e389 = probePosition;
                let _e390 = (*world_4);
                facing = ((dot(_e388, normalize((_e389 - _e390))) * 0.5f) + 0.5f);
                let _e396 = facing;
                let _e397 = facing;
                probeWeight = ((_e396 * _e397) + 0.2f);
                let _e400 = direction_2;
                param_173 = -(_e400);
                let _e402 = ProbeOctahedral_u0028_vf3_u003b((&param_173));
                let _e403 = momentCorner;
                param_174 = _e403;
                let _e404 = depthTile;
                param_175 = _e404;
                param_176 = _e402;
                let _e405 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_174), (&param_175), (&param_176));
                moments_3 = _e405.xy;
                chebyshev = 1f;
                let _e407 = distance_4;
                let _e409 = moments_3[0u];
                if (_e407 > _e409) {
                    let _e412 = moments_3[1u];
                    let _e414 = moments_3[0u];
                    let _e416 = moments_3[0u];
                    variance_1 = max((_e412 - (_e414 * _e416)), 0.000001f);
                    let _e420 = distance_4;
                    let _e422 = moments_3[0u];
                    difference = (_e420 - _e422);
                    let _e424 = variance_1;
                    let _e425 = variance_1;
                    let _e426 = difference;
                    let _e427 = difference;
                    chebyshev = (_e424 / (_e425 + (_e426 * _e427)));
                    let _e431 = chebyshev;
                    let _e432 = chebyshev;
                    let _e434 = chebyshev;
                    chebyshev = ((_e431 * _e432) * _e434);
                }
                let _e436 = probeWeight;
                let _e437 = chebyshev;
                probeWeight = max((_e436 * max(_e437, 0.05f)), 0.000001f);
                let _e441 = probeWeight;
                if (_e441 < 0.2f) {
                    let _e443 = probeWeight;
                    let _e444 = probeWeight;
                    let _e447 = probeWeight;
                    probeWeight = (_e447 * ((_e443 * _e444) * 25f));
                }
                let _e449 = probeWeight;
                let _e450 = weight_2;
                weight_2 = (_e450 * _e449);
            }
            let _e452 = unit;
            param_177 = _e452;
            let _e453 = ProbeOctahedral_u0028_vf3_u003b((&param_177));
            let _e454 = irradianceCorner;
            param_178 = _e454;
            let _e455 = irradianceTile;
            param_179 = _e455;
            param_180 = _e453;
            let _e456 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_178), (&param_179), (&param_180));
            let _e458 = weight_2;
            let _e460 = total_2;
            total_2 = (_e460 + (_e456.xyz * _e458));
            let _e462 = weight_2;
            let _e463 = weights;
            weights = (_e463 + _e462);
            continue;
        } else {
            break;
        }
        continuing {
            let _e465 = corner_1;
            corner_1 = (_e465 + 1i);
        }
    }
    let _e467 = weights;
    if (_e467 > 0f) {
        let _e469 = total_2;
        let _e470 = weights;
        local_36 = (_e469 / vec3(_e470));
    } else {
        local_36 = vec3<f32>(0f, 0f, 0f);
    }
    let _e473 = local_36;
    return _e473;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e196 = irradiance_info.origin[3u];
    return (_e196 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var param_181: vec3<f32>;
    var param_182: vec3<f32>;
    var param_183: vec3<f32>;
    var param_184: Surface;
    var param_185: Surface;
    var param_186: Surface;

    let _e201 = IrradianceEnabled_u0028_();
    if _e201 {
        let _e202 = v_world_position_1;
        param_181 = _e202;
        let _e204 = (*s_13).n;
        param_182 = _e204;
        let _e206 = (*s_13).v;
        param_183 = _e206;
        let _e207 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_181), (&param_182), (&param_183));
        let _e210 = frag_info.material[2u];
        (*s_13).ambient = (_e207 * _e210);
    }
    let _e213 = (*s_13);
    param_184 = _e213;
    ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_184));
    let _e214 = param_184;
    (*s_13) = _e214;
    let _e215 = (*s_13);
    param_185 = _e215;
    ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_185));
    let _e216 = param_185;
    (*s_13) = _e216;
    let _e217 = (*s_13);
    param_186 = _e217;
    ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_186));
    let _e218 = param_186;
    (*s_13) = _e218;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_37: vec3<f32>;

    let _e195 = Orthographic_u0028_();
    if _e195 {
        let _e197 = fog_info.forward;
        local_37 = -(_e197.xyz);
    } else {
        let _e201 = fog_info.eye;
        let _e203 = v_world_position_1;
        local_37 = normalize((_e201.xyz - _e203));
    }
    let _e206 = local_37;
    return _e206;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_14: Surface;
    var param_187: vec3<f32>;
    var param_188: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e200 = v_texcoord_1;
    let _e201 = MaterialLodBias_u0028_();
    let _e202 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e200, _e201);
    texel_6 = _e202;
    let _e203 = texel_6;
    param_187 = _e203.xyz;
    let _e205 = SrgbToLinear_u0028_vf3_u003b((&param_187));
    let _e207 = frag_info.base_color;
    param_188 = _e207.xyz;
    let _e209 = SrgbToLinear_u0028_vf3_u003b((&param_188));
    let _e211 = v_color_1;
    s_14.albedo = ((_e205 * _e209) * _e211.xyz);
    let _e216 = texel_6[3u];
    let _e219 = frag_info.base_color[3u];
    let _e222 = v_color_1[3u];
    s_14.alpha = ((_e216 * _e219) * _e222);
    let _e226 = s_14.albedo;
    g_albedo = _e226;
    let _e229 = frag_info.material2_[0u];
    cutoff = _e229;
    let _e230 = cutoff;
    if (_e230 > 1f) {
        let _e232 = cutoff;
        edge = (_e232 - 1f);
        let _e235 = s_14.alpha;
        let _e236 = edge;
        let _e239 = s_14.alpha;
        let _e240 = fwidth(_e239);
        s_14.alpha = clamp((((_e235 - _e236) / max(_e240, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e246 = cutoff;
        if (_e246 >= 0f) {
            s_14.alpha = 1f;
        }
    }
    let _e249 = cutoff;
    let _e251 = cutoff;
    g_premultiply = ((_e249 < 0f) && (_e251 > -0.75f));
    let _e254 = v_normal_1;
    s_14.n = normalize(_e254);
    let _e257 = gl_FrontFacing_1;
    if !(_e257) {
        let _e260 = s_14.n;
        s_14.n = -(_e260);
    }
    let _e263 = TowardsEye_u0028_();
    s_14.v = _e263;
    let _e266 = s_14.n;
    let _e268 = s_14.v;
    s_14.n_dot_v = max(dot(_e266, _e268), 0.0001f);
    let _e274 = frag_info.material[0u];
    s_14.metallic = clamp(_e274, 0f, 1f);
    let _e279 = frag_info.material[1u];
    s_14.roughness = clamp(_e279, 0.02f, 1f);
    let _e283 = frag_info.ambient_ground;
    let _e286 = frag_info.ambient_sky;
    let _e290 = s_14.n[1u];
    let _e297 = frag_info.material[2u];
    s_14.ambient = (mix(_e283.xyz, _e286.xyz, vec3(((_e290 * 0.5f) + 0.5f))) * _e297);
    let _e302 = frag_info.frame_params[0u];
    s_14.exposure = max(_e302, 0f);
    s_14.occlusion = 1f;
    s_14.emissive = vec3<f32>(0f, 0f, 0f);
    let _e307 = s_14;
    return _e307;
}

fn main_1() {
    var s_15: Surface;
    var param_189: Surface;
    var param_190: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_191: vec3<f32>;
    var param_192: f32;
    var param_193: f32;
    var directOcclusion: f32;
    var param_194: Surface;
    var indirectOcclusion: f32;
    var param_195: Surface;
    var ambient: vec3<f32>;
    var levels: f32;
    var f0_3: vec3<f32>;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_1: vec2<f32>;
    var param_196: f32;
    var param_197: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var lit_2: vec3<f32>;
    var param_198: Surface;
    var param_199: vec3<f32>;
    var param_200: f32;
    var param_201: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e225 = ReadSurface_u0028_();
    s_15 = _e225;
    let _e226 = s_15;
    param_189 = _e226;
    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((&param_189));
    let _e227 = param_189;
    s_15 = _e227;
    let _e228 = s_15;
    param_190 = _e228;
    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((&param_190));
    let _e229 = param_190;
    s_15 = _e229;
    let _e231 = s_15.metallic;
    metallic = clamp(_e231, 0f, 1f);
    let _e234 = s_15.albedo;
    let _e235 = metallic;
    diffuseColor_1 = (_e234 * (1f - _e235));
    let _e238 = EonDiffuse_u0028_();
    if _e238 {
        let _e239 = diffuseColor_1;
        param_191 = _e239;
        let _e241 = s_15.roughness;
        param_192 = _e241;
        let _e243 = s_15.n_dot_v;
        param_193 = _e243;
        let _e244 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_191), (&param_192), (&param_193));
        diffuseColor_1 = _e244;
    }
    let _e245 = s_15;
    param_194 = _e245;
    let _e246 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_194));
    directOcclusion = _e246;
    let _e247 = s_15;
    param_195 = _e247;
    let _e248 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_195));
    indirectOcclusion = _e248;
    let _e249 = diffuseColor_1;
    let _e251 = s_15.ambient;
    let _e253 = indirectOcclusion;
    ambient = ((_e249 * _e251) * _e253);
    let _e257 = frag_info.frame_params[3u];
    levels = _e257;
    let _e258 = levels;
    if (_e258 > 0f) {
        let _e261 = s_15.albedo;
        let _e262 = metallic;
        f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e261, vec3(_e262));
        let _e266 = s_15.v;
        let _e269 = s_15.n;
        reflected = reflect(-(_e266), _e269);
        let _e272 = s_15.n;
        let _e273 = levels;
        let _e274 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e272, _e273);
        irradiance = _e274.xyz;
        let _e276 = reflected;
        let _e278 = s_15.roughness;
        let _e279 = levels;
        let _e281 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e276, (_e278 * _e279));
        prefiltered = _e281.xyz;
        let _e284 = s_15.roughness;
        param_196 = _e284;
        let _e286 = s_15.n_dot_v;
        param_197 = _e286;
        let _e287 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_196), (&param_197));
        ab_1 = _e287;
        let _e288 = f0_3;
        let _e290 = ab_1[0u];
        let _e293 = ab_1[1u];
        single_1 = ((_e288 * _e290) + vec3(_e293));
        let _e296 = prefiltered;
        let _e297 = single_1;
        specular_1 = (_e296 * _e297);
        let _e299 = EnergyCompensation_u0028_();
        if _e299 {
            let _e301 = ab_1[0u];
            let _e303 = ab_1[1u];
            missed = (1f - (_e301 + _e303));
            let _e306 = f0_3;
            let _e307 = f0_3;
            average_2 = (_e306 + ((vec3<f32>(1f, 1f, 1f) - _e307) / vec3(21f)));
            let _e312 = single_1;
            let _e313 = average_2;
            let _e315 = missed;
            let _e316 = average_2;
            multiple = ((_e312 * _e313) / (vec3<f32>(1f, 1f, 1f) - (_e316 * _e315)));
            let _e320 = multiple;
            let _e321 = missed;
            let _e323 = irradiance;
            let _e325 = specular_1;
            specular_1 = (_e325 + ((_e320 * _e321) * _e323));
        }
        let _e327 = diffuseColor_1;
        let _e328 = irradiance;
        let _e330 = specular_1;
        let _e334 = frag_info.material[2u];
        let _e336 = indirectOcclusion;
        ambient = ((((_e327 * _e328) + _e330) * _e334) * _e336);
    }
    let _e338 = diffuseColor_1;
    let _e339 = SampleLightmap_u0028_();
    let _e341 = indirectOcclusion;
    let _e343 = ambient;
    ambient = (_e343 + ((_e338 * _e339) * _e341));
    let _e345 = s_15;
    param_198 = _e345;
    let _e346 = 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((&param_198));
    let _e347 = directOcclusion;
    let _e349 = ambient;
    let _e352 = s_15.emissive;
    lit_2 = (((_e346 * _e347) + _e349) + _e352);
    let _e354 = lit_2;
    param_199 = _e354;
    let _e356 = s_15.alpha;
    param_200 = _e356;
    let _e358 = s_15.roughness;
    param_201 = _e358;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_199), (&param_200), (&param_201));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 27,
          samplerBinding: 28,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 29,
          samplerBinding: 30,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrLayeredOpaque': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct LayerInfo {
    specular: vec4<f32>,
    coat: vec4<f32>,
    sheen: vec4<f32>,
    anisotropy: vec4<f32>,
    transmission: vec4<f32>,
    attenuation: vec4<f32>,
    iridescence: vec4<f32>,
    uv_transform: array<vec4<f32>, 10>,
    scene_color: vec4<f32>,
    scene_viewport: vec4<f32>,
    scene_levels: array<vec4<f32>, 6>,
    scene_view_projection: mat4x4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
var<private> g_f0_dielectric: vec3<f32>;
var<private> g_f90_: f32;
var<private> g_coat: f32;
var<private> g_coat_roughness: f32;
var<private> g_coat_n: vec3<f32>;
var<private> g_coat_n_dot_v: f32;
var<private> g_coat_through: f32;
var<private> g_sheen: vec3<f32>;
var<private> g_sheen_roughness: f32;
var<private> g_sheen_albedo: f32;
var<private> g_sheen_scale: f32;
var<private> g_aniso: f32;
var<private> g_aniso_t: vec3<f32>;
var<private> g_aniso_b: vec3<f32>;
var<private> g_transmission: f32;
var<private> g_thickness: f32;
var<private> g_transmittance: vec3<f32>;
var<private> g_iridescence: f32;
var<private> g_irid_fresnel: vec3<f32>;
var<private> g_pane: bool;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(16)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(6)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var base_color_texture_smp: sampler;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(20)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var ltc_texture_smp: sampler;
var<private> g_rect_corners: array<vec3<f32>, 4>;
@group(1) @binding(5)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(30)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(31)
var point_shadow_texture_smp: sampler;
@group(1) @binding(28)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(29)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(14)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var irradiance_texture_smp: sampler;
@group(1) @binding(18)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(22)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(26)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(27)
var occlusion_texture_smp: sampler;
@group(1) @binding(10)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var emissive_texture_smp: sampler;
@group(1) @binding(24)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(34)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(35)
var shadow_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(3)
var<uniform> layer_info: LayerInfo;
@group(1) @binding(8)
var coat_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var coat_texture_smp: sampler;
@group(1) @binding(36)
var sheen_texture_tex: texture_2d<f32>;
@group(1) @binding(37)
var sheen_texture_smp: sampler;
@group(1) @binding(12)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(13)
var environment_texture_smp: sampler;
@group(1) @binding(32)
var scene_color_texture_tex: texture_2d<f32>;
@group(1) @binding(33)
var scene_color_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e261 = v_world_position_1;
    let _e263 = fog_info.eye;
    let _e267 = fog_info.forward;
    return dot((_e261 - _e263.xyz), _e267.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e266 = ViewDepth_u0028_();
    z = abs(_e266);
    let _e268 = z;
    near = (_e268 / 5f);
    let _e270 = z;
    far = (_e270 / 200f);
    let _e272 = far;
    let _e273 = far;
    let _e275 = far;
    far3_ = ((_e272 * _e273) * _e275);
    let _e277 = (*alpha);
    let _e278 = near;
    let _e279 = near;
    let _e282 = far3_;
    let _e283 = far3_;
    return (_e277 * clamp((10f / ((0.00001f + (_e278 * _e279)) + (_e282 * _e283))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e270 = fog_info.forward[3u];
    mode = _e270;
    let _e271 = mode;
    if (_e271 > 0.5f) {
        let _e274 = frag_color[3u];
        alpha_1 = _e274;
        let _e275 = alpha_1;
        param = _e275;
        let _e276 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e276;
        let _e277 = frag_color;
        let _e279 = weight;
        let _e280 = (_e277.xyz * _e279);
        let _e281 = alpha_1;
        let _e282 = weight;
        accumulate = vec4<f32>(_e280.x, _e280.y, _e280.z, (_e281 * _e282));
        let _e288 = mode;
        let _e290 = mode;
        revealage = ((_e288 > 1.5f) && (_e290 < 2.5f));
        let _e293 = revealage;
        if _e293 {
            let _e294 = alpha_1;
            local = vec4(_e294);
        } else {
            let _e296 = accumulate;
            local = _e296;
        }
        let _e297 = local;
        frag_color = _e297;
        let _e298 = mode;
        if (_e298 > 2.5f) {
            let _e300 = alpha_1;
            frag_surface = vec4(_e300);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e264 = (*n)[0u];
    let _e267 = (*n)[1u];
    let _e271 = (*n)[2u];
    let _e274 = (*n);
    (*n) = (_e274 / vec3(((abs(_e264) + abs(_e267)) + abs(_e271))));
    let _e277 = (*n);
    e = _e277.xy;
    let _e280 = (*n)[2u];
    if (_e280 < 0f) {
        let _e282 = (*n);
        let _e288 = (*n)[0u];
        let _e292 = (*n)[1u];
        e = ((vec2(1f) - abs(_e282.yx)) * vec2<f32>(select(-1f, 1f, (_e288 >= 0f)), select(-1f, 1f, (_e292 >= 0f))));
    }
    let _e297 = e;
    return ((_e297 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e262 = (*linear);
    let _e264 = (*linear);
    let _e268 = (*linear);
    return mix((_e262 * 12.92f), ((pow(_e264, 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), _e268));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e265 = g_albedo;
    param_1 = clamp(_e265, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e267 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e267.x, _e267.y, _e267.z, 1f);
    let _e272 = g_debug_surface_on;
    if _e272 {
        let _e273 = g_debug_surface;
        let _e274 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e273.x, _e273.y, _e273.z, _e274);
        return;
    }
    let _e279 = v_normal_1;
    geometric = normalize(_e279);
    let _e281 = gl_FrontFacing_1;
    if !(_e281) {
        let _e283 = geometric;
        geometric = -(_e283);
    }
    let _e285 = geometric;
    param_2 = _e285;
    let _e286 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e287 = (*roughness);
    let _e289 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e286.x, _e286.y, clamp(_e287, 0f, 1f), _e289);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e263 = fog_info.projection[0u];
    return (_e263 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e262 = Orthographic_u0028_();
    if _e262 {
        let _e263 = ViewDepth_u0028_();
        local_1 = max(_e263, 0f);
    } else {
        let _e265 = v_world_position_1;
        let _e267 = fog_info.eye;
        local_1 = distance(_e265, _e267.xyz);
    }
    let _e270 = local_1;
    return _e270;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e269 = fog_info.fog[3u];
    density = _e269;
    let _e270 = density;
    if (_e270 <= 0f) {
        let _e272 = (*color);
        return _e272;
    }
    let _e273 = EyeDistance_u0028_();
    d = _e273;
    let _e276 = fog_info.eye[3u];
    falloff = _e276;
    let _e277 = falloff;
    if (_e277 > 0f) {
        let _e279 = falloff;
        let _e281 = v_world_position_1[1u];
        let _e284 = fog_info.eye[1u];
        k = (_e279 * (_e281 - _e284));
        let _e287 = k;
        if (abs(_e287) > 0.001f) {
            let _e290 = k;
            let _e294 = k;
            local_2 = ((1f - exp(-(_e290))) / _e294);
        } else {
            let _e296 = k;
            local_2 = (1f - (0.5f * _e296));
        }
        let _e299 = local_2;
        let _e300 = density;
        density = (_e300 * _e299);
    }
    let _e303 = fog_info.fog;
    let _e305 = (*color);
    let _e306 = density;
    let _e308 = d;
    return mix(_e303.xyz, _e305, vec3(clamp(exp((-(_e306) * _e308)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e267 = g_premultiply;
    let _e268 = (*alpha_2);
    weight_1 = select(1f, _e268, _e267);
    let _e270 = (*linearColor);
    param_3 = _e270;
    let _e271 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e272 = weight_1;
    let _e273 = (_e271 * _e272);
    let _e274 = (*alpha_2);
    let _e275 = g_pass_through;
    frag_color = vec4<f32>(_e273.x, _e273.y, _e273.z, (_e274 * (1f - _e275)));
    let _e282 = (*roughness_1);
    param_4 = _e282;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e267 = (*alpha_3);
    let _e268 = (*alpha_3);
    a2_ = (_e267 * _e268);
    let _e270 = (*n_dot_l);
    let _e271 = (*n_dot_v);
    let _e272 = (*n_dot_v);
    let _e274 = a2_;
    let _e277 = a2_;
    lambda_v = (_e270 * sqrt((((_e271 * _e272) * (1f - _e274)) + _e277)));
    let _e281 = (*n_dot_v);
    let _e282 = (*n_dot_l);
    let _e283 = (*n_dot_l);
    let _e285 = a2_;
    let _e288 = a2_;
    lambda_l = (_e281 * sqrt((((_e282 * _e283) * (1f - _e285)) + _e288)));
    let _e292 = lambda_v;
    let _e293 = lambda_l;
    return (0.5f / max((_e292 + _e293), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_1: f32;

    let _e265 = (*n_dot_h);
    let _e266 = (*alpha_4);
    a = (_e265 * _e266);
    let _e268 = (*alpha_4);
    let _e269 = (*n_dot_h);
    let _e270 = (*n_dot_h);
    let _e273 = a;
    let _e274 = a;
    k_1 = (_e268 / max(((1f - (_e269 * _e270)) + (_e273 * _e274)), 0.0000001f));
    let _e279 = k_1;
    let _e280 = k_1;
    return ((_e279 * _e280) * 0.31830987f);
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle: f32;
    var local_3: vec3<f32>;

    let _e267 = (*a_1);
    let _e268 = (*b);
    axis = cross(_e267, _e268);
    let _e270 = axis;
    len = length(_e270);
    let _e272 = (*a_1);
    let _e273 = (*b);
    angle = acos(clamp(dot(_e272, _e273), -1f, 1f));
    let _e277 = len;
    if (_e277 > 0.000001f) {
        let _e279 = axis;
        let _e280 = angle;
        let _e281 = len;
        local_3 = (_e279 * (_e280 / (_e281 * 6.2831855f)));
    } else {
        local_3 = vec3<f32>(0f, 0f, 0f);
    }
    let _e285 = local_3;
    return _e285;
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e265 = (*x);
    let _e266 = (*y);
    inTable = ((vec2<f32>(_e265, _e266) * 0.984375f) + vec2(0.0078125f));
    let _e272 = inTable[0u];
    let _e274 = inTable[1u];
    let _e275 = (*table);
    return vec2<f32>(_e272, ((_e274 + _e275) * 0.5f));
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_2: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv: vec2<f32>;
    var inverse: vec4<f32>;
    var param_5: f32;
    var param_6: f32;
    var param_7: f32;
    var fit: vec4<f32>;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_4: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i: i32;
    var p: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f: vec3<f32>;
    var param_11: vec3<f32>;
    var param_12: vec3<f32>;
    var param_13: vec3<f32>;
    var param_14: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: vec3<f32>;
    var param_17: vec3<f32>;
    var param_18: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_5: f32;
    var sphere: f32;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;

    let _e299 = (*roughness_2);
    let _e301 = (*n_1);
    let _e302 = (*v);
    uv = vec2<f32>(clamp(_e299, 0f, 1f), sqrt(clamp((1f - dot(_e301, _e302)), 0f, 1f)));
    let _e309 = uv[0u];
    param_5 = _e309;
    let _e311 = uv[1u];
    param_6 = _e311;
    param_7 = 0f;
    let _e312 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    let _e313 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e312, 0f);
    inverse = _e313;
    let _e315 = uv[0u];
    param_8 = _e315;
    let _e317 = uv[1u];
    param_9 = _e317;
    param_10 = 1f;
    let _e318 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_8), (&param_9), (&param_10));
    let _e319 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e318, 0f);
    fit = _e319;
    let _e320 = (*v);
    let _e321 = (*n_1);
    let _e322 = (*v);
    let _e323 = (*n_1);
    along = (_e320 - (_e321 * dot(_e322, _e323)));
    let _e327 = along;
    alongLength = length(_e327);
    let _e329 = alongLength;
    if (_e329 > 0.00001f) {
        let _e331 = along;
        let _e332 = alongLength;
        local_4 = (_e331 / vec3(_e332));
    } else {
        let _e335 = (*n_1);
        let _e337 = (*n_1)[2u];
        local_4 = normalize(cross(_e335, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e337) < 0.999f)))));
    }
    let _e344 = local_4;
    t1_ = _e344;
    let _e345 = (*n_1);
    let _e346 = t1_;
    t2_ = cross(_e345, _e346);
    let _e349 = inverse[0u];
    let _e351 = inverse[1u];
    let _e352 = vec3<f32>(_e349, 0f, _e351);
    let _e354 = inverse[2u];
    let _e356 = inverse[3u];
    let _e357 = vec3<f32>(_e354, 0f, _e356);
    minv = mat3x3<f32>(vec3<f32>(_e352.x, _e352.y, _e352.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e357.x, _e357.y, _e357.z));
    i = 0i;
    loop {
        let _e371 = i;
        if (_e371 < 4i) {
            let _e373 = i;
            let _e375 = (*corners)[_e373];
            p = _e375;
            let _e376 = i;
            let _e377 = minv;
            let _e378 = p;
            let _e379 = t1_;
            let _e381 = p;
            let _e382 = t2_;
            let _e384 = p;
            let _e385 = (*n_1);
            l[_e376] = normalize((_e377 * vec3<f32>(dot(_e378, _e379), dot(_e381, _e382), dot(_e384, _e385))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e391 = i;
            i = (_e391 + 1i);
        }
    }
    let _e394 = l[0i];
    param_11 = _e394;
    let _e396 = l[1i];
    param_12 = _e396;
    let _e397 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_11), (&param_12));
    let _e399 = l[1i];
    param_13 = _e399;
    let _e401 = l[2i];
    param_14 = _e401;
    let _e402 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_13), (&param_14));
    let _e405 = l[2i];
    param_15 = _e405;
    let _e407 = l[3i];
    param_16 = _e407;
    let _e408 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_15), (&param_16));
    let _e411 = l[3i];
    param_17 = _e411;
    let _e413 = l[0i];
    param_18 = _e413;
    let _e414 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_17), (&param_18));
    f = -((((_e397 + _e402) + _e408) + _e414));
    let _e417 = f;
    len_1 = length(_e417);
    let _e419 = len_1;
    if (_e419 > 0.000000001f) {
        let _e422 = f[2u];
        let _e423 = len_1;
        local_5 = (_e422 / _e423);
    } else {
        local_5 = 0f;
    }
    let _e425 = local_5;
    z_1 = _e425;
    let _e426 = z_1;
    let _e429 = len_1;
    param_19 = ((_e426 * 0.5f) + 0.5f);
    param_20 = clamp(_e429, 0f, 1f);
    param_21 = 1f;
    let _e431 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21));
    let _e432 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e431, 0f);
    sphere = _e432.w;
    let _e434 = len_1;
    let _e435 = sphere;
    let _e439 = fit[0u];
    let _e441 = fit[1u];
    return vec3<f32>(max((_e434 * _e435), 0f), _e439, _e441);
}

fn CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
    var ltc: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: f32;
    var param_25: array<vec3<f32>, 4>;
    var lobe: f32;
    var alpha_5: f32;
    var n_dot_l_1: f32;
    var n_dot_h_1: f32;
    var d_1: f32;
    var param_26: f32;
    var param_27: f32;
    var vis: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var f_1: f32;

    let _e281 = (*light).integrated;
    if (_e281 > 0.5f) {
        let _e283 = g_coat_n;
        param_22 = _e283;
        let _e285 = (*s).v;
        param_23 = _e285;
        let _e286 = g_coat_roughness;
        param_24 = _e286;
        let _e287 = g_rect_corners;
        param_25 = _e287;
        let _e288 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_22), (&param_23), (&param_24), (&param_25));
        ltc = _e288;
        let _e290 = ltc[0u];
        let _e292 = ltc[1u];
        let _e295 = ltc[2u];
        let _e301 = frag_info.material[3u];
        let _e304 = (*light).n_dot_l;
        return (((_e290 * ((0.04f * _e292) + (0.96f * _e295))) * _e301) / max(_e304, 0.000001f));
    }
    let _e307 = g_coat_roughness;
    lobe = max(_e307, 0.045f);
    let _e309 = lobe;
    let _e310 = lobe;
    alpha_5 = (_e309 * _e310);
    let _e312 = g_coat_n;
    let _e314 = (*light).l;
    n_dot_l_1 = max(dot(_e312, _e314), 0f);
    let _e317 = g_coat_n;
    let _e319 = (*light).h;
    n_dot_h_1 = max(dot(_e317, _e319), 0f);
    let _e322 = n_dot_h_1;
    param_26 = _e322;
    let _e323 = alpha_5;
    param_27 = _e323;
    let _e324 = D_GGX_u0028_f1_u003b_f1_u003b((&param_26), (&param_27));
    d_1 = _e324;
    let _e325 = g_coat_n_dot_v;
    param_28 = _e325;
    let _e326 = n_dot_l_1;
    param_29 = _e326;
    let _e327 = alpha_5;
    param_30 = _e327;
    let _e328 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_28), (&param_29), (&param_30));
    vis = _e328;
    let _e330 = (*light).v_dot_h;
    f_1 = (0.04f + (0.96f * pow((1f - _e330), 5f)));
    let _e335 = d_1;
    let _e336 = vis;
    let _e338 = f_1;
    let _e342 = frag_info.material[3u];
    let _e344 = n_dot_l_1;
    let _e347 = (*light).n_dot_l;
    return (((((_e335 * _e336) * _e338) * _e342) * _e344) / max(_e347, 0.000001f));
}

fn V_Neubelt_u0028_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l_2: ptr<function, f32>) -> f32 {
    let _e263 = (*n_dot_l_2);
    let _e264 = (*n_dot_v_1);
    let _e266 = (*n_dot_l_2);
    let _e267 = (*n_dot_v_1);
    return (1f / (4f * ((_e263 + _e264) - (_e266 * _e267))));
}

fn D_Charlie_u0028_f1_u003b_f1_u003b(roughness_3: ptr<function, f32>, n_dot_h_2: ptr<function, f32>) -> f32 {
    var inv_alpha: f32;
    var sin2h: f32;

    let _e265 = (*roughness_3);
    let _e266 = (*roughness_3);
    inv_alpha = (1f / (_e265 * _e266));
    let _e269 = (*n_dot_h_2);
    let _e270 = (*n_dot_h_2);
    sin2h = max((1f - (_e269 * _e270)), 0.0078125f);
    let _e274 = inv_alpha;
    let _e276 = sin2h;
    let _e277 = inv_alpha;
    return (((2f + _e274) * pow(_e276, (_e277 * 0.5f))) / 6.2831855f);
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m: f32;
    var g: f32;

    let _e265 = (*mu);
    m = (1f - _e265);
    let _e267 = m;
    let _e268 = m;
    let _e269 = m;
    let _e270 = m;
    g = (_e267 * (0.05710853f + (_e268 * (0.49188188f + (_e269 * (-0.33218145f + (_e270 * 0.071443f)))))));
    let _e278 = (*r);
    let _e279 = g;
    let _e282 = (*r);
    return ((1f + (_e278 * _e279)) / (1f + (0.2877934f * _e282)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e263 = (*rho);
    let _e264 = (*rho);
    let _e266 = (*average);
    let _e268 = (*rho);
    let _e269 = (*average);
    return (((_e263 * _e264) * _e266) / (vec3<f32>(1f, 1f, 1f) - (_e268 * (1f - _e269))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e262 = (*r_1);
    let _e265 = (*r_1);
    return ((1f + (0.07248821f * _e262)) / (1f + (0.2877934f * _e265)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s_1: f32;
    var s_over_t: f32;
    var local_6: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_31: f32;
    var multi: vec3<f32>;
    var param_32: vec3<f32>;
    var param_33: f32;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;

    let _e280 = (*l_dot_v);
    let _e281 = (*mu_i);
    let _e282 = (*mu_o);
    s_1 = (_e280 - (_e281 * _e282));
    let _e285 = s_1;
    if (_e285 > 0f) {
        let _e287 = s_1;
        let _e288 = (*mu_i);
        let _e289 = (*mu_o);
        local_6 = (_e287 / max(_e288, _e289));
    } else {
        let _e292 = s_1;
        local_6 = _e292;
    }
    let _e293 = local_6;
    s_over_t = _e293;
    let _e294 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e294)));
    let _e298 = (*rho_1);
    let _e299 = af;
    let _e300 = (*r_2);
    let _e301 = s_over_t;
    single = (_e298 * (_e299 * (1f + (_e300 * _e301))));
    let _e306 = (*r_2);
    param_31 = _e306;
    let _e307 = FonAverage_u0028_f1_u003b((&param_31));
    average_1 = _e307;
    let _e308 = (*rho_1);
    param_32 = _e308;
    let _e309 = average_1;
    param_33 = _e309;
    let _e310 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_32), (&param_33));
    let _e311 = (*mu_o);
    param_34 = _e311;
    let _e312 = (*r_2);
    param_35 = _e312;
    let _e313 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_34), (&param_35));
    let _e316 = (*mu_i);
    param_36 = _e316;
    let _e317 = (*r_2);
    param_37 = _e317;
    let _e318 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_36), (&param_37));
    let _e322 = average_1;
    multi = (_e310 * ((max((1f - _e313), 0.0000001f) * max((1f - _e318), 0.0000001f)) / max((1f - _e322), 0.0000001f)));
    let _e327 = single;
    let _e328 = multi;
    return ((_e327 + _e328) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e263 = frag_info.ambient_sky[3u];
    return (_e263 > 0.5f);
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_38: f32;
    var param_39: f32;
    var param_40: f32;

    let _e267 = (*roughness_4);
    let _e269 = (*n_dot_v_2);
    param_38 = clamp(_e267, 0f, 1f);
    param_39 = sqrt(clamp((1f - _e269), 0f, 1f));
    param_40 = 1f;
    let _e273 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_38), (&param_39), (&param_40));
    let _e274 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e273, 0f);
    dfg = _e274.xy;
    let _e277 = dfg[0u];
    let _e279 = dfg[1u];
    let _e282 = dfg[1u];
    return vec2<f32>((_e277 - _e279), _e282);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_2: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_41: f32;
    var param_42: f32;
    var ess: f32;

    let _e268 = (*s_2).roughness;
    param_41 = max(_e268, 0.045f);
    let _e271 = (*s_2).n_dot_v;
    param_42 = _e271;
    let _e272 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_41), (&param_42));
    ab = _e272;
    let _e274 = ab[0u];
    let _e276 = ab[1u];
    ess = max((_e274 + _e276), 0.0001f);
    let _e279 = (*f0_);
    let _e280 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e279 * ((1f / _e280) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e263 = frag_info.target_origin[2u];
    return (_e263 > 0.5f);
}

fn F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, f90_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f_2: f32;

    let _e265 = (*v_dot_h);
    f_2 = pow((1f - _e265), 5f);
    let _e268 = (*f0_1);
    let _e269 = (*f90_);
    let _e270 = (*f0_1);
    let _e272 = f_2;
    return (_e268 + ((_e269 - _e270) * _e272));
}

fn V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_l_3: ptr<function, f32>, n_dot_v_3: ptr<function, f32>, b_dot_v: ptr<function, f32>, t_dot_v: ptr<function, f32>, t_dot_l: ptr<function, f32>, b_dot_l: ptr<function, f32>, at: ptr<function, f32>, ab_1: ptr<function, f32>) -> f32 {
    var ggx_v: f32;
    var ggx_l: f32;

    let _e271 = (*n_dot_l_3);
    let _e272 = (*at);
    let _e273 = (*t_dot_v);
    let _e275 = (*ab_1);
    let _e276 = (*b_dot_v);
    let _e278 = (*n_dot_v_3);
    ggx_v = (_e271 * length(vec3<f32>((_e272 * _e273), (_e275 * _e276), _e278)));
    let _e282 = (*n_dot_v_3);
    let _e283 = (*at);
    let _e284 = (*t_dot_l);
    let _e286 = (*ab_1);
    let _e287 = (*b_dot_l);
    let _e289 = (*n_dot_l_3);
    ggx_l = (_e282 * length(vec3<f32>((_e283 * _e284), (_e286 * _e287), _e289)));
    let _e293 = ggx_v;
    let _e294 = ggx_l;
    return clamp((0.5f / max((_e293 + _e294), 0.00001f)), 0f, 1f);
}

fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3: ptr<function, f32>, t_dot_h: ptr<function, f32>, b_dot_h: ptr<function, f32>, at_1: ptr<function, f32>, ab_2: ptr<function, f32>) -> f32 {
    var a2_1: f32;
    var f_3: vec3<f32>;
    var w2_: f32;

    let _e269 = (*at_1);
    let _e270 = (*ab_2);
    a2_1 = (_e269 * _e270);
    let _e272 = (*ab_2);
    let _e273 = (*t_dot_h);
    let _e275 = (*at_1);
    let _e276 = (*b_dot_h);
    let _e278 = a2_1;
    let _e279 = (*n_dot_h_3);
    f_3 = vec3<f32>((_e272 * _e273), (_e275 * _e276), (_e278 * _e279));
    let _e282 = a2_1;
    let _e283 = f_3;
    let _e284 = f_3;
    w2_ = (_e282 / max(dot(_e283, _e284), 0.000000000001f));
    let _e288 = a2_1;
    let _e289 = w2_;
    let _e291 = w2_;
    return (((_e288 * _e289) * _e291) / 3.1415927f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>) -> vec3<f32> {
    var lobe_1: f32;
    var alpha_6: f32;
    var f0_2: vec3<f32>;
    var f90_1: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_2: f32;
    var param_43: f32;
    var param_44: f32;
    var vis_1: f32;
    var param_45: f32;
    var param_46: f32;
    var param_47: f32;
    var at_2: f32;
    var ab_3: f32;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var param_51: f32;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;
    var param_55: f32;
    var param_56: f32;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var param_60: f32;
    var f_4: vec3<f32>;
    var param_61: vec3<f32>;
    var param_62: vec3<f32>;
    var param_63: f32;
    var specular: vec3<f32>;
    var param_64: vec3<f32>;
    var param_65: Surface;
    var diffuse: vec3<f32>;
    var param_66: vec3<f32>;
    var param_67: f32;
    var param_68: f32;
    var param_69: f32;
    var param_70: f32;
    var sheen: vec3<f32>;
    var param_71: f32;
    var param_72: f32;
    var param_73: f32;
    var param_74: f32;
    var param_75: Surface;
    var param_76: LightSample;

    let _e311 = (*s_3).roughness;
    lobe_1 = max(_e311, 0.045f);
    let _e313 = lobe_1;
    let _e314 = lobe_1;
    alpha_6 = (_e313 * _e314);
    let _e316 = g_f0_dielectric;
    let _e318 = (*s_3).albedo;
    let _e320 = (*s_3).metallic;
    f0_2 = mix(_e316, _e318, vec3(_e320));
    let _e323 = g_f90_;
    let _e325 = (*s_3).metallic;
    f90_1 = vec3(mix(_e323, 1f, _e325));
    let _e329 = (*s_3).albedo;
    let _e331 = (*s_3).metallic;
    diffuseColor = (_e329 * (1f - _e331));
    let _e335 = (*light_1).n_dot_h;
    param_43 = _e335;
    let _e336 = alpha_6;
    param_44 = _e336;
    let _e337 = D_GGX_u0028_f1_u003b_f1_u003b((&param_43), (&param_44));
    d_2 = _e337;
    let _e339 = (*s_3).n_dot_v;
    param_45 = _e339;
    let _e341 = (*light_1).n_dot_l;
    param_46 = _e341;
    let _e342 = alpha_6;
    param_47 = _e342;
    let _e343 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47));
    vis_1 = _e343;
    let _e344 = g_aniso;
    if (_e344 > 0f) {
        let _e346 = alpha_6;
        let _e347 = g_aniso;
        let _e348 = g_aniso;
        at_2 = mix(_e346, 1f, (_e347 * _e348));
        let _e351 = alpha_6;
        ab_3 = max(_e351, 0.001f);
        let _e353 = g_aniso_t;
        let _e355 = (*light_1).h;
        let _e357 = g_aniso_b;
        let _e359 = (*light_1).h;
        let _e362 = (*light_1).n_dot_h;
        param_48 = _e362;
        param_49 = dot(_e353, _e355);
        param_50 = dot(_e357, _e359);
        let _e363 = at_2;
        param_51 = _e363;
        let _e364 = ab_3;
        param_52 = _e364;
        let _e365 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_48), (&param_49), (&param_50), (&param_51), (&param_52));
        d_2 = _e365;
        let _e366 = g_aniso_b;
        let _e368 = (*s_3).v;
        let _e370 = g_aniso_t;
        let _e372 = (*s_3).v;
        let _e374 = g_aniso_t;
        let _e376 = (*light_1).l;
        let _e378 = g_aniso_b;
        let _e380 = (*light_1).l;
        let _e383 = (*light_1).n_dot_l;
        param_53 = _e383;
        let _e385 = (*s_3).n_dot_v;
        param_54 = _e385;
        param_55 = dot(_e366, _e368);
        param_56 = dot(_e370, _e372);
        param_57 = dot(_e374, _e376);
        param_58 = dot(_e378, _e380);
        let _e386 = at_2;
        param_59 = _e386;
        let _e387 = ab_3;
        param_60 = _e387;
        let _e388 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56), (&param_57), (&param_58), (&param_59), (&param_60));
        vis_1 = _e388;
    }
    let _e389 = f0_2;
    param_61 = _e389;
    let _e390 = f90_1;
    param_62 = _e390;
    let _e392 = (*light_1).v_dot_h;
    param_63 = _e392;
    let _e393 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
    f_4 = _e393;
    let _e394 = f_4;
    let _e395 = g_irid_fresnel;
    let _e396 = g_iridescence;
    f_4 = mix(_e394, _e395, vec3(_e396));
    let _e399 = d_2;
    let _e400 = vis_1;
    let _e402 = f_4;
    let _e406 = frag_info.material[3u];
    specular = ((_e402 * (_e399 * _e400)) * _e406);
    let _e409 = (*light_1).integrated;
    if (_e409 > 0.5f) {
        let _e413 = (*light_1).ltc[0u];
        let _e414 = f0_2;
        let _e417 = (*light_1).ltc[1u];
        let _e419 = f90_1;
        let _e420 = f0_2;
        let _e424 = (*light_1).ltc[2u];
        let _e430 = frag_info.material[3u];
        let _e433 = (*light_1).n_dot_l;
        specular = (((((_e414 * _e417) + ((_e419 - _e420) * _e424)) * _e413) * _e430) / vec3(max(_e433, 0.000001f)));
    }
    let _e437 = EnergyCompensation_u0028_();
    if _e437 {
        let _e438 = f0_2;
        param_64 = _e438;
        let _e439 = (*s_3);
        param_65 = _e439;
        let _e440 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_64), (&param_65));
        let _e441 = specular;
        specular = (_e441 * _e440);
    }
    let _e443 = diffuseColor;
    let _e444 = f_4;
    diffuse = ((_e443 * (vec3<f32>(1f, 1f, 1f) - _e444)) / vec3(3.1415927f));
    let _e449 = EonDiffuse_u0028_();
    if _e449 {
        let _e451 = (*s_3).n;
        let _e453 = (*light_1).l;
        let _e457 = (*light_1).l;
        let _e459 = (*s_3).v;
        let _e461 = diffuseColor;
        param_66 = _e461;
        let _e463 = (*s_3).roughness;
        param_67 = _e463;
        param_68 = clamp(dot(_e451, _e453), 0.0001f, 1f);
        let _e465 = (*s_3).n_dot_v;
        param_69 = _e465;
        param_70 = dot(_e457, _e459);
        let _e466 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_66), (&param_67), (&param_68), (&param_69), (&param_70));
        let _e467 = f_4;
        diffuse = (_e466 * (vec3<f32>(1f, 1f, 1f) - _e467));
    }
    let _e470 = g_transmission;
    let _e472 = diffuse;
    diffuse = (_e472 * (1f - _e470));
    let _e474 = g_sheen;
    let _e475 = g_sheen_roughness;
    param_71 = _e475;
    let _e477 = (*light_1).n_dot_h;
    param_72 = _e477;
    let _e478 = D_Charlie_u0028_f1_u003b_f1_u003b((&param_71), (&param_72));
    let _e481 = (*s_3).n;
    let _e483 = (*light_1).l;
    let _e487 = (*s_3).n_dot_v;
    param_73 = _e487;
    param_74 = clamp(dot(_e481, _e483), 0f, 1f);
    let _e488 = V_Neubelt_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
    sheen = ((_e474 * _e478) * _e488);
    let _e490 = diffuse;
    let _e491 = specular;
    let _e493 = g_sheen_scale;
    let _e495 = sheen;
    let _e497 = g_coat_through;
    let _e499 = g_coat;
    let _e500 = (*s_3);
    param_75 = _e500;
    let _e501 = (*light_1);
    param_76 = _e501;
    let _e502 = CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_75), (&param_76));
    return ((((((_e490 + _e491) * _e493) + _e495) * _e497) + vec3((_e499 * _e502))) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
    let _e262 = (*i_1);
    if (_e262 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e264 = (*i_1);
    if (_e264 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e266 = (*i_1);
    if (_e266 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e268 = (*i_1);
    if (_e268 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e270 = (*i_1);
    if (_e270 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e272 = (*i_1);
    if (_e272 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e274 = (*i_1);
    if (_e274 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_2: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p_1: vec2<f32>;
    var param_77: i32;

    let _e267 = (*i_2);
    param_77 = _e267;
    let _e268 = PointShadowDiskTap_u0028_i1_u003b((&param_77));
    p_1 = _e268;
    let _e270 = p_1[0u];
    let _e271 = (*ca);
    let _e274 = p_1[1u];
    let _e275 = (*sa);
    let _e279 = p_1[0u];
    let _e280 = (*sa);
    let _e283 = p_1[1u];
    let _e284 = (*ca);
    let _e288 = (*radius);
    return (vec2<f32>(((_e270 * _e271) - (_e274 * _e275)), ((_e279 * _e280) + (_e283 * _e284))) * _e288);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_7: vec2<f32>;
    var atlas: vec2<f32>;

    let _e270 = point_shadow.params[0u];
    inset = _e270;
    let _e271 = (*uv_1);
    let _e272 = (*offset);
    let _e274 = inset;
    let _e275 = inset;
    local_7 = clamp((_e271 + _e272), vec2(_e274), vec2((1f - _e275)));
    let _e280 = local_7;
    let _e281 = (*tile);
    atlas = ((_e280 + _e281) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e286 = point_shadow.params3_[0u];
    if (_e286 > 0.5f) {
        let _e289 = atlas[1u];
        atlas[1u] = (1f - _e289);
    }
    let _e292 = atlas;
    let _e293 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e292, 0f);
    let _e295 = atlas;
    let _e296 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e295, 0f);
    let _e299 = (*range);
    return (min(_e293.x, _e296.x) * _e299);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_78: vec2<f32>;
    var param_79: vec2<f32>;
    var param_80: vec2<f32>;
    var param_81: f32;

    let _e271 = (*uv_2);
    param_78 = _e271;
    let _e272 = (*offset_1);
    param_79 = _e272;
    let _e273 = (*tile_1);
    param_80 = _e273;
    let _e274 = (*range_1);
    param_81 = _e274;
    let _e275 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_78), (&param_79), (&param_80), (&param_81));
    stored = _e275;
    let _e276 = stored;
    let _e277 = (*range_1);
    if (_e276 >= (_e277 * 0.999f)) {
        return 1f;
    }
    let _e280 = (*receiver);
    let _e281 = stored;
    return select(1f, 0f, (_e280 > _e281));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_82: vec2<f32>;
    var param_83: vec2<f32>;
    var param_84: vec2<f32>;
    var param_85: f32;
    var sum: f32;
    var count: f32;
    var i_3: i32;
    var stored_1: f32;
    var param_86: i32;
    var param_87: f32;
    var param_88: f32;
    var param_89: f32;
    var param_90: vec2<f32>;
    var param_91: vec2<f32>;
    var param_92: vec2<f32>;
    var param_93: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e292 = point_shadow.params2_[1u];
    lightRadius = _e292;
    let _e295 = point_shadow.params2_[0u];
    minRadius = _e295;
    let _e298 = point_shadow.params2_[2u];
    maxRadius = _e298;
    let _e299 = lightRadius;
    if (_e299 <= 0f) {
        let _e301 = (*uv_3);
        param_82 = _e301;
        param_83 = vec2<f32>(0f, 0f);
        let _e302 = (*tile_2);
        param_84 = _e302;
        let _e303 = (*range_2);
        param_85 = _e303;
        let _e304 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_82), (&param_83), (&param_84), (&param_85));
        (*blockerOut) = _e304;
        let _e305 = minRadius;
        return _e305;
    }
    sum = 0f;
    count = 0f;
    i_3 = 0i;
    loop {
        let _e306 = i_3;
        if (_e306 < 8i) {
            let _e308 = i_3;
            param_86 = _e308;
            let _e309 = (*ca_1);
            param_87 = _e309;
            let _e310 = (*sa_1);
            param_88 = _e310;
            let _e311 = maxRadius;
            param_89 = _e311;
            let _e312 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_86), (&param_87), (&param_88), (&param_89));
            let _e313 = (*uv_3);
            param_90 = _e313;
            param_91 = _e312;
            let _e314 = (*tile_2);
            param_92 = _e314;
            let _e315 = (*range_2);
            param_93 = _e315;
            let _e316 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_90), (&param_91), (&param_92), (&param_93));
            stored_1 = _e316;
            let _e317 = stored_1;
            let _e318 = (*range_2);
            if (_e317 >= (_e318 * 0.999f)) {
                continue;
            }
            let _e321 = stored_1;
            let _e322 = (*receiver_1);
            if (_e321 >= _e322) {
                continue;
            }
            let _e324 = stored_1;
            let _e325 = sum;
            sum = (_e325 + _e324);
            let _e327 = count;
            count = (_e327 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e329 = i_3;
            i_3 = (_e329 + 1i);
        }
    }
    let _e331 = count;
    if (_e331 < 0.5f) {
        return -1f;
    }
    let _e333 = sum;
    let _e334 = count;
    blocker = max((_e333 / _e334), 0.0001f);
    let _e337 = blocker;
    (*blockerOut) = _e337;
    let _e338 = lightRadius;
    let _e339 = (*receiver_1);
    let _e340 = blocker;
    let _e344 = blocker;
    world = ((_e338 * max((_e339 - _e340), 0f)) / _e344);
    let _e346 = world;
    let _e347 = (*receiver_1);
    let _e349 = (*tanHalf);
    let _e352 = minRadius;
    let _e353 = maxRadius;
    return clamp((_e346 / ((2f * _e347) * _e349)), _e352, _e353);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_8: vec2<f32>;

    let _e263 = (*rows);
    if (_e263 > 0f) {
        let _e266 = gl_FragCoord_1[0u];
        let _e267 = (*rows);
        let _e269 = gl_FragCoord_1[1u];
        local_8 = vec2<f32>(_e266, (_e267 - _e269));
    } else {
        let _e272 = gl_FragCoord_1;
        local_8 = _e272.xy;
    }
    let _e274 = local_8;
    return _e274;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_2: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_94: f32;
    var angle_1: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_95: vec2<f32>;
    var param_96: vec2<f32>;
    var param_97: f32;
    var param_98: f32;
    var param_99: f32;
    var param_100: f32;
    var param_101: f32;
    var param_102: f32;
    var local_9: vec3<f32>;
    var lit: f32;
    var param_103: vec2<f32>;
    var param_104: vec2<f32>;
    var param_105: vec2<f32>;
    var param_106: f32;
    var param_107: f32;
    var i_4: i32;
    var param_108: i32;
    var param_109: f32;
    var param_110: f32;
    var param_111: f32;
    var param_112: vec2<f32>;
    var param_113: vec2<f32>;
    var param_114: vec2<f32>;
    var param_115: f32;
    var param_116: f32;
    var phi_2696_: bool;
    var phi_2757_: bool;

    let _e315 = (*lightIndex);
    let _e319 = point_shadow.slots[_e315][0u];
    slot = i32((_e319 + 0.5f));
    let _e322 = (*lightIndex);
    let _e326 = point_shadow.slots[_e322][0u];
    if (_e326 < 0f) {
        return 1f;
    }
    let _e330 = point_shadow.params[2u];
    strength = _e330;
    let _e331 = strength;
    if (_e331 <= 0f) {
        return 1f;
    }
    let _e333 = slot;
    let _e336 = point_shadow.lights[_e333];
    let _e338 = (*world_1);
    toLight = (_e336.xyz - _e338);
    let _e340 = toLight;
    toLightLength = max(length(_e340), 0.000001f);
    let _e343 = (*normal);
    let _e344 = toLight;
    let _e345 = toLightLength;
    nDotL = max(dot(_e343, (_e344 / vec3(_e345))), 0.15f);
    let _e350 = nDotL;
    let _e351 = nDotL;
    let _e356 = nDotL;
    let _e357 = nDotL;
    slope = min((sqrt(max((1f - (_e350 * _e351)), 0f)) / (_e356 * _e357)), 8f);
    let _e361 = toLightLength;
    let _e363 = (*lightIndex);
    let _e367 = point_shadow.slots[_e363][2u];
    let _e372 = point_shadow.params3_[1u];
    texel = (((2f * _e361) * max(_e367, 0.0001f)) * _e372);
    let _e374 = (*world_1);
    let _e375 = (*normal);
    let _e376 = texel;
    let _e380 = point_shadow.params[3u];
    let _e382 = slope;
    origin = (_e374 + (((_e375 * _e376) * _e380) * (1f + _e382)));
    let _e386 = origin;
    let _e387 = slot;
    let _e390 = point_shadow.lights[_e387];
    toFragment = (_e386 - _e390.xyz);
    let _e393 = toFragment;
    distance_ = length(_e393);
    let _e395 = slot;
    let _e399 = point_shadow.lights[_e395][3u];
    range_3 = max(_e399, 0.0001f);
    let _e401 = distance_;
    let _e402 = range_3;
    if (_e401 >= _e402) {
        return 1f;
    }
    face = 0i;
    let _e404 = (*lightIndex);
    let _e408 = point_shadow.slots[_e404][1u];
    if (_e408 < 0.5f) {
        let _e410 = toFragment;
        a_2 = abs(_e410);
        let _e413 = a_2[0u];
        let _e415 = a_2[1u];
        let _e416 = (_e413 >= _e415);
        phi_2696_ = _e416;
        if _e416 {
            let _e418 = a_2[0u];
            let _e420 = a_2[2u];
            phi_2696_ = (_e418 >= _e420);
        }
        let _e423 = phi_2696_;
        if _e423 {
            let _e425 = toFragment[0u];
            face = select(1i, 0i, (_e425 > 0f));
        } else {
            let _e429 = a_2[1u];
            let _e431 = a_2[2u];
            if (_e429 >= _e431) {
                let _e434 = toFragment[1u];
                face = select(3i, 2i, (_e434 > 0f));
            } else {
                let _e438 = toFragment[2u];
                face = select(5i, 4i, (_e438 > 0f));
            }
        }
    }
    let _e441 = slot;
    let _e443 = face;
    let _e447 = point_shadow.faces[((_e441 * 6i) + _e443)];
    let _e448 = origin;
    clip = (_e447 * vec4<f32>(_e448.x, _e448.y, _e448.z, 1f));
    let _e455 = clip[3u];
    if (_e455 <= 0f) {
        return 1f;
    }
    let _e457 = clip;
    let _e460 = clip[3u];
    ndc = (_e457.xy / vec2(_e460));
    let _e464 = ndc[0u];
    let _e466 = (abs(_e464) > 1f);
    phi_2757_ = _e466;
    if !(_e466) {
        let _e469 = ndc[1u];
        phi_2757_ = (abs(_e469) > 1f);
    }
    let _e473 = phi_2757_;
    if _e473 {
        return 1f;
    }
    let _e475 = ndc[0u];
    let _e479 = ndc[1u];
    uv_4 = vec2<f32>(((_e475 * 0.5f) + 0.5f), (0.5f - (_e479 * 0.5f)));
    let _e483 = face;
    let _e485 = slot;
    tile_3 = vec2<f32>(f32(_e483), f32(_e485));
    let _e488 = distance_;
    let _e491 = point_shadow.params[1u];
    receiver_2 = (_e488 - _e491);
    let _e495 = frag_info.target_origin[0u];
    param_94 = _e495;
    let _e496 = FragCoordFromTop_u0028_f1_u003b((&param_94));
    noise = fract((52.982918f * fract(dot(_e496, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e501 = noise;
    angle_1 = (_e501 * 6.2831855f);
    let _e503 = angle_1;
    ca_2 = cos(_e503);
    let _e505 = angle_1;
    sa_2 = sin(_e505);
    let _e507 = (*lightIndex);
    let _e511 = point_shadow.slots[_e507][2u];
    tanHalf_1 = max(_e511, 0.0001f);
    blocker_1 = -1f;
    let _e513 = uv_4;
    param_95 = _e513;
    let _e514 = tile_3;
    param_96 = _e514;
    let _e515 = range_3;
    param_97 = _e515;
    let _e516 = receiver_2;
    param_98 = _e516;
    let _e517 = ca_2;
    param_99 = _e517;
    let _e518 = sa_2;
    param_100 = _e518;
    let _e519 = tanHalf_1;
    param_101 = _e519;
    let _e520 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_95), (&param_96), (&param_97), (&param_98), (&param_99), (&param_100), (&param_101), (&param_102));
    let _e521 = param_102;
    blocker_1 = _e521;
    radius_1 = _e520;
    let _e524 = point_shadow.params2_[3u];
    if (_e524 > 0.5f) {
        g_debug_surface_on = true;
        let _e526 = radius_1;
        if (_e526 < 0f) {
            local_9 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e528 = radius_1;
            let _e531 = point_shadow.params2_[2u];
            let _e535 = blocker_1;
            let _e536 = range_3;
            local_9 = vec3<f32>(clamp((_e528 / max(_e531, 0.000001f)), 0f, 1f), clamp((_e535 / _e536), 0f, 1f), 0f);
        }
        let _e540 = local_9;
        g_debug_surface = _e540;
    }
    let _e541 = radius_1;
    if (_e541 < 0f) {
        return 1f;
    }
    let _e543 = uv_4;
    param_103 = _e543;
    param_104 = vec2<f32>(0f, 0f);
    let _e544 = tile_3;
    param_105 = _e544;
    let _e545 = range_3;
    param_106 = _e545;
    let _e546 = receiver_2;
    param_107 = _e546;
    let _e547 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
    lit = _e547;
    let _e548 = radius_1;
    if (_e548 > 0f) {
        i_4 = 0i;
        loop {
            let _e550 = i_4;
            if (_e550 < 8i) {
                let _e552 = i_4;
                param_108 = _e552;
                let _e553 = ca_2;
                param_109 = _e553;
                let _e554 = sa_2;
                param_110 = _e554;
                let _e555 = radius_1;
                param_111 = _e555;
                let _e556 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_108), (&param_109), (&param_110), (&param_111));
                let _e557 = uv_4;
                param_112 = _e557;
                param_113 = _e556;
                let _e558 = tile_3;
                param_114 = _e558;
                let _e559 = range_3;
                param_115 = _e559;
                let _e560 = receiver_2;
                param_116 = _e560;
                let _e561 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_112), (&param_113), (&param_114), (&param_115), (&param_116));
                let _e562 = lit;
                lit = (_e562 + _e561);
                continue;
            } else {
                break;
            }
            continuing {
                let _e564 = i_4;
                i_4 = (_e564 + 1i);
            }
        }
        let _e566 = lit;
        lit = (_e566 * 0.11111111f);
    }
    let _e568 = lit;
    let _e569 = strength;
    return mix(1f, _e568, clamp(_e569, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_5: ptr<function, i32>, n_2: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e266 = (*i_5);
    let _e269 = (*n_2);
    r_3 = sqrt(((f32(_e266) + 0.5f) / f32(_e269)));
    let _e273 = (*i_5);
    let _e276 = (*turn);
    theta = ((f32(_e273) * 2.3999631f) + _e276);
    let _e278 = r_3;
    let _e279 = theta;
    let _e281 = theta;
    return (vec2<f32>(cos(_e279), sin(_e281)) * _e278);
}

fn ShadowNoise_u0028_() -> f32 {
    var at_3: vec2<f32>;
    var param_117: f32;

    let _e265 = frag_info.target_origin[0u];
    param_117 = _e265;
    let _e266 = FragCoordFromTop_u0028_f1_u003b((&param_117));
    let _e269 = frag_info.target_origin[3u];
    at_3 = (_e266 + vec2((5.588238f * max(_e269, 0f))));
    let _e274 = at_3;
    return fract((52.982918f * fract(dot(_e274, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_10: f32;

    let _e264 = (*mode_1);
    if (_e264 > 0.5f) {
        let _e266 = (*stored_2);
        local_10 = (1f - _e266);
    } else {
        let _e268 = (*stored_2);
        local_10 = _e268;
    }
    let _e269 = local_10;
    return _e269;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_3: f32;
    var pMax: f32;
    var reduced: f32;

    let _e270 = (*moments)[1u];
    let _e272 = (*moments)[0u];
    let _e274 = (*moments)[0u];
    let _e277 = (*minVariance);
    variance = max((_e270 - (_e272 * _e274)), _e277);
    let _e279 = (*t);
    let _e281 = (*moments)[0u];
    d_3 = (_e279 - _e281);
    let _e283 = variance;
    let _e284 = variance;
    let _e285 = d_3;
    let _e286 = d_3;
    pMax = (_e283 / (_e284 + (_e285 * _e286)));
    let _e290 = pMax;
    let _e291 = (*bleed);
    let _e293 = (*bleed);
    reduced = clamp(((_e290 - _e291) / max((1f - _e293), 0.0001f)), 0f, 1f);
    let _e298 = (*t);
    let _e300 = (*moments)[0u];
    let _e302 = reduced;
    return select(_e302, 1f, (_e298 <= _e300));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_4: f32;

    let _e263 = (*depth);
    d_4 = ((2f * clamp(_e263, 0f, 1f)) - 1f);
    let _e267 = d_4;
    let _e270 = d_4;
    return vec2<f32>(exp((40f * _e267)), -(exp((-5f * _e270))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_118: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_119: vec2<f32>;
    var param_120: f32;
    var param_121: f32;
    var param_122: f32;
    var negative: f32;
    var param_123: vec2<f32>;
    var param_124: f32;
    var param_125: f32;
    var param_126: f32;

    let _e277 = (*depth_1);
    param_118 = _e277;
    let _e278 = EvsmWarp_u0028_f1_u003b((&param_118));
    warped = _e278;
    let _e279 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e279);
    let _e282 = scale[0u];
    let _e284 = scale[0u];
    let _e286 = (*moments_1);
    param_119 = _e286.xy;
    let _e289 = warped[0u];
    param_120 = _e289;
    param_121 = (_e282 * _e284);
    let _e290 = (*bleed_1);
    param_122 = _e290;
    let _e291 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_119), (&param_120), (&param_121), (&param_122));
    positive = _e291;
    let _e293 = scale[1u];
    let _e295 = scale[1u];
    let _e297 = (*moments_1);
    param_123 = _e297.zw;
    let _e300 = warped[1u];
    param_124 = _e300;
    param_125 = (_e293 * _e295);
    let _e301 = (*bleed_1);
    param_126 = _e301;
    let _e302 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_123), (&param_124), (&param_125), (&param_126));
    negative = _e302;
    let _e303 = positive;
    let _e304 = negative;
    return min(_e303, _e304);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e263 = (*depth_2);
    stored_3 = max((1f - _e263), 0.000061035156f);
    let _e266 = stored_3;
    return exp2((floor(log2(_e266)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_11: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var local_13: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_14: f32;
    var local_15: f32;
    var storage_: f32;
    var param_127: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_128: vec4<f32>;
    var param_129: f32;
    var param_130: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_131: f32;
    var param_132: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_6: i32;
    var disc: vec2<f32>;
    var param_133: i32;
    var param_134: i32;
    var param_135: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_136: f32;
    var param_137: f32;
    var gap: f32;
    var radius_2: f32;
    var i_7: i32;
    var disc_1: vec2<f32>;
    var param_138: i32;
    var param_139: i32;
    var param_140: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_141: f32;
    var param_142: f32;
    var phi_3994_: bool;
    var phi_4005_: bool;
    var phi_4166_: bool;
    var phi_4173_: bool;
    var phi_4180_: bool;

    let _e342 = frag_info.shadow_params[3u];
    strength_1 = _e342;
    let _e343 = strength_1;
    if (_e343 <= 0f) {
        return 1f;
    }
    let _e345 = (*lightIndex_1);
    let _e348 = frag_info.frame_params[2u];
    if (_e345 != i32(floor((_e348 + 0.5f)))) {
        return 1f;
    }
    let _e355 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e355 + 0.5f));
    let _e358 = Orthographic_u0028_();
    if _e358 {
        let _e359 = ViewDepth_u0028_();
        local_11 = _e359;
    } else {
        let _e360 = v_world_position_1;
        let _e362 = frag_info.camera_position;
        local_11 = length((_e360 - _e362.xyz));
    }
    let _e366 = local_11;
    viewDistance = _e366;
    cascade = 0i;
    let _e367 = cascadeCount;
    let _e368 = (_e367 > 1i);
    phi_3994_ = _e368;
    if _e368 {
        let _e369 = viewDistance;
        let _e372 = frag_info.shadow_cascades[0u];
        phi_3994_ = (_e369 > _e372);
    }
    let _e375 = phi_3994_;
    if _e375 {
        cascade = 1i;
    }
    let _e376 = cascadeCount;
    let _e377 = (_e376 > 2i);
    phi_4005_ = _e377;
    if _e377 {
        let _e378 = viewDistance;
        let _e381 = frag_info.shadow_cascades[1u];
        phi_4005_ = (_e378 > _e381);
    }
    let _e384 = phi_4005_;
    if _e384 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e385 = attempt;
        if (_e385 < 3i) {
            let _e387 = cascade;
            let _e388 = attempt;
            which = (_e387 + _e388);
            let _e390 = which;
            let _e391 = cascadeCount;
            if (_e390 >= _e391) {
                break;
            }
            let _e393 = which;
            if (_e393 == 0i) {
                let _e396 = frag_info.shadow_matrix;
                local_12 = _e396;
            } else {
                let _e397 = which;
                if (_e397 == 1i) {
                    let _e400 = frag_info.shadow_matrix_far;
                    local_13 = _e400;
                } else {
                    let _e402 = frag_info.shadow_matrix_farthest;
                    local_13 = _e402;
                }
                let _e403 = local_13;
                local_12 = _e403;
            }
            let _e404 = local_12;
            matrix = _e404;
            let _e407 = matrix[0][0u];
            let _e410 = matrix[1][0u];
            let _e413 = matrix[2][0u];
            axisX = vec3<f32>(_e407, _e410, _e413);
            let _e417 = matrix[0][1u];
            let _e420 = matrix[1][1u];
            let _e423 = matrix[2][1u];
            axisY = vec3<f32>(_e417, _e420, _e423);
            let _e425 = axisX;
            rowX = max(length(_e425), 0.000001f);
            let _e428 = axisY;
            rowY = max(length(_e428), 0.000001f);
            let _e433 = frag_info.shadow_cascades[3u];
            let _e435 = rowX;
            texelMetres = ((2f * _e433) / _e435);
            let _e439 = frag_info.shadow_cascades[3u];
            let _e442 = (*s_4).n;
            let _e443 = axisX;
            let _e446 = rowX;
            let _e447 = rowX;
            let _e451 = (*s_4).n;
            let _e452 = axisY;
            let _e455 = rowY;
            let _e456 = rowY;
            reach = ((3f * _e439) * ((abs(dot(_e442, _e443)) / (_e446 * _e447)) + (abs(dot(_e451, _e452)) / (_e455 * _e456))));
            let _e463 = frag_info.shadow_params[2u];
            let _e464 = texelMetres;
            flatOffset = min(_e463, _e464);
            let _e466 = v_world_position_1;
            let _e468 = (*s_4).n;
            let _e469 = flatOffset;
            let _e470 = reach;
            origin_1 = (_e466 + (_e468 * (_e469 + _e470)));
            let _e474 = matrix;
            let _e475 = origin_1;
            lightSpace = (_e474 * vec4<f32>(_e475.x, _e475.y, _e475.z, 1f));
            let _e482 = lightSpace[3u];
            if (_e482 <= 0f) {
                continue;
            }
            let _e484 = lightSpace;
            let _e487 = lightSpace[3u];
            candidate = (_e484.xyz / vec3(_e487));
            let _e491 = candidate[0u];
            let _e495 = candidate[1u];
            inTile = vec2<f32>(((_e491 * 0.5f) + 0.5f), (0.5f - (_e495 * 0.5f)));
            let _e500 = inTile[0u];
            let _e501 = (_e500 < 0f);
            phi_4166_ = _e501;
            if !(_e501) {
                let _e504 = inTile[0u];
                phi_4166_ = (_e504 > 1f);
            }
            let _e507 = phi_4166_;
            phi_4173_ = _e507;
            if !(_e507) {
                let _e510 = inTile[1u];
                phi_4173_ = (_e510 < 0f);
            }
            let _e513 = phi_4173_;
            phi_4180_ = _e513;
            if !(_e513) {
                let _e516 = inTile[1u];
                phi_4180_ = (_e516 > 1f);
            }
            let _e519 = phi_4180_;
            if _e519 {
                continue;
            }
            let _e521 = candidate[2u];
            if (_e521 > 1f) {
                let _e523 = which;
                let _e524 = cascadeCount;
                if (_e523 < (_e524 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e529 = inTile[0u];
            let _e530 = which;
            let _e533 = cascadeCount;
            let _e537 = inTile[1u];
            uv_5 = vec2<f32>(((_e529 + f32(_e530)) / f32(_e533)), _e537);
            let _e539 = candidate;
            projected = _e539;
            let _e540 = which;
            cascade = _e540;
            let _e541 = texelMetres;
            cascadeTexel = _e541;
            let _e544 = matrix[0][2u];
            let _e547 = matrix[1][2u];
            let _e550 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e544, _e547, _e550)), 0.000001f));
            let _e556 = (*s_4).n;
            let _e559 = matrix[0][2u];
            let _e562 = matrix[1][2u];
            let _e565 = matrix[2][2u];
            let _e569 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e556, vec3<f32>(_e559, _e562, _e565))) * _e569), 0.1f, 1f);
            let _e572 = texelMetres;
            let _e573 = cosSlope;
            let _e574 = cosSlope;
            let _e580 = cosSlope;
            let _e582 = cascadeDepth;
            receiverSlope = (((_e572 * sqrt(max((1f - (_e573 * _e574)), 0f))) / _e580) / _e582);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e584 = attempt;
            attempt = (_e584 + 1i);
        }
    }
    let _e586 = found;
    if !(_e586) {
        return 1f;
    }
    let _e588 = cascade;
    if (_e588 == 0i) {
        let _e592 = frag_info.shadow_bias[0u];
        local_14 = _e592;
    } else {
        let _e593 = cascade;
        if (_e593 == 1i) {
            let _e597 = frag_info.shadow_bias[1u];
            local_15 = _e597;
        } else {
            let _e600 = frag_info.shadow_bias[2u];
            local_15 = _e600;
        }
        let _e601 = local_15;
        local_14 = _e601;
    }
    let _e602 = local_14;
    bias = _e602;
    let _e605 = frag_info.shadow_params[1u];
    storage_ = _e605;
    let _e606 = storage_;
    let _e608 = storage_;
    if ((_e606 > 0.5f) && (_e608 < 1.5f)) {
        let _e611 = bias;
        let _e613 = projected[2u];
        param_127 = _e613;
        let _e614 = ShadowStoredStep_u0028_f1_u003b((&param_127));
        bias = max(_e611, _e614);
    }
    let _e618 = frag_info.shadow_params[0u];
    let _e621 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e618, _e621);
    let _e623 = cascade;
    let _e625 = cascadeCount;
    let _e629 = texel_1;
    tileLo = (vec2<f32>((f32(_e623) / f32(_e625)), 0f) + (_e629 * 0.5f));
    let _e632 = cascade;
    let _e635 = cascadeCount;
    let _e639 = texel_1;
    tileHi = (vec2<f32>((f32((_e632 + 1i)) / f32(_e635)), 1f) - (_e639 * 0.5f));
    let _e644 = frag_info.shadow_bias[3u];
    if (_e644 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e646 = y_1;
            if (_e646 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e648 = x_1;
                    if (_e648 <= 1i) {
                        let _e650 = uv_5;
                        let _e651 = x_1;
                        let _e653 = y_1;
                        let _e656 = texel_1;
                        let _e659 = tileLo;
                        let _e660 = tileHi;
                        let _e662 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e650 + (vec2<f32>(f32(_e651), f32(_e653)) * _e656)), _e659, _e660), 0f);
                        let _e663 = stored_4;
                        stored_4 = (_e663 + _e662);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e665 = x_1;
                        x_1 = (_e665 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e667 = y_1;
                y_1 = (_e667 + 1i);
            }
        }
        let _e669 = stored_4;
        stored_4 = (_e669 * 0.11111111f);
        let _e672 = stored_4[1u];
        let _e675 = stored_4[2u];
        let _e678 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e672), (1f - _e675), _e678), vec3(0f), vec3(4f));
        let _e683 = through;
        let _e684 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e683, vec3(clamp(_e684, 0f, 1f)));
    }
    let _e690 = frag_info.ambient_ground[3u];
    softness = _e690;
    lit_1 = 0f;
    let _e691 = softness;
    if (_e691 < 0f) {
        let _e693 = uv_5;
        let _e694 = tileLo;
        let _e695 = tileHi;
        let _e697 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e693, _e694, _e695), 0f);
        moments_2 = _e697;
        let _e699 = projected[2u];
        let _e700 = bias;
        let _e702 = softness;
        let _e706 = moments_2;
        param_128 = _e706;
        param_129 = (_e699 - _e700);
        param_130 = clamp((-(_e702) - 1f), 0f, 0.95f);
        let _e707 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_128), (&param_129), (&param_130));
        lit_1 = _e707;
    } else {
        let _e708 = softness;
        if (_e708 <= 0f) {
            y_2 = -1i;
            loop {
                let _e710 = y_2;
                if (_e710 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e712 = x_2;
                        if (_e712 <= 1i) {
                            let _e714 = uv_5;
                            let _e715 = x_2;
                            let _e717 = y_2;
                            let _e720 = texel_1;
                            let _e723 = tileLo;
                            let _e724 = tileHi;
                            let _e726 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e714 + (vec2<f32>(f32(_e715), f32(_e717)) * _e720)), _e723, _e724), 0f);
                            param_131 = _e726.x;
                            let _e728 = storage_;
                            param_132 = _e728;
                            let _e729 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_131), (&param_132));
                            occluder = _e729;
                            let _e731 = projected[2u];
                            let _e732 = bias;
                            let _e734 = occluder;
                            let _e737 = lit_1;
                            lit_1 = (_e737 + select(1f, 0f, ((_e731 - _e732) > _e734)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e739 = x_2;
                            x_2 = (_e739 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e741 = y_2;
                    y_2 = (_e741 + 1i);
                }
            }
            let _e743 = lit_1;
            lit_1 = (_e743 * 0.11111111f);
        } else {
            let _e745 = softness;
            spread = tan(min(_e745, 0.5f));
            let _e748 = ShadowNoise_u0028_();
            turn_1 = (_e748 * 6.2831855f);
            let _e750 = spread;
            let _e752 = projected[2u];
            let _e754 = cascadeDepth;
            let _e756 = cascadeTexel;
            searchRadius = clamp((((_e750 * _e752) * _e754) / _e756), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_6 = 0i;
            loop {
                let _e759 = i_6;
                if (_e759 < 16i) {
                    let _e761 = i_6;
                    param_133 = _e761;
                    param_134 = 16i;
                    let _e762 = turn_1;
                    param_135 = _e762;
                    let _e763 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_133), (&param_134), (&param_135));
                    disc = _e763;
                    let _e764 = bias;
                    let _e765 = disc;
                    let _e767 = searchRadius;
                    let _e771 = receiverSlope;
                    tapBias = (_e764 + (max(((length(_e765) * _e767) - 1.5f), 0f) * _e771));
                    let _e774 = uv_5;
                    let _e775 = disc;
                    let _e776 = texel_1;
                    let _e778 = searchRadius;
                    let _e781 = tileLo;
                    let _e782 = tileHi;
                    let _e784 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e774 + ((_e775 * _e776) * _e778)), _e781, _e782), 0f);
                    param_136 = _e784.x;
                    let _e786 = storage_;
                    param_137 = _e786;
                    let _e787 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_136), (&param_137));
                    occluder_1 = _e787;
                    let _e789 = projected[2u];
                    let _e790 = tapBias;
                    let _e792 = occluder_1;
                    if ((_e789 - _e790) > _e792) {
                        let _e794 = occluder_1;
                        let _e795 = blockerSum;
                        blockerSum = (_e795 + _e794);
                        let _e797 = blockerCount;
                        blockerCount = (_e797 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e799 = i_6;
                    i_6 = (_e799 + 1i);
                }
            }
            let _e801 = blockerCount;
            if (_e801 <= 0f) {
                return 1f;
            }
            let _e804 = projected[2u];
            let _e805 = blockerSum;
            let _e806 = blockerCount;
            let _e810 = cascadeDepth;
            gap = (max((_e804 - (_e805 / _e806)), 0f) * _e810);
            let _e812 = spread;
            let _e813 = gap;
            let _e815 = cascadeTexel;
            radius_2 = clamp(((_e812 * _e813) / _e815), 1f, 16f);
            i_7 = 0i;
            loop {
                let _e818 = i_7;
                if (_e818 < 16i) {
                    let _e820 = turn_1;
                    let _e822 = i_7;
                    param_138 = _e822;
                    param_139 = 16i;
                    param_140 = (_e820 + 1f);
                    let _e823 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_138), (&param_139), (&param_140));
                    disc_1 = _e823;
                    let _e824 = bias;
                    let _e825 = disc_1;
                    let _e827 = radius_2;
                    let _e831 = receiverSlope;
                    tapBias_1 = (_e824 + (max(((length(_e825) * _e827) - 1.5f), 0f) * _e831));
                    let _e834 = uv_5;
                    let _e835 = disc_1;
                    let _e836 = texel_1;
                    let _e838 = radius_2;
                    let _e841 = tileLo;
                    let _e842 = tileHi;
                    let _e844 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e834 + ((_e835 * _e836) * _e838)), _e841, _e842), 0f);
                    param_141 = _e844.x;
                    let _e846 = storage_;
                    param_142 = _e846;
                    let _e847 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_141), (&param_142));
                    occluder_2 = _e847;
                    let _e849 = projected[2u];
                    let _e850 = tapBias_1;
                    let _e852 = occluder_2;
                    let _e855 = lit_1;
                    lit_1 = (_e855 + select(1f, 0f, ((_e849 - _e850) > _e852)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e857 = i_7;
                    i_7 = (_e857 + 1i);
                }
            }
            let _e859 = lit_1;
            lit_1 = (_e859 * 0.0625f);
        }
    }
    let _e861 = lit_1;
    let _e862 = strength_1;
    return mix(1f, _e861, clamp(_e862, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_143: Surface;
    var param_144: LightSample;
    var param_145: i32;

    let _e267 = (*s_5);
    param_143 = _e267;
    let _e268 = (*light_3);
    param_144 = _e268;
    let _e269 = (*index);
    param_145 = _e269;
    let _e270 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_143), (&param_144), (&param_145));
    return _e270;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e262 = (*index_1);
    return (_e262 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e266 = (*distance_1);
    let _e267 = (*distance_1);
    attenuation = (1f / max((_e266 * _e267), 0.0001f));
    let _e271 = (*range_4);
    if (_e271 > 0f) {
        let _e273 = (*distance_1);
        let _e274 = (*range_4);
        ratio = (_e273 / _e274);
        let _e276 = ratio;
        let _e277 = ratio;
        let _e279 = ratio;
        let _e281 = ratio;
        window = clamp((1f - (((_e276 * _e277) * _e279) * _e281)), 0f, 1f);
        let _e285 = window;
        let _e286 = window;
        let _e288 = attenuation;
        attenuation = (_e288 * (_e285 * _e286));
    }
    let _e290 = attenuation;
    return _e290;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_16: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e278 = (*halfWidth);
    let _e279 = (*halfHeight);
    n_3 = cross(_e278, _e279);
    let _e281 = n_3;
    nLen = length(_e281);
    let _e283 = nLen;
    if (_e283 < 0.000000000001f) {
        let _e285 = (*centre);
        return _e285;
    }
    let _e286 = nLen;
    let _e287 = n_3;
    n_3 = (_e287 / vec3(_e286));
    let _e290 = (*centre);
    let _e291 = (*world_2);
    toPlane = (_e290 - _e291);
    let _e293 = (*mirror);
    let _e294 = n_3;
    denom = dot(_e293, _e294);
    let _e296 = denom;
    if (abs(_e296) < 0.00001f) {
        let _e299 = toPlane;
        let _e300 = n_3;
        let _e301 = toPlane;
        let _e302 = n_3;
        onPlane = (_e299 - (_e300 * dot(_e301, _e302)));
    } else {
        let _e306 = toPlane;
        let _e307 = n_3;
        let _e309 = denom;
        t_1 = (dot(_e306, _e307) / _e309);
        let _e311 = t_1;
        if (_e311 > 0f) {
            let _e313 = (*mirror);
            let _e314 = t_1;
            local_16 = (_e313 * _e314);
        } else {
            let _e316 = toPlane;
            let _e317 = n_3;
            let _e318 = toPlane;
            let _e319 = n_3;
            local_16 = (_e316 - (_e317 * dot(_e318, _e319)));
        }
        let _e323 = local_16;
        onPlane = _e323;
    }
    let _e324 = onPlane;
    let _e325 = toPlane;
    offset_2 = (_e324 - _e325);
    let _e327 = (*halfWidth);
    let _e328 = (*halfWidth);
    wLen2_ = max(dot(_e327, _e328), 0.000000000001f);
    let _e331 = (*halfHeight);
    let _e332 = (*halfHeight);
    hLen2_ = max(dot(_e331, _e332), 0.000000000001f);
    let _e335 = offset_2;
    let _e336 = (*halfWidth);
    let _e338 = wLen2_;
    u = clamp((dot(_e335, _e336) / _e338), -1f, 1f);
    let _e341 = offset_2;
    let _e342 = (*halfHeight);
    let _e344 = hLen2_;
    v_1 = clamp((dot(_e341, _e342) / _e344), -1f, 1f);
    let _e347 = (*centre);
    let _e348 = (*halfWidth);
    let _e349 = u;
    let _e352 = (*halfHeight);
    let _e353 = v_1;
    return ((_e347 + (_e348 * _e349)) + (_e352 * _e353));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_17: f32;

    let _e270 = (*a_3);
    let _e271 = (*a_3);
    ua = (_e270 / vec3(max(length(_e271), 0.000000000001f)));
    let _e276 = (*b_1);
    let _e277 = (*b_1);
    ub = (_e276 / vec3(max(length(_e277), 0.000000000001f)));
    let _e282 = ua;
    let _e283 = ub;
    angle_2 = acos(clamp(dot(_e282, _e283), -1f, 1f));
    let _e287 = ua;
    let _e288 = ub;
    axis_1 = cross(_e287, _e288);
    let _e290 = axis_1;
    len_2 = length(_e290);
    let _e292 = len_2;
    if (_e292 > 0.000001f) {
        let _e294 = angle_2;
        let _e295 = axis_1;
        let _e296 = (*n_4);
        let _e299 = len_2;
        local_17 = ((_e294 * dot(_e295, _e296)) / _e299);
    } else {
        local_17 = 0f;
    }
    let _e301 = local_17;
    return _e301;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_18: i32;
    var ha: f32;
    var hb: f32;
    var d_5: f32;
    var q: vec3<f32>;
    var local_19: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_20: f32;
    var param_146: vec3<f32>;
    var param_147: vec3<f32>;
    var param_148: vec3<f32>;
    var param_149: vec3<f32>;
    var param_150: vec3<f32>;
    var param_151: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e284 = i_8;
        if (_e284 < 4i) {
            let _e286 = i_8;
            let _e288 = (*corners_1)[_e286];
            a_4 = _e288;
            let _e289 = i_8;
            if (_e289 == 3i) {
                local_18 = 0i;
            } else {
                let _e291 = i_8;
                local_18 = (_e291 + 1i);
            }
            let _e293 = local_18;
            let _e295 = (*corners_1)[_e293];
            b_2 = _e295;
            let _e296 = a_4;
            let _e297 = (*n_5);
            ha = dot(_e296, _e297);
            let _e299 = b_2;
            let _e300 = (*n_5);
            hb = dot(_e299, _e300);
            let _e302 = ha;
            let _e303 = hb;
            d_5 = (_e302 - _e303);
            let _e305 = a_4;
            let _e306 = b_2;
            let _e307 = a_4;
            let _e309 = d_5;
            if (abs(_e309) > 0.000000000001f) {
                let _e312 = ha;
                let _e313 = d_5;
                local_19 = (_e312 / _e313);
            } else {
                local_19 = 0f;
            }
            let _e315 = local_19;
            q = (_e305 + ((_e306 - _e307) * _e315));
            let _e318 = ha;
            aAbove = (_e318 > 0f);
            let _e320 = hb;
            bAbove = (_e320 > 0f);
            let _e322 = aAbove;
            let _e323 = bAbove;
            if (_e322 || _e323) {
                let _e325 = aAbove;
                let _e326 = a_4;
                let _e327 = q;
                let _e330 = bAbove;
                let _e331 = b_2;
                let _e332 = q;
                param_146 = select(_e327, _e326, vec3(_e325));
                param_147 = select(_e332, _e331, vec3(_e330));
                let _e335 = (*n_5);
                param_148 = _e335;
                let _e336 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_146), (&param_147), (&param_148));
                local_20 = _e336;
            } else {
                local_20 = 0f;
            }
            let _e337 = local_20;
            let _e338 = total;
            total = (_e338 + _e337);
            let _e340 = aAbove;
            let _e341 = bAbove;
            let _e344 = q;
            let _e345 = exit;
            exit = select(_e345, _e344, vec3((_e340 && !(_e341))));
            let _e348 = aAbove;
            let _e350 = bAbove;
            let _e352 = q;
            let _e353 = entry;
            entry = select(_e353, _e352, vec3((!(_e348) && _e350)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e356 = i_8;
            i_8 = (_e356 + 1i);
        }
    }
    let _e358 = exit;
    param_149 = _e358;
    let _e359 = entry;
    param_150 = _e359;
    let _e360 = (*n_5);
    param_151 = _e360;
    let _e361 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_149), (&param_150), (&param_151));
    let _e362 = total;
    total = (_e362 + _e361);
    let _e364 = total;
    return max((-(_e364) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_21: f32;
    var local_22: f32;
    var local_23: f32;

    let _e267 = (*slot_1);
    let _e268 = (*slot_1);
    lane = (_e267 - ((_e268 / 4i) * 4i));
    let _e272 = lane;
    if (_e272 == 0i) {
        let _e275 = (*four)[0u];
        local_21 = _e275;
    } else {
        let _e276 = lane;
        if (_e276 == 1i) {
            let _e279 = (*four)[1u];
            local_22 = _e279;
        } else {
            let _e280 = lane;
            if (_e280 == 2i) {
                let _e283 = (*four)[2u];
                local_23 = _e283;
            } else {
                let _e285 = (*four)[3u];
                local_23 = _e285;
            }
            let _e286 = local_23;
            local_22 = _e286;
        }
        let _e287 = local_22;
        local_21 = _e287;
    }
    let _e288 = local_21;
    return _e288;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_152: vec4<f32>;
    var param_153: i32;

    let _e264 = (*slot_2);
    let _e268 = light_list_info.scales[(_e264 / 4i)];
    param_152 = _e268;
    let _e269 = (*slot_2);
    param_153 = _e269;
    let _e270 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_152), (&param_153));
    return _e270;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e266 = light_list_info.slot_rows[0i];
    let _e267 = (*row);
    a_5 = abs((_e266 - vec4(_e267)));
    let _e273 = light_list_info.slot_rows[1i];
    let _e274 = (*row);
    b_3 = abs((_e273 - vec4(_e274)));
    let _e279 = a_5[0u];
    let _e281 = a_5[1u];
    let _e284 = a_5[2u];
    let _e286 = a_5[3u];
    let _e290 = b_3[0u];
    let _e292 = b_3[1u];
    let _e295 = b_3[2u];
    let _e297 = b_3[3u];
    return (min(min(min(_e279, _e281), min(_e284, _e286)), min(min(_e290, _e292), min(_e295, _e297))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_154: vec4<f32>;
    var param_155: i32;

    let _e264 = (*slot_3);
    let _e268 = light_list_info.indices[(_e264 / 4i)];
    param_154 = _e268;
    let _e269 = (*slot_3);
    param_155 = _e269;
    let _e270 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_154), (&param_155));
    return _e270;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e263 = (*texel_2);
    let _e267 = light_list_info.list[1u];
    let _e269 = (*row_1);
    let _e273 = light_list_info.list[2u];
    let _e276 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e263 + 0.5f) * _e267), ((_e269 + 0.5f) * _e273)), 0f);
    return _e276;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_156: f32;
    var param_157: f32;
    var param_158: vec4<f32>;
    var param_159: i32;

    let _e271 = g_cluster_offset;
    let _e272 = (*slot_4);
    entry_1 = (_e271 + f32(_e272));
    let _e275 = entry_1;
    row_2 = floor((_e275 / 16f));
    let _e278 = entry_1;
    let _e279 = row_2;
    within = (_e278 - (_e279 * 16f));
    let _e282 = within;
    texel_3 = floor((_e282 / 4f));
    let _e287 = light_list_info.cluster_depth[3u];
    let _e288 = row_2;
    let _e290 = texel_3;
    param_156 = _e290;
    param_157 = (_e287 + _e288);
    let _e291 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_156), (&param_157));
    four_1 = _e291;
    let _e292 = within;
    let _e293 = texel_3;
    let _e298 = four_1;
    param_158 = _e298;
    param_159 = i32(((_e292 - (_e293 * 4f)) + 0.5f));
    let _e299 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_158), (&param_159));
    return _e299;
}

fn Clustered_u0028_() -> bool {
    let _e263 = light_list_info.cluster_grid[3u];
    return (_e263 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_6: ptr<function, Surface>) -> LightSample {
    var light_4: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_24: f32;
    var param_160: i32;
    var param_161: i32;
    var v_2: f32;
    var u_1: f32;
    var local_25: f32;
    var param_162: f32;
    var param_163: i32;
    var type_45: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_26: f32;
    var param_164: array<vec3<f32>, 4>;
    var param_165: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_27: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_166: vec3<f32>;
    var param_167: vec3<f32>;
    var param_168: vec3<f32>;
    var param_169: vec3<f32>;
    var param_170: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_28: vec3<f32>;
    var param_171: vec3<f32>;
    var param_172: vec3<f32>;
    var param_173: f32;
    var param_174: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_175: f32;
    var param_176: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_4.integrated = 0f;
    light_4.ltc = vec3<f32>(0f, 0f, 0f);
    let _e319 = (*index_2);
    if (_e319 < 8i) {
        let _e321 = (*index_2);
        let _e324 = frag_info.light_position[_e321];
        position = _e324;
        let _e325 = (*index_2);
        let _e328 = frag_info.light_color[_e325];
        color_1 = _e328;
        let _e329 = (*index_2);
        let _e332 = frag_info.light_direction[_e329];
        direction = _e332;
        let _e333 = (*index_2);
        let _e336 = frag_info.light_cone[_e333];
        cone = _e336;
    } else {
        let _e337 = (*index_2);
        slot_5 = (_e337 - 8i);
        let _e339 = Clustered_u0028_();
        clustered = _e339;
        let _e340 = clustered;
        if _e340 {
            let _e341 = slot_5;
            param_160 = _e341;
            let _e342 = ClusterRow_u0028_i1_u003b((&param_160));
            local_24 = _e342;
        } else {
            let _e343 = slot_5;
            param_161 = _e343;
            let _e344 = LightListRow_u0028_i1_u003b((&param_161));
            local_24 = _e344;
        }
        let _e345 = local_24;
        listRow = _e345;
        let _e346 = listRow;
        let _e350 = light_list_info.list[2u];
        v_2 = ((_e346 + 0.5f) * _e350);
        let _e354 = light_list_info.list[1u];
        u_1 = _e354;
        let _e355 = u_1;
        let _e357 = v_2;
        let _e359 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e355), _e357), 0f);
        position = _e359;
        let _e360 = u_1;
        let _e362 = v_2;
        let _e364 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e360), _e362), 0f);
        color_1 = _e364;
        let _e365 = u_1;
        let _e367 = v_2;
        let _e369 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e365), _e367), 0f);
        direction = _e369;
        let _e370 = u_1;
        let _e372 = v_2;
        let _e374 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e370), _e372), 0f);
        cone = _e374;
        let _e375 = clustered;
        if _e375 {
            let _e376 = listRow;
            param_162 = _e376;
            let _e377 = InSlots_u0028_f1_u003b((&param_162));
            local_25 = select(1f, 0f, _e377);
        } else {
            let _e379 = slot_5;
            param_163 = _e379;
            let _e380 = LightListScale_u0028_i1_u003b((&param_163));
            local_25 = _e380;
        }
        let _e381 = local_25;
        let _e383 = color_1[3u];
        color_1[3u] = (_e383 * _e381);
    }
    let _e387 = position[3u];
    type_45 = _e387;
    let _e388 = type_45;
    if (_e388 > 15.5f) {
        let _e391 = (*s_6).n;
        light_4.l = _e391;
        let _e394 = (*s_6).n;
        light_4.h = _e394;
        light_4.radiance = vec3<f32>(0f, 0f, 0f);
        light_4.n_dot_l = 0f;
        light_4.n_dot_h = 0f;
        light_4.v_dot_h = 0f;
        let _e400 = light_4;
        return _e400;
    }
    let _e401 = type_45;
    if (_e401 > 2.5f) {
        let _e403 = direction;
        halfWidth_1 = _e403.xyz;
        let _e405 = cone;
        halfHeight_1 = _e405.xyz;
        let _e407 = position;
        let _e409 = v_world_position_1;
        toCentre = (_e407.xyz - _e409);
        let _e411 = toCentre;
        let _e412 = halfWidth_1;
        let _e414 = halfHeight_1;
        corners_2[0i] = ((_e411 - _e412) - _e414);
        let _e417 = toCentre;
        let _e418 = halfWidth_1;
        let _e420 = halfHeight_1;
        corners_2[1i] = ((_e417 + _e418) - _e420);
        let _e423 = toCentre;
        let _e424 = halfWidth_1;
        let _e426 = halfHeight_1;
        corners_2[2i] = ((_e423 + _e424) + _e426);
        let _e429 = toCentre;
        let _e430 = halfWidth_1;
        let _e432 = halfHeight_1;
        corners_2[3i] = ((_e429 - _e430) + _e432);
        let _e435 = toCentre;
        let _e436 = halfWidth_1;
        let _e437 = halfHeight_1;
        behind = (dot(_e435, cross(_e436, _e437)) >= 0f);
        let _e441 = behind;
        if _e441 {
            local_26 = 0f;
        } else {
            let _e442 = corners_2;
            param_164 = _e442;
            let _e444 = (*s_6).n;
            param_165 = _e444;
            let _e445 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_164), (&param_165));
            local_26 = _e445;
        }
        let _e446 = local_26;
        formFactor = _e446;
        let _e447 = halfWidth_1;
        let _e448 = halfHeight_1;
        area = (length(cross(_e447, _e448)) * 4f);
        let _e452 = area;
        if (_e452 > 0.000000001f) {
            let _e454 = area;
            local_27 = (1f / _e454);
        } else {
            local_27 = 0f;
        }
        let _e456 = local_27;
        radiance = _e456;
        let _e457 = toCentre;
        distance_2 = length(_e457);
        let _e460 = direction[3u];
        if (_e460 > 0f) {
            let _e462 = distance_2;
            let _e464 = direction[3u];
            ratio_1 = (_e462 / _e464);
            let _e466 = ratio_1;
            let _e467 = ratio_1;
            let _e469 = ratio_1;
            let _e471 = ratio_1;
            window_1 = clamp((1f - (((_e466 * _e467) * _e469) * _e471)), 0f, 1f);
            let _e475 = window_1;
            let _e476 = window_1;
            let _e478 = radiance;
            radiance = (_e478 * (_e475 * _e476));
        }
        let _e481 = (*s_6).v;
        let _e484 = (*s_6).n;
        mirror_1 = reflect(-(_e481), _e484);
        let _e486 = position;
        param_166 = _e486.xyz;
        let _e488 = halfWidth_1;
        param_167 = _e488;
        let _e489 = halfHeight_1;
        param_168 = _e489;
        let _e490 = v_world_position_1;
        param_169 = _e490;
        let _e491 = mirror_1;
        param_170 = _e491;
        let _e492 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_166), (&param_167), (&param_168), (&param_169), (&param_170));
        representative = _e492;
        let _e493 = representative;
        let _e494 = v_world_position_1;
        toPoint = (_e493 - _e494);
        let _e496 = toPoint;
        pointDistance = length(_e496);
        let _e498 = pointDistance;
        if (_e498 > 0.000001f) {
            let _e500 = toPoint;
            let _e501 = pointDistance;
            local_28 = (_e500 / vec3(_e501));
        } else {
            let _e505 = (*s_6).n;
            local_28 = _e505;
        }
        let _e506 = local_28;
        light_4.l = _e506;
        let _e509 = light_4.l;
        let _e511 = (*s_6).v;
        light_4.h = normalize((_e509 + _e511));
        let _e515 = formFactor;
        light_4.n_dot_l = _e515;
        let _e518 = (*s_6).n;
        let _e520 = light_4.h;
        light_4.n_dot_h = max(dot(_e518, _e520), 0f);
        let _e525 = (*s_6).v;
        let _e527 = light_4.h;
        light_4.v_dot_h = max(dot(_e525, _e527), 0f);
        let _e531 = color_1;
        let _e534 = color_1[3u];
        let _e536 = radiance;
        light_4.radiance = ((_e531.xyz * _e534) * _e536);
        light_4.integrated = 1f;
        let _e541 = (*s_6).n;
        param_171 = _e541;
        let _e543 = (*s_6).v;
        param_172 = _e543;
        let _e545 = (*s_6).roughness;
        param_173 = _e545;
        let _e546 = corners_2;
        param_174 = _e546;
        let _e547 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_171), (&param_172), (&param_173), (&param_174));
        light_4.ltc = _e547;
        let _e549 = corners_2;
        g_rect_corners = _e549;
        let _e550 = light_4;
        return _e550;
    }
    let _e551 = direction;
    aim = normalize(_e551.xyz);
    attenuation_1 = 1f;
    let _e554 = type_45;
    if (_e554 < 0.5f) {
        let _e556 = aim;
        light_4.l = -(_e556);
    } else {
        let _e559 = position;
        let _e561 = v_world_position_1;
        toLight_1 = (_e559.xyz - _e561);
        let _e563 = toLight_1;
        distance_3 = length(_e563);
        let _e565 = distance_3;
        if (_e565 < 0.000001f) {
            let _e568 = (*s_6).n;
            light_4.l = _e568;
            let _e571 = (*s_6).n;
            light_4.h = _e571;
            light_4.radiance = vec3<f32>(0f, 0f, 0f);
            light_4.n_dot_l = 0f;
            light_4.n_dot_h = 0f;
            light_4.v_dot_h = 0f;
            let _e577 = light_4;
            return _e577;
        }
        let _e578 = toLight_1;
        let _e579 = distance_3;
        light_4.l = (_e578 / vec3(_e579));
        let _e583 = distance_3;
        param_175 = _e583;
        let _e585 = direction[3u];
        param_176 = _e585;
        let _e586 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_175), (&param_176));
        attenuation_1 = _e586;
        let _e587 = type_45;
        if (_e587 > 1.5f) {
            let _e589 = aim;
            let _e591 = light_4.l;
            cosAngle = dot(_e589, -(_e591));
            let _e594 = cosAngle;
            let _e596 = cone[1u];
            let _e599 = cone[0u];
            let _e601 = cone[1u];
            ramp = clamp(((_e594 - _e596) / (_e599 - _e601)), 0f, 1f);
            let _e605 = ramp;
            let _e606 = ramp;
            let _e608 = attenuation_1;
            attenuation_1 = (_e608 * (_e605 * _e606));
        }
    }
    let _e611 = light_4.l;
    let _e613 = (*s_6).v;
    light_4.h = normalize((_e611 + _e613));
    let _e618 = (*s_6).n;
    let _e620 = light_4.l;
    light_4.n_dot_l = max(dot(_e618, _e620), 0f);
    let _e625 = (*s_6).n;
    let _e627 = light_4.h;
    light_4.n_dot_h = max(dot(_e625, _e627), 0f);
    let _e632 = (*s_6).v;
    let _e634 = light_4.h;
    light_4.v_dot_h = max(dot(_e632, _e634), 0f);
    let _e638 = color_1;
    let _e641 = color_1[3u];
    let _e643 = attenuation_1;
    light_4.radiance = ((_e638.xyz * _e641) * _e643);
    let _e646 = light_4;
    return _e646;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_29: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_177: f32;
    var param_178: f32;

    let _e276 = light_list_info.cluster_view_projection;
    let _e277 = (*world_3);
    clip_1 = (_e276 * vec4<f32>(_e277.x, _e277.y, _e277.z, 1f));
    let _e283 = clip_1;
    let _e286 = clip_1[3u];
    ndc_1 = (_e283.xy / vec2(max(_e286, 0.000001f)));
    let _e291 = light_list_info.cluster_grid;
    grid = _e291.xyz;
    let _e295 = light_list_info.cluster_depth[0u];
    near_1 = _e295;
    let _e297 = ndc_1[0u];
    let _e301 = grid[0u];
    let _e305 = grid[0u];
    tx = clamp(floor((((_e297 * 0.5f) + 0.5f) * _e301)), 0f, (_e305 - 1f));
    let _e309 = ndc_1[1u];
    let _e313 = grid[1u];
    let _e317 = grid[1u];
    ty = clamp(floor((((_e309 * 0.5f) + 0.5f) * _e313)), 0f, (_e317 - 1f));
    let _e321 = clip_1[3u];
    let _e322 = near_1;
    if (_e321 <= _e322) {
        local_29 = 0f;
    } else {
        let _e325 = clip_1[3u];
        let _e326 = near_1;
        let _e331 = light_list_info.cluster_depth[1u];
        let _e335 = grid[2u];
        local_29 = clamp(floor((log((_e325 / _e326)) * _e331)), 0f, (_e335 - 1f));
    }
    let _e338 = local_29;
    tz = _e338;
    let _e339 = tx;
    let _e340 = ty;
    let _e342 = grid[0u];
    let _e345 = tz;
    let _e347 = grid[0u];
    let _e350 = grid[1u];
    cell = ((_e339 + (_e340 * _e342)) + ((_e345 * _e347) * _e350));
    let _e353 = cell;
    row_3 = floor((_e353 / 4f));
    let _e356 = cell;
    let _e357 = row_3;
    let _e362 = light_list_info.cluster_depth[2u];
    let _e363 = row_3;
    param_177 = (_e356 - (_e357 * 4f));
    param_178 = (_e362 + _e363);
    let _e365 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_177), (&param_178));
    header = _e365;
    let _e367 = header[0u];
    g_cluster_offset = _e367;
    let _e369 = header[1u];
    g_cluster_count = _e369;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_179: vec3<f32>;

    let _e265 = light_list_info.list[0u];
    tail = _e265;
    let _e266 = Clustered_u0028_();
    if _e266 {
        let _e267 = v_world_position_1;
        param_179 = _e267;
        FindCluster_u0028_vf3_u003b((&param_179));
        let _e268 = g_cluster_count;
        tail = _e268;
    }
    let _e271 = frag_info.frame_params[1u];
    let _e275 = tail;
    return (clamp(i32((_e271 + 0.5f)), 0i, 8i) + clamp(i32((_e275 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_5: LightSample;
    var param_180: i32;
    var param_181: Surface;
    var visibility: f32;
    var param_182: i32;
    var local_30: f32;
    var param_183: Surface;
    var param_184: LightSample;
    var param_185: i32;
    var param_186: vec3<f32>;
    var param_187: vec3<f32>;
    var param_188: i32;
    var param_189: Surface;
    var param_190: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e279 = LightCount_u0028_();
    count_1 = _e279;
    i_9 = 0i;
    loop {
        let _e280 = i_9;
        if (_e280 < 32i) {
            let _e282 = i_9;
            let _e283 = count_1;
            if (_e282 >= _e283) {
                break;
            }
            let _e285 = i_9;
            param_180 = _e285;
            let _e286 = (*s_7);
            param_181 = _e286;
            let _e287 = 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((&param_180), (&param_181));
            light_5 = _e287;
            let _e289 = light_5.n_dot_l;
            if (_e289 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e291 = i_9;
            param_182 = _e291;
            let _e292 = LightHasShadow_u0028_i1_u003b((&param_182));
            if _e292 {
                let _e293 = (*s_7);
                param_183 = _e293;
                let _e294 = light_5;
                param_184 = _e294;
                let _e295 = i_9;
                param_185 = _e295;
                let _e296 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_183), (&param_184), (&param_185));
                let _e297 = v_world_position_1;
                param_186 = _e297;
                let _e299 = (*s_7).n;
                param_187 = _e299;
                let _e300 = i_9;
                param_188 = _e300;
                let _e301 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_186), (&param_187), (&param_188));
                local_30 = (_e296 * _e301);
            } else {
                local_30 = 1f;
            }
            let _e303 = local_30;
            visibility = _e303;
            let _e304 = visibility;
            if (_e304 <= 0f) {
                continue;
            }
            let _e306 = (*s_7);
            param_189 = _e306;
            let _e307 = light_5;
            param_190 = _e307;
            let _e308 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_189), (&param_190));
            let _e310 = light_5.radiance;
            let _e313 = light_5.n_dot_l;
            let _e315 = visibility;
            let _e317 = light_transmittance;
            let _e319 = total_1;
            total_1 = (_e319 + ((((_e308 * _e310) * _e313) * _e315) * _e317));
            continue;
        } else {
            break;
        }
        continuing {
            let _e321 = i_9;
            i_9 = (_e321 + 1i);
        }
    }
    let _e323 = total_1;
    return _e323;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e262 = v_lightmap_uv_1;
    let _e263 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e262);
    texel_4 = _e263;
    let _e264 = texel_4;
    let _e267 = texel_4[3u];
    return ((_e264.xyz * _e267) * 8f);
}

fn SceneColorLevel_u0028_vf2_u003b_i1_u003b(uv_6: ptr<function, vec2<f32>>, level: ptr<function, i32>) -> vec3<f32> {
    var rect: vec4<f32>;
    var inset_1: vec2<f32>;
    var at_4: vec2<f32>;

    let _e266 = (*level);
    let _e269 = layer_info.scene_levels[_e266];
    rect = _e269;
    let _e271 = layer_info.scene_color;
    inset_1 = (_e271.yz * 0.5f);
    let _e274 = rect;
    let _e276 = (*uv_6);
    let _e277 = rect;
    let _e280 = inset_1;
    let _e281 = rect;
    let _e283 = inset_1;
    let _e285 = inset_1;
    at_4 = (_e274.xy + clamp((_e276 * _e277.zw), _e280, max((_e281.zw - _e283), _e285)));
    let _e289 = at_4;
    let _e290 = textureSampleLevel(scene_color_texture_tex, scene_color_texture_smp, _e289, 0f);
    return _e290.xyz;
}

fn SceneColorAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod: ptr<function, f32>) -> vec3<f32> {
    var clip_2: vec4<f32>;
    var ndc_2: vec2<f32>;
    var view: vec2<f32>;
    var uv_7: vec2<f32>;
    var top: f32;
    var level_1: f32;
    var lower: f32;
    var near_2: vec3<f32>;
    var param_191: vec2<f32>;
    var param_192: i32;
    var far_1: vec3<f32>;
    var param_193: vec2<f32>;
    var param_194: i32;

    let _e277 = layer_info.scene_view_projection;
    let _e278 = (*world_4);
    clip_2 = (_e277 * vec4<f32>(_e278.x, _e278.y, _e278.z, 1f));
    let _e284 = clip_2;
    let _e287 = clip_2[3u];
    ndc_2 = (_e284.xy / vec2(max(_e287, 0.000001f)));
    let _e292 = ndc_2[0u];
    let _e296 = ndc_2[1u];
    view = clamp(vec2<f32>(((_e292 * 0.5f) + 0.5f), (0.5f - (_e296 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
    let _e302 = layer_info.scene_viewport;
    let _e304 = view;
    let _e306 = layer_info.scene_viewport;
    uv_7 = (_e302.xy + (_e304 * _e306.zw));
    let _e312 = layer_info.scene_color[0u];
    top = (_e312 - 1f);
    let _e314 = (*lod);
    let _e315 = top;
    level_1 = clamp(_e314, 0f, _e315);
    let _e317 = level_1;
    lower = floor(_e317);
    let _e319 = lower;
    let _e321 = uv_7;
    param_191 = _e321;
    param_192 = i32(_e319);
    let _e322 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_191), (&param_192));
    near_2 = _e322;
    let _e323 = lower;
    let _e325 = top;
    let _e328 = uv_7;
    param_193 = _e328;
    param_194 = i32(min((_e323 + 1f), _e325));
    let _e329 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_193), (&param_194));
    far_1 = _e329;
    let _e330 = near_2;
    let _e331 = far_1;
    let _e332 = level_1;
    let _e333 = lower;
    return mix(_e330, _e331, vec3((_e332 - _e333)));
}

fn IorInfinite_u0028_() -> bool {
    let _e263 = layer_info.coat[2u];
    return (_e263 == 0f);
}

fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
    var local_31: f32;

    let _e263 = IorInfinite_u0028_();
    if _e263 {
        local_31 = 0f;
    } else {
        let _e264 = (*ior);
        let _e269 = layer_info.transmission[3u];
        local_31 = (((_e264 - 1f) * 0.025f) * _e269);
    }
    let _e271 = local_31;
    return _e271;
}

fn RefractionIor_u0028_() -> f32 {
    var local_32: f32;

    let _e262 = IorInfinite_u0028_();
    if _e262 {
        local_32 = 10000f;
    } else {
        let _e265 = layer_info.coat[2u];
        local_32 = max(_e265, 1f);
    }
    let _e267 = local_32;
    return _e267;
}

fn SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) -> vec3<f32> {
    var ior_1: f32;
    var spread_1: f32;
    var param_195: f32;
    var width: f32;
    var lod_1: f32;
    var thin: bool;
    var red: vec3<f32>;
    var local_33: vec3<f32>;
    var green: vec3<f32>;
    var local_34: vec3<f32>;
    var blue: vec3<f32>;
    var local_35: vec3<f32>;
    var param_196: vec3<f32>;
    var param_197: f32;
    var param_198: vec3<f32>;
    var param_199: f32;
    var param_200: vec3<f32>;
    var param_201: f32;

    let _e280 = RefractionIor_u0028_();
    ior_1 = _e280;
    let _e281 = ior_1;
    param_195 = _e281;
    let _e282 = DispersionSpread_u0028_f1_u003b((&param_195));
    spread_1 = _e282;
    let _e286 = layer_info.scene_levels[0i][2u];
    let _e289 = layer_info.scene_color[1u];
    width = (_e286 / max(_e289, 0.000000001f));
    let _e292 = width;
    let _e296 = (*s_8).roughness;
    let _e298 = ior_1;
    lod_1 = ((log2(max(_e292, 1f)) * _e296) * clamp(((_e298 * 2f) - 2f), 0f, 1f));
    let _e303 = g_thickness;
    thin = (_e303 <= 0f);
    let _e305 = thin;
    if _e305 {
        let _e307 = (*s_8).v;
        local_33 = -(_e307);
    } else {
        let _e310 = (*s_8).v;
        let _e313 = (*s_8).n;
        let _e314 = ior_1;
        let _e315 = spread_1;
        local_33 = refract(-(_e310), _e313, (1f / max((_e314 - _e315), 1f)));
    }
    let _e320 = local_33;
    red = _e320;
    let _e321 = thin;
    if _e321 {
        let _e323 = (*s_8).v;
        local_34 = -(_e323);
    } else {
        let _e326 = (*s_8).v;
        let _e329 = (*s_8).n;
        let _e330 = ior_1;
        local_34 = refract(-(_e326), _e329, (1f / _e330));
    }
    let _e333 = local_34;
    green = _e333;
    let _e334 = thin;
    if _e334 {
        let _e336 = (*s_8).v;
        local_35 = -(_e336);
    } else {
        let _e339 = (*s_8).v;
        let _e342 = (*s_8).n;
        let _e343 = ior_1;
        let _e344 = spread_1;
        local_35 = refract(-(_e339), _e342, (1f / (_e343 + _e344)));
    }
    let _e348 = local_35;
    blue = _e348;
    let _e349 = v_world_position_1;
    let _e350 = red;
    let _e351 = g_thickness;
    param_196 = (_e349 + (_e350 * _e351));
    let _e354 = lod_1;
    param_197 = _e354;
    let _e355 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_196), (&param_197));
    let _e357 = v_world_position_1;
    let _e358 = green;
    let _e359 = g_thickness;
    param_198 = (_e357 + (_e358 * _e359));
    let _e362 = lod_1;
    param_199 = _e362;
    let _e363 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_198), (&param_199));
    let _e365 = v_world_position_1;
    let _e366 = blue;
    let _e367 = g_thickness;
    param_200 = (_e365 + (_e366 * _e367));
    let _e370 = lod_1;
    param_201 = _e370;
    let _e371 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_200), (&param_201));
    return vec3<f32>(_e355.x, _e363.y, _e371.z);
}

fn TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b(s_9: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
    var ior_2: f32;
    var spread_2: f32;
    var param_202: f32;
    var lod_2: f32;
    var thin_1: bool;
    var red_1: vec3<f32>;
    var local_36: vec3<f32>;
    var green_1: vec3<f32>;
    var local_37: vec3<f32>;
    var blue_1: vec3<f32>;
    var local_38: vec3<f32>;

    let _e274 = RefractionIor_u0028_();
    ior_2 = _e274;
    let _e275 = ior_2;
    param_202 = _e275;
    let _e276 = DispersionSpread_u0028_f1_u003b((&param_202));
    spread_2 = _e276;
    let _e278 = (*s_9).roughness;
    let _e279 = ior_2;
    let _e284 = (*levels);
    lod_2 = ((_e278 * clamp(((_e279 * 2f) - 2f), 0f, 1f)) * _e284);
    let _e286 = g_thickness;
    thin_1 = (_e286 <= 0f);
    let _e288 = thin_1;
    if _e288 {
        let _e290 = (*s_9).v;
        local_36 = -(_e290);
    } else {
        let _e293 = (*s_9).v;
        let _e296 = (*s_9).n;
        let _e297 = ior_2;
        let _e298 = spread_2;
        local_36 = refract(-(_e293), _e296, (1f / max((_e297 - _e298), 1f)));
    }
    let _e303 = local_36;
    red_1 = _e303;
    let _e304 = thin_1;
    if _e304 {
        let _e306 = (*s_9).v;
        local_37 = -(_e306);
    } else {
        let _e309 = (*s_9).v;
        let _e312 = (*s_9).n;
        let _e313 = ior_2;
        local_37 = refract(-(_e309), _e312, (1f / _e313));
    }
    let _e316 = local_37;
    green_1 = _e316;
    let _e317 = thin_1;
    if _e317 {
        let _e319 = (*s_9).v;
        local_38 = -(_e319);
    } else {
        let _e322 = (*s_9).v;
        let _e325 = (*s_9).n;
        let _e326 = ior_2;
        let _e327 = spread_2;
        local_38 = refract(-(_e322), _e325, (1f / (_e326 + _e327)));
    }
    let _e331 = local_38;
    blue_1 = _e331;
    let _e332 = red_1;
    let _e333 = lod_2;
    let _e334 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e332, _e333);
    let _e336 = green_1;
    let _e337 = lod_2;
    let _e338 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e336, _e337);
    let _e340 = blue_1;
    let _e341 = lod_2;
    let _e342 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e340, _e341);
    return vec3<f32>(_e334.x, _e338.y, _e342.z);
}

fn SceneColorBound_u0028_() -> bool {
    let _e263 = layer_info.scene_color[0u];
    return (_e263 > 0f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_39: f32;

    let _e264 = frag_info.material2_[2u];
    local_39 = floor((_e264 * 0.5f));
    let _e267 = local_39;
    return _e267;
}

fn IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) -> f32 {
    var target_: f32;
    var local_40: f32;
    var local_41: f32;

    let _e265 = OcclusionTarget_u0028_();
    target_ = _e265;
    let _e266 = target_;
    let _e268 = target_;
    if ((_e266 > 0.5f) && (_e268 < 1.5f)) {
        local_40 = 1f;
    } else {
        let _e272 = (*s_10).occlusion;
        local_40 = _e272;
    }
    let _e273 = local_40;
    local_41 = _e273;
    let _e274 = local_41;
    return _e274;
}

fn DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) -> f32 {
    var local_42: f32;
    var local_43: f32;

    let _e264 = OcclusionTarget_u0028_();
    if (_e264 > 1.5f) {
        local_42 = 1f;
    } else {
        let _e267 = (*s_11).occlusion;
        local_42 = _e267;
    }
    let _e268 = local_42;
    local_43 = _e268;
    let _e269 = local_43;
    return _e269;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_203: f32;
    var param_204: f32;
    var param_205: f32;
    var param_206: vec3<f32>;
    var param_207: f32;

    let _e270 = (*mu_1);
    param_203 = _e270;
    let _e271 = (*r_4);
    param_204 = _e271;
    let _e272 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_203), (&param_204));
    e_1 = _e272;
    let _e273 = (*rho_2);
    let _e274 = e_1;
    let _e276 = (*r_4);
    param_205 = _e276;
    let _e277 = FonAverage_u0028_f1_u003b((&param_205));
    let _e278 = (*rho_2);
    param_206 = _e278;
    param_207 = _e277;
    let _e279 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_206), (&param_207));
    let _e280 = e_1;
    return ((_e273 * _e274) + (_e279 * (1f - _e280)));
}

fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shift: ptr<function, vec3<f32>>) -> vec3<f32> {
    var phase: f32;
    var val: vec3<f32>;
    var pos: vec3<f32>;
    var variance_1: vec3<f32>;
    var xyz: vec3<f32>;

    let _e268 = (*opd);
    phase = ((6.2831855f * _e268) * 0.000000001f);
    val = vec3<f32>(0.00000000000054856f, 0.00000000000044201f, 0.00000000000052481f);
    pos = vec3<f32>(1681000f, 1795300f, 2208400f);
    variance_1 = vec3<f32>(4327800000f, 9304600000f, 6612100000f);
    let _e271 = val;
    let _e272 = variance_1;
    let _e276 = pos;
    let _e277 = phase;
    let _e279 = (*shift);
    let _e283 = phase;
    let _e284 = phase;
    let _e287 = variance_1;
    xyz = (((_e271 * sqrt((_e272 * 6.2831855f))) * cos(((_e276 * _e277) + _e279))) * exp((_e287 * -((_e283 * _e284)))));
    let _e291 = phase;
    let _e294 = (*shift)[0u];
    let _e298 = phase;
    let _e300 = phase;
    let _e305 = xyz[0u];
    xyz[0u] = (_e305 + ((0.00000001644083f * cos(((2239900f * _e291) + _e294))) * exp(((-4528200000f * _e298) * _e300))));
    let _e308 = xyz;
    xyz = (_e308 / vec3(0.00000010685f));
    let _e311 = xyz;
    return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e311);
}

fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<function, f32>, cos1_: ptr<function, f32>, thickness: ptr<function, f32>, base: ptr<function, vec3<f32>>) -> vec3<f32> {
    var eta2_: f32;
    var sin2Sq: f32;
    var cos2Sq: f32;
    var cos2_: f32;
    var r0_: f32;
    var r12_: f32;
    var t121_: f32;
    var phi12_: f32;
    var phi21_: f32;
    var sqrtBase: vec3<f32>;
    var baseIor: vec3<f32>;
    var r1_: vec3<f32>;
    var r23_: vec3<f32>;
    var phi23_: vec3<f32>;
    var opd_1: f32;
    var phi: vec3<f32>;
    var r123_: vec3<f32>;
    var rootR123_: vec3<f32>;
    var rs: vec3<f32>;
    var total_2: vec3<f32>;
    var cm: vec3<f32>;
    var m_1: i32;
    var param_208: f32;
    var param_209: vec3<f32>;
    var local_44: vec3<f32>;

    let _e290 = (*film);
    let _e291 = (*thickness);
    eta2_ = mix(1f, _e290, smoothstep(0f, 0.03f, _e291));
    let _e294 = (*cos1_);
    let _e295 = (*cos1_);
    let _e298 = eta2_;
    let _e299 = eta2_;
    sin2Sq = ((1f - (_e294 * _e295)) / (_e298 * _e299));
    let _e302 = sin2Sq;
    cos2Sq = (1f - _e302);
    let _e304 = cos2Sq;
    cos2_ = sqrt(max(_e304, 0f));
    let _e307 = eta2_;
    let _e309 = eta2_;
    r0_ = ((_e307 - 1f) / (_e309 + 1f));
    let _e312 = r0_;
    let _e313 = r0_;
    let _e315 = r0_;
    let _e316 = r0_;
    let _e319 = (*cos1_);
    r12_ = ((_e312 * _e313) + ((1f - (_e315 * _e316)) * pow((1f - _e319), 5f)));
    let _e324 = r12_;
    t121_ = (1f - _e324);
    let _e326 = eta2_;
    phi12_ = select(0f, 3.1415927f, (_e326 < 1f));
    let _e329 = phi12_;
    phi21_ = (3.1415927f - _e329);
    let _e331 = (*base);
    sqrtBase = sqrt(clamp(_e331, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
    let _e334 = sqrtBase;
    let _e336 = sqrtBase;
    baseIor = ((vec3<f32>(1f, 1f, 1f) + _e334) / (vec3<f32>(1f, 1f, 1f) - _e336));
    let _e339 = baseIor;
    let _e340 = eta2_;
    let _e343 = baseIor;
    let _e344 = eta2_;
    r1_ = ((_e339 - vec3(_e340)) / (_e343 + vec3(_e344)));
    let _e348 = r1_;
    let _e349 = r1_;
    r1_ = (_e349 * _e348);
    let _e351 = r1_;
    let _e352 = r1_;
    let _e354 = cos2_;
    r23_ = (_e351 + ((vec3<f32>(1f, 1f, 1f) - _e352) * pow((1f - _e354), 5f)));
    let _e360 = baseIor[0u];
    let _e361 = eta2_;
    let _e365 = baseIor[1u];
    let _e366 = eta2_;
    let _e370 = baseIor[2u];
    let _e371 = eta2_;
    phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e360 < _e361)), select(0f, 3.1415927f, (_e365 < _e366)), select(0f, 3.1415927f, (_e370 < _e371)));
    let _e375 = eta2_;
    let _e377 = (*thickness);
    let _e379 = cos2_;
    opd_1 = (((2f * _e375) * _e377) * _e379);
    let _e381 = phi21_;
    let _e383 = phi23_;
    phi = (vec3(_e381) + _e383);
    let _e385 = r12_;
    let _e386 = r23_;
    r123_ = clamp((_e386 * _e385), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
    let _e389 = r123_;
    rootR123_ = sqrt(_e389);
    let _e391 = t121_;
    let _e392 = t121_;
    let _e394 = r23_;
    let _e396 = r123_;
    rs = ((_e394 * (_e391 * _e392)) / (vec3<f32>(1f, 1f, 1f) - _e396));
    let _e399 = r12_;
    let _e401 = rs;
    total_2 = (vec3(_e399) + _e401);
    let _e403 = rs;
    let _e404 = t121_;
    cm = (_e403 - vec3(_e404));
    m_1 = 1i;
    loop {
        let _e407 = m_1;
        if (_e407 <= 2i) {
            let _e409 = rootR123_;
            let _e410 = cm;
            cm = (_e410 * _e409);
            let _e412 = cm;
            let _e414 = m_1;
            let _e416 = opd_1;
            let _e418 = m_1;
            let _e420 = phi;
            param_208 = (f32(_e414) * _e416);
            param_209 = (_e420 * f32(_e418));
            let _e422 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((&param_208), (&param_209));
            let _e424 = total_2;
            total_2 = (_e424 + ((_e412 * 2f) * _e422));
            continue;
        } else {
            break;
        }
        continuing {
            let _e426 = m_1;
            m_1 = (_e426 + 1i);
        }
    }
    let _e428 = cos2Sq;
    if (_e428 < 0f) {
        local_44 = vec3<f32>(1f, 1f, 1f);
    } else {
        let _e430 = total_2;
        local_44 = max(_e430, vec3<f32>(0f, 0f, 0f));
    }
    let _e432 = local_44;
    return _e432;
}

fn ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
    var f0_3: vec3<f32>;
    var param_210: f32;
    var param_211: f32;
    var param_212: f32;
    var param_213: vec3<f32>;

    let _e267 = g_f0_dielectric;
    let _e269 = (*s_12).albedo;
    let _e271 = (*s_12).metallic;
    f0_3 = mix(_e267, _e269, vec3(clamp(_e271, 0f, 1f)));
    let _e277 = layer_info.iridescence[1u];
    param_210 = _e277;
    let _e279 = (*s_12).n_dot_v;
    param_211 = _e279;
    let _e282 = layer_info.iridescence[2u];
    param_212 = _e282;
    let _e283 = f0_3;
    param_213 = _e283;
    let _e284 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((&param_210), (&param_211), (&param_212), (&param_213));
    g_irid_fresnel = _e284;
    return;
}

fn ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var param_214: f32;
    var param_215: f32;
    var param_216: f32;
    var t_2: vec3<f32>;
    var usable: bool;
    var local_45: vec3<f32>;
    var b_4: vec3<f32>;
    var turn_2: vec2<f32>;
    var along_1: vec3<f32>;
    var local_46: f32;
    var local_47: vec3<f32>;
    var phi_4975_: bool;

    let _e274 = (*s_13).n_dot_v;
    let _e278 = g_sheen_roughness;
    param_214 = _e278;
    param_215 = sqrt(clamp((1f - _e274), 0f, 1f));
    param_216 = 1f;
    let _e279 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_214), (&param_215), (&param_216));
    let _e280 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e279, 0f);
    g_sheen_albedo = _e280.z;
    let _e283 = g_sheen[0u];
    let _e285 = g_sheen[1u];
    let _e288 = g_sheen[2u];
    let _e290 = g_sheen_albedo;
    g_sheen_scale = (1f - (max(max(_e283, _e285), _e288) * _e290));
    let _e293 = v_tangent_1;
    let _e296 = (*s_13).n;
    let _e298 = (*s_13).n;
    let _e299 = v_tangent_1;
    t_2 = (_e293.xyz - (_e296 * dot(_e298, _e299.xyz)));
    let _e304 = t_2;
    let _e305 = t_2;
    usable = (dot(_e304, _e305) > 0.000000000001f);
    let _e308 = usable;
    if _e308 {
        let _e309 = t_2;
        local_45 = normalize(_e309);
    } else {
        local_45 = vec3<f32>(1f, 0f, 0f);
    }
    let _e311 = local_45;
    t_2 = _e311;
    let _e313 = (*s_13).n;
    let _e314 = t_2;
    let _e317 = v_tangent_1[3u];
    b_4 = (cross(_e313, _e314) * _e317);
    let _e319 = gl_FrontFacing_1;
    if !(_e319) {
        let _e321 = t_2;
        t_2 = -(_e321);
    }
    let _e324 = layer_info.anisotropy;
    turn_2 = _e324.yz;
    let _e326 = t_2;
    let _e328 = turn_2[0u];
    let _e330 = b_4;
    let _e332 = turn_2[1u];
    along_1 = ((_e326 * _e328) + (_e330 * _e332));
    let _e335 = usable;
    phi_4975_ = _e335;
    if _e335 {
        let _e336 = along_1;
        let _e337 = along_1;
        phi_4975_ = (dot(_e336, _e337) > 0.000000000001f);
    }
    let _e341 = phi_4975_;
    if _e341 {
        let _e344 = layer_info.anisotropy[0u];
        local_46 = clamp(_e344, 0f, 1f);
    } else {
        local_46 = 0f;
    }
    let _e346 = local_46;
    g_aniso = _e346;
    let _e347 = g_aniso;
    if (_e347 > 0f) {
        let _e349 = along_1;
        local_47 = normalize(_e349);
    } else {
        let _e351 = t_2;
        local_47 = _e351;
    }
    let _e352 = local_47;
    g_aniso_t = _e352;
    let _e354 = (*s_13).n;
    let _e355 = g_aniso_t;
    g_aniso_b = cross(_e354, _e355);
    return;
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e263 = frag_info.target_origin[1u];
    return _e263;
}

fn MapUv_u0028_i1_u003b(slot_6: ptr<function, i32>) -> vec2<f32> {
    var uvw: vec3<f32>;

    let _e263 = v_texcoord_1;
    uvw = vec3<f32>(_e263.x, _e263.y, 1f);
    let _e267 = (*slot_6);
    let _e271 = layer_info.uv_transform[(_e267 * 2i)];
    let _e273 = uvw;
    let _e275 = (*slot_6);
    let _e280 = layer_info.uv_transform[((_e275 * 2i) + 1i)];
    let _e282 = uvw;
    return vec2<f32>(dot(_e271.xyz, _e273), dot(_e280.xyz, _e282));
}

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_14: ptr<function, Surface>) {
    var orm: vec3<f32>;
    var param_217: i32;

    param_217 = 1i;
    let _e264 = MapUv_u0028_i1_u003b((&param_217));
    let _e265 = MaterialLodBias_u0028_();
    let _e266 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e264, _e265);
    orm = _e266.xyz;
    let _e269 = (*s_14).metallic;
    let _e271 = orm[2u];
    (*s_14).metallic = clamp((_e269 * _e271), 0f, 1f);
    let _e276 = (*s_14).roughness;
    let _e278 = orm[1u];
    (*s_14).roughness = clamp((_e276 * _e278), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e262 = (*srgb);
    let _e265 = (*srgb);
    let _e270 = (*srgb);
    return mix((_e262 / vec3(12.92f)), pow(((_e265 + 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), _e270));
}

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_15: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_218: i32;
    var param_219: vec3<f32>;

    param_218 = 4i;
    let _e265 = MapUv_u0028_i1_u003b((&param_218));
    let _e266 = MaterialLodBias_u0028_();
    let _e267 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e265, _e266);
    param_219 = _e267.xyz;
    let _e269 = SrgbToLinear_u0028_vf3_u003b((&param_219));
    emissive = _e269;
    let _e270 = emissive;
    let _e272 = frag_info.emissive;
    let _e277 = frag_info.material2_[3u];
    (*s_15).emissive = ((_e270 * _e272.xyz) * _e277);
    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_16: ptr<function, Surface>) {
    var occlusion: f32;
    var param_220: i32;
    var strength_2: f32;

    param_220 = 3i;
    let _e265 = MapUv_u0028_i1_u003b((&param_220));
    let _e266 = MaterialLodBias_u0028_();
    let _e267 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e265, _e266);
    occlusion = _e267.x;
    let _e271 = frag_info.material2_[2u];
    let _e272 = OcclusionTarget_u0028_();
    strength_2 = (_e271 - (2f * _e272));
    let _e275 = occlusion;
    let _e276 = strength_2;
    (*s_16).occlusion = mix(1f, _e275, clamp(_e276, 0f, 1f));
    return;
}

fn MapMatrix_u0028_i1_u003b(slot_7: ptr<function, i32>) -> vec4<f32> {
    var u_2: vec4<f32>;
    var v_3: vec4<f32>;

    let _e264 = (*slot_7);
    let _e268 = layer_info.uv_transform[(_e264 * 2i)];
    u_2 = _e268;
    let _e269 = (*slot_7);
    let _e274 = layer_info.uv_transform[((_e269 * 2i) + 1i)];
    v_3 = _e274;
    let _e276 = u_2[0u];
    let _e278 = u_2[1u];
    let _e280 = v_3[0u];
    let _e282 = v_3[1u];
    return vec4<f32>(_e276, _e278, _e280, _e282);
}

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_17: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var param_221: i32;
    var t_3: vec3<f32>;
    var b_5: vec3<f32>;
    var m_2: vec4<f32>;
    var param_222: i32;
    var det: f32;
    var flip: f32;
    var front: vec3<f32>;
    var local_48: vec3<f32>;
    var turned: vec3<f32>;
    var turns: bool;
    var local_49: vec3<f32>;
    var local_50: vec3<f32>;
    var sampled: vec3<f32>;
    var phi_3641_: bool;
    var phi_3648_: bool;
    var phi_3655_: bool;
    var phi_3662_: bool;

    param_221 = 2i;
    let _e277 = MapUv_u0028_i1_u003b((&param_221));
    let _e278 = MaterialLodBias_u0028_();
    let _e279 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e277, _e278);
    sampledTexel = _e279;
    let _e280 = v_tangent_1;
    t_3 = _e280.xyz;
    let _e282 = t_3;
    let _e284 = (*s_17).n;
    let _e286 = (*s_17).n;
    let _e287 = t_3;
    t_3 = (_e282 - (_e284 * dot(_e286, _e287)));
    let _e291 = t_3;
    let _e292 = t_3;
    if (dot(_e291, _e292) < 0.000000000001f) {
        return;
    }
    let _e295 = t_3;
    t_3 = normalize(_e295);
    let _e298 = (*s_17).n;
    let _e299 = t_3;
    let _e302 = v_tangent_1[3u];
    b_5 = (cross(_e298, _e299) * _e302);
    param_222 = 2i;
    let _e304 = MapMatrix_u0028_i1_u003b((&param_222));
    m_2 = _e304;
    let _e306 = m_2[0u];
    let _e308 = m_2[3u];
    let _e311 = m_2[1u];
    let _e313 = m_2[2u];
    det = ((_e306 * _e308) - (_e311 * _e313));
    let _e316 = det;
    flip = select(1f, -1f, (_e316 < 0f));
    let _e319 = gl_FrontFacing_1;
    if _e319 {
        let _e320 = b_5;
        local_48 = _e320;
    } else {
        let _e321 = b_5;
        local_48 = -(_e321);
    }
    let _e323 = local_48;
    front = _e323;
    let _e324 = t_3;
    let _e326 = m_2[3u];
    let _e328 = front;
    let _e330 = m_2[2u];
    let _e333 = flip;
    turned = (((_e324 * _e326) + (_e328 * _e330)) * _e333);
    let _e336 = m_2[1u];
    let _e337 = (_e336 != 0f);
    phi_3641_ = _e337;
    if !(_e337) {
        let _e340 = m_2[2u];
        phi_3641_ = (_e340 != 0f);
    }
    let _e343 = phi_3641_;
    phi_3648_ = _e343;
    if !(_e343) {
        let _e346 = m_2[0u];
        phi_3648_ = (_e346 < 0f);
    }
    let _e349 = phi_3648_;
    phi_3655_ = _e349;
    if !(_e349) {
        let _e352 = m_2[3u];
        phi_3655_ = (_e352 < 0f);
    }
    let _e355 = phi_3655_;
    phi_3662_ = _e355;
    if _e355 {
        let _e356 = turned;
        let _e357 = turned;
        phi_3662_ = (dot(_e356, _e357) > 0.000000000001f);
    }
    let _e361 = phi_3662_;
    turns = _e361;
    let _e362 = turns;
    if _e362 {
        let _e363 = turned;
        local_49 = normalize(_e363);
    } else {
        let _e365 = t_3;
        local_49 = _e365;
    }
    let _e366 = local_49;
    t_3 = _e366;
    let _e367 = turns;
    if _e367 {
        let _e369 = (*s_17).n;
        let _e370 = t_3;
        let _e373 = v_tangent_1[3u];
        let _e375 = flip;
        local_50 = ((cross(_e369, _e370) * _e373) * _e375);
    } else {
        let _e377 = b_5;
        local_50 = _e377;
    }
    let _e378 = local_50;
    b_5 = _e378;
    let _e379 = gl_FrontFacing_1;
    if !(_e379) {
        let _e381 = t_3;
        t_3 = -(_e381);
    }
    let _e383 = sampledTexel;
    sampled = ((_e383.xyz * 2f) - vec3(1f));
    let _e390 = frag_info.emissive[3u];
    if (_e390 > 0.5f) {
        let _e392 = sampled;
        let _e394 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e392.xy, _e394.xy)), 0f));
    }
    let _e403 = frag_info.material2_[1u];
    let _e404 = sampled;
    let _e406 = (_e404.xy * _e403);
    sampled[0u] = _e406.x;
    sampled[1u] = _e406.y;
    let _e411 = t_3;
    let _e413 = sampled[0u];
    let _e415 = b_5;
    let _e417 = sampled[1u];
    let _e421 = (*s_17).n;
    let _e423 = sampled[2u];
    (*s_17).n = normalize((((_e411 * _e413) + (_e415 * _e417)) + (_e421 * _e423)));
    let _e429 = (*s_17).n;
    let _e431 = (*s_17).v;
    (*s_17).n_dot_v = max(dot(_e429, _e431), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e262 = (*texel_5);
    let _e266 = irradiance_info.atlas;
    let _e269 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e262 + vec2(0.5f)) * _e266.xy), 0f);
    return _e269;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_8: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_5: vec2<f32>;
    var low: vec2<f32>;
    var f_5: vec2<f32>;
    var a_6: vec4<f32>;
    var param_223: vec2<f32>;
    var b_6: vec4<f32>;
    var param_224: vec2<f32>;
    var c: vec4<f32>;
    var param_225: vec2<f32>;
    var d_6: vec4<f32>;
    var param_226: vec2<f32>;

    let _e275 = (*uv_8);
    let _e276 = (*interior);
    at_5 = ((vec2(1f) + (_e275 * _e276)) - vec2(0.5f));
    let _e282 = at_5;
    low = floor(_e282);
    let _e284 = at_5;
    let _e285 = low;
    f_5 = (_e284 - _e285);
    let _e287 = (*corner);
    let _e288 = low;
    param_223 = (_e287 + _e288);
    let _e290 = AtlasTexel_u0028_vf2_u003b((&param_223));
    a_6 = _e290;
    let _e291 = (*corner);
    let _e292 = low;
    param_224 = ((_e291 + _e292) + vec2<f32>(1f, 0f));
    let _e295 = AtlasTexel_u0028_vf2_u003b((&param_224));
    b_6 = _e295;
    let _e296 = (*corner);
    let _e297 = low;
    param_225 = ((_e296 + _e297) + vec2<f32>(0f, 1f));
    let _e300 = AtlasTexel_u0028_vf2_u003b((&param_225));
    c = _e300;
    let _e301 = (*corner);
    let _e302 = low;
    param_226 = ((_e301 + _e302) + vec2<f32>(1f, 1f));
    let _e305 = AtlasTexel_u0028_vf2_u003b((&param_226));
    d_6 = _e305;
    let _e306 = a_6;
    let _e307 = b_6;
    let _e309 = f_5[0u];
    let _e312 = c;
    let _e313 = d_6;
    let _e315 = f_5[0u];
    let _e319 = f_5[1u];
    return mix(mix(_e306, _e307, vec4(_e309)), mix(_e312, _e313, vec4(_e315)), vec4(_e319));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e266 = (*direction_1)[0u];
    let _e269 = (*direction_1)[1u];
    let _e273 = (*direction_1)[2u];
    sum_1 = ((abs(_e266) + abs(_e269)) + abs(_e273));
    let _e276 = sum_1;
    if (_e276 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e278 = (*direction_1);
    let _e279 = sum_1;
    n_6 = (_e278 / vec3(_e279));
    let _e282 = n_6;
    xy = _e282.xy;
    let _e285 = n_6[2u];
    if (_e285 < 0f) {
        let _e288 = n_6[1u];
        let _e292 = n_6[0u];
        let _e297 = n_6[0u];
        let _e301 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e288)) * select(-1f, 1f, (_e292 >= 0f))), ((1f - abs(_e297)) * select(-1f, 1f, (_e301 >= 0f))));
    }
    let _e306 = xy;
    return ((_e306 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base_1: vec3<f32>;
    var f_6: vec3<f32>;
    var total_3: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_227: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_228: vec3<f32>;
    var param_229: vec2<f32>;
    var param_230: f32;
    var param_231: vec2<f32>;
    var chebyshev: f32;
    var variance_2: f32;
    var difference: f32;
    var param_232: vec3<f32>;
    var param_233: vec2<f32>;
    var param_234: f32;
    var param_235: vec2<f32>;
    var local_51: vec3<f32>;

    let _e308 = irradiance_info.origin;
    origin_2 = _e308.xyz;
    let _e311 = irradiance_info.spacing;
    spacing = _e311.xyz;
    let _e314 = irradiance_info.counts;
    counts = _e314.xyz;
    let _e318 = irradiance_info.tiles[0u];
    irradianceTile = _e318;
    let _e321 = irradiance_info.tiles[1u];
    depthTile = _e321;
    let _e324 = irradiance_info.tiles[2u];
    columns = _e324;
    let _e327 = irradiance_info.tiles[3u];
    momentsTop = _e327;
    let _e328 = (*normal_1);
    unit = normalize(_e328);
    let _e330 = (*world_5);
    let _e331 = unit;
    let _e334 = irradiance_info.spacing[3u];
    let _e337 = (*view_1);
    let _e340 = irradiance_info.counts[3u];
    biased = ((_e330 + (_e331 * _e334)) + (_e337 * _e340));
    let _e343 = biased;
    let _e344 = origin_2;
    let _e346 = spacing;
    grid_1 = ((_e343 - _e344) / _e346);
    let _e348 = grid_1;
    let _e350 = counts;
    base_1 = clamp(floor(_e348), vec3<f32>(0f, 0f, 0f), (_e350 - vec3(2f)));
    let _e354 = grid_1;
    let _e355 = base_1;
    f_6 = clamp((_e354 - _e355), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_3 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e358 = corner_1;
        if (_e358 < 8i) {
            let _e360 = corner_1;
            let _e363 = corner_1;
            let _e368 = corner_1;
            offset_3 = vec3<f32>(f32((_e360 & 1i)), f32(((_e363 >> bitcast<u32>(1i)) & 1i)), f32(((_e368 >> bitcast<u32>(2i)) & 1i)));
            let _e374 = base_1;
            let _e375 = offset_3;
            cell_1 = (_e374 + _e375);
            let _e378 = cell_1[2u];
            let _e380 = counts[1u];
            let _e383 = cell_1[1u];
            let _e386 = counts[0u];
            let _e389 = cell_1[0u];
            probe = ((((_e378 * _e380) + _e383) * _e386) + _e389);
            let _e391 = probe;
            let _e392 = columns;
            let _e397 = probe;
            let _e398 = columns;
            tile_4 = vec2<f32>((_e391 - (floor((_e391 / _e392)) * _e392)), floor((_e397 / _e398)));
            let _e402 = tile_4;
            let _e403 = irradianceTile;
            irradianceCorner = (_e402 * (_e403 + 2f));
            let _e407 = tile_4[0u];
            let _e408 = depthTile;
            let _e411 = momentsTop;
            let _e413 = tile_4[1u];
            let _e414 = depthTile;
            momentCorner = vec2<f32>((_e407 * (_e408 + 2f)), (_e411 + (_e413 * (_e414 + 2f))));
            let _e419 = irradianceCorner;
            param_227 = (_e419 + vec2(1f));
            let _e422 = AtlasTexel_u0028_vf2_u003b((&param_227));
            if (_e422.w < 0.5f) {
                continue;
            }
            let _e425 = f_6;
            let _e427 = f_6;
            let _e428 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e425), _e427, _e428);
            let _e431 = trilinear[0u];
            let _e433 = trilinear[1u];
            let _e436 = trilinear[2u];
            weight_2 = max(((_e431 * _e433) * _e436), 0.001f);
            let _e439 = origin_2;
            let _e440 = spacing;
            let _e441 = cell_1;
            probePosition = (_e439 + (_e440 * _e441));
            let _e444 = probePosition;
            let _e445 = biased;
            toProbe = (_e444 - _e445);
            let _e447 = toProbe;
            distance_4 = length(_e447);
            let _e449 = distance_4;
            if (_e449 > 0.000001f) {
                let _e451 = toProbe;
                let _e452 = distance_4;
                direction_2 = (_e451 / vec3(_e452));
                let _e455 = unit;
                let _e456 = probePosition;
                let _e457 = (*world_5);
                facing = ((dot(_e455, normalize((_e456 - _e457))) * 0.5f) + 0.5f);
                let _e463 = facing;
                let _e464 = facing;
                probeWeight = ((_e463 * _e464) + 0.2f);
                let _e467 = direction_2;
                param_228 = -(_e467);
                let _e469 = ProbeOctahedral_u0028_vf3_u003b((&param_228));
                let _e470 = momentCorner;
                param_229 = _e470;
                let _e471 = depthTile;
                param_230 = _e471;
                param_231 = _e469;
                let _e472 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_229), (&param_230), (&param_231));
                moments_3 = _e472.xy;
                chebyshev = 1f;
                let _e474 = distance_4;
                let _e476 = moments_3[0u];
                if (_e474 > _e476) {
                    let _e479 = moments_3[1u];
                    let _e481 = moments_3[0u];
                    let _e483 = moments_3[0u];
                    variance_2 = max((_e479 - (_e481 * _e483)), 0.000001f);
                    let _e487 = distance_4;
                    let _e489 = moments_3[0u];
                    difference = (_e487 - _e489);
                    let _e491 = variance_2;
                    let _e492 = variance_2;
                    let _e493 = difference;
                    let _e494 = difference;
                    chebyshev = (_e491 / (_e492 + (_e493 * _e494)));
                    let _e498 = chebyshev;
                    let _e499 = chebyshev;
                    let _e501 = chebyshev;
                    chebyshev = ((_e498 * _e499) * _e501);
                }
                let _e503 = probeWeight;
                let _e504 = chebyshev;
                probeWeight = max((_e503 * max(_e504, 0.05f)), 0.000001f);
                let _e508 = probeWeight;
                if (_e508 < 0.2f) {
                    let _e510 = probeWeight;
                    let _e511 = probeWeight;
                    let _e514 = probeWeight;
                    probeWeight = (_e514 * ((_e510 * _e511) * 25f));
                }
                let _e516 = probeWeight;
                let _e517 = weight_2;
                weight_2 = (_e517 * _e516);
            }
            let _e519 = unit;
            param_232 = _e519;
            let _e520 = ProbeOctahedral_u0028_vf3_u003b((&param_232));
            let _e521 = irradianceCorner;
            param_233 = _e521;
            let _e522 = irradianceTile;
            param_234 = _e522;
            param_235 = _e520;
            let _e523 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_233), (&param_234), (&param_235));
            let _e525 = weight_2;
            let _e527 = total_3;
            total_3 = (_e527 + (_e523.xyz * _e525));
            let _e529 = weight_2;
            let _e530 = weights;
            weights = (_e530 + _e529);
            continue;
        } else {
            break;
        }
        continuing {
            let _e532 = corner_1;
            corner_1 = (_e532 + 1i);
        }
    }
    let _e534 = weights;
    if (_e534 > 0f) {
        let _e536 = total_3;
        let _e537 = weights;
        local_51 = (_e536 / vec3(_e537));
    } else {
        local_51 = vec3<f32>(0f, 0f, 0f);
    }
    let _e540 = local_51;
    return _e540;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e263 = irradiance_info.origin[3u];
    return (_e263 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_18: ptr<function, Surface>) {
    var param_236: vec3<f32>;
    var param_237: vec3<f32>;
    var param_238: vec3<f32>;
    var param_239: Surface;
    var param_240: Surface;
    var param_241: Surface;

    let _e268 = IrradianceEnabled_u0028_();
    if _e268 {
        let _e269 = v_world_position_1;
        param_236 = _e269;
        let _e271 = (*s_18).n;
        param_237 = _e271;
        let _e273 = (*s_18).v;
        param_238 = _e273;
        let _e274 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_236), (&param_237), (&param_238));
        let _e277 = frag_info.material[2u];
        (*s_18).ambient = (_e274 * _e277);
    }
    let _e280 = (*s_18);
    param_239 = _e280;
    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((&param_239));
    let _e281 = param_239;
    (*s_18) = _e281;
    let _e282 = (*s_18);
    param_240 = _e282;
    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((&param_240));
    let _e283 = param_240;
    (*s_18) = _e283;
    let _e284 = (*s_18);
    param_241 = _e284;
    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((&param_241));
    let _e285 = param_241;
    (*s_18) = _e285;
    return;
}

fn ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_19: ptr<function, Surface>) {
    var coatTexel: vec4<f32>;
    var sheenTexel: vec4<f32>;
    var param_242: vec3<f32>;
    var ior_3: f32;
    var r_5: f32;
    var local_52: f32;
    var bent: vec3<f32>;
    var distance_5: f32;
    var local_53: vec3<f32>;
    var fc: f32;

    let _e272 = v_texcoord_1;
    let _e273 = MaterialLodBias_u0028_();
    let _e274 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e272, _e273);
    coatTexel = _e274;
    let _e275 = v_texcoord_1;
    let _e276 = MaterialLodBias_u0028_();
    let _e277 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e275, _e276);
    sheenTexel = _e277;
    let _e279 = layer_info.sheen;
    let _e281 = sheenTexel;
    param_242 = _e281.xyz;
    let _e283 = SrgbToLinear_u0028_vf3_u003b((&param_242));
    g_sheen = (_e279.xyz * _e283);
    let _e287 = layer_info.sheen[3u];
    let _e289 = sheenTexel[3u];
    g_sheen_roughness = clamp((_e287 * _e289), 0.07f, 1f);
    let _e294 = layer_info.coat[2u];
    ior_3 = max(_e294, 1f);
    let _e296 = IorInfinite_u0028_();
    if _e296 {
        local_52 = 1f;
    } else {
        let _e297 = ior_3;
        let _e299 = ior_3;
        local_52 = ((_e297 - 1f) / (_e299 + 1f));
    }
    let _e302 = local_52;
    r_5 = _e302;
    let _e303 = r_5;
    let _e304 = r_5;
    let _e308 = layer_info.specular;
    let _e314 = layer_info.specular[3u];
    g_f0_dielectric = (min((vec3((_e303 * _e304)) * _e308.xyz), vec3<f32>(1f, 1f, 1f)) * _e314);
    let _e318 = layer_info.specular[3u];
    g_f90_ = _e318;
    let _e321 = layer_info.coat[0u];
    let _e323 = coatTexel[0u];
    g_coat = clamp((_e321 * _e323), 0f, 1f);
    let _e328 = layer_info.coat[1u];
    let _e330 = coatTexel[1u];
    g_coat_roughness = clamp((_e328 * _e330), 0.02f, 1f);
    let _e335 = layer_info.transmission[0u];
    let _e337 = coatTexel[2u];
    g_transmission = clamp((_e335 * _e337), 0f, 1f);
    let _e342 = layer_info.transmission[1u];
    let _e344 = coatTexel[3u];
    g_thickness = max((_e342 * _e344), 0f);
    let _e349 = layer_info.attenuation[3u];
    let _e351 = g_thickness;
    if ((_e349 > 0.5f) && (_e351 > 0f)) {
        let _e355 = (*s_19).v;
        let _e358 = (*s_19).n;
        let _e359 = RefractionIor_u0028_();
        bent = refract(-(_e355), _e358, (1f / _e359));
        let _e362 = g_thickness;
        let _e364 = (*s_19).n;
        let _e365 = bent;
        let _e370 = g_thickness;
        g_thickness = max((_e362 * max(-(dot(_e364, _e365)), 0f)), (0.0001f * _e370));
    }
    let _e375 = layer_info.transmission[2u];
    distance_5 = _e375;
    let _e376 = distance_5;
    if (_e376 > 0f) {
        let _e379 = layer_info.attenuation;
        let _e382 = g_thickness;
        let _e383 = distance_5;
        local_53 = pow(max(_e379.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e382 / _e383)));
    } else {
        local_53 = vec3<f32>(1f, 1f, 1f);
    }
    let _e387 = local_53;
    g_transmittance = _e387;
    let _e390 = layer_info.iridescence[0u];
    g_iridescence = clamp(_e390, 0f, 1f);
    let _e393 = (*s_19).n;
    g_coat_n = _e393;
    let _e395 = (*s_19).n;
    let _e397 = (*s_19).v;
    g_coat_n_dot_v = max(dot(_e395, _e397), 0.0001f);
    let _e400 = g_coat_n_dot_v;
    fc = (0.04f + (0.96f * pow((1f - _e400), 5f)));
    let _e405 = g_coat;
    let _e406 = fc;
    g_coat_through = (1f - (_e405 * _e406));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_54: vec3<f32>;

    let _e262 = Orthographic_u0028_();
    if _e262 {
        let _e264 = fog_info.forward;
        local_54 = -(_e264.xyz);
    } else {
        let _e268 = fog_info.eye;
        let _e270 = v_world_position_1;
        local_54 = normalize((_e268.xyz - _e270));
    }
    let _e273 = local_54;
    return _e273;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var param_243: i32;
    var s_20: Surface;
    var param_244: vec3<f32>;
    var param_245: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    param_243 = 0i;
    let _e268 = MapUv_u0028_i1_u003b((&param_243));
    let _e269 = MaterialLodBias_u0028_();
    let _e270 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e268, _e269);
    texel_6 = _e270;
    let _e271 = texel_6;
    param_244 = _e271.xyz;
    let _e273 = SrgbToLinear_u0028_vf3_u003b((&param_244));
    let _e275 = frag_info.base_color;
    param_245 = _e275.xyz;
    let _e277 = SrgbToLinear_u0028_vf3_u003b((&param_245));
    let _e279 = v_color_1;
    s_20.albedo = ((_e273 * _e277) * _e279.xyz);
    let _e284 = texel_6[3u];
    let _e287 = frag_info.base_color[3u];
    let _e290 = v_color_1[3u];
    s_20.alpha = ((_e284 * _e287) * _e290);
    let _e294 = s_20.albedo;
    g_albedo = _e294;
    let _e297 = frag_info.material2_[0u];
    cutoff = _e297;
    let _e298 = cutoff;
    if (_e298 > 1f) {
        let _e300 = cutoff;
        edge = (_e300 - 1f);
        let _e303 = s_20.alpha;
        let _e304 = edge;
        let _e307 = s_20.alpha;
        let _e308 = fwidth(_e307);
        s_20.alpha = clamp((((_e303 - _e304) / max(_e308, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e314 = cutoff;
        if (_e314 >= 0f) {
            s_20.alpha = 1f;
        }
    }
    let _e317 = cutoff;
    let _e319 = cutoff;
    g_premultiply = ((_e317 < 0f) && (_e319 > -0.75f));
    let _e322 = v_normal_1;
    s_20.n = normalize(_e322);
    let _e325 = gl_FrontFacing_1;
    if !(_e325) {
        let _e328 = s_20.n;
        s_20.n = -(_e328);
    }
    let _e331 = TowardsEye_u0028_();
    s_20.v = _e331;
    let _e334 = s_20.n;
    let _e336 = s_20.v;
    s_20.n_dot_v = max(dot(_e334, _e336), 0.0001f);
    let _e342 = frag_info.material[0u];
    s_20.metallic = clamp(_e342, 0f, 1f);
    let _e347 = frag_info.material[1u];
    s_20.roughness = clamp(_e347, 0.02f, 1f);
    let _e351 = frag_info.ambient_ground;
    let _e354 = frag_info.ambient_sky;
    let _e358 = s_20.n[1u];
    let _e365 = frag_info.material[2u];
    s_20.ambient = (mix(_e351.xyz, _e354.xyz, vec3(((_e358 * 0.5f) + 0.5f))) * _e365);
    let _e370 = frag_info.frame_params[0u];
    s_20.exposure = max(_e370, 0f);
    s_20.occlusion = 1f;
    s_20.emissive = vec3<f32>(0f, 0f, 0f);
    let _e375 = s_20;
    return _e375;
}

fn main_1() {
    var s_21: Surface;
    var param_246: Surface;
    var param_247: Surface;
    var param_248: Surface;
    var param_249: Surface;
    var param_250: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_251: vec3<f32>;
    var param_252: f32;
    var param_253: f32;
    var directOcclusion: f32;
    var param_254: Surface;
    var indirectOcclusion: f32;
    var param_255: Surface;
    var ambient: vec3<f32>;
    var levels_1: f32;
    var coatAmbient: vec3<f32>;
    var sheenIncoming: vec3<f32>;
    var f0_4: vec3<f32>;
    var f90_2: f32;
    var bent_1: vec3<f32>;
    var across: vec3<f32>;
    var anisoN: vec3<f32>;
    var bend: f32;
    var bend4_: f32;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_4: vec2<f32>;
    var param_256: f32;
    var param_257: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var reflects: vec3<f32>;
    var through_1: vec3<f32>;
    var local_55: vec3<f32>;
    var param_258: Surface;
    var param_259: f32;
    var coatPrefiltered: vec3<f32>;
    var coatAb: vec2<f32>;
    var param_260: f32;
    var param_261: f32;
    var sceneAb: vec2<f32>;
    var param_262: f32;
    var param_263: f32;
    var sceneReflects: vec3<f32>;
    var passes: vec3<f32>;
    var param_264: Surface;
    var sheenAmbient: vec3<f32>;
    var lit_2: vec3<f32>;
    var param_265: Surface;
    var param_266: vec3<f32>;
    var param_267: f32;
    var param_268: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    g_f0_dielectric = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_f90_ = 1f;
    g_coat = 0f;
    g_coat_roughness = 0.02f;
    g_coat_n = vec3<f32>(0f, 0f, 1f);
    g_coat_n_dot_v = 1f;
    g_coat_through = 1f;
    g_sheen = vec3<f32>(0f, 0f, 0f);
    g_sheen_roughness = 0.07f;
    g_sheen_albedo = 0f;
    g_sheen_scale = 1f;
    g_aniso = 0f;
    g_aniso_t = vec3<f32>(1f, 0f, 0f);
    g_aniso_b = vec3<f32>(0f, 1f, 0f);
    g_transmission = 0f;
    g_thickness = 0f;
    g_transmittance = vec3<f32>(1f, 1f, 1f);
    g_iridescence = 0f;
    g_irid_fresnel = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_pane = false;
    let _e319 = ReadSurface_u0028_();
    s_21 = _e319;
    let _e320 = s_21;
    param_246 = _e320;
    ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_246));
    let _e321 = s_21;
    param_247 = _e321;
    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((&param_247));
    let _e322 = param_247;
    s_21 = _e322;
    let _e323 = s_21;
    param_248 = _e323;
    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((&param_248));
    let _e324 = param_248;
    s_21 = _e324;
    let _e325 = s_21;
    param_249 = _e325;
    ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_249));
    let _e326 = s_21;
    param_250 = _e326;
    ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_250));
    let _e328 = s_21.metallic;
    metallic = clamp(_e328, 0f, 1f);
    let _e331 = s_21.albedo;
    let _e332 = metallic;
    diffuseColor_1 = (_e331 * (1f - _e332));
    let _e335 = EonDiffuse_u0028_();
    if _e335 {
        let _e336 = diffuseColor_1;
        param_251 = _e336;
        let _e338 = s_21.roughness;
        param_252 = _e338;
        let _e340 = s_21.n_dot_v;
        param_253 = _e340;
        let _e341 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_251), (&param_252), (&param_253));
        diffuseColor_1 = _e341;
    }
    let _e342 = s_21;
    param_254 = _e342;
    let _e343 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_254));
    directOcclusion = _e343;
    let _e344 = s_21;
    param_255 = _e344;
    let _e345 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_255));
    indirectOcclusion = _e345;
    let _e346 = diffuseColor_1;
    let _e348 = s_21.ambient;
    let _e350 = indirectOcclusion;
    ambient = ((_e346 * _e348) * _e350);
    let _e352 = g_premultiply;
    let _e353 = g_transmission;
    let _e356 = g_thickness;
    g_pane = ((_e352 && (_e353 > 0f)) && (_e356 <= 0f));
    let _e359 = SceneColorBound_u0028_();
    let _e360 = g_pane;
    let _e362 = g_transmittance;
    let _e365 = g_transmission;
    let _e368 = ambient;
    ambient = (_e368 * mix(vec3<f32>(1f, 1f, 1f), select(_e362, vec3<f32>(0f, 0f, 0f), vec3((_e359 || _e360))), vec3(_e365)));
    let _e372 = frag_info.frame_params[3u];
    levels_1 = _e372;
    coatAmbient = vec3<f32>(0f, 0f, 0f);
    let _e374 = s_21.ambient;
    sheenIncoming = _e374;
    let _e375 = levels_1;
    if (_e375 > 0f) {
        let _e377 = g_f0_dielectric;
        let _e379 = s_21.albedo;
        let _e380 = metallic;
        f0_4 = mix(_e377, _e379, vec3(_e380));
        let _e383 = g_f90_;
        let _e384 = metallic;
        f90_2 = mix(_e383, 1f, _e384);
        let _e387 = s_21.n;
        bent_1 = _e387;
        let _e388 = g_aniso;
        if (_e388 > 0f) {
            let _e390 = g_aniso_t;
            let _e392 = s_21.v;
            across = cross(_e390, _e392);
            let _e394 = across;
            let _e395 = g_aniso_t;
            anisoN = cross(_e394, _e395);
            let _e397 = g_aniso;
            let _e399 = s_21.roughness;
            bend = (1f - (_e397 * (1f - _e399)));
            let _e403 = bend;
            let _e404 = bend;
            let _e406 = bend;
            let _e408 = bend;
            bend4_ = (((_e403 * _e404) * _e406) * _e408);
            let _e410 = anisoN;
            let _e412 = s_21.n;
            let _e413 = bend4_;
            bent_1 = normalize(mix(_e410, _e412, vec3(_e413)));
        }
        let _e418 = s_21.v;
        let _e420 = bent_1;
        reflected = reflect(-(_e418), _e420);
        let _e423 = s_21.n;
        let _e424 = levels_1;
        let _e425 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e423, _e424);
        irradiance = _e425.xyz;
        let _e427 = reflected;
        let _e429 = s_21.roughness;
        let _e430 = levels_1;
        let _e432 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e427, (_e429 * _e430));
        prefiltered = _e432.xyz;
        let _e435 = s_21.roughness;
        param_256 = _e435;
        let _e437 = s_21.n_dot_v;
        param_257 = _e437;
        let _e438 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_256), (&param_257));
        ab_4 = _e438;
        let _e439 = f0_4;
        let _e440 = g_irid_fresnel;
        let _e441 = g_iridescence;
        let _e445 = ab_4[0u];
        let _e447 = f90_2;
        let _e449 = ab_4[1u];
        single_1 = ((mix(_e439, _e440, vec3(_e441)) * _e445) + vec3((_e447 * _e449)));
        let _e453 = prefiltered;
        let _e454 = single_1;
        specular_1 = (_e453 * _e454);
        let _e456 = EnergyCompensation_u0028_();
        if _e456 {
            let _e458 = ab_4[0u];
            let _e460 = ab_4[1u];
            missed = (1f - (_e458 + _e460));
            let _e463 = f0_4;
            let _e464 = f0_4;
            average_2 = (_e463 + ((vec3<f32>(1f, 1f, 1f) - _e464) / vec3(21f)));
            let _e469 = single_1;
            let _e470 = average_2;
            let _e472 = missed;
            let _e473 = average_2;
            multiple = ((_e469 * _e470) / (vec3<f32>(1f, 1f, 1f) - (_e473 * _e472)));
            let _e477 = multiple;
            let _e478 = missed;
            let _e480 = irradiance;
            let _e482 = specular_1;
            specular_1 = (_e482 + ((_e477 * _e478) * _e480));
        }
        let _e484 = diffuseColor_1;
        let _e485 = irradiance;
        let _e487 = specular_1;
        let _e491 = frag_info.material[2u];
        let _e493 = indirectOcclusion;
        ambient = ((((_e484 * _e485) + _e487) * _e491) * _e493);
        let _e495 = g_f0_dielectric;
        let _e496 = g_irid_fresnel;
        let _e497 = g_iridescence;
        let _e501 = ab_4[0u];
        let _e503 = g_f90_;
        let _e505 = ab_4[1u];
        reflects = ((mix(_e495, _e496, vec3(_e497)) * _e501) + vec3((_e503 * _e505)));
        let _e509 = SceneColorBound_u0028_();
        let _e510 = g_pane;
        if (_e509 || _e510) {
            local_55 = vec3<f32>(0f, 0f, 0f);
        } else {
            let _e512 = s_21;
            param_258 = _e512;
            let _e513 = levels_1;
            param_259 = _e513;
            let _e514 = TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b((&param_258), (&param_259));
            let _e515 = g_transmittance;
            let _e517 = reflects;
            local_55 = ((_e514 * _e515) * (vec3<f32>(1f, 1f, 1f) - min(_e517, vec3<f32>(1f, 1f, 1f))));
        }
        let _e521 = local_55;
        through_1 = _e521;
        let _e522 = diffuseColor_1;
        let _e523 = through_1;
        let _e524 = irradiance;
        let _e527 = g_transmission;
        let _e531 = frag_info.material[2u];
        let _e533 = indirectOcclusion;
        let _e535 = ambient;
        ambient = (_e535 + ((((_e522 * (_e523 - _e524)) * _e527) * _e531) * _e533));
        let _e538 = s_21.v;
        let _e540 = g_coat_n;
        let _e542 = g_coat_roughness;
        let _e543 = levels_1;
        let _e545 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e538), _e540), (_e542 * _e543));
        coatPrefiltered = _e545.xyz;
        let _e547 = g_coat_roughness;
        param_260 = _e547;
        let _e548 = g_coat_n_dot_v;
        param_261 = _e548;
        let _e549 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_260), (&param_261));
        coatAb = _e549;
        let _e550 = coatPrefiltered;
        let _e552 = coatAb[0u];
        let _e555 = coatAb[1u];
        let _e558 = g_coat;
        let _e562 = frag_info.material[2u];
        let _e564 = indirectOcclusion;
        coatAmbient = ((((_e550 * ((0.04f * _e552) + _e555)) * _e558) * _e562) * _e564);
        let _e567 = s_21.n;
        let _e568 = g_sheen_roughness;
        let _e569 = levels_1;
        let _e571 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e567, (_e568 * _e569));
        let _e575 = frag_info.material[2u];
        sheenIncoming = (_e571.xyz * _e575);
    }
    let _e578 = s_21.roughness;
    param_262 = _e578;
    let _e580 = s_21.n_dot_v;
    param_263 = _e580;
    let _e581 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_262), (&param_263));
    sceneAb = _e581;
    let _e582 = g_f0_dielectric;
    let _e583 = g_irid_fresnel;
    let _e584 = g_iridescence;
    let _e588 = sceneAb[0u];
    let _e590 = g_f90_;
    let _e592 = sceneAb[1u];
    sceneReflects = ((mix(_e582, _e583, vec3(_e584)) * _e588) + vec3((_e590 * _e592)));
    let _e596 = diffuseColor_1;
    let _e597 = g_transmittance;
    let _e599 = sceneReflects;
    let _e603 = g_transmission;
    passes = (((_e596 * _e597) * (vec3<f32>(1f, 1f, 1f) - min(_e599, vec3<f32>(1f, 1f, 1f)))) * _e603);
    let _e605 = g_pane;
    if _e605 {
        let _e607 = passes[0u];
        let _e609 = passes[1u];
        let _e612 = passes[2u];
        g_pass_through = clamp((((_e607 + _e609) + _e612) / 3f), 0f, 1f);
    } else {
        let _e616 = SceneColorBound_u0028_();
        if _e616 {
            let _e617 = s_21;
            param_264 = _e617;
            let _e618 = SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_264));
            let _e619 = passes;
            let _e621 = ambient;
            ambient = (_e621 + (_e618 * _e619));
        }
    }
    let _e623 = diffuseColor_1;
    let _e624 = SampleLightmap_u0028_();
    let _e626 = indirectOcclusion;
    let _e628 = ambient;
    ambient = (_e628 + ((_e623 * _e624) * _e626));
    let _e630 = g_sheen;
    let _e631 = g_sheen_albedo;
    let _e633 = sheenIncoming;
    let _e635 = indirectOcclusion;
    sheenAmbient = (((_e630 * _e631) * _e633) * _e635);
    let _e637 = s_21;
    param_265 = _e637;
    let _e638 = 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((&param_265));
    let _e639 = directOcclusion;
    let _e641 = ambient;
    let _e642 = g_sheen_scale;
    let _e644 = sheenAmbient;
    let _e647 = s_21.emissive;
    let _e649 = g_coat_through;
    let _e652 = coatAmbient;
    lit_2 = (((_e638 * _e639) + ((((_e641 * _e642) + _e644) + _e647) * _e649)) + _e652);
    let _e654 = lit_2;
    param_266 = _e654;
    let _e656 = s_21.alpha;
    param_267 = _e656;
    let _e658 = s_21.roughness;
    param_268 = _e658;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_266), (&param_267), (&param_268));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(5) v_texcoord: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    v_texcoord_1 = v_texcoord;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LayerInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 464,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'specular',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'coat', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'sheen',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'anisotropy',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'transmission',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'attenuation',
              offsetInBytes: 80,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'iridescence',
              offsetInBytes: 96,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'uv_transform',
              offsetInBytes: 112,
              sizeInBytes: 160,
            ),
            WebGpuBlockMember(
              name: 'scene_color',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_viewport',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_levels',
              offsetInBytes: 304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scene_view_projection',
              offsetInBytes: 400,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 4,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 5,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'coat_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 16,
          samplerBinding: 17,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 18,
          samplerBinding: 19,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 20,
          samplerBinding: 21,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 22,
          samplerBinding: 23,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 24,
          samplerBinding: 25,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 26,
          samplerBinding: 27,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 28,
          samplerBinding: 29,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 30,
          samplerBinding: 31,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_color_texture',
          group: 1,
          textureBinding: 32,
          samplerBinding: 33,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 34,
          samplerBinding: 35,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'sheen_texture',
          group: 1,
          textureBinding: 36,
          samplerBinding: 37,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ToonOpaque': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e176 = v_world_position_1;
    let _e178 = fog_info.eye;
    let _e182 = fog_info.forward;
    return dot((_e176 - _e178.xyz), _e182.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e181 = ViewDepth_u0028_();
    z = abs(_e181);
    let _e183 = z;
    near = (_e183 / 5f);
    let _e185 = z;
    far = (_e185 / 200f);
    let _e187 = far;
    let _e188 = far;
    let _e190 = far;
    far3_ = ((_e187 * _e188) * _e190);
    let _e192 = (*alpha);
    let _e193 = near;
    let _e194 = near;
    let _e197 = far3_;
    let _e198 = far3_;
    return (_e192 * clamp((10f / ((0.00001f + (_e193 * _e194)) + (_e197 * _e198))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e185 = fog_info.forward[3u];
    mode = _e185;
    let _e186 = mode;
    if (_e186 > 0.5f) {
        let _e189 = frag_color[3u];
        alpha_1 = _e189;
        let _e190 = alpha_1;
        param = _e190;
        let _e191 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e191;
        let _e192 = frag_color;
        let _e194 = weight;
        let _e195 = (_e192.xyz * _e194);
        let _e196 = alpha_1;
        let _e197 = weight;
        accumulate = vec4<f32>(_e195.x, _e195.y, _e195.z, (_e196 * _e197));
        let _e203 = mode;
        let _e205 = mode;
        revealage = ((_e203 > 1.5f) && (_e205 < 2.5f));
        let _e208 = revealage;
        if _e208 {
            let _e209 = alpha_1;
            local = vec4(_e209);
        } else {
            let _e211 = accumulate;
            local = _e211;
        }
        let _e212 = local;
        frag_color = _e212;
        let _e213 = mode;
        if (_e213 > 2.5f) {
            let _e215 = alpha_1;
            frag_surface = vec4(_e215);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e179 = (*n)[0u];
    let _e182 = (*n)[1u];
    let _e186 = (*n)[2u];
    let _e189 = (*n);
    (*n) = (_e189 / vec3(((abs(_e179) + abs(_e182)) + abs(_e186))));
    let _e192 = (*n);
    e = _e192.xy;
    let _e195 = (*n)[2u];
    if (_e195 < 0f) {
        let _e197 = (*n);
        let _e203 = (*n)[0u];
        let _e207 = (*n)[1u];
        e = ((vec2(1f) - abs(_e197.yx)) * vec2<f32>(select(-1f, 1f, (_e203 >= 0f)), select(-1f, 1f, (_e207 >= 0f))));
    }
    let _e212 = e;
    return ((_e212 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e177 = (*linear);
    let _e179 = (*linear);
    let _e183 = (*linear);
    return mix((_e177 * 12.92f), ((pow(_e179, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e183));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e180 = g_albedo;
    param_1 = clamp(_e180, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e182 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e182.x, _e182.y, _e182.z, 1f);
    let _e187 = g_debug_surface_on;
    if _e187 {
        let _e188 = g_debug_surface;
        let _e189 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e188.x, _e188.y, _e188.z, _e189);
        return;
    }
    let _e194 = v_normal_1;
    geometric = normalize(_e194);
    let _e196 = gl_FrontFacing_1;
    if !(_e196) {
        let _e198 = geometric;
        geometric = -(_e198);
    }
    let _e200 = geometric;
    param_2 = _e200;
    let _e201 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e202 = (*roughness);
    let _e204 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e201.x, _e201.y, clamp(_e202, 0f, 1f), _e204);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e178 = fog_info.projection[0u];
    return (_e178 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e177 = Orthographic_u0028_();
    if _e177 {
        let _e178 = ViewDepth_u0028_();
        local_1 = max(_e178, 0f);
    } else {
        let _e180 = v_world_position_1;
        let _e182 = fog_info.eye;
        local_1 = distance(_e180, _e182.xyz);
    }
    let _e185 = local_1;
    return _e185;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e184 = fog_info.fog[3u];
    density = _e184;
    let _e185 = density;
    if (_e185 <= 0f) {
        let _e187 = (*color);
        return _e187;
    }
    let _e188 = EyeDistance_u0028_();
    d = _e188;
    let _e191 = fog_info.eye[3u];
    falloff = _e191;
    let _e192 = falloff;
    if (_e192 > 0f) {
        let _e194 = falloff;
        let _e196 = v_world_position_1[1u];
        let _e199 = fog_info.eye[1u];
        k = (_e194 * (_e196 - _e199));
        let _e202 = k;
        if (abs(_e202) > 0.001f) {
            let _e205 = k;
            let _e209 = k;
            local_2 = ((1f - exp(-(_e205))) / _e209);
        } else {
            let _e211 = k;
            local_2 = (1f - (0.5f * _e211));
        }
        let _e214 = local_2;
        let _e215 = density;
        density = (_e215 * _e214);
    }
    let _e218 = fog_info.fog;
    let _e220 = (*color);
    let _e221 = density;
    let _e223 = d;
    return mix(_e218.xyz, _e220, vec3(clamp(exp((-(_e221) * _e223)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e182 = g_premultiply;
    let _e183 = (*alpha_2);
    weight_1 = select(1f, _e183, _e182);
    let _e185 = (*linearColor);
    param_3 = _e185;
    let _e186 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e187 = weight_1;
    let _e188 = (_e186 * _e187);
    let _e189 = (*alpha_2);
    let _e190 = g_pass_through;
    frag_color = vec4<f32>(_e188.x, _e188.y, _e188.z, (_e189 * (1f - _e190)));
    let _e197 = (*roughness_1);
    param_4 = _e197;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_3: f32;

    let _e179 = frag_info.material2_[2u];
    local_3 = floor((_e179 * 0.5f));
    let _e182 = local_3;
    return _e182;
}

fn DirectOcclusion_u0028_struct_u002d_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: ptr<function, Surface>) -> f32 {
    var local_4: f32;
    var local_5: f32;

    let _e179 = OcclusionTarget_u0028_();
    if (_e179 > 1.5f) {
        local_4 = 1f;
    } else {
        let _e182 = (*s).occlusion;
        local_4 = _e182;
    }
    let _e183 = local_4;
    local_5 = _e183;
    let _e184 = local_5;
    return _e184;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var bands: f32;
    var quantized: f32;
    var fraction: f32;
    var ramp: f32;

    let _e183 = (*s_1).roughness;
    bands = mix(5f, 2f, _e183);
    let _e186 = (*light).n_dot_l;
    let _e187 = bands;
    let _e190 = bands;
    quantized = (floor((_e186 * _e187)) / _e190);
    let _e193 = (*light).n_dot_l;
    let _e194 = bands;
    fraction = fract((_e193 * _e194));
    let _e197 = fraction;
    let _e199 = bands;
    let _e201 = quantized;
    quantized = (_e201 + (smoothstep(0.85f, 1f, _e197) / _e199));
    let _e203 = quantized;
    let _e205 = (*light).n_dot_l;
    ramp = (_e203 / max(_e205, 0.001f));
    let _e209 = (*s_1).albedo;
    let _e210 = ramp;
    return (_e209 * _e210);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e177 = (*i);
    if (_e177 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e179 = (*i);
    if (_e179 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e181 = (*i);
    if (_e181 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e183 = (*i);
    if (_e183 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e185 = (*i);
    if (_e185 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e187 = (*i);
    if (_e187 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e189 = (*i);
    if (_e189 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e182 = (*i_1);
    param_5 = _e182;
    let _e183 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e183;
    let _e185 = p[0u];
    let _e186 = (*ca);
    let _e189 = p[1u];
    let _e190 = (*sa);
    let _e194 = p[0u];
    let _e195 = (*sa);
    let _e198 = p[1u];
    let _e199 = (*ca);
    let _e203 = (*radius);
    return (vec2<f32>(((_e185 * _e186) - (_e189 * _e190)), ((_e194 * _e195) + (_e198 * _e199))) * _e203);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_6: vec2<f32>;
    var atlas: vec2<f32>;

    let _e185 = point_shadow.params[0u];
    inset = _e185;
    let _e186 = (*uv);
    let _e187 = (*offset);
    let _e189 = inset;
    let _e190 = inset;
    local_6 = clamp((_e186 + _e187), vec2(_e189), vec2((1f - _e190)));
    let _e195 = local_6;
    let _e196 = (*tile);
    atlas = ((_e195 + _e196) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e201 = point_shadow.params3_[0u];
    if (_e201 > 0.5f) {
        let _e204 = atlas[1u];
        atlas[1u] = (1f - _e204);
    }
    let _e207 = atlas;
    let _e208 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e207, 0f);
    let _e210 = atlas;
    let _e211 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e210, 0f);
    let _e214 = (*range);
    return (min(_e208.x, _e211.x) * _e214);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e186 = (*uv_1);
    param_6 = _e186;
    let _e187 = (*offset_1);
    param_7 = _e187;
    let _e188 = (*tile_1);
    param_8 = _e188;
    let _e189 = (*range_1);
    param_9 = _e189;
    let _e190 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e190;
    let _e191 = stored;
    let _e192 = (*range_1);
    if (_e191 >= (_e192 * 0.999f)) {
        return 1f;
    }
    let _e195 = (*receiver);
    let _e196 = stored;
    return select(1f, 0f, (_e195 > _e196));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e207 = point_shadow.params2_[1u];
    lightRadius = _e207;
    let _e210 = point_shadow.params2_[0u];
    minRadius = _e210;
    let _e213 = point_shadow.params2_[2u];
    maxRadius = _e213;
    let _e214 = lightRadius;
    if (_e214 <= 0f) {
        let _e216 = (*uv_2);
        param_10 = _e216;
        param_11 = vec2<f32>(0f, 0f);
        let _e217 = (*tile_2);
        param_12 = _e217;
        let _e218 = (*range_2);
        param_13 = _e218;
        let _e219 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e219;
        let _e220 = minRadius;
        return _e220;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e221 = i_2;
        if (_e221 < 8i) {
            let _e223 = i_2;
            param_14 = _e223;
            let _e224 = (*ca_1);
            param_15 = _e224;
            let _e225 = (*sa_1);
            param_16 = _e225;
            let _e226 = maxRadius;
            param_17 = _e226;
            let _e227 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e228 = (*uv_2);
            param_18 = _e228;
            param_19 = _e227;
            let _e229 = (*tile_2);
            param_20 = _e229;
            let _e230 = (*range_2);
            param_21 = _e230;
            let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e231;
            let _e232 = stored_1;
            let _e233 = (*range_2);
            if (_e232 >= (_e233 * 0.999f)) {
                continue;
            }
            let _e236 = stored_1;
            let _e237 = (*receiver_1);
            if (_e236 >= _e237) {
                continue;
            }
            let _e239 = stored_1;
            let _e240 = sum;
            sum = (_e240 + _e239);
            let _e242 = count;
            count = (_e242 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e244 = i_2;
            i_2 = (_e244 + 1i);
        }
    }
    let _e246 = count;
    if (_e246 < 0.5f) {
        return -1f;
    }
    let _e248 = sum;
    let _e249 = count;
    blocker = max((_e248 / _e249), 0.0001f);
    let _e252 = blocker;
    (*blockerOut) = _e252;
    let _e253 = lightRadius;
    let _e254 = (*receiver_1);
    let _e255 = blocker;
    let _e259 = blocker;
    world = ((_e253 * max((_e254 - _e255), 0f)) / _e259);
    let _e261 = world;
    let _e262 = (*receiver_1);
    let _e264 = (*tanHalf);
    let _e267 = minRadius;
    let _e268 = maxRadius;
    return clamp((_e261 / ((2f * _e262) * _e264)), _e267, _e268);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_7: vec2<f32>;

    let _e178 = (*rows);
    if (_e178 > 0f) {
        let _e181 = gl_FragCoord_1[0u];
        let _e182 = (*rows);
        let _e184 = gl_FragCoord_1[1u];
        local_7 = vec2<f32>(_e181, (_e182 - _e184));
    } else {
        let _e187 = gl_FragCoord_1;
        local_7 = _e187.xy;
    }
    let _e189 = local_7;
    return _e189;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_8: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2242_: bool;
    var phi_2303_: bool;

    let _e230 = (*lightIndex);
    let _e234 = point_shadow.slots[_e230][0u];
    slot = i32((_e234 + 0.5f));
    let _e237 = (*lightIndex);
    let _e241 = point_shadow.slots[_e237][0u];
    if (_e241 < 0f) {
        return 1f;
    }
    let _e245 = point_shadow.params[2u];
    strength = _e245;
    let _e246 = strength;
    if (_e246 <= 0f) {
        return 1f;
    }
    let _e248 = slot;
    let _e251 = point_shadow.lights[_e248];
    let _e253 = (*world_1);
    toLight = (_e251.xyz - _e253);
    let _e255 = toLight;
    toLightLength = max(length(_e255), 0.000001f);
    let _e258 = (*normal);
    let _e259 = toLight;
    let _e260 = toLightLength;
    nDotL = max(dot(_e258, (_e259 / vec3(_e260))), 0.15f);
    let _e265 = nDotL;
    let _e266 = nDotL;
    let _e271 = nDotL;
    let _e272 = nDotL;
    slope = min((sqrt(max((1f - (_e265 * _e266)), 0f)) / (_e271 * _e272)), 8f);
    let _e276 = toLightLength;
    let _e278 = (*lightIndex);
    let _e282 = point_shadow.slots[_e278][2u];
    let _e287 = point_shadow.params3_[1u];
    texel = (((2f * _e276) * max(_e282, 0.0001f)) * _e287);
    let _e289 = (*world_1);
    let _e290 = (*normal);
    let _e291 = texel;
    let _e295 = point_shadow.params[3u];
    let _e297 = slope;
    origin = (_e289 + (((_e290 * _e291) * _e295) * (1f + _e297)));
    let _e301 = origin;
    let _e302 = slot;
    let _e305 = point_shadow.lights[_e302];
    toFragment = (_e301 - _e305.xyz);
    let _e308 = toFragment;
    distance_ = length(_e308);
    let _e310 = slot;
    let _e314 = point_shadow.lights[_e310][3u];
    range_3 = max(_e314, 0.0001f);
    let _e316 = distance_;
    let _e317 = range_3;
    if (_e316 >= _e317) {
        return 1f;
    }
    face = 0i;
    let _e319 = (*lightIndex);
    let _e323 = point_shadow.slots[_e319][1u];
    if (_e323 < 0.5f) {
        let _e325 = toFragment;
        a = abs(_e325);
        let _e328 = a[0u];
        let _e330 = a[1u];
        let _e331 = (_e328 >= _e330);
        phi_2242_ = _e331;
        if _e331 {
            let _e333 = a[0u];
            let _e335 = a[2u];
            phi_2242_ = (_e333 >= _e335);
        }
        let _e338 = phi_2242_;
        if _e338 {
            let _e340 = toFragment[0u];
            face = select(1i, 0i, (_e340 > 0f));
        } else {
            let _e344 = a[1u];
            let _e346 = a[2u];
            if (_e344 >= _e346) {
                let _e349 = toFragment[1u];
                face = select(3i, 2i, (_e349 > 0f));
            } else {
                let _e353 = toFragment[2u];
                face = select(5i, 4i, (_e353 > 0f));
            }
        }
    }
    let _e356 = slot;
    let _e358 = face;
    let _e362 = point_shadow.faces[((_e356 * 6i) + _e358)];
    let _e363 = origin;
    clip = (_e362 * vec4<f32>(_e363.x, _e363.y, _e363.z, 1f));
    let _e370 = clip[3u];
    if (_e370 <= 0f) {
        return 1f;
    }
    let _e372 = clip;
    let _e375 = clip[3u];
    ndc = (_e372.xy / vec2(_e375));
    let _e379 = ndc[0u];
    let _e381 = (abs(_e379) > 1f);
    phi_2303_ = _e381;
    if !(_e381) {
        let _e384 = ndc[1u];
        phi_2303_ = (abs(_e384) > 1f);
    }
    let _e388 = phi_2303_;
    if _e388 {
        return 1f;
    }
    let _e390 = ndc[0u];
    let _e394 = ndc[1u];
    uv_3 = vec2<f32>(((_e390 * 0.5f) + 0.5f), (0.5f - (_e394 * 0.5f)));
    let _e398 = face;
    let _e400 = slot;
    tile_3 = vec2<f32>(f32(_e398), f32(_e400));
    let _e403 = distance_;
    let _e406 = point_shadow.params[1u];
    receiver_2 = (_e403 - _e406);
    let _e410 = frag_info.target_origin[0u];
    param_22 = _e410;
    let _e411 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e411, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e416 = noise;
    angle = (_e416 * 6.2831855f);
    let _e418 = angle;
    ca_2 = cos(_e418);
    let _e420 = angle;
    sa_2 = sin(_e420);
    let _e422 = (*lightIndex);
    let _e426 = point_shadow.slots[_e422][2u];
    tanHalf_1 = max(_e426, 0.0001f);
    blocker_1 = -1f;
    let _e428 = uv_3;
    param_23 = _e428;
    let _e429 = tile_3;
    param_24 = _e429;
    let _e430 = range_3;
    param_25 = _e430;
    let _e431 = receiver_2;
    param_26 = _e431;
    let _e432 = ca_2;
    param_27 = _e432;
    let _e433 = sa_2;
    param_28 = _e433;
    let _e434 = tanHalf_1;
    param_29 = _e434;
    let _e435 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e436 = param_30;
    blocker_1 = _e436;
    radius_1 = _e435;
    let _e439 = point_shadow.params2_[3u];
    if (_e439 > 0.5f) {
        g_debug_surface_on = true;
        let _e441 = radius_1;
        if (_e441 < 0f) {
            local_8 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e443 = radius_1;
            let _e446 = point_shadow.params2_[2u];
            let _e450 = blocker_1;
            let _e451 = range_3;
            local_8 = vec3<f32>(clamp((_e443 / max(_e446, 0.000001f)), 0f, 1f), clamp((_e450 / _e451), 0f, 1f), 0f);
        }
        let _e455 = local_8;
        g_debug_surface = _e455;
    }
    let _e456 = radius_1;
    if (_e456 < 0f) {
        return 1f;
    }
    let _e458 = uv_3;
    param_31 = _e458;
    param_32 = vec2<f32>(0f, 0f);
    let _e459 = tile_3;
    param_33 = _e459;
    let _e460 = range_3;
    param_34 = _e460;
    let _e461 = receiver_2;
    param_35 = _e461;
    let _e462 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e462;
    let _e463 = radius_1;
    if (_e463 > 0f) {
        i_3 = 0i;
        loop {
            let _e465 = i_3;
            if (_e465 < 8i) {
                let _e467 = i_3;
                param_36 = _e467;
                let _e468 = ca_2;
                param_37 = _e468;
                let _e469 = sa_2;
                param_38 = _e469;
                let _e470 = radius_1;
                param_39 = _e470;
                let _e471 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e472 = uv_3;
                param_40 = _e472;
                param_41 = _e471;
                let _e473 = tile_3;
                param_42 = _e473;
                let _e474 = range_3;
                param_43 = _e474;
                let _e475 = receiver_2;
                param_44 = _e475;
                let _e476 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e477 = lit;
                lit = (_e477 + _e476);
                continue;
            } else {
                break;
            }
            continuing {
                let _e479 = i_3;
                i_3 = (_e479 + 1i);
            }
        }
        let _e481 = lit;
        lit = (_e481 * 0.11111111f);
    }
    let _e483 = lit;
    let _e484 = strength;
    return mix(1f, _e483, clamp(_e484, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e181 = (*i_4);
    let _e184 = (*n_1);
    r = sqrt(((f32(_e181) + 0.5f) / f32(_e184)));
    let _e188 = (*i_4);
    let _e191 = (*turn);
    theta = ((f32(_e188) * 2.3999631f) + _e191);
    let _e193 = r;
    let _e194 = theta;
    let _e196 = theta;
    return (vec2<f32>(cos(_e194), sin(_e196)) * _e193);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e180 = frag_info.target_origin[0u];
    param_45 = _e180;
    let _e181 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e184 = frag_info.target_origin[3u];
    at = (_e181 + vec2((5.588238f * max(_e184, 0f))));
    let _e189 = at;
    return fract((52.982918f * fract(dot(_e189, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_9: f32;

    let _e179 = (*mode_1);
    if (_e179 > 0.5f) {
        let _e181 = (*stored_2);
        local_9 = (1f - _e181);
    } else {
        let _e183 = (*stored_2);
        local_9 = _e183;
    }
    let _e184 = local_9;
    return _e184;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e185 = (*moments)[1u];
    let _e187 = (*moments)[0u];
    let _e189 = (*moments)[0u];
    let _e192 = (*minVariance);
    variance = max((_e185 - (_e187 * _e189)), _e192);
    let _e194 = (*t);
    let _e196 = (*moments)[0u];
    d_1 = (_e194 - _e196);
    let _e198 = variance;
    let _e199 = variance;
    let _e200 = d_1;
    let _e201 = d_1;
    pMax = (_e198 / (_e199 + (_e200 * _e201)));
    let _e205 = pMax;
    let _e206 = (*bleed);
    let _e208 = (*bleed);
    reduced = clamp(((_e205 - _e206) / max((1f - _e208), 0.0001f)), 0f, 1f);
    let _e213 = (*t);
    let _e215 = (*moments)[0u];
    let _e217 = reduced;
    return select(_e217, 1f, (_e213 <= _e215));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e178 = (*depth);
    d_2 = ((2f * clamp(_e178, 0f, 1f)) - 1f);
    let _e182 = d_2;
    let _e185 = d_2;
    return vec2<f32>(exp((40f * _e182)), -(exp((-5f * _e185))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e192 = (*depth_1);
    param_46 = _e192;
    let _e193 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e193;
    let _e194 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e194);
    let _e197 = scale[0u];
    let _e199 = scale[0u];
    let _e201 = (*moments_1);
    param_47 = _e201.xy;
    let _e204 = warped[0u];
    param_48 = _e204;
    param_49 = (_e197 * _e199);
    let _e205 = (*bleed_1);
    param_50 = _e205;
    let _e206 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e206;
    let _e208 = scale[1u];
    let _e210 = scale[1u];
    let _e212 = (*moments_1);
    param_51 = _e212.zw;
    let _e215 = warped[1u];
    param_52 = _e215;
    param_53 = (_e208 * _e210);
    let _e216 = (*bleed_1);
    param_54 = _e216;
    let _e217 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e217;
    let _e218 = positive;
    let _e219 = negative;
    return min(_e218, _e219);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e178 = (*depth_2);
    stored_3 = max((1f - _e178), 0.000061035156f);
    let _e181 = stored_3;
    return exp2((floor(log2(_e181)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_10: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_11: mat4x4<f32>;
    var local_12: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_13: f32;
    var local_14: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_3439_: bool;
    var phi_3450_: bool;
    var phi_3611_: bool;
    var phi_3618_: bool;
    var phi_3625_: bool;

    let _e257 = frag_info.shadow_params[3u];
    strength_1 = _e257;
    let _e258 = strength_1;
    if (_e258 <= 0f) {
        return 1f;
    }
    let _e260 = (*lightIndex_1);
    let _e263 = frag_info.frame_params[2u];
    if (_e260 != i32(floor((_e263 + 0.5f)))) {
        return 1f;
    }
    let _e270 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e270 + 0.5f));
    let _e273 = Orthographic_u0028_();
    if _e273 {
        let _e274 = ViewDepth_u0028_();
        local_10 = _e274;
    } else {
        let _e275 = v_world_position_1;
        let _e277 = frag_info.camera_position;
        local_10 = length((_e275 - _e277.xyz));
    }
    let _e281 = local_10;
    viewDistance = _e281;
    cascade = 0i;
    let _e282 = cascadeCount;
    let _e283 = (_e282 > 1i);
    phi_3439_ = _e283;
    if _e283 {
        let _e284 = viewDistance;
        let _e287 = frag_info.shadow_cascades[0u];
        phi_3439_ = (_e284 > _e287);
    }
    let _e290 = phi_3439_;
    if _e290 {
        cascade = 1i;
    }
    let _e291 = cascadeCount;
    let _e292 = (_e291 > 2i);
    phi_3450_ = _e292;
    if _e292 {
        let _e293 = viewDistance;
        let _e296 = frag_info.shadow_cascades[1u];
        phi_3450_ = (_e293 > _e296);
    }
    let _e299 = phi_3450_;
    if _e299 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e300 = attempt;
        if (_e300 < 3i) {
            let _e302 = cascade;
            let _e303 = attempt;
            which = (_e302 + _e303);
            let _e305 = which;
            let _e306 = cascadeCount;
            if (_e305 >= _e306) {
                break;
            }
            let _e308 = which;
            if (_e308 == 0i) {
                let _e311 = frag_info.shadow_matrix;
                local_11 = _e311;
            } else {
                let _e312 = which;
                if (_e312 == 1i) {
                    let _e315 = frag_info.shadow_matrix_far;
                    local_12 = _e315;
                } else {
                    let _e317 = frag_info.shadow_matrix_farthest;
                    local_12 = _e317;
                }
                let _e318 = local_12;
                local_11 = _e318;
            }
            let _e319 = local_11;
            matrix = _e319;
            let _e322 = matrix[0][0u];
            let _e325 = matrix[1][0u];
            let _e328 = matrix[2][0u];
            axisX = vec3<f32>(_e322, _e325, _e328);
            let _e332 = matrix[0][1u];
            let _e335 = matrix[1][1u];
            let _e338 = matrix[2][1u];
            axisY = vec3<f32>(_e332, _e335, _e338);
            let _e340 = axisX;
            rowX = max(length(_e340), 0.000001f);
            let _e343 = axisY;
            rowY = max(length(_e343), 0.000001f);
            let _e348 = frag_info.shadow_cascades[3u];
            let _e350 = rowX;
            texelMetres = ((2f * _e348) / _e350);
            let _e354 = frag_info.shadow_cascades[3u];
            let _e357 = (*s_2).n;
            let _e358 = axisX;
            let _e361 = rowX;
            let _e362 = rowX;
            let _e366 = (*s_2).n;
            let _e367 = axisY;
            let _e370 = rowY;
            let _e371 = rowY;
            reach = ((3f * _e354) * ((abs(dot(_e357, _e358)) / (_e361 * _e362)) + (abs(dot(_e366, _e367)) / (_e370 * _e371))));
            let _e378 = frag_info.shadow_params[2u];
            let _e379 = texelMetres;
            flatOffset = min(_e378, _e379);
            let _e381 = v_world_position_1;
            let _e383 = (*s_2).n;
            let _e384 = flatOffset;
            let _e385 = reach;
            origin_1 = (_e381 + (_e383 * (_e384 + _e385)));
            let _e389 = matrix;
            let _e390 = origin_1;
            lightSpace = (_e389 * vec4<f32>(_e390.x, _e390.y, _e390.z, 1f));
            let _e397 = lightSpace[3u];
            if (_e397 <= 0f) {
                continue;
            }
            let _e399 = lightSpace;
            let _e402 = lightSpace[3u];
            candidate = (_e399.xyz / vec3(_e402));
            let _e406 = candidate[0u];
            let _e410 = candidate[1u];
            inTile = vec2<f32>(((_e406 * 0.5f) + 0.5f), (0.5f - (_e410 * 0.5f)));
            let _e415 = inTile[0u];
            let _e416 = (_e415 < 0f);
            phi_3611_ = _e416;
            if !(_e416) {
                let _e419 = inTile[0u];
                phi_3611_ = (_e419 > 1f);
            }
            let _e422 = phi_3611_;
            phi_3618_ = _e422;
            if !(_e422) {
                let _e425 = inTile[1u];
                phi_3618_ = (_e425 < 0f);
            }
            let _e428 = phi_3618_;
            phi_3625_ = _e428;
            if !(_e428) {
                let _e431 = inTile[1u];
                phi_3625_ = (_e431 > 1f);
            }
            let _e434 = phi_3625_;
            if _e434 {
                continue;
            }
            let _e436 = candidate[2u];
            if (_e436 > 1f) {
                let _e438 = which;
                let _e439 = cascadeCount;
                if (_e438 < (_e439 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e444 = inTile[0u];
            let _e445 = which;
            let _e448 = cascadeCount;
            let _e452 = inTile[1u];
            uv_4 = vec2<f32>(((_e444 + f32(_e445)) / f32(_e448)), _e452);
            let _e454 = candidate;
            projected = _e454;
            let _e455 = which;
            cascade = _e455;
            let _e456 = texelMetres;
            cascadeTexel = _e456;
            let _e459 = matrix[0][2u];
            let _e462 = matrix[1][2u];
            let _e465 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e459, _e462, _e465)), 0.000001f));
            let _e471 = (*s_2).n;
            let _e474 = matrix[0][2u];
            let _e477 = matrix[1][2u];
            let _e480 = matrix[2][2u];
            let _e484 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e471, vec3<f32>(_e474, _e477, _e480))) * _e484), 0.1f, 1f);
            let _e487 = texelMetres;
            let _e488 = cosSlope;
            let _e489 = cosSlope;
            let _e495 = cosSlope;
            let _e497 = cascadeDepth;
            receiverSlope = (((_e487 * sqrt(max((1f - (_e488 * _e489)), 0f))) / _e495) / _e497);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e499 = attempt;
            attempt = (_e499 + 1i);
        }
    }
    let _e501 = found;
    if !(_e501) {
        return 1f;
    }
    let _e503 = cascade;
    if (_e503 == 0i) {
        let _e507 = frag_info.shadow_bias[0u];
        local_13 = _e507;
    } else {
        let _e508 = cascade;
        if (_e508 == 1i) {
            let _e512 = frag_info.shadow_bias[1u];
            local_14 = _e512;
        } else {
            let _e515 = frag_info.shadow_bias[2u];
            local_14 = _e515;
        }
        let _e516 = local_14;
        local_13 = _e516;
    }
    let _e517 = local_13;
    bias = _e517;
    let _e520 = frag_info.shadow_params[1u];
    storage_ = _e520;
    let _e521 = storage_;
    let _e523 = storage_;
    if ((_e521 > 0.5f) && (_e523 < 1.5f)) {
        let _e526 = bias;
        let _e528 = projected[2u];
        param_55 = _e528;
        let _e529 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e526, _e529);
    }
    let _e533 = frag_info.shadow_params[0u];
    let _e536 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e533, _e536);
    let _e538 = cascade;
    let _e540 = cascadeCount;
    let _e544 = texel_1;
    tileLo = (vec2<f32>((f32(_e538) / f32(_e540)), 0f) + (_e544 * 0.5f));
    let _e547 = cascade;
    let _e550 = cascadeCount;
    let _e554 = texel_1;
    tileHi = (vec2<f32>((f32((_e547 + 1i)) / f32(_e550)), 1f) - (_e554 * 0.5f));
    let _e559 = frag_info.shadow_bias[3u];
    if (_e559 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e561 = y;
            if (_e561 <= 1i) {
                x = -1i;
                loop {
                    let _e563 = x;
                    if (_e563 <= 1i) {
                        let _e565 = uv_4;
                        let _e566 = x;
                        let _e568 = y;
                        let _e571 = texel_1;
                        let _e574 = tileLo;
                        let _e575 = tileHi;
                        let _e577 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e565 + (vec2<f32>(f32(_e566), f32(_e568)) * _e571)), _e574, _e575), 0f);
                        let _e578 = stored_4;
                        stored_4 = (_e578 + _e577);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e580 = x;
                        x = (_e580 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e582 = y;
                y = (_e582 + 1i);
            }
        }
        let _e584 = stored_4;
        stored_4 = (_e584 * 0.11111111f);
        let _e587 = stored_4[1u];
        let _e590 = stored_4[2u];
        let _e593 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e587), (1f - _e590), _e593), vec3(0f), vec3(4f));
        let _e598 = through;
        let _e599 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e598, vec3(clamp(_e599, 0f, 1f)));
    }
    let _e605 = frag_info.ambient_ground[3u];
    softness = _e605;
    lit_1 = 0f;
    let _e606 = softness;
    if (_e606 < 0f) {
        let _e608 = uv_4;
        let _e609 = tileLo;
        let _e610 = tileHi;
        let _e612 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e608, _e609, _e610), 0f);
        moments_2 = _e612;
        let _e614 = projected[2u];
        let _e615 = bias;
        let _e617 = softness;
        let _e621 = moments_2;
        param_56 = _e621;
        param_57 = (_e614 - _e615);
        param_58 = clamp((-(_e617) - 1f), 0f, 0.95f);
        let _e622 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e622;
    } else {
        let _e623 = softness;
        if (_e623 <= 0f) {
            y_1 = -1i;
            loop {
                let _e625 = y_1;
                if (_e625 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e627 = x_1;
                        if (_e627 <= 1i) {
                            let _e629 = uv_4;
                            let _e630 = x_1;
                            let _e632 = y_1;
                            let _e635 = texel_1;
                            let _e638 = tileLo;
                            let _e639 = tileHi;
                            let _e641 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e629 + (vec2<f32>(f32(_e630), f32(_e632)) * _e635)), _e638, _e639), 0f);
                            param_59 = _e641.x;
                            let _e643 = storage_;
                            param_60 = _e643;
                            let _e644 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e644;
                            let _e646 = projected[2u];
                            let _e647 = bias;
                            let _e649 = occluder;
                            let _e652 = lit_1;
                            lit_1 = (_e652 + select(1f, 0f, ((_e646 - _e647) > _e649)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e654 = x_1;
                            x_1 = (_e654 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e656 = y_1;
                    y_1 = (_e656 + 1i);
                }
            }
            let _e658 = lit_1;
            lit_1 = (_e658 * 0.11111111f);
        } else {
            let _e660 = softness;
            spread = tan(min(_e660, 0.5f));
            let _e663 = ShadowNoise_u0028_();
            turn_1 = (_e663 * 6.2831855f);
            let _e665 = spread;
            let _e667 = projected[2u];
            let _e669 = cascadeDepth;
            let _e671 = cascadeTexel;
            searchRadius = clamp((((_e665 * _e667) * _e669) / _e671), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e674 = i_5;
                if (_e674 < 16i) {
                    let _e676 = i_5;
                    param_61 = _e676;
                    param_62 = 16i;
                    let _e677 = turn_1;
                    param_63 = _e677;
                    let _e678 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e678;
                    let _e679 = bias;
                    let _e680 = disc;
                    let _e682 = searchRadius;
                    let _e686 = receiverSlope;
                    tapBias = (_e679 + (max(((length(_e680) * _e682) - 1.5f), 0f) * _e686));
                    let _e689 = uv_4;
                    let _e690 = disc;
                    let _e691 = texel_1;
                    let _e693 = searchRadius;
                    let _e696 = tileLo;
                    let _e697 = tileHi;
                    let _e699 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e689 + ((_e690 * _e691) * _e693)), _e696, _e697), 0f);
                    param_64 = _e699.x;
                    let _e701 = storage_;
                    param_65 = _e701;
                    let _e702 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e702;
                    let _e704 = projected[2u];
                    let _e705 = tapBias;
                    let _e707 = occluder_1;
                    if ((_e704 - _e705) > _e707) {
                        let _e709 = occluder_1;
                        let _e710 = blockerSum;
                        blockerSum = (_e710 + _e709);
                        let _e712 = blockerCount;
                        blockerCount = (_e712 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e714 = i_5;
                    i_5 = (_e714 + 1i);
                }
            }
            let _e716 = blockerCount;
            if (_e716 <= 0f) {
                return 1f;
            }
            let _e719 = projected[2u];
            let _e720 = blockerSum;
            let _e721 = blockerCount;
            let _e725 = cascadeDepth;
            gap = (max((_e719 - (_e720 / _e721)), 0f) * _e725);
            let _e727 = spread;
            let _e728 = gap;
            let _e730 = cascadeTexel;
            radius_2 = clamp(((_e727 * _e728) / _e730), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e733 = i_6;
                if (_e733 < 16i) {
                    let _e735 = turn_1;
                    let _e737 = i_6;
                    param_66 = _e737;
                    param_67 = 16i;
                    param_68 = (_e735 + 1f);
                    let _e738 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e738;
                    let _e739 = bias;
                    let _e740 = disc_1;
                    let _e742 = radius_2;
                    let _e746 = receiverSlope;
                    tapBias_1 = (_e739 + (max(((length(_e740) * _e742) - 1.5f), 0f) * _e746));
                    let _e749 = uv_4;
                    let _e750 = disc_1;
                    let _e751 = texel_1;
                    let _e753 = radius_2;
                    let _e756 = tileLo;
                    let _e757 = tileHi;
                    let _e759 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e749 + ((_e750 * _e751) * _e753)), _e756, _e757), 0f);
                    param_69 = _e759.x;
                    let _e761 = storage_;
                    param_70 = _e761;
                    let _e762 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e762;
                    let _e764 = projected[2u];
                    let _e765 = tapBias_1;
                    let _e767 = occluder_2;
                    let _e770 = lit_1;
                    lit_1 = (_e770 + select(1f, 0f, ((_e764 - _e765) > _e767)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e772 = i_6;
                    i_6 = (_e772 + 1i);
                }
            }
            let _e774 = lit_1;
            lit_1 = (_e774 * 0.0625f);
        }
    }
    let _e776 = lit_1;
    let _e777 = strength_1;
    return mix(1f, _e776, clamp(_e777, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e182 = (*s_3);
    param_71 = _e182;
    let _e183 = (*light_2);
    param_72 = _e183;
    let _e184 = (*index);
    param_73 = _e184;
    let _e185 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e185;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e177 = (*index_1);
    return (_e177 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e181 = (*distance_1);
    let _e182 = (*distance_1);
    attenuation = (1f / max((_e181 * _e182), 0.0001f));
    let _e186 = (*range_4);
    if (_e186 > 0f) {
        let _e188 = (*distance_1);
        let _e189 = (*range_4);
        ratio = (_e188 / _e189);
        let _e191 = ratio;
        let _e192 = ratio;
        let _e194 = ratio;
        let _e196 = ratio;
        window = clamp((1f - (((_e191 * _e192) * _e194) * _e196)), 0f, 1f);
        let _e200 = window;
        let _e201 = window;
        let _e203 = attenuation;
        attenuation = (_e203 * (_e200 * _e201));
    }
    let _e205 = attenuation;
    return _e205;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_15: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e193 = (*halfWidth);
    let _e194 = (*halfHeight);
    n_2 = cross(_e193, _e194);
    let _e196 = n_2;
    nLen = length(_e196);
    let _e198 = nLen;
    if (_e198 < 0.000000000001f) {
        let _e200 = (*centre);
        return _e200;
    }
    let _e201 = nLen;
    let _e202 = n_2;
    n_2 = (_e202 / vec3(_e201));
    let _e205 = (*centre);
    let _e206 = (*world_2);
    toPlane = (_e205 - _e206);
    let _e208 = (*mirror);
    let _e209 = n_2;
    denom = dot(_e208, _e209);
    let _e211 = denom;
    if (abs(_e211) < 0.00001f) {
        let _e214 = toPlane;
        let _e215 = n_2;
        let _e216 = toPlane;
        let _e217 = n_2;
        onPlane = (_e214 - (_e215 * dot(_e216, _e217)));
    } else {
        let _e221 = toPlane;
        let _e222 = n_2;
        let _e224 = denom;
        t_1 = (dot(_e221, _e222) / _e224);
        let _e226 = t_1;
        if (_e226 > 0f) {
            let _e228 = (*mirror);
            let _e229 = t_1;
            local_15 = (_e228 * _e229);
        } else {
            let _e231 = toPlane;
            let _e232 = n_2;
            let _e233 = toPlane;
            let _e234 = n_2;
            local_15 = (_e231 - (_e232 * dot(_e233, _e234)));
        }
        let _e238 = local_15;
        onPlane = _e238;
    }
    let _e239 = onPlane;
    let _e240 = toPlane;
    offset_2 = (_e239 - _e240);
    let _e242 = (*halfWidth);
    let _e243 = (*halfWidth);
    wLen2_ = max(dot(_e242, _e243), 0.000000000001f);
    let _e246 = (*halfHeight);
    let _e247 = (*halfHeight);
    hLen2_ = max(dot(_e246, _e247), 0.000000000001f);
    let _e250 = offset_2;
    let _e251 = (*halfWidth);
    let _e253 = wLen2_;
    u = clamp((dot(_e250, _e251) / _e253), -1f, 1f);
    let _e256 = offset_2;
    let _e257 = (*halfHeight);
    let _e259 = hLen2_;
    v = clamp((dot(_e256, _e257) / _e259), -1f, 1f);
    let _e262 = (*centre);
    let _e263 = (*halfWidth);
    let _e264 = u;
    let _e267 = (*halfHeight);
    let _e268 = v;
    return ((_e262 + (_e263 * _e264)) + (_e267 * _e268));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_16: f32;

    let _e185 = (*a_1);
    let _e186 = (*a_1);
    ua = (_e185 / vec3(max(length(_e186), 0.000000000001f)));
    let _e191 = (*b);
    let _e192 = (*b);
    ub = (_e191 / vec3(max(length(_e192), 0.000000000001f)));
    let _e197 = ua;
    let _e198 = ub;
    angle_1 = acos(clamp(dot(_e197, _e198), -1f, 1f));
    let _e202 = ua;
    let _e203 = ub;
    axis = cross(_e202, _e203);
    let _e205 = axis;
    len = length(_e205);
    let _e207 = len;
    if (_e207 > 0.000001f) {
        let _e209 = angle_1;
        let _e210 = axis;
        let _e211 = (*n_3);
        let _e214 = len;
        local_16 = ((_e209 * dot(_e210, _e211)) / _e214);
    } else {
        local_16 = 0f;
    }
    let _e216 = local_16;
    return _e216;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_17: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_18: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_19: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e199 = i_7;
        if (_e199 < 4i) {
            let _e201 = i_7;
            let _e203 = (*corners)[_e201];
            a_2 = _e203;
            let _e204 = i_7;
            if (_e204 == 3i) {
                local_17 = 0i;
            } else {
                let _e206 = i_7;
                local_17 = (_e206 + 1i);
            }
            let _e208 = local_17;
            let _e210 = (*corners)[_e208];
            b_1 = _e210;
            let _e211 = a_2;
            let _e212 = (*n_4);
            ha = dot(_e211, _e212);
            let _e214 = b_1;
            let _e215 = (*n_4);
            hb = dot(_e214, _e215);
            let _e217 = ha;
            let _e218 = hb;
            d_3 = (_e217 - _e218);
            let _e220 = a_2;
            let _e221 = b_1;
            let _e222 = a_2;
            let _e224 = d_3;
            if (abs(_e224) > 0.000000000001f) {
                let _e227 = ha;
                let _e228 = d_3;
                local_18 = (_e227 / _e228);
            } else {
                local_18 = 0f;
            }
            let _e230 = local_18;
            q = (_e220 + ((_e221 - _e222) * _e230));
            let _e233 = ha;
            aAbove = (_e233 > 0f);
            let _e235 = hb;
            bAbove = (_e235 > 0f);
            let _e237 = aAbove;
            let _e238 = bAbove;
            if (_e237 || _e238) {
                let _e240 = aAbove;
                let _e241 = a_2;
                let _e242 = q;
                let _e245 = bAbove;
                let _e246 = b_1;
                let _e247 = q;
                param_74 = select(_e242, _e241, vec3(_e240));
                param_75 = select(_e247, _e246, vec3(_e245));
                let _e250 = (*n_4);
                param_76 = _e250;
                let _e251 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_19 = _e251;
            } else {
                local_19 = 0f;
            }
            let _e252 = local_19;
            let _e253 = total;
            total = (_e253 + _e252);
            let _e255 = aAbove;
            let _e256 = bAbove;
            let _e259 = q;
            let _e260 = exit;
            exit = select(_e260, _e259, vec3((_e255 && !(_e256))));
            let _e263 = aAbove;
            let _e265 = bAbove;
            let _e267 = q;
            let _e268 = entry;
            entry = select(_e268, _e267, vec3((!(_e263) && _e265)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e271 = i_7;
            i_7 = (_e271 + 1i);
        }
    }
    let _e273 = exit;
    param_77 = _e273;
    let _e274 = entry;
    param_78 = _e274;
    let _e275 = (*n_4);
    param_79 = _e275;
    let _e276 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e277 = total;
    total = (_e277 + _e276);
    let _e279 = total;
    return max((-(_e279) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_20: f32;
    var local_21: f32;
    var local_22: f32;

    let _e182 = (*slot_1);
    let _e183 = (*slot_1);
    lane = (_e182 - ((_e183 / 4i) * 4i));
    let _e187 = lane;
    if (_e187 == 0i) {
        let _e190 = (*four)[0u];
        local_20 = _e190;
    } else {
        let _e191 = lane;
        if (_e191 == 1i) {
            let _e194 = (*four)[1u];
            local_21 = _e194;
        } else {
            let _e195 = lane;
            if (_e195 == 2i) {
                let _e198 = (*four)[2u];
                local_22 = _e198;
            } else {
                let _e200 = (*four)[3u];
                local_22 = _e200;
            }
            let _e201 = local_22;
            local_21 = _e201;
        }
        let _e202 = local_21;
        local_20 = _e202;
    }
    let _e203 = local_20;
    return _e203;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e179 = (*slot_2);
    let _e183 = light_list_info.scales[(_e179 / 4i)];
    param_80 = _e183;
    let _e184 = (*slot_2);
    param_81 = _e184;
    let _e185 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e185;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e181 = light_list_info.slot_rows[0i];
    let _e182 = (*row);
    a_3 = abs((_e181 - vec4(_e182)));
    let _e188 = light_list_info.slot_rows[1i];
    let _e189 = (*row);
    b_2 = abs((_e188 - vec4(_e189)));
    let _e194 = a_3[0u];
    let _e196 = a_3[1u];
    let _e199 = a_3[2u];
    let _e201 = a_3[3u];
    let _e205 = b_2[0u];
    let _e207 = b_2[1u];
    let _e210 = b_2[2u];
    let _e212 = b_2[3u];
    return (min(min(min(_e194, _e196), min(_e199, _e201)), min(min(_e205, _e207), min(_e210, _e212))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e179 = (*slot_3);
    let _e183 = light_list_info.indices[(_e179 / 4i)];
    param_82 = _e183;
    let _e184 = (*slot_3);
    param_83 = _e184;
    let _e185 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e185;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e178 = (*texel_2);
    let _e182 = light_list_info.list[1u];
    let _e184 = (*row_1);
    let _e188 = light_list_info.list[2u];
    let _e191 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e178 + 0.5f) * _e182), ((_e184 + 0.5f) * _e188)), 0f);
    return _e191;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e186 = g_cluster_offset;
    let _e187 = (*slot_4);
    entry_1 = (_e186 + f32(_e187));
    let _e190 = entry_1;
    row_2 = floor((_e190 / 16f));
    let _e193 = entry_1;
    let _e194 = row_2;
    within = (_e193 - (_e194 * 16f));
    let _e197 = within;
    texel_3 = floor((_e197 / 4f));
    let _e202 = light_list_info.cluster_depth[3u];
    let _e203 = row_2;
    let _e205 = texel_3;
    param_84 = _e205;
    param_85 = (_e202 + _e203);
    let _e206 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e206;
    let _e207 = within;
    let _e208 = texel_3;
    let _e213 = four_1;
    param_86 = _e213;
    param_87 = i32(((_e207 - (_e208 * 4f)) + 0.5f));
    let _e214 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e214;
}

fn Clustered_u0028_() -> bool {
    let _e178 = light_list_info.cluster_grid[3u];
    return (_e178 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_23: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_24: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_25: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_26: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_27: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp_1: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e230 = (*index_2);
    if (_e230 < 8i) {
        let _e232 = (*index_2);
        let _e235 = frag_info.light_position[_e232];
        position = _e235;
        let _e236 = (*index_2);
        let _e239 = frag_info.light_color[_e236];
        color_1 = _e239;
        let _e240 = (*index_2);
        let _e243 = frag_info.light_direction[_e240];
        direction = _e243;
        let _e244 = (*index_2);
        let _e247 = frag_info.light_cone[_e244];
        cone = _e247;
    } else {
        let _e248 = (*index_2);
        slot_5 = (_e248 - 8i);
        let _e250 = Clustered_u0028_();
        clustered = _e250;
        let _e251 = clustered;
        if _e251 {
            let _e252 = slot_5;
            param_88 = _e252;
            let _e253 = ClusterRow_u0028_i1_u003b((&param_88));
            local_23 = _e253;
        } else {
            let _e254 = slot_5;
            param_89 = _e254;
            let _e255 = LightListRow_u0028_i1_u003b((&param_89));
            local_23 = _e255;
        }
        let _e256 = local_23;
        listRow = _e256;
        let _e257 = listRow;
        let _e261 = light_list_info.list[2u];
        v_1 = ((_e257 + 0.5f) * _e261);
        let _e265 = light_list_info.list[1u];
        u_1 = _e265;
        let _e266 = u_1;
        let _e268 = v_1;
        let _e270 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e266), _e268), 0f);
        position = _e270;
        let _e271 = u_1;
        let _e273 = v_1;
        let _e275 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e271), _e273), 0f);
        color_1 = _e275;
        let _e276 = u_1;
        let _e278 = v_1;
        let _e280 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e276), _e278), 0f);
        direction = _e280;
        let _e281 = u_1;
        let _e283 = v_1;
        let _e285 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e281), _e283), 0f);
        cone = _e285;
        let _e286 = clustered;
        if _e286 {
            let _e287 = listRow;
            param_90 = _e287;
            let _e288 = InSlots_u0028_f1_u003b((&param_90));
            local_24 = select(1f, 0f, _e288);
        } else {
            let _e290 = slot_5;
            param_91 = _e290;
            let _e291 = LightListScale_u0028_i1_u003b((&param_91));
            local_24 = _e291;
        }
        let _e292 = local_24;
        let _e294 = color_1[3u];
        color_1[3u] = (_e294 * _e292);
    }
    let _e298 = position[3u];
    type_39 = _e298;
    let _e299 = type_39;
    if (_e299 > 15.5f) {
        let _e302 = (*s_4).n;
        light_3.l = _e302;
        let _e305 = (*s_4).n;
        light_3.h = _e305;
        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 _e311 = light_3;
        return _e311;
    }
    let _e312 = type_39;
    if (_e312 > 2.5f) {
        let _e314 = direction;
        halfWidth_1 = _e314.xyz;
        let _e316 = cone;
        halfHeight_1 = _e316.xyz;
        let _e318 = position;
        let _e320 = v_world_position_1;
        toCentre = (_e318.xyz - _e320);
        let _e322 = toCentre;
        let _e323 = halfWidth_1;
        let _e325 = halfHeight_1;
        corners_1[0i] = ((_e322 - _e323) - _e325);
        let _e328 = toCentre;
        let _e329 = halfWidth_1;
        let _e331 = halfHeight_1;
        corners_1[1i] = ((_e328 + _e329) - _e331);
        let _e334 = toCentre;
        let _e335 = halfWidth_1;
        let _e337 = halfHeight_1;
        corners_1[2i] = ((_e334 + _e335) + _e337);
        let _e340 = toCentre;
        let _e341 = halfWidth_1;
        let _e343 = halfHeight_1;
        corners_1[3i] = ((_e340 - _e341) + _e343);
        let _e346 = toCentre;
        let _e347 = halfWidth_1;
        let _e348 = halfHeight_1;
        behind = (dot(_e346, cross(_e347, _e348)) >= 0f);
        let _e352 = behind;
        if _e352 {
            local_25 = 0f;
        } else {
            let _e353 = corners_1;
            param_92 = _e353;
            let _e355 = (*s_4).n;
            param_93 = _e355;
            let _e356 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_25 = _e356;
        }
        let _e357 = local_25;
        formFactor = _e357;
        let _e358 = halfWidth_1;
        let _e359 = halfHeight_1;
        area = (length(cross(_e358, _e359)) * 4f);
        let _e363 = area;
        if (_e363 > 0.000000001f) {
            let _e365 = area;
            local_26 = (1f / _e365);
        } else {
            local_26 = 0f;
        }
        let _e367 = local_26;
        radiance = _e367;
        let _e368 = toCentre;
        distance_2 = length(_e368);
        let _e371 = direction[3u];
        if (_e371 > 0f) {
            let _e373 = distance_2;
            let _e375 = direction[3u];
            ratio_1 = (_e373 / _e375);
            let _e377 = ratio_1;
            let _e378 = ratio_1;
            let _e380 = ratio_1;
            let _e382 = ratio_1;
            window_1 = clamp((1f - (((_e377 * _e378) * _e380) * _e382)), 0f, 1f);
            let _e386 = window_1;
            let _e387 = window_1;
            let _e389 = radiance;
            radiance = (_e389 * (_e386 * _e387));
        }
        let _e392 = (*s_4).v;
        let _e395 = (*s_4).n;
        mirror_1 = reflect(-(_e392), _e395);
        let _e397 = position;
        param_94 = _e397.xyz;
        let _e399 = halfWidth_1;
        param_95 = _e399;
        let _e400 = halfHeight_1;
        param_96 = _e400;
        let _e401 = v_world_position_1;
        param_97 = _e401;
        let _e402 = mirror_1;
        param_98 = _e402;
        let _e403 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e403;
        let _e404 = representative;
        let _e405 = v_world_position_1;
        toPoint = (_e404 - _e405);
        let _e407 = toPoint;
        pointDistance = length(_e407);
        let _e409 = pointDistance;
        if (_e409 > 0.000001f) {
            let _e411 = toPoint;
            let _e412 = pointDistance;
            local_27 = (_e411 / vec3(_e412));
        } else {
            let _e416 = (*s_4).n;
            local_27 = _e416;
        }
        let _e417 = local_27;
        light_3.l = _e417;
        let _e420 = light_3.l;
        let _e422 = (*s_4).v;
        light_3.h = normalize((_e420 + _e422));
        let _e426 = formFactor;
        light_3.n_dot_l = _e426;
        let _e429 = (*s_4).n;
        let _e431 = light_3.h;
        light_3.n_dot_h = max(dot(_e429, _e431), 0f);
        let _e436 = (*s_4).v;
        let _e438 = light_3.h;
        light_3.v_dot_h = max(dot(_e436, _e438), 0f);
        let _e442 = color_1;
        let _e445 = color_1[3u];
        let _e447 = radiance;
        light_3.radiance = ((_e442.xyz * _e445) * _e447);
        let _e450 = light_3;
        return _e450;
    }
    let _e451 = direction;
    aim = normalize(_e451.xyz);
    attenuation_1 = 1f;
    let _e454 = type_39;
    if (_e454 < 0.5f) {
        let _e456 = aim;
        light_3.l = -(_e456);
    } else {
        let _e459 = position;
        let _e461 = v_world_position_1;
        toLight_1 = (_e459.xyz - _e461);
        let _e463 = toLight_1;
        distance_3 = length(_e463);
        let _e465 = distance_3;
        if (_e465 < 0.000001f) {
            let _e468 = (*s_4).n;
            light_3.l = _e468;
            let _e471 = (*s_4).n;
            light_3.h = _e471;
            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 _e477 = light_3;
            return _e477;
        }
        let _e478 = toLight_1;
        let _e479 = distance_3;
        light_3.l = (_e478 / vec3(_e479));
        let _e483 = distance_3;
        param_99 = _e483;
        let _e485 = direction[3u];
        param_100 = _e485;
        let _e486 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e486;
        let _e487 = type_39;
        if (_e487 > 1.5f) {
            let _e489 = aim;
            let _e491 = light_3.l;
            cosAngle = dot(_e489, -(_e491));
            let _e494 = cosAngle;
            let _e496 = cone[1u];
            let _e499 = cone[0u];
            let _e501 = cone[1u];
            ramp_1 = clamp(((_e494 - _e496) / (_e499 - _e501)), 0f, 1f);
            let _e505 = ramp_1;
            let _e506 = ramp_1;
            let _e508 = attenuation_1;
            attenuation_1 = (_e508 * (_e505 * _e506));
        }
    }
    let _e511 = light_3.l;
    let _e513 = (*s_4).v;
    light_3.h = normalize((_e511 + _e513));
    let _e518 = (*s_4).n;
    let _e520 = light_3.l;
    light_3.n_dot_l = max(dot(_e518, _e520), 0f);
    let _e525 = (*s_4).n;
    let _e527 = light_3.h;
    light_3.n_dot_h = max(dot(_e525, _e527), 0f);
    let _e532 = (*s_4).v;
    let _e534 = light_3.h;
    light_3.v_dot_h = max(dot(_e532, _e534), 0f);
    let _e538 = color_1;
    let _e541 = color_1[3u];
    let _e543 = attenuation_1;
    light_3.radiance = ((_e538.xyz * _e541) * _e543);
    let _e546 = light_3;
    return _e546;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_28: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e191 = light_list_info.cluster_view_projection;
    let _e192 = (*world_3);
    clip_1 = (_e191 * vec4<f32>(_e192.x, _e192.y, _e192.z, 1f));
    let _e198 = clip_1;
    let _e201 = clip_1[3u];
    ndc_1 = (_e198.xy / vec2(max(_e201, 0.000001f)));
    let _e206 = light_list_info.cluster_grid;
    grid = _e206.xyz;
    let _e210 = light_list_info.cluster_depth[0u];
    near_1 = _e210;
    let _e212 = ndc_1[0u];
    let _e216 = grid[0u];
    let _e220 = grid[0u];
    tx = clamp(floor((((_e212 * 0.5f) + 0.5f) * _e216)), 0f, (_e220 - 1f));
    let _e224 = ndc_1[1u];
    let _e228 = grid[1u];
    let _e232 = grid[1u];
    ty = clamp(floor((((_e224 * 0.5f) + 0.5f) * _e228)), 0f, (_e232 - 1f));
    let _e236 = clip_1[3u];
    let _e237 = near_1;
    if (_e236 <= _e237) {
        local_28 = 0f;
    } else {
        let _e240 = clip_1[3u];
        let _e241 = near_1;
        let _e246 = light_list_info.cluster_depth[1u];
        let _e250 = grid[2u];
        local_28 = clamp(floor((log((_e240 / _e241)) * _e246)), 0f, (_e250 - 1f));
    }
    let _e253 = local_28;
    tz = _e253;
    let _e254 = tx;
    let _e255 = ty;
    let _e257 = grid[0u];
    let _e260 = tz;
    let _e262 = grid[0u];
    let _e265 = grid[1u];
    cell = ((_e254 + (_e255 * _e257)) + ((_e260 * _e262) * _e265));
    let _e268 = cell;
    row_3 = floor((_e268 / 4f));
    let _e271 = cell;
    let _e272 = row_3;
    let _e277 = light_list_info.cluster_depth[2u];
    let _e278 = row_3;
    param_101 = (_e271 - (_e272 * 4f));
    param_102 = (_e277 + _e278);
    let _e280 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e280;
    let _e282 = header[0u];
    g_cluster_offset = _e282;
    let _e284 = header[1u];
    g_cluster_count = _e284;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e180 = light_list_info.list[0u];
    tail = _e180;
    let _e181 = Clustered_u0028_();
    if _e181 {
        let _e182 = v_world_position_1;
        param_103 = _e182;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e183 = g_cluster_count;
        tail = _e183;
    }
    let _e186 = frag_info.frame_params[1u];
    let _e190 = tail;
    return (clamp(i32((_e186 + 0.5f)), 0i, 8i) + clamp(i32((_e190 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_29: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e194 = LightCount_u0028_();
    count_1 = _e194;
    i_8 = 0i;
    loop {
        let _e195 = i_8;
        if (_e195 < 32i) {
            let _e197 = i_8;
            let _e198 = count_1;
            if (_e197 >= _e198) {
                break;
            }
            let _e200 = i_8;
            param_104 = _e200;
            let _e201 = (*s_5);
            param_105 = _e201;
            let _e202 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_104), (&param_105));
            light_4 = _e202;
            let _e204 = light_4.n_dot_l;
            if (_e204 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e206 = i_8;
            param_106 = _e206;
            let _e207 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e207 {
                let _e208 = (*s_5);
                param_107 = _e208;
                let _e209 = light_4;
                param_108 = _e209;
                let _e210 = i_8;
                param_109 = _e210;
                let _e211 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e212 = v_world_position_1;
                param_110 = _e212;
                let _e214 = (*s_5).n;
                param_111 = _e214;
                let _e215 = i_8;
                param_112 = _e215;
                let _e216 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_29 = (_e211 * _e216);
            } else {
                local_29 = 1f;
            }
            let _e218 = local_29;
            visibility = _e218;
            let _e219 = visibility;
            if (_e219 <= 0f) {
                continue;
            }
            let _e221 = (*s_5);
            param_113 = _e221;
            let _e222 = light_4;
            param_114 = _e222;
            let _e223 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e225 = light_4.radiance;
            let _e228 = light_4.n_dot_l;
            let _e230 = visibility;
            let _e232 = light_transmittance;
            let _e234 = total_1;
            total_1 = (_e234 + ((((_e223 * _e225) * _e228) * _e230) * _e232));
            continue;
        } else {
            break;
        }
        continuing {
            let _e236 = i_8;
            i_8 = (_e236 + 1i);
        }
    }
    let _e238 = total_1;
    return _e238;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_30: f32;
    var local_31: f32;

    let _e180 = OcclusionTarget_u0028_();
    target_ = _e180;
    let _e181 = target_;
    let _e183 = target_;
    if ((_e181 > 0.5f) && (_e183 < 1.5f)) {
        local_30 = 1f;
    } else {
        let _e187 = (*s_6).occlusion;
        local_30 = _e187;
    }
    let _e188 = local_30;
    local_31 = _e188;
    let _e189 = local_31;
    return _e189;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e177 = v_lightmap_uv_1;
    let _e178 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e177);
    texel_4 = _e178;
    let _e179 = texel_4;
    let _e182 = texel_4[3u];
    return ((_e179.xyz * _e182) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e178 = frag_info.target_origin[1u];
    return _e178;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e178 = v_texcoord_1;
    let _e179 = MaterialLodBias_u0028_();
    let _e180 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e178, _e179);
    orm = _e180.xyz;
    let _e183 = (*s_7).metallic;
    let _e185 = orm[2u];
    (*s_7).metallic = clamp((_e183 * _e185), 0f, 1f);
    let _e190 = (*s_7).roughness;
    let _e192 = orm[1u];
    (*s_7).roughness = clamp((_e190 * _e192), 0.02f, 1f);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e177 = (*srgb);
    let _e180 = (*srgb);
    let _e185 = (*srgb);
    return mix((_e177 / vec3(12.92f)), pow(((_e180 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e185));
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_115: vec3<f32>;

    let _e179 = v_texcoord_1;
    let _e180 = MaterialLodBias_u0028_();
    let _e181 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e179, _e180);
    param_115 = _e181.xyz;
    let _e183 = SrgbToLinear_u0028_vf3_u003b((&param_115));
    emissive = _e183;
    let _e184 = emissive;
    let _e186 = frag_info.emissive;
    let _e191 = frag_info.material2_[3u];
    (*s_8).emissive = ((_e184 * _e186.xyz) * _e191);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e179 = v_texcoord_1;
    let _e180 = MaterialLodBias_u0028_();
    let _e181 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e179, _e180);
    occlusion = _e181.x;
    let _e185 = frag_info.material2_[2u];
    let _e186 = OcclusionTarget_u0028_();
    strength_2 = (_e185 - (2f * _e186));
    let _e189 = occlusion;
    let _e190 = strength_2;
    (*s_9).occlusion = mix(1f, _e189, clamp(_e190, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e181 = v_texcoord_1;
    let _e182 = MaterialLodBias_u0028_();
    let _e183 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e181, _e182);
    sampledTexel = _e183;
    let _e184 = v_tangent_1;
    t_2 = _e184.xyz;
    let _e186 = t_2;
    let _e188 = (*s_10).n;
    let _e190 = (*s_10).n;
    let _e191 = t_2;
    t_2 = (_e186 - (_e188 * dot(_e190, _e191)));
    let _e195 = t_2;
    let _e196 = t_2;
    if (dot(_e195, _e196) < 0.000000000001f) {
        return;
    }
    let _e199 = t_2;
    t_2 = normalize(_e199);
    let _e202 = (*s_10).n;
    let _e203 = t_2;
    let _e206 = v_tangent_1[3u];
    b_3 = (cross(_e202, _e203) * _e206);
    let _e208 = gl_FrontFacing_1;
    if !(_e208) {
        let _e210 = t_2;
        t_2 = -(_e210);
    }
    let _e212 = sampledTexel;
    sampled = ((_e212.xyz * 2f) - vec3(1f));
    let _e219 = frag_info.emissive[3u];
    if (_e219 > 0.5f) {
        let _e221 = sampled;
        let _e223 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e221.xy, _e223.xy)), 0f));
    }
    let _e232 = frag_info.material2_[1u];
    let _e233 = sampled;
    let _e235 = (_e233.xy * _e232);
    sampled[0u] = _e235.x;
    sampled[1u] = _e235.y;
    let _e240 = t_2;
    let _e242 = sampled[0u];
    let _e244 = b_3;
    let _e246 = sampled[1u];
    let _e250 = (*s_10).n;
    let _e252 = sampled[2u];
    (*s_10).n = normalize((((_e240 * _e242) + (_e244 * _e246)) + (_e250 * _e252)));
    let _e258 = (*s_10).n;
    let _e260 = (*s_10).v;
    (*s_10).n_dot_v = max(dot(_e258, _e260), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e177 = (*texel_5);
    let _e181 = irradiance_info.atlas;
    let _e184 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e177 + vec2(0.5f)) * _e181.xy), 0f);
    return _e184;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_116: vec2<f32>;
    var b_4: vec4<f32>;
    var param_117: vec2<f32>;
    var c: vec4<f32>;
    var param_118: vec2<f32>;
    var d_4: vec4<f32>;
    var param_119: vec2<f32>;

    let _e190 = (*uv_5);
    let _e191 = (*interior);
    at_1 = ((vec2(1f) + (_e190 * _e191)) - vec2(0.5f));
    let _e197 = at_1;
    low = floor(_e197);
    let _e199 = at_1;
    let _e200 = low;
    f = (_e199 - _e200);
    let _e202 = (*corner);
    let _e203 = low;
    param_116 = (_e202 + _e203);
    let _e205 = AtlasTexel_u0028_vf2_u003b((&param_116));
    a_4 = _e205;
    let _e206 = (*corner);
    let _e207 = low;
    param_117 = ((_e206 + _e207) + vec2<f32>(1f, 0f));
    let _e210 = AtlasTexel_u0028_vf2_u003b((&param_117));
    b_4 = _e210;
    let _e211 = (*corner);
    let _e212 = low;
    param_118 = ((_e211 + _e212) + vec2<f32>(0f, 1f));
    let _e215 = AtlasTexel_u0028_vf2_u003b((&param_118));
    c = _e215;
    let _e216 = (*corner);
    let _e217 = low;
    param_119 = ((_e216 + _e217) + vec2<f32>(1f, 1f));
    let _e220 = AtlasTexel_u0028_vf2_u003b((&param_119));
    d_4 = _e220;
    let _e221 = a_4;
    let _e222 = b_4;
    let _e224 = f[0u];
    let _e227 = c;
    let _e228 = d_4;
    let _e230 = f[0u];
    let _e234 = f[1u];
    return mix(mix(_e221, _e222, vec4(_e224)), mix(_e227, _e228, vec4(_e230)), vec4(_e234));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e181 = (*direction_1)[0u];
    let _e184 = (*direction_1)[1u];
    let _e188 = (*direction_1)[2u];
    sum_1 = ((abs(_e181) + abs(_e184)) + abs(_e188));
    let _e191 = sum_1;
    if (_e191 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e193 = (*direction_1);
    let _e194 = sum_1;
    n_5 = (_e193 / vec3(_e194));
    let _e197 = n_5;
    xy = _e197.xy;
    let _e200 = n_5[2u];
    if (_e200 < 0f) {
        let _e203 = n_5[1u];
        let _e207 = n_5[0u];
        let _e212 = n_5[0u];
        let _e216 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e203)) * select(-1f, 1f, (_e207 >= 0f))), ((1f - abs(_e212)) * select(-1f, 1f, (_e216 >= 0f))));
    }
    let _e221 = xy;
    return ((_e221 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_1: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_120: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_2: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_121: vec3<f32>;
    var param_122: vec2<f32>;
    var param_123: f32;
    var param_124: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_125: vec3<f32>;
    var param_126: vec2<f32>;
    var param_127: f32;
    var param_128: vec2<f32>;
    var local_32: vec3<f32>;

    let _e223 = irradiance_info.origin;
    origin_2 = _e223.xyz;
    let _e226 = irradiance_info.spacing;
    spacing = _e226.xyz;
    let _e229 = irradiance_info.counts;
    counts = _e229.xyz;
    let _e233 = irradiance_info.tiles[0u];
    irradianceTile = _e233;
    let _e236 = irradiance_info.tiles[1u];
    depthTile = _e236;
    let _e239 = irradiance_info.tiles[2u];
    columns = _e239;
    let _e242 = irradiance_info.tiles[3u];
    momentsTop = _e242;
    let _e243 = (*normal_1);
    unit = normalize(_e243);
    let _e245 = (*world_4);
    let _e246 = unit;
    let _e249 = irradiance_info.spacing[3u];
    let _e252 = (*view);
    let _e255 = irradiance_info.counts[3u];
    biased = ((_e245 + (_e246 * _e249)) + (_e252 * _e255));
    let _e258 = biased;
    let _e259 = origin_2;
    let _e261 = spacing;
    grid_1 = ((_e258 - _e259) / _e261);
    let _e263 = grid_1;
    let _e265 = counts;
    base = clamp(floor(_e263), vec3<f32>(0f, 0f, 0f), (_e265 - vec3(2f)));
    let _e269 = grid_1;
    let _e270 = base;
    f_1 = clamp((_e269 - _e270), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e273 = corner_1;
        if (_e273 < 8i) {
            let _e275 = corner_1;
            let _e278 = corner_1;
            let _e283 = corner_1;
            offset_3 = vec3<f32>(f32((_e275 & 1i)), f32(((_e278 >> bitcast<u32>(1i)) & 1i)), f32(((_e283 >> bitcast<u32>(2i)) & 1i)));
            let _e289 = base;
            let _e290 = offset_3;
            cell_1 = (_e289 + _e290);
            let _e293 = cell_1[2u];
            let _e295 = counts[1u];
            let _e298 = cell_1[1u];
            let _e301 = counts[0u];
            let _e304 = cell_1[0u];
            probe = ((((_e293 * _e295) + _e298) * _e301) + _e304);
            let _e306 = probe;
            let _e307 = columns;
            let _e312 = probe;
            let _e313 = columns;
            tile_4 = vec2<f32>((_e306 - (floor((_e306 / _e307)) * _e307)), floor((_e312 / _e313)));
            let _e317 = tile_4;
            let _e318 = irradianceTile;
            irradianceCorner = (_e317 * (_e318 + 2f));
            let _e322 = tile_4[0u];
            let _e323 = depthTile;
            let _e326 = momentsTop;
            let _e328 = tile_4[1u];
            let _e329 = depthTile;
            momentCorner = vec2<f32>((_e322 * (_e323 + 2f)), (_e326 + (_e328 * (_e329 + 2f))));
            let _e334 = irradianceCorner;
            param_120 = (_e334 + vec2(1f));
            let _e337 = AtlasTexel_u0028_vf2_u003b((&param_120));
            if (_e337.w < 0.5f) {
                continue;
            }
            let _e340 = f_1;
            let _e342 = f_1;
            let _e343 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e340), _e342, _e343);
            let _e346 = trilinear[0u];
            let _e348 = trilinear[1u];
            let _e351 = trilinear[2u];
            weight_2 = max(((_e346 * _e348) * _e351), 0.001f);
            let _e354 = origin_2;
            let _e355 = spacing;
            let _e356 = cell_1;
            probePosition = (_e354 + (_e355 * _e356));
            let _e359 = probePosition;
            let _e360 = biased;
            toProbe = (_e359 - _e360);
            let _e362 = toProbe;
            distance_4 = length(_e362);
            let _e364 = distance_4;
            if (_e364 > 0.000001f) {
                let _e366 = toProbe;
                let _e367 = distance_4;
                direction_2 = (_e366 / vec3(_e367));
                let _e370 = unit;
                let _e371 = probePosition;
                let _e372 = (*world_4);
                facing = ((dot(_e370, normalize((_e371 - _e372))) * 0.5f) + 0.5f);
                let _e378 = facing;
                let _e379 = facing;
                probeWeight = ((_e378 * _e379) + 0.2f);
                let _e382 = direction_2;
                param_121 = -(_e382);
                let _e384 = ProbeOctahedral_u0028_vf3_u003b((&param_121));
                let _e385 = momentCorner;
                param_122 = _e385;
                let _e386 = depthTile;
                param_123 = _e386;
                param_124 = _e384;
                let _e387 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_122), (&param_123), (&param_124));
                moments_3 = _e387.xy;
                chebyshev = 1f;
                let _e389 = distance_4;
                let _e391 = moments_3[0u];
                if (_e389 > _e391) {
                    let _e394 = moments_3[1u];
                    let _e396 = moments_3[0u];
                    let _e398 = moments_3[0u];
                    variance_1 = max((_e394 - (_e396 * _e398)), 0.000001f);
                    let _e402 = distance_4;
                    let _e404 = moments_3[0u];
                    difference = (_e402 - _e404);
                    let _e406 = variance_1;
                    let _e407 = variance_1;
                    let _e408 = difference;
                    let _e409 = difference;
                    chebyshev = (_e406 / (_e407 + (_e408 * _e409)));
                    let _e413 = chebyshev;
                    let _e414 = chebyshev;
                    let _e416 = chebyshev;
                    chebyshev = ((_e413 * _e414) * _e416);
                }
                let _e418 = probeWeight;
                let _e419 = chebyshev;
                probeWeight = max((_e418 * max(_e419, 0.05f)), 0.000001f);
                let _e423 = probeWeight;
                if (_e423 < 0.2f) {
                    let _e425 = probeWeight;
                    let _e426 = probeWeight;
                    let _e429 = probeWeight;
                    probeWeight = (_e429 * ((_e425 * _e426) * 25f));
                }
                let _e431 = probeWeight;
                let _e432 = weight_2;
                weight_2 = (_e432 * _e431);
            }
            let _e434 = unit;
            param_125 = _e434;
            let _e435 = ProbeOctahedral_u0028_vf3_u003b((&param_125));
            let _e436 = irradianceCorner;
            param_126 = _e436;
            let _e437 = irradianceTile;
            param_127 = _e437;
            param_128 = _e435;
            let _e438 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_126), (&param_127), (&param_128));
            let _e440 = weight_2;
            let _e442 = total_2;
            total_2 = (_e442 + (_e438.xyz * _e440));
            let _e444 = weight_2;
            let _e445 = weights;
            weights = (_e445 + _e444);
            continue;
        } else {
            break;
        }
        continuing {
            let _e447 = corner_1;
            corner_1 = (_e447 + 1i);
        }
    }
    let _e449 = weights;
    if (_e449 > 0f) {
        let _e451 = total_2;
        let _e452 = weights;
        local_32 = (_e451 / vec3(_e452));
    } else {
        local_32 = vec3<f32>(0f, 0f, 0f);
    }
    let _e455 = local_32;
    return _e455;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e178 = irradiance_info.origin[3u];
    return (_e178 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;
    var param_132: Surface;
    var param_133: Surface;
    var param_134: Surface;

    let _e183 = IrradianceEnabled_u0028_();
    if _e183 {
        let _e184 = v_world_position_1;
        param_129 = _e184;
        let _e186 = (*s_11).n;
        param_130 = _e186;
        let _e188 = (*s_11).v;
        param_131 = _e188;
        let _e189 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
        let _e192 = frag_info.material[2u];
        (*s_11).ambient = (_e189 * _e192);
    }
    let _e195 = (*s_11);
    param_132 = _e195;
    ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_132));
    let _e196 = param_132;
    (*s_11) = _e196;
    let _e197 = (*s_11);
    param_133 = _e197;
    ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_133));
    let _e198 = param_133;
    (*s_11) = _e198;
    let _e199 = (*s_11);
    param_134 = _e199;
    ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_134));
    let _e200 = param_134;
    (*s_11) = _e200;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_33: vec3<f32>;

    let _e177 = Orthographic_u0028_();
    if _e177 {
        let _e179 = fog_info.forward;
        local_33 = -(_e179.xyz);
    } else {
        let _e183 = fog_info.eye;
        let _e185 = v_world_position_1;
        local_33 = normalize((_e183.xyz - _e185));
    }
    let _e188 = local_33;
    return _e188;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_12: Surface;
    var param_135: vec3<f32>;
    var param_136: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e182 = v_texcoord_1;
    let _e183 = MaterialLodBias_u0028_();
    let _e184 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e182, _e183);
    texel_6 = _e184;
    let _e185 = texel_6;
    param_135 = _e185.xyz;
    let _e187 = SrgbToLinear_u0028_vf3_u003b((&param_135));
    let _e189 = frag_info.base_color;
    param_136 = _e189.xyz;
    let _e191 = SrgbToLinear_u0028_vf3_u003b((&param_136));
    let _e193 = v_color_1;
    s_12.albedo = ((_e187 * _e191) * _e193.xyz);
    let _e198 = texel_6[3u];
    let _e201 = frag_info.base_color[3u];
    let _e204 = v_color_1[3u];
    s_12.alpha = ((_e198 * _e201) * _e204);
    let _e208 = s_12.albedo;
    g_albedo = _e208;
    let _e211 = frag_info.material2_[0u];
    cutoff = _e211;
    let _e212 = cutoff;
    if (_e212 > 1f) {
        let _e214 = cutoff;
        edge = (_e214 - 1f);
        let _e217 = s_12.alpha;
        let _e218 = edge;
        let _e221 = s_12.alpha;
        let _e222 = fwidth(_e221);
        s_12.alpha = clamp((((_e217 - _e218) / max(_e222, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e228 = cutoff;
        if (_e228 >= 0f) {
            s_12.alpha = 1f;
        }
    }
    let _e231 = cutoff;
    let _e233 = cutoff;
    g_premultiply = ((_e231 < 0f) && (_e233 > -0.75f));
    let _e236 = v_normal_1;
    s_12.n = normalize(_e236);
    let _e239 = gl_FrontFacing_1;
    if !(_e239) {
        let _e242 = s_12.n;
        s_12.n = -(_e242);
    }
    let _e245 = TowardsEye_u0028_();
    s_12.v = _e245;
    let _e248 = s_12.n;
    let _e250 = s_12.v;
    s_12.n_dot_v = max(dot(_e248, _e250), 0.0001f);
    let _e256 = frag_info.material[0u];
    s_12.metallic = clamp(_e256, 0f, 1f);
    let _e261 = frag_info.material[1u];
    s_12.roughness = clamp(_e261, 0.02f, 1f);
    let _e265 = frag_info.ambient_ground;
    let _e268 = frag_info.ambient_sky;
    let _e272 = s_12.n[1u];
    let _e279 = frag_info.material[2u];
    s_12.ambient = (mix(_e265.xyz, _e268.xyz, vec3(((_e272 * 0.5f) + 0.5f))) * _e279);
    let _e284 = frag_info.frame_params[0u];
    s_12.exposure = max(_e284, 0f);
    s_12.occlusion = 1f;
    s_12.emissive = vec3<f32>(0f, 0f, 0f);
    let _e289 = s_12;
    return _e289;
}

fn main_1() {
    var s_13: Surface;
    var param_137: Surface;
    var param_138: Surface;
    var rim: f32;
    var ambient: vec3<f32>;
    var param_139: Surface;
    var lit_2: vec3<f32>;
    var param_140: Surface;
    var param_141: Surface;
    var param_142: vec3<f32>;
    var param_143: f32;
    var param_144: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e188 = ReadSurface_u0028_();
    s_13 = _e188;
    let _e189 = s_13;
    param_137 = _e189;
    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((&param_137));
    let _e190 = param_137;
    s_13 = _e190;
    let _e191 = s_13;
    param_138 = _e191;
    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((&param_138));
    let _e192 = param_138;
    s_13 = _e192;
    let _e194 = s_13.n_dot_v;
    let _e199 = frag_info.material[3u];
    rim = (pow((1f - _e194), 3f) * _e199);
    let _e202 = s_13.albedo;
    let _e204 = s_13.ambient;
    let _e205 = SampleLightmap_u0028_();
    let _e208 = s_13;
    param_139 = _e208;
    let _e209 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_139));
    ambient = ((_e202 * (_e204 + _e205)) * _e209);
    let _e211 = s_13;
    param_140 = _e211;
    let _e212 = 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((&param_140));
    let _e213 = s_13;
    param_141 = _e213;
    let _e214 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    let _e216 = ambient;
    let _e218 = rim;
    let _e223 = s_13.emissive;
    lit_2 = ((((_e212 * _e214) + _e216) + vec3((_e218 * 0.35f))) + _e223);
    let _e225 = lit_2;
    param_142 = _e225;
    let _e227 = s_13.alpha;
    param_143 = _e227;
    let _e229 = s_13.roughness;
    param_144 = _e229;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_142), (&param_143), (&param_144));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(4) v_tangent: vec4<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_tangent_1 = v_tangent;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'UnlitDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e131 = v_world_position_1;
    let _e133 = fog_info.eye;
    let _e137 = fog_info.forward;
    return dot((_e131 - _e133.xyz), _e137.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e136 = ViewDepth_u0028_();
    z = abs(_e136);
    let _e138 = z;
    near = (_e138 / 5f);
    let _e140 = z;
    far = (_e140 / 200f);
    let _e142 = far;
    let _e143 = far;
    let _e145 = far;
    far3_ = ((_e142 * _e143) * _e145);
    let _e147 = (*alpha);
    let _e148 = near;
    let _e149 = near;
    let _e152 = far3_;
    let _e153 = far3_;
    return (_e147 * clamp((10f / ((0.00001f + (_e148 * _e149)) + (_e152 * _e153))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e140 = fog_info.forward[3u];
    mode = _e140;
    let _e141 = mode;
    if (_e141 > 0.5f) {
        let _e144 = frag_color[3u];
        alpha_1 = _e144;
        let _e145 = alpha_1;
        param = _e145;
        let _e146 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e146;
        let _e147 = frag_color;
        let _e149 = weight;
        let _e150 = (_e147.xyz * _e149);
        let _e151 = alpha_1;
        let _e152 = weight;
        accumulate = vec4<f32>(_e150.x, _e150.y, _e150.z, (_e151 * _e152));
        let _e158 = mode;
        let _e160 = mode;
        revealage = ((_e158 > 1.5f) && (_e160 < 2.5f));
        let _e163 = revealage;
        if _e163 {
            let _e164 = alpha_1;
            local = vec4(_e164);
        } else {
            let _e166 = accumulate;
            local = _e166;
        }
        let _e167 = local;
        frag_color = _e167;
        let _e168 = mode;
        if (_e168 > 2.5f) {
            let _e170 = alpha_1;
            frag_surface = vec4(_e170);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e134 = (*n)[0u];
    let _e137 = (*n)[1u];
    let _e141 = (*n)[2u];
    let _e144 = (*n);
    (*n) = (_e144 / vec3(((abs(_e134) + abs(_e137)) + abs(_e141))));
    let _e147 = (*n);
    e = _e147.xy;
    let _e150 = (*n)[2u];
    if (_e150 < 0f) {
        let _e152 = (*n);
        let _e158 = (*n)[0u];
        let _e162 = (*n)[1u];
        e = ((vec2(1f) - abs(_e152.yx)) * vec2<f32>(select(-1f, 1f, (_e158 >= 0f)), select(-1f, 1f, (_e162 >= 0f))));
    }
    let _e167 = e;
    return ((_e167 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e132 = (*linear);
    let _e134 = (*linear);
    let _e138 = (*linear);
    return mix((_e132 * 12.92f), ((pow(_e134, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e138));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e135 = g_albedo;
    param_1 = clamp(_e135, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e137 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e137.x, _e137.y, _e137.z, 1f);
    let _e142 = g_debug_surface_on;
    if _e142 {
        let _e143 = g_debug_surface;
        let _e144 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e143.x, _e143.y, _e143.z, _e144);
        return;
    }
    let _e149 = v_normal_1;
    geometric = normalize(_e149);
    let _e151 = gl_FrontFacing_1;
    if !(_e151) {
        let _e153 = geometric;
        geometric = -(_e153);
    }
    let _e155 = geometric;
    param_2 = _e155;
    let _e156 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e157 = (*roughness);
    let _e159 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e156.x, _e156.y, clamp(_e157, 0f, 1f), _e159);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e133 = fog_info.projection[0u];
    return (_e133 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e132 = Orthographic_u0028_();
    if _e132 {
        let _e133 = ViewDepth_u0028_();
        local_1 = max(_e133, 0f);
    } else {
        let _e135 = v_world_position_1;
        let _e137 = fog_info.eye;
        local_1 = distance(_e135, _e137.xyz);
    }
    let _e140 = local_1;
    return _e140;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e139 = fog_info.fog[3u];
    density = _e139;
    let _e140 = density;
    if (_e140 <= 0f) {
        let _e142 = (*color);
        return _e142;
    }
    let _e143 = EyeDistance_u0028_();
    d = _e143;
    let _e146 = fog_info.eye[3u];
    falloff = _e146;
    let _e147 = falloff;
    if (_e147 > 0f) {
        let _e149 = falloff;
        let _e151 = v_world_position_1[1u];
        let _e154 = fog_info.eye[1u];
        k = (_e149 * (_e151 - _e154));
        let _e157 = k;
        if (abs(_e157) > 0.001f) {
            let _e160 = k;
            let _e164 = k;
            local_2 = ((1f - exp(-(_e160))) / _e164);
        } else {
            let _e166 = k;
            local_2 = (1f - (0.5f * _e166));
        }
        let _e169 = local_2;
        let _e170 = density;
        density = (_e170 * _e169);
    }
    let _e173 = fog_info.fog;
    let _e175 = (*color);
    let _e176 = density;
    let _e178 = d;
    return mix(_e173.xyz, _e175, vec3(clamp(exp((-(_e176) * _e178)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e137 = g_premultiply;
    let _e138 = (*alpha_2);
    weight_1 = select(1f, _e138, _e137);
    let _e140 = (*linearColor);
    param_3 = _e140;
    let _e141 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e142 = weight_1;
    let _e143 = (_e141 * _e142);
    let _e144 = (*alpha_2);
    let _e145 = g_pass_through;
    frag_color = vec4<f32>(_e143.x, _e143.y, _e143.z, (_e144 * (1f - _e145)));
    let _e152 = (*roughness_1);
    param_4 = _e152;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
    var param_5: vec3<f32>;
    var param_6: f32;
    var param_7: f32;

    let _e136 = (*linearColor_1);
    param_5 = _e136;
    let _e137 = (*alpha_3);
    param_6 = _e137;
    param_7 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e132 = (*srgb);
    let _e135 = (*srgb);
    let _e140 = (*srgb);
    return mix((_e132 / vec3(12.92f)), pow(((_e135 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e140));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e134 = (*key);
    hue = fract(((_e134 * 0.618034f) + 0.13f));
    let _e138 = hue;
    k_1 = clamp((abs(((fract((vec3(_e138) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e151 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e151, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_710_: bool;

    let _e132 = (*c);
    let _e133 = (*c);
    let _e135 = any((_e132 != _e133));
    phi_710_ = _e135;
    if !(_e135) {
        let _e137 = (*c);
        phi_710_ = any((abs(_e137) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e142 = phi_710_;
    return _e142;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_8: vec3<f32>;
    var param_9: vec3<f32>;
    var grey: f32;
    var param_10: vec3<f32>;
    var param_11: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_12: vec3<f32>;
    var key_1: f32;
    var param_13: f32;
    var srgb_1: vec3<f32>;
    var param_14: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_15: vec3<f32>;
    var param_16: f32;
    var phi_803_: bool;
    var phi_1074_: bool;

    let _e174 = gl_FragCoord_1[0u];
    let _e177 = frag_info.debug_view[1u];
    if (_e174 < _e177) {
        let _e181 = frag_info.debug_view[2u];
        local_3 = _e181;
    } else {
        let _e184 = frag_info.debug_view[0u];
        local_3 = _e184;
    }
    let _e185 = local_3;
    view = _e185;
    let _e186 = view;
    if (_e186 < 0.5f) {
        return false;
    }
    let _e188 = view;
    code = i32((_e188 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e191 = v_normal_1;
    geometric_n = normalize(_e191);
    let _e193 = v_tangent_1;
    let _e195 = geometric_n;
    let _e196 = geometric_n;
    let _e197 = v_tangent_1;
    tangent = (_e193.xyz - (_e195 * dot(_e196, _e197.xyz)));
    let _e202 = tangent;
    let _e203 = tangent;
    let _e205 = (dot(_e202, _e203) > 0.000000000001f);
    phi_803_ = _e205;
    if _e205 {
        let _e207 = v_tangent_1[3u];
        phi_803_ = (abs((abs(_e207) - 1f)) < 0.01f);
    }
    let _e213 = phi_803_;
    tangent_usable = _e213;
    let _e216 = frag_info.debug_view[3u];
    identity = _e216;
    let _e217 = identity;
    identity_object = floor((_e217 / 8192f));
    let _e220 = identity;
    let _e221 = identity_object;
    identity_rest = (_e220 - (_e221 * 8192f));
    let _e224 = identity_rest;
    identity_material = floor((_e224 / 2f));
    let _e227 = identity_rest;
    let _e228 = identity_material;
    normal_mapped = ((_e227 - (_e228 * 2f)) > 0.5f);
    let _e232 = code;
    if (_e232 == 1i) {
        let _e235 = (*s).albedo;
        param_8 = clamp(_e235, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e237 = LinearToSrgb_u0028_vf3_u003b((&param_8));
        shown = _e237;
    } else {
        let _e238 = code;
        if (_e238 == 2i) {
            let _e241 = (*s).n;
            shown = ((_e241 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e244 = code;
            if (_e244 == 3i) {
                let _e247 = (*s).roughness;
                shown = vec3(clamp(_e247, 0f, 1f));
            } else {
                let _e250 = code;
                if (_e250 == 4i) {
                    let _e253 = (*s).metallic;
                    shown = vec3(clamp(_e253, 0f, 1f));
                } else {
                    let _e256 = code;
                    if (_e256 == 5i) {
                        let _e259 = (*s).occlusion;
                        shown = vec3(clamp(_e259, 0f, 1f));
                    } else {
                        let _e262 = code;
                        if (_e262 == 6i) {
                            let _e265 = (*s).emissive;
                            param_9 = clamp(_e265, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e267 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                            shown = _e267;
                        } else {
                            let _e268 = code;
                            if (_e268 == 7i) {
                                let _e270 = v_texcoord_1;
                                let _e271 = fract(_e270);
                                shown = vec3<f32>(_e271.x, _e271.y, 0f);
                            } else {
                                let _e275 = code;
                                if (_e275 == 8i) {
                                    let _e277 = (*lit);
                                    param_10 = clamp(_e277, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e279 = LinearToSrgb_u0028_vf3_u003b((&param_10));
                                    grey = dot(_e279, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e281 = (*lit);
                                    param_11 = _e281;
                                    let _e282 = NonFinite_u0028_vf3_u003b((&param_11));
                                    if _e282 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e283 = grey;
                                        local_4 = vec3((_e283 * 0.5f));
                                    }
                                    let _e286 = local_4;
                                    shown = _e286;
                                } else {
                                    let _e287 = code;
                                    if (_e287 == 9i) {
                                        let _e289 = tangent_usable;
                                        if _e289 {
                                            let _e290 = tangent;
                                            local_5 = ((normalize(_e290) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e294 = local_5;
                                        shown = _e294;
                                    } else {
                                        let _e295 = code;
                                        if (_e295 == 10i) {
                                            let _e297 = v_texcoord_1;
                                            uv = _e297;
                                            let _e298 = uv;
                                            cell = floor((_e298 * 8f));
                                            let _e302 = cell[0u];
                                            let _e304 = cell[1u];
                                            odd = (fract(((_e302 + _e304) * 0.5f)) * 2f);
                                            let _e309 = uv;
                                            within = fract(_e309);
                                            let _e311 = odd;
                                            let _e315 = within[0u];
                                            let _e319 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e311)) * vec3<f32>((0.55f + (0.45f * _e315)), (0.55f + (0.45f * _e319)), 0.85f));
                                        } else {
                                            let _e324 = code;
                                            if (_e324 == 11i) {
                                                let _e326 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e326));
                                            } else {
                                                let _e329 = code;
                                                if (_e329 == 12i) {
                                                    let _e331 = v_color_1;
                                                    param_12 = clamp(_e331.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e334 = LinearToSrgb_u0028_vf3_u003b((&param_12));
                                                    shown = _e334;
                                                } else {
                                                    let _e335 = code;
                                                    let _e337 = code;
                                                    if ((_e335 == 13i) || (_e337 == 14i)) {
                                                        let _e340 = code;
                                                        let _e342 = identity_object;
                                                        let _e343 = identity_material;
                                                        key_1 = select(_e343, _e342, (_e340 == 13i));
                                                        let _e345 = key_1;
                                                        param_13 = _e345;
                                                        let _e346 = DebugIdentityColour_u0028_f1_u003b((&param_13));
                                                        let _e348 = (*s).n_dot_v;
                                                        shown = (_e346 * (0.55f + (0.45f * _e348)));
                                                    } else {
                                                        let _e352 = code;
                                                        if (_e352 == 15i) {
                                                            let _e355 = (*s).albedo;
                                                            param_14 = clamp(_e355, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e357 = LinearToSrgb_u0028_vf3_u003b((&param_14));
                                                            srgb_1 = _e357;
                                                            let _e358 = srgb_1;
                                                            luma = dot(_e358, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e361 = (*s).metallic;
                                                            metal = (_e361 > 0.5f);
                                                            let _e363 = metal;
                                                            let _e365 = luma;
                                                            if (!(_e363) && (_e365 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e368 = metal;
                                                                let _e369 = !(_e368);
                                                                phi_1074_ = _e369;
                                                                if _e369 {
                                                                    let _e371 = srgb_1[0u];
                                                                    let _e373 = srgb_1[1u];
                                                                    let _e375 = srgb_1[2u];
                                                                    phi_1074_ = (max(_e371, max(_e373, _e375)) > 0.9411765f);
                                                                }
                                                                let _e380 = phi_1074_;
                                                                if _e380 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e381 = metal;
                                                                    let _e382 = luma;
                                                                    if (_e381 && (_e382 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e385 = luma;
                                                                        local_8 = vec3(_e385);
                                                                    }
                                                                    let _e387 = local_8;
                                                                    local_7 = _e387;
                                                                }
                                                                let _e388 = local_7;
                                                                local_6 = _e388;
                                                            }
                                                            let _e389 = local_6;
                                                            shown = _e389;
                                                        } else {
                                                            let _e390 = code;
                                                            if (_e390 == 16i) {
                                                                let _e393 = (*s).metallic;
                                                                m = _e393;
                                                                let _e394 = m;
                                                                let _e396 = m;
                                                                if ((_e394 > 0.05f) && (_e396 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e399 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e399 > 0.5f)));
                                                                }
                                                                let _e403 = local_9;
                                                                shown = _e403;
                                                            } else {
                                                                let _e404 = code;
                                                                if (_e404 == 17i) {
                                                                    let _e406 = normal_mapped;
                                                                    if !(_e406) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e408 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e408));
                                                                    }
                                                                    let _e411 = local_10;
                                                                    shown = _e411;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e412 = g_premultiply;
    if _e412 {
        let _e414 = (*s).alpha;
        local_11 = _e414;
    } else {
        local_11 = 1f;
    }
    let _e415 = local_11;
    weight_2 = _e415;
    let _e416 = shown;
    param_15 = _e416;
    let _e417 = SrgbToLinear_u0028_vf3_u003b((&param_15));
    let _e418 = weight_2;
    let _e419 = (_e417 * _e418);
    let _e421 = (*s).alpha;
    frag_color = vec4<f32>(_e419.x, _e419.y, _e419.z, _e421);
    let _e427 = (*s).roughness;
    param_16 = _e427;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_16));
    WriteWeightedBlended_u0028_();
    return true;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_12: vec3<f32>;

    let _e132 = Orthographic_u0028_();
    if _e132 {
        let _e134 = fog_info.forward;
        local_12 = -(_e134.xyz);
    } else {
        let _e138 = fog_info.eye;
        let _e140 = v_world_position_1;
        local_12 = normalize((_e138.xyz - _e140));
    }
    let _e143 = local_12;
    return _e143;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin: vec3<f32>;
    var cell_1: vec3<f32>;
    var p3_: vec3<f32>;

    let _e137 = (*cutoff);
    key_2 = (-2f - _e137);
    let _e139 = key_2;
    let _e142 = key_2;
    let _e144 = floor((_e142 / 128f));
    let _e149 = key_2;
    origin = vec3<f32>(floor((_e139 / 16384f)), (_e144 - (floor((_e144 / 128f)) * 128f)), (_e149 - (floor((_e149 / 128f)) * 128f)));
    let _e155 = (*scenePosition);
    let _e158 = origin;
    let _e159 = (floor((_e155 * 16f)) + _e158);
    let _e160 = vec3(128f);
    cell_1 = (_e159 - (floor((_e159 / _e160)) * _e160));
    let _e165 = cell_1;
    p3_ = fract((_e165 * 0.1031f));
    let _e168 = p3_;
    let _e169 = p3_;
    let _e174 = p3_;
    p3_ = (_e174 + vec3(dot(_e168, (_e169.zyx + vec3(31.32f)))));
    let _e178 = p3_[0u];
    let _e180 = p3_[1u];
    let _e183 = p3_[2u];
    return fract(((_e178 + _e180) * _e183));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e133 = frag_info.target_origin[1u];
    return _e133;
}

fn ReadSurface_u0028_() -> Surface {
    var texel: vec4<f32>;
    var s_1: Surface;
    var param_17: vec3<f32>;
    var param_18: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_19: vec3<f32>;
    var param_20: f32;

    let _e139 = v_texcoord_1;
    let _e140 = MaterialLodBias_u0028_();
    let _e141 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e139, _e140);
    texel = _e141;
    let _e142 = texel;
    param_17 = _e142.xyz;
    let _e144 = SrgbToLinear_u0028_vf3_u003b((&param_17));
    let _e146 = frag_info.base_color;
    param_18 = _e146.xyz;
    let _e148 = SrgbToLinear_u0028_vf3_u003b((&param_18));
    let _e150 = v_color_1;
    s_1.albedo = ((_e144 * _e148) * _e150.xyz);
    let _e155 = texel[3u];
    let _e158 = frag_info.base_color[3u];
    let _e161 = v_color_1[3u];
    s_1.alpha = ((_e155 * _e158) * _e161);
    let _e165 = s_1.albedo;
    g_albedo = _e165;
    let _e168 = frag_info.material2_[0u];
    cutoff_1 = _e168;
    let _e169 = cutoff_1;
    if (_e169 > 1f) {
        let _e171 = cutoff_1;
        edge = (_e171 - 1f);
        let _e174 = s_1.alpha;
        let _e175 = edge;
        let _e178 = s_1.alpha;
        let _e179 = fwidth(_e178);
        s_1.alpha = clamp((((_e174 - _e175) / max(_e179, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e185 = cutoff_1;
        if (_e185 >= 0f) {
            let _e188 = s_1.alpha;
            let _e189 = cutoff_1;
            if (_e188 < _e189) {
                discard;
            }
            s_1.alpha = 1f;
        } else {
            let _e192 = cutoff_1;
            if (_e192 < -1.5f) {
                let _e195 = s_1.alpha;
                let _e196 = v_world_position_1;
                param_19 = _e196;
                let _e197 = cutoff_1;
                param_20 = _e197;
                let _e198 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_19), (&param_20));
                if (_e195 < _e198) {
                    discard;
                }
            }
        }
    }
    let _e200 = cutoff_1;
    let _e202 = cutoff_1;
    g_premultiply = ((_e200 < 0f) && (_e202 > -0.75f));
    let _e205 = v_normal_1;
    s_1.n = normalize(_e205);
    let _e208 = gl_FrontFacing_1;
    if !(_e208) {
        let _e211 = s_1.n;
        s_1.n = -(_e211);
    }
    let _e214 = TowardsEye_u0028_();
    s_1.v = _e214;
    let _e217 = s_1.n;
    let _e219 = s_1.v;
    s_1.n_dot_v = max(dot(_e217, _e219), 0.0001f);
    let _e225 = frag_info.material[0u];
    s_1.metallic = clamp(_e225, 0f, 1f);
    let _e230 = frag_info.material[1u];
    s_1.roughness = clamp(_e230, 0.02f, 1f);
    let _e234 = frag_info.ambient_ground;
    let _e237 = frag_info.ambient_sky;
    let _e241 = s_1.n[1u];
    let _e248 = frag_info.material[2u];
    s_1.ambient = (mix(_e234.xyz, _e237.xyz, vec3(((_e241 * 0.5f) + 0.5f))) * _e248);
    let _e253 = frag_info.frame_params[0u];
    s_1.exposure = max(_e253, 0f);
    s_1.occlusion = 1f;
    s_1.emissive = vec3<f32>(0f, 0f, 0f);
    let _e258 = s_1;
    return _e258;
}

fn main_1() {
    var s_2: Surface;
    var param_21: Surface;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e136 = ReadSurface_u0028_();
    s_2 = _e136;
    g_albedo = vec3<f32>(0f, 0f, 0f);
    let _e137 = s_2;
    param_21 = _e137;
    let _e139 = s_2.albedo;
    param_22 = _e139;
    let _e140 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_21), (&param_22));
    if _e140 {
        return;
    }
    let _e142 = s_2.albedo;
    param_23 = _e142;
    let _e144 = s_2.alpha;
    param_24 = _e144;
    WriteSurface_u0028_vf3_u003b_f1_u003b((&param_23), (&param_24));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    gl_FragCoord_1 = gl_FragCoord;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LambertDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e217 = v_world_position_1;
    let _e219 = fog_info.eye;
    let _e223 = fog_info.forward;
    return dot((_e217 - _e219.xyz), _e223.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e222 = ViewDepth_u0028_();
    z = abs(_e222);
    let _e224 = z;
    near = (_e224 / 5f);
    let _e226 = z;
    far = (_e226 / 200f);
    let _e228 = far;
    let _e229 = far;
    let _e231 = far;
    far3_ = ((_e228 * _e229) * _e231);
    let _e233 = (*alpha);
    let _e234 = near;
    let _e235 = near;
    let _e238 = far3_;
    let _e239 = far3_;
    return (_e233 * clamp((10f / ((0.00001f + (_e234 * _e235)) + (_e238 * _e239))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e226 = fog_info.forward[3u];
    mode = _e226;
    let _e227 = mode;
    if (_e227 > 0.5f) {
        let _e230 = frag_color[3u];
        alpha_1 = _e230;
        let _e231 = alpha_1;
        param = _e231;
        let _e232 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e232;
        let _e233 = frag_color;
        let _e235 = weight;
        let _e236 = (_e233.xyz * _e235);
        let _e237 = alpha_1;
        let _e238 = weight;
        accumulate = vec4<f32>(_e236.x, _e236.y, _e236.z, (_e237 * _e238));
        let _e244 = mode;
        let _e246 = mode;
        revealage = ((_e244 > 1.5f) && (_e246 < 2.5f));
        let _e249 = revealage;
        if _e249 {
            let _e250 = alpha_1;
            local = vec4(_e250);
        } else {
            let _e252 = accumulate;
            local = _e252;
        }
        let _e253 = local;
        frag_color = _e253;
        let _e254 = mode;
        if (_e254 > 2.5f) {
            let _e256 = alpha_1;
            frag_surface = vec4(_e256);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e220 = (*n)[0u];
    let _e223 = (*n)[1u];
    let _e227 = (*n)[2u];
    let _e230 = (*n);
    (*n) = (_e230 / vec3(((abs(_e220) + abs(_e223)) + abs(_e227))));
    let _e233 = (*n);
    e = _e233.xy;
    let _e236 = (*n)[2u];
    if (_e236 < 0f) {
        let _e238 = (*n);
        let _e244 = (*n)[0u];
        let _e248 = (*n)[1u];
        e = ((vec2(1f) - abs(_e238.yx)) * vec2<f32>(select(-1f, 1f, (_e244 >= 0f)), select(-1f, 1f, (_e248 >= 0f))));
    }
    let _e253 = e;
    return ((_e253 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e218 = (*linear);
    let _e220 = (*linear);
    let _e224 = (*linear);
    return mix((_e218 * 12.92f), ((pow(_e220, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e224));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e221 = g_albedo;
    param_1 = clamp(_e221, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e223 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e223.x, _e223.y, _e223.z, 1f);
    let _e228 = g_debug_surface_on;
    if _e228 {
        let _e229 = g_debug_surface;
        let _e230 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e229.x, _e229.y, _e229.z, _e230);
        return;
    }
    let _e235 = v_normal_1;
    geometric = normalize(_e235);
    let _e237 = gl_FrontFacing_1;
    if !(_e237) {
        let _e239 = geometric;
        geometric = -(_e239);
    }
    let _e241 = geometric;
    param_2 = _e241;
    let _e242 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e243 = (*roughness);
    let _e245 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e242.x, _e242.y, clamp(_e243, 0f, 1f), _e245);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e219 = fog_info.projection[0u];
    return (_e219 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e218 = Orthographic_u0028_();
    if _e218 {
        let _e219 = ViewDepth_u0028_();
        local_1 = max(_e219, 0f);
    } else {
        let _e221 = v_world_position_1;
        let _e223 = fog_info.eye;
        local_1 = distance(_e221, _e223.xyz);
    }
    let _e226 = local_1;
    return _e226;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e225 = fog_info.fog[3u];
    density = _e225;
    let _e226 = density;
    if (_e226 <= 0f) {
        let _e228 = (*color);
        return _e228;
    }
    let _e229 = EyeDistance_u0028_();
    d = _e229;
    let _e232 = fog_info.eye[3u];
    falloff = _e232;
    let _e233 = falloff;
    if (_e233 > 0f) {
        let _e235 = falloff;
        let _e237 = v_world_position_1[1u];
        let _e240 = fog_info.eye[1u];
        k = (_e235 * (_e237 - _e240));
        let _e243 = k;
        if (abs(_e243) > 0.001f) {
            let _e246 = k;
            let _e250 = k;
            local_2 = ((1f - exp(-(_e246))) / _e250);
        } else {
            let _e252 = k;
            local_2 = (1f - (0.5f * _e252));
        }
        let _e255 = local_2;
        let _e256 = density;
        density = (_e256 * _e255);
    }
    let _e259 = fog_info.fog;
    let _e261 = (*color);
    let _e262 = density;
    let _e264 = d;
    return mix(_e259.xyz, _e261, vec3(clamp(exp((-(_e262) * _e264)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e223 = g_premultiply;
    let _e224 = (*alpha_2);
    weight_1 = select(1f, _e224, _e223);
    let _e226 = (*linearColor);
    param_3 = _e226;
    let _e227 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e228 = weight_1;
    let _e229 = (_e227 * _e228);
    let _e230 = (*alpha_2);
    let _e231 = g_pass_through;
    frag_color = vec4<f32>(_e229.x, _e229.y, _e229.z, (_e230 * (1f - _e231)));
    let _e238 = (*roughness_1);
    param_4 = _e238;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e218 = (*srgb);
    let _e221 = (*srgb);
    let _e226 = (*srgb);
    return mix((_e218 / vec3(12.92f)), pow(((_e221 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e226));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e220 = (*key);
    hue = fract(((_e220 * 0.618034f) + 0.13f));
    let _e224 = hue;
    k_1 = clamp((abs(((fract((vec3(_e224) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e237 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e237, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2645_: bool;

    let _e218 = (*c);
    let _e219 = (*c);
    let _e221 = any((_e218 != _e219));
    phi_2645_ = _e221;
    if !(_e221) {
        let _e223 = (*c);
        phi_2645_ = any((abs(_e223) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e228 = phi_2645_;
    return _e228;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2735_: bool;
    var phi_3003_: bool;

    let _e260 = gl_FragCoord_1[0u];
    let _e263 = frag_info.debug_view[1u];
    if (_e260 < _e263) {
        let _e267 = frag_info.debug_view[2u];
        local_3 = _e267;
    } else {
        let _e270 = frag_info.debug_view[0u];
        local_3 = _e270;
    }
    let _e271 = local_3;
    view = _e271;
    let _e272 = view;
    if (_e272 < 0.5f) {
        return false;
    }
    let _e274 = view;
    code = i32((_e274 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e277 = v_normal_1;
    geometric_n = normalize(_e277);
    let _e279 = v_tangent_1;
    let _e281 = geometric_n;
    let _e282 = geometric_n;
    let _e283 = v_tangent_1;
    tangent = (_e279.xyz - (_e281 * dot(_e282, _e283.xyz)));
    let _e288 = tangent;
    let _e289 = tangent;
    let _e291 = (dot(_e288, _e289) > 0.000000000001f);
    phi_2735_ = _e291;
    if _e291 {
        let _e293 = v_tangent_1[3u];
        phi_2735_ = (abs((abs(_e293) - 1f)) < 0.01f);
    }
    let _e299 = phi_2735_;
    tangent_usable = _e299;
    let _e302 = frag_info.debug_view[3u];
    identity = _e302;
    let _e303 = identity;
    identity_object = floor((_e303 / 8192f));
    let _e306 = identity;
    let _e307 = identity_object;
    identity_rest = (_e306 - (_e307 * 8192f));
    let _e310 = identity_rest;
    identity_material = floor((_e310 / 2f));
    let _e313 = identity_rest;
    let _e314 = identity_material;
    normal_mapped = ((_e313 - (_e314 * 2f)) > 0.5f);
    let _e318 = code;
    if (_e318 == 1i) {
        let _e321 = (*s).albedo;
        param_5 = clamp(_e321, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e323 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e323;
    } else {
        let _e324 = code;
        if (_e324 == 2i) {
            let _e327 = (*s).n;
            shown = ((_e327 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e330 = code;
            if (_e330 == 3i) {
                let _e333 = (*s).roughness;
                shown = vec3(clamp(_e333, 0f, 1f));
            } else {
                let _e336 = code;
                if (_e336 == 4i) {
                    let _e339 = (*s).metallic;
                    shown = vec3(clamp(_e339, 0f, 1f));
                } else {
                    let _e342 = code;
                    if (_e342 == 5i) {
                        let _e345 = (*s).occlusion;
                        shown = vec3(clamp(_e345, 0f, 1f));
                    } else {
                        let _e348 = code;
                        if (_e348 == 6i) {
                            let _e351 = (*s).emissive;
                            param_6 = clamp(_e351, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e353 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e353;
                        } else {
                            let _e354 = code;
                            if (_e354 == 7i) {
                                let _e356 = v_texcoord_1;
                                let _e357 = fract(_e356);
                                shown = vec3<f32>(_e357.x, _e357.y, 0f);
                            } else {
                                let _e361 = code;
                                if (_e361 == 8i) {
                                    let _e363 = (*lit);
                                    param_7 = clamp(_e363, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e365 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e365, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e367 = (*lit);
                                    param_8 = _e367;
                                    let _e368 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e368 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e369 = grey;
                                        local_4 = vec3((_e369 * 0.5f));
                                    }
                                    let _e372 = local_4;
                                    shown = _e372;
                                } else {
                                    let _e373 = code;
                                    if (_e373 == 9i) {
                                        let _e375 = tangent_usable;
                                        if _e375 {
                                            let _e376 = tangent;
                                            local_5 = ((normalize(_e376) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e380 = local_5;
                                        shown = _e380;
                                    } else {
                                        let _e381 = code;
                                        if (_e381 == 10i) {
                                            let _e383 = v_texcoord_1;
                                            uv = _e383;
                                            let _e384 = uv;
                                            cell = floor((_e384 * 8f));
                                            let _e388 = cell[0u];
                                            let _e390 = cell[1u];
                                            odd = (fract(((_e388 + _e390) * 0.5f)) * 2f);
                                            let _e395 = uv;
                                            within = fract(_e395);
                                            let _e397 = odd;
                                            let _e401 = within[0u];
                                            let _e405 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e397)) * vec3<f32>((0.55f + (0.45f * _e401)), (0.55f + (0.45f * _e405)), 0.85f));
                                        } else {
                                            let _e410 = code;
                                            if (_e410 == 11i) {
                                                let _e412 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e412));
                                            } else {
                                                let _e415 = code;
                                                if (_e415 == 12i) {
                                                    let _e417 = v_color_1;
                                                    param_9 = clamp(_e417.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e420 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e420;
                                                } else {
                                                    let _e421 = code;
                                                    let _e423 = code;
                                                    if ((_e421 == 13i) || (_e423 == 14i)) {
                                                        let _e426 = code;
                                                        let _e428 = identity_object;
                                                        let _e429 = identity_material;
                                                        key_1 = select(_e429, _e428, (_e426 == 13i));
                                                        let _e431 = key_1;
                                                        param_10 = _e431;
                                                        let _e432 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e434 = (*s).n_dot_v;
                                                        shown = (_e432 * (0.55f + (0.45f * _e434)));
                                                    } else {
                                                        let _e438 = code;
                                                        if (_e438 == 15i) {
                                                            let _e441 = (*s).albedo;
                                                            param_11 = clamp(_e441, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e443 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e443;
                                                            let _e444 = srgb_1;
                                                            luma = dot(_e444, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e447 = (*s).metallic;
                                                            metal = (_e447 > 0.5f);
                                                            let _e449 = metal;
                                                            let _e451 = luma;
                                                            if (!(_e449) && (_e451 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e454 = metal;
                                                                let _e455 = !(_e454);
                                                                phi_3003_ = _e455;
                                                                if _e455 {
                                                                    let _e457 = srgb_1[0u];
                                                                    let _e459 = srgb_1[1u];
                                                                    let _e461 = srgb_1[2u];
                                                                    phi_3003_ = (max(_e457, max(_e459, _e461)) > 0.9411765f);
                                                                }
                                                                let _e466 = phi_3003_;
                                                                if _e466 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e467 = metal;
                                                                    let _e468 = luma;
                                                                    if (_e467 && (_e468 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e471 = luma;
                                                                        local_8 = vec3(_e471);
                                                                    }
                                                                    let _e473 = local_8;
                                                                    local_7 = _e473;
                                                                }
                                                                let _e474 = local_7;
                                                                local_6 = _e474;
                                                            }
                                                            let _e475 = local_6;
                                                            shown = _e475;
                                                        } else {
                                                            let _e476 = code;
                                                            if (_e476 == 16i) {
                                                                let _e479 = (*s).metallic;
                                                                m = _e479;
                                                                let _e480 = m;
                                                                let _e482 = m;
                                                                if ((_e480 > 0.05f) && (_e482 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e485 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e485 > 0.5f)));
                                                                }
                                                                let _e489 = local_9;
                                                                shown = _e489;
                                                            } else {
                                                                let _e490 = code;
                                                                if (_e490 == 17i) {
                                                                    let _e492 = normal_mapped;
                                                                    if !(_e492) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e494 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e494));
                                                                    }
                                                                    let _e497 = local_10;
                                                                    shown = _e497;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e498 = g_premultiply;
    if _e498 {
        let _e500 = (*s).alpha;
        local_11 = _e500;
    } else {
        local_11 = 1f;
    }
    let _e501 = local_11;
    weight_2 = _e501;
    let _e502 = shown;
    param_12 = _e502;
    let _e503 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e504 = weight_2;
    let _e505 = (_e503 * _e504);
    let _e507 = (*s).alpha;
    frag_color = vec4<f32>(_e505.x, _e505.y, _e505.z, _e507);
    let _e513 = (*s).roughness;
    param_13 = _e513;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_12: f32;

    let _e220 = frag_info.material2_[2u];
    local_12 = floor((_e220 * 0.5f));
    let _e223 = local_12;
    return _e223;
}

fn DirectOcclusion_u0028_struct_u002d_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_1: ptr<function, Surface>) -> f32 {
    var local_13: f32;
    var local_14: f32;

    let _e220 = OcclusionTarget_u0028_();
    if (_e220 > 1.5f) {
        local_13 = 1f;
    } else {
        let _e223 = (*s_1).occlusion;
        local_13 = _e223;
    }
    let _e224 = local_13;
    local_14 = _e224;
    let _e225 = local_14;
    return _e225;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    let _e220 = (*s_2).albedo;
    return _e220;
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e218 = (*i);
    if (_e218 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e220 = (*i);
    if (_e220 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e222 = (*i);
    if (_e222 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e224 = (*i);
    if (_e224 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e226 = (*i);
    if (_e226 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e228 = (*i);
    if (_e228 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e230 = (*i);
    if (_e230 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e223 = (*i_1);
    param_14 = _e223;
    let _e224 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e224;
    let _e226 = p[0u];
    let _e227 = (*ca);
    let _e230 = p[1u];
    let _e231 = (*sa);
    let _e235 = p[0u];
    let _e236 = (*sa);
    let _e239 = p[1u];
    let _e240 = (*ca);
    let _e244 = (*radius);
    return (vec2<f32>(((_e226 * _e227) - (_e230 * _e231)), ((_e235 * _e236) + (_e239 * _e240))) * _e244);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_15: vec2<f32>;
    var atlas: vec2<f32>;

    let _e226 = point_shadow.params[0u];
    inset = _e226;
    let _e227 = (*uv_1);
    let _e228 = (*offset);
    let _e230 = inset;
    let _e231 = inset;
    local_15 = clamp((_e227 + _e228), vec2(_e230), vec2((1f - _e231)));
    let _e236 = local_15;
    let _e237 = (*tile);
    atlas = ((_e236 + _e237) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e242 = point_shadow.params3_[0u];
    if (_e242 > 0.5f) {
        let _e245 = atlas[1u];
        atlas[1u] = (1f - _e245);
    }
    let _e248 = atlas;
    let _e249 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e248, 0f);
    let _e251 = atlas;
    let _e252 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e251, 0f);
    let _e255 = (*range);
    return (min(_e249.x, _e252.x) * _e255);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e227 = (*uv_2);
    param_15 = _e227;
    let _e228 = (*offset_1);
    param_16 = _e228;
    let _e229 = (*tile_1);
    param_17 = _e229;
    let _e230 = (*range_1);
    param_18 = _e230;
    let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e231;
    let _e232 = stored;
    let _e233 = (*range_1);
    if (_e232 >= (_e233 * 0.999f)) {
        return 1f;
    }
    let _e236 = (*receiver);
    let _e237 = stored;
    return select(1f, 0f, (_e236 > _e237));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e248 = point_shadow.params2_[1u];
    lightRadius = _e248;
    let _e251 = point_shadow.params2_[0u];
    minRadius = _e251;
    let _e254 = point_shadow.params2_[2u];
    maxRadius = _e254;
    let _e255 = lightRadius;
    if (_e255 <= 0f) {
        let _e257 = (*uv_3);
        param_19 = _e257;
        param_20 = vec2<f32>(0f, 0f);
        let _e258 = (*tile_2);
        param_21 = _e258;
        let _e259 = (*range_2);
        param_22 = _e259;
        let _e260 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e260;
        let _e261 = minRadius;
        return _e261;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e262 = i_2;
        if (_e262 < 8i) {
            let _e264 = i_2;
            param_23 = _e264;
            let _e265 = (*ca_1);
            param_24 = _e265;
            let _e266 = (*sa_1);
            param_25 = _e266;
            let _e267 = maxRadius;
            param_26 = _e267;
            let _e268 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e269 = (*uv_3);
            param_27 = _e269;
            param_28 = _e268;
            let _e270 = (*tile_2);
            param_29 = _e270;
            let _e271 = (*range_2);
            param_30 = _e271;
            let _e272 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e272;
            let _e273 = stored_1;
            let _e274 = (*range_2);
            if (_e273 >= (_e274 * 0.999f)) {
                continue;
            }
            let _e277 = stored_1;
            let _e278 = (*receiver_1);
            if (_e277 >= _e278) {
                continue;
            }
            let _e280 = stored_1;
            let _e281 = sum;
            sum = (_e281 + _e280);
            let _e283 = count;
            count = (_e283 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e285 = i_2;
            i_2 = (_e285 + 1i);
        }
    }
    let _e287 = count;
    if (_e287 < 0.5f) {
        return -1f;
    }
    let _e289 = sum;
    let _e290 = count;
    blocker = max((_e289 / _e290), 0.0001f);
    let _e293 = blocker;
    (*blockerOut) = _e293;
    let _e294 = lightRadius;
    let _e295 = (*receiver_1);
    let _e296 = blocker;
    let _e300 = blocker;
    world = ((_e294 * max((_e295 - _e296), 0f)) / _e300);
    let _e302 = world;
    let _e303 = (*receiver_1);
    let _e305 = (*tanHalf);
    let _e308 = minRadius;
    let _e309 = maxRadius;
    return clamp((_e302 / ((2f * _e303) * _e305)), _e308, _e309);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_16: vec2<f32>;

    let _e219 = (*rows);
    if (_e219 > 0f) {
        let _e222 = gl_FragCoord_1[0u];
        let _e223 = (*rows);
        let _e225 = gl_FragCoord_1[1u];
        local_16 = vec2<f32>(_e222, (_e223 - _e225));
    } else {
        let _e228 = gl_FragCoord_1;
        local_16 = _e228.xy;
    }
    let _e230 = local_16;
    return _e230;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_17: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2332_: bool;
    var phi_2393_: bool;

    let _e271 = (*lightIndex);
    let _e275 = point_shadow.slots[_e271][0u];
    slot = i32((_e275 + 0.5f));
    let _e278 = (*lightIndex);
    let _e282 = point_shadow.slots[_e278][0u];
    if (_e282 < 0f) {
        return 1f;
    }
    let _e286 = point_shadow.params[2u];
    strength = _e286;
    let _e287 = strength;
    if (_e287 <= 0f) {
        return 1f;
    }
    let _e289 = slot;
    let _e292 = point_shadow.lights[_e289];
    let _e294 = (*world_1);
    toLight = (_e292.xyz - _e294);
    let _e296 = toLight;
    toLightLength = max(length(_e296), 0.000001f);
    let _e299 = (*normal);
    let _e300 = toLight;
    let _e301 = toLightLength;
    nDotL = max(dot(_e299, (_e300 / vec3(_e301))), 0.15f);
    let _e306 = nDotL;
    let _e307 = nDotL;
    let _e312 = nDotL;
    let _e313 = nDotL;
    slope = min((sqrt(max((1f - (_e306 * _e307)), 0f)) / (_e312 * _e313)), 8f);
    let _e317 = toLightLength;
    let _e319 = (*lightIndex);
    let _e323 = point_shadow.slots[_e319][2u];
    let _e328 = point_shadow.params3_[1u];
    texel = (((2f * _e317) * max(_e323, 0.0001f)) * _e328);
    let _e330 = (*world_1);
    let _e331 = (*normal);
    let _e332 = texel;
    let _e336 = point_shadow.params[3u];
    let _e338 = slope;
    origin = (_e330 + (((_e331 * _e332) * _e336) * (1f + _e338)));
    let _e342 = origin;
    let _e343 = slot;
    let _e346 = point_shadow.lights[_e343];
    toFragment = (_e342 - _e346.xyz);
    let _e349 = toFragment;
    distance_ = length(_e349);
    let _e351 = slot;
    let _e355 = point_shadow.lights[_e351][3u];
    range_3 = max(_e355, 0.0001f);
    let _e357 = distance_;
    let _e358 = range_3;
    if (_e357 >= _e358) {
        return 1f;
    }
    face = 0i;
    let _e360 = (*lightIndex);
    let _e364 = point_shadow.slots[_e360][1u];
    if (_e364 < 0.5f) {
        let _e366 = toFragment;
        a = abs(_e366);
        let _e369 = a[0u];
        let _e371 = a[1u];
        let _e372 = (_e369 >= _e371);
        phi_2332_ = _e372;
        if _e372 {
            let _e374 = a[0u];
            let _e376 = a[2u];
            phi_2332_ = (_e374 >= _e376);
        }
        let _e379 = phi_2332_;
        if _e379 {
            let _e381 = toFragment[0u];
            face = select(1i, 0i, (_e381 > 0f));
        } else {
            let _e385 = a[1u];
            let _e387 = a[2u];
            if (_e385 >= _e387) {
                let _e390 = toFragment[1u];
                face = select(3i, 2i, (_e390 > 0f));
            } else {
                let _e394 = toFragment[2u];
                face = select(5i, 4i, (_e394 > 0f));
            }
        }
    }
    let _e397 = slot;
    let _e399 = face;
    let _e403 = point_shadow.faces[((_e397 * 6i) + _e399)];
    let _e404 = origin;
    clip = (_e403 * vec4<f32>(_e404.x, _e404.y, _e404.z, 1f));
    let _e411 = clip[3u];
    if (_e411 <= 0f) {
        return 1f;
    }
    let _e413 = clip;
    let _e416 = clip[3u];
    ndc = (_e413.xy / vec2(_e416));
    let _e420 = ndc[0u];
    let _e422 = (abs(_e420) > 1f);
    phi_2393_ = _e422;
    if !(_e422) {
        let _e425 = ndc[1u];
        phi_2393_ = (abs(_e425) > 1f);
    }
    let _e429 = phi_2393_;
    if _e429 {
        return 1f;
    }
    let _e431 = ndc[0u];
    let _e435 = ndc[1u];
    uv_4 = vec2<f32>(((_e431 * 0.5f) + 0.5f), (0.5f - (_e435 * 0.5f)));
    let _e439 = face;
    let _e441 = slot;
    tile_3 = vec2<f32>(f32(_e439), f32(_e441));
    let _e444 = distance_;
    let _e447 = point_shadow.params[1u];
    receiver_2 = (_e444 - _e447);
    let _e451 = frag_info.target_origin[0u];
    param_31 = _e451;
    let _e452 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e452, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e457 = noise;
    angle = (_e457 * 6.2831855f);
    let _e459 = angle;
    ca_2 = cos(_e459);
    let _e461 = angle;
    sa_2 = sin(_e461);
    let _e463 = (*lightIndex);
    let _e467 = point_shadow.slots[_e463][2u];
    tanHalf_1 = max(_e467, 0.0001f);
    blocker_1 = -1f;
    let _e469 = uv_4;
    param_32 = _e469;
    let _e470 = tile_3;
    param_33 = _e470;
    let _e471 = range_3;
    param_34 = _e471;
    let _e472 = receiver_2;
    param_35 = _e472;
    let _e473 = ca_2;
    param_36 = _e473;
    let _e474 = sa_2;
    param_37 = _e474;
    let _e475 = tanHalf_1;
    param_38 = _e475;
    let _e476 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e477 = param_39;
    blocker_1 = _e477;
    radius_1 = _e476;
    let _e480 = point_shadow.params2_[3u];
    if (_e480 > 0.5f) {
        g_debug_surface_on = true;
        let _e482 = radius_1;
        if (_e482 < 0f) {
            local_17 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e484 = radius_1;
            let _e487 = point_shadow.params2_[2u];
            let _e491 = blocker_1;
            let _e492 = range_3;
            local_17 = vec3<f32>(clamp((_e484 / max(_e487, 0.000001f)), 0f, 1f), clamp((_e491 / _e492), 0f, 1f), 0f);
        }
        let _e496 = local_17;
        g_debug_surface = _e496;
    }
    let _e497 = radius_1;
    if (_e497 < 0f) {
        return 1f;
    }
    let _e499 = uv_4;
    param_40 = _e499;
    param_41 = vec2<f32>(0f, 0f);
    let _e500 = tile_3;
    param_42 = _e500;
    let _e501 = range_3;
    param_43 = _e501;
    let _e502 = receiver_2;
    param_44 = _e502;
    let _e503 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e503;
    let _e504 = radius_1;
    if (_e504 > 0f) {
        i_3 = 0i;
        loop {
            let _e506 = i_3;
            if (_e506 < 8i) {
                let _e508 = i_3;
                param_45 = _e508;
                let _e509 = ca_2;
                param_46 = _e509;
                let _e510 = sa_2;
                param_47 = _e510;
                let _e511 = radius_1;
                param_48 = _e511;
                let _e512 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e513 = uv_4;
                param_49 = _e513;
                param_50 = _e512;
                let _e514 = tile_3;
                param_51 = _e514;
                let _e515 = range_3;
                param_52 = _e515;
                let _e516 = receiver_2;
                param_53 = _e516;
                let _e517 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e518 = lit_1;
                lit_1 = (_e518 + _e517);
                continue;
            } else {
                break;
            }
            continuing {
                let _e520 = i_3;
                i_3 = (_e520 + 1i);
            }
        }
        let _e522 = lit_1;
        lit_1 = (_e522 * 0.11111111f);
    }
    let _e524 = lit_1;
    let _e525 = strength;
    return mix(1f, _e524, clamp(_e525, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e222 = (*i_4);
    let _e225 = (*n_1);
    r = sqrt(((f32(_e222) + 0.5f) / f32(_e225)));
    let _e229 = (*i_4);
    let _e232 = (*turn);
    theta = ((f32(_e229) * 2.3999631f) + _e232);
    let _e234 = r;
    let _e235 = theta;
    let _e237 = theta;
    return (vec2<f32>(cos(_e235), sin(_e237)) * _e234);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e221 = frag_info.target_origin[0u];
    param_54 = _e221;
    let _e222 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e225 = frag_info.target_origin[3u];
    at = (_e222 + vec2((5.588238f * max(_e225, 0f))));
    let _e230 = at;
    return fract((52.982918f * fract(dot(_e230, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_18: f32;

    let _e220 = (*mode_1);
    if (_e220 > 0.5f) {
        let _e222 = (*stored_2);
        local_18 = (1f - _e222);
    } else {
        let _e224 = (*stored_2);
        local_18 = _e224;
    }
    let _e225 = local_18;
    return _e225;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e226 = (*moments)[1u];
    let _e228 = (*moments)[0u];
    let _e230 = (*moments)[0u];
    let _e233 = (*minVariance);
    variance = max((_e226 - (_e228 * _e230)), _e233);
    let _e235 = (*t);
    let _e237 = (*moments)[0u];
    d_1 = (_e235 - _e237);
    let _e239 = variance;
    let _e240 = variance;
    let _e241 = d_1;
    let _e242 = d_1;
    pMax = (_e239 / (_e240 + (_e241 * _e242)));
    let _e246 = pMax;
    let _e247 = (*bleed);
    let _e249 = (*bleed);
    reduced = clamp(((_e246 - _e247) / max((1f - _e249), 0.0001f)), 0f, 1f);
    let _e254 = (*t);
    let _e256 = (*moments)[0u];
    let _e258 = reduced;
    return select(_e258, 1f, (_e254 <= _e256));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e219 = (*depth);
    d_2 = ((2f * clamp(_e219, 0f, 1f)) - 1f);
    let _e223 = d_2;
    let _e226 = d_2;
    return vec2<f32>(exp((40f * _e223)), -(exp((-5f * _e226))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e233 = (*depth_1);
    param_55 = _e233;
    let _e234 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e234;
    let _e235 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e235);
    let _e238 = scale[0u];
    let _e240 = scale[0u];
    let _e242 = (*moments_1);
    param_56 = _e242.xy;
    let _e245 = warped[0u];
    param_57 = _e245;
    param_58 = (_e238 * _e240);
    let _e246 = (*bleed_1);
    param_59 = _e246;
    let _e247 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e247;
    let _e249 = scale[1u];
    let _e251 = scale[1u];
    let _e253 = (*moments_1);
    param_60 = _e253.zw;
    let _e256 = warped[1u];
    param_61 = _e256;
    param_62 = (_e249 * _e251);
    let _e257 = (*bleed_1);
    param_63 = _e257;
    let _e258 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e258;
    let _e259 = positive;
    let _e260 = negative;
    return min(_e259, _e260);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e219 = (*depth_2);
    stored_3 = max((1f - _e219), 0.000061035156f);
    let _e222 = stored_3;
    return exp2((floor(log2(_e222)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_19: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_20: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_22: f32;
    var local_23: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3962_: bool;
    var phi_3973_: bool;
    var phi_4130_: bool;
    var phi_4137_: bool;
    var phi_4144_: bool;

    let _e298 = frag_info.shadow_params[3u];
    strength_1 = _e298;
    let _e299 = strength_1;
    if (_e299 <= 0f) {
        return 1f;
    }
    let _e301 = (*lightIndex_1);
    let _e304 = frag_info.frame_params[2u];
    if (_e301 != i32(floor((_e304 + 0.5f)))) {
        return 1f;
    }
    let _e311 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e311 + 0.5f));
    let _e314 = Orthographic_u0028_();
    if _e314 {
        let _e315 = ViewDepth_u0028_();
        local_19 = _e315;
    } else {
        let _e316 = v_world_position_1;
        let _e318 = frag_info.camera_position;
        local_19 = length((_e316 - _e318.xyz));
    }
    let _e322 = local_19;
    viewDistance = _e322;
    cascade = 0i;
    let _e323 = cascadeCount;
    let _e324 = (_e323 > 1i);
    phi_3962_ = _e324;
    if _e324 {
        let _e325 = viewDistance;
        let _e328 = frag_info.shadow_cascades[0u];
        phi_3962_ = (_e325 > _e328);
    }
    let _e331 = phi_3962_;
    if _e331 {
        cascade = 1i;
    }
    let _e332 = cascadeCount;
    let _e333 = (_e332 > 2i);
    phi_3973_ = _e333;
    if _e333 {
        let _e334 = viewDistance;
        let _e337 = frag_info.shadow_cascades[1u];
        phi_3973_ = (_e334 > _e337);
    }
    let _e340 = phi_3973_;
    if _e340 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e341 = attempt;
        if (_e341 < 3i) {
            let _e343 = cascade;
            let _e344 = attempt;
            which = (_e343 + _e344);
            let _e346 = which;
            let _e347 = cascadeCount;
            if (_e346 >= _e347) {
                break;
            }
            let _e349 = which;
            if (_e349 == 0i) {
                let _e352 = frag_info.shadow_matrix;
                local_20 = _e352;
            } else {
                let _e353 = which;
                if (_e353 == 1i) {
                    let _e356 = frag_info.shadow_matrix_far;
                    local_21 = _e356;
                } else {
                    let _e358 = frag_info.shadow_matrix_farthest;
                    local_21 = _e358;
                }
                let _e359 = local_21;
                local_20 = _e359;
            }
            let _e360 = local_20;
            matrix = _e360;
            let _e363 = matrix[0][0u];
            let _e366 = matrix[1][0u];
            let _e369 = matrix[2][0u];
            axisX = vec3<f32>(_e363, _e366, _e369);
            let _e373 = matrix[0][1u];
            let _e376 = matrix[1][1u];
            let _e379 = matrix[2][1u];
            axisY = vec3<f32>(_e373, _e376, _e379);
            let _e381 = axisX;
            rowX = max(length(_e381), 0.000001f);
            let _e384 = axisY;
            rowY = max(length(_e384), 0.000001f);
            let _e389 = frag_info.shadow_cascades[3u];
            let _e391 = rowX;
            texelMetres = ((2f * _e389) / _e391);
            let _e395 = frag_info.shadow_cascades[3u];
            let _e398 = (*s_3).n;
            let _e399 = axisX;
            let _e402 = rowX;
            let _e403 = rowX;
            let _e407 = (*s_3).n;
            let _e408 = axisY;
            let _e411 = rowY;
            let _e412 = rowY;
            reach = ((3f * _e395) * ((abs(dot(_e398, _e399)) / (_e402 * _e403)) + (abs(dot(_e407, _e408)) / (_e411 * _e412))));
            let _e419 = frag_info.shadow_params[2u];
            let _e420 = texelMetres;
            flatOffset = min(_e419, _e420);
            let _e422 = v_world_position_1;
            let _e424 = (*s_3).n;
            let _e425 = flatOffset;
            let _e426 = reach;
            origin_1 = (_e422 + (_e424 * (_e425 + _e426)));
            let _e430 = matrix;
            let _e431 = origin_1;
            lightSpace = (_e430 * vec4<f32>(_e431.x, _e431.y, _e431.z, 1f));
            let _e438 = lightSpace[3u];
            if (_e438 <= 0f) {
                continue;
            }
            let _e440 = lightSpace;
            let _e443 = lightSpace[3u];
            candidate = (_e440.xyz / vec3(_e443));
            let _e447 = candidate[0u];
            let _e451 = candidate[1u];
            inTile = vec2<f32>(((_e447 * 0.5f) + 0.5f), (0.5f - (_e451 * 0.5f)));
            let _e456 = inTile[0u];
            let _e457 = (_e456 < 0f);
            phi_4130_ = _e457;
            if !(_e457) {
                let _e460 = inTile[0u];
                phi_4130_ = (_e460 > 1f);
            }
            let _e463 = phi_4130_;
            phi_4137_ = _e463;
            if !(_e463) {
                let _e466 = inTile[1u];
                phi_4137_ = (_e466 < 0f);
            }
            let _e469 = phi_4137_;
            phi_4144_ = _e469;
            if !(_e469) {
                let _e472 = inTile[1u];
                phi_4144_ = (_e472 > 1f);
            }
            let _e475 = phi_4144_;
            if _e475 {
                continue;
            }
            let _e477 = candidate[2u];
            if (_e477 > 1f) {
                let _e479 = which;
                let _e480 = cascadeCount;
                if (_e479 < (_e480 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e485 = inTile[0u];
            let _e486 = which;
            let _e489 = cascadeCount;
            let _e493 = inTile[1u];
            uv_5 = vec2<f32>(((_e485 + f32(_e486)) / f32(_e489)), _e493);
            let _e495 = candidate;
            projected = _e495;
            let _e496 = which;
            cascade = _e496;
            let _e497 = texelMetres;
            cascadeTexel = _e497;
            let _e500 = matrix[0][2u];
            let _e503 = matrix[1][2u];
            let _e506 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e500, _e503, _e506)), 0.000001f));
            let _e512 = (*s_3).n;
            let _e515 = matrix[0][2u];
            let _e518 = matrix[1][2u];
            let _e521 = matrix[2][2u];
            let _e525 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e512, vec3<f32>(_e515, _e518, _e521))) * _e525), 0.1f, 1f);
            let _e528 = texelMetres;
            let _e529 = cosSlope;
            let _e530 = cosSlope;
            let _e536 = cosSlope;
            let _e538 = cascadeDepth;
            receiverSlope = (((_e528 * sqrt(max((1f - (_e529 * _e530)), 0f))) / _e536) / _e538);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e540 = attempt;
            attempt = (_e540 + 1i);
        }
    }
    let _e542 = found;
    if !(_e542) {
        return 1f;
    }
    let _e544 = cascade;
    if (_e544 == 0i) {
        let _e548 = frag_info.shadow_bias[0u];
        local_22 = _e548;
    } else {
        let _e549 = cascade;
        if (_e549 == 1i) {
            let _e553 = frag_info.shadow_bias[1u];
            local_23 = _e553;
        } else {
            let _e556 = frag_info.shadow_bias[2u];
            local_23 = _e556;
        }
        let _e557 = local_23;
        local_22 = _e557;
    }
    let _e558 = local_22;
    bias = _e558;
    let _e561 = frag_info.shadow_params[1u];
    storage_ = _e561;
    let _e562 = storage_;
    let _e564 = storage_;
    if ((_e562 > 0.5f) && (_e564 < 1.5f)) {
        let _e567 = bias;
        let _e569 = projected[2u];
        param_64 = _e569;
        let _e570 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e567, _e570);
    }
    let _e574 = frag_info.shadow_params[0u];
    let _e577 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e574, _e577);
    let _e579 = cascade;
    let _e581 = cascadeCount;
    let _e585 = texel_1;
    tileLo = (vec2<f32>((f32(_e579) / f32(_e581)), 0f) + (_e585 * 0.5f));
    let _e588 = cascade;
    let _e591 = cascadeCount;
    let _e595 = texel_1;
    tileHi = (vec2<f32>((f32((_e588 + 1i)) / f32(_e591)), 1f) - (_e595 * 0.5f));
    let _e600 = frag_info.shadow_bias[3u];
    if (_e600 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e602 = y;
            if (_e602 <= 1i) {
                x = -1i;
                loop {
                    let _e604 = x;
                    if (_e604 <= 1i) {
                        let _e606 = uv_5;
                        let _e607 = x;
                        let _e609 = y;
                        let _e612 = texel_1;
                        let _e615 = tileLo;
                        let _e616 = tileHi;
                        let _e618 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e606 + (vec2<f32>(f32(_e607), f32(_e609)) * _e612)), _e615, _e616), 0f);
                        let _e619 = stored_4;
                        stored_4 = (_e619 + _e618);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e621 = x;
                        x = (_e621 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e623 = y;
                y = (_e623 + 1i);
            }
        }
        let _e625 = stored_4;
        stored_4 = (_e625 * 0.11111111f);
        let _e628 = stored_4[1u];
        let _e631 = stored_4[2u];
        let _e634 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e628), (1f - _e631), _e634), vec3(0f), vec3(4f));
        let _e639 = through;
        let _e640 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e639, vec3(clamp(_e640, 0f, 1f)));
    }
    let _e646 = frag_info.ambient_ground[3u];
    softness = _e646;
    lit_2 = 0f;
    let _e647 = softness;
    if (_e647 < 0f) {
        let _e649 = uv_5;
        let _e650 = tileLo;
        let _e651 = tileHi;
        let _e653 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e649, _e650, _e651), 0f);
        moments_2 = _e653;
        let _e655 = projected[2u];
        let _e656 = bias;
        let _e658 = softness;
        let _e662 = moments_2;
        param_65 = _e662;
        param_66 = (_e655 - _e656);
        param_67 = clamp((-(_e658) - 1f), 0f, 0.95f);
        let _e663 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e663;
    } else {
        let _e664 = softness;
        if (_e664 <= 0f) {
            y_1 = -1i;
            loop {
                let _e666 = y_1;
                if (_e666 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e668 = x_1;
                        if (_e668 <= 1i) {
                            let _e670 = uv_5;
                            let _e671 = x_1;
                            let _e673 = y_1;
                            let _e676 = texel_1;
                            let _e679 = tileLo;
                            let _e680 = tileHi;
                            let _e682 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e670 + (vec2<f32>(f32(_e671), f32(_e673)) * _e676)), _e679, _e680), 0f);
                            param_68 = _e682.x;
                            let _e684 = storage_;
                            param_69 = _e684;
                            let _e685 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e685;
                            let _e687 = projected[2u];
                            let _e688 = bias;
                            let _e690 = occluder;
                            let _e693 = lit_2;
                            lit_2 = (_e693 + select(1f, 0f, ((_e687 - _e688) > _e690)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e695 = x_1;
                            x_1 = (_e695 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e697 = y_1;
                    y_1 = (_e697 + 1i);
                }
            }
            let _e699 = lit_2;
            lit_2 = (_e699 * 0.11111111f);
        } else {
            let _e701 = softness;
            spread = tan(min(_e701, 0.5f));
            let _e704 = ShadowNoise_u0028_();
            turn_1 = (_e704 * 6.2831855f);
            let _e706 = spread;
            let _e708 = projected[2u];
            let _e710 = cascadeDepth;
            let _e712 = cascadeTexel;
            searchRadius = clamp((((_e706 * _e708) * _e710) / _e712), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e715 = i_5;
                if (_e715 < 16i) {
                    let _e717 = i_5;
                    param_70 = _e717;
                    param_71 = 16i;
                    let _e718 = turn_1;
                    param_72 = _e718;
                    let _e719 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e719;
                    let _e720 = bias;
                    let _e721 = disc;
                    let _e723 = searchRadius;
                    let _e727 = receiverSlope;
                    tapBias = (_e720 + (max(((length(_e721) * _e723) - 1.5f), 0f) * _e727));
                    let _e730 = uv_5;
                    let _e731 = disc;
                    let _e732 = texel_1;
                    let _e734 = searchRadius;
                    let _e737 = tileLo;
                    let _e738 = tileHi;
                    let _e740 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e730 + ((_e731 * _e732) * _e734)), _e737, _e738), 0f);
                    param_73 = _e740.x;
                    let _e742 = storage_;
                    param_74 = _e742;
                    let _e743 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e743;
                    let _e745 = projected[2u];
                    let _e746 = tapBias;
                    let _e748 = occluder_1;
                    if ((_e745 - _e746) > _e748) {
                        let _e750 = occluder_1;
                        let _e751 = blockerSum;
                        blockerSum = (_e751 + _e750);
                        let _e753 = blockerCount;
                        blockerCount = (_e753 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e755 = i_5;
                    i_5 = (_e755 + 1i);
                }
            }
            let _e757 = blockerCount;
            if (_e757 <= 0f) {
                return 1f;
            }
            let _e760 = projected[2u];
            let _e761 = blockerSum;
            let _e762 = blockerCount;
            let _e766 = cascadeDepth;
            gap = (max((_e760 - (_e761 / _e762)), 0f) * _e766);
            let _e768 = spread;
            let _e769 = gap;
            let _e771 = cascadeTexel;
            radius_2 = clamp(((_e768 * _e769) / _e771), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e774 = i_6;
                if (_e774 < 16i) {
                    let _e776 = turn_1;
                    let _e778 = i_6;
                    param_75 = _e778;
                    param_76 = 16i;
                    param_77 = (_e776 + 1f);
                    let _e779 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e779;
                    let _e780 = bias;
                    let _e781 = disc_1;
                    let _e783 = radius_2;
                    let _e787 = receiverSlope;
                    tapBias_1 = (_e780 + (max(((length(_e781) * _e783) - 1.5f), 0f) * _e787));
                    let _e790 = uv_5;
                    let _e791 = disc_1;
                    let _e792 = texel_1;
                    let _e794 = radius_2;
                    let _e797 = tileLo;
                    let _e798 = tileHi;
                    let _e800 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e790 + ((_e791 * _e792) * _e794)), _e797, _e798), 0f);
                    param_78 = _e800.x;
                    let _e802 = storage_;
                    param_79 = _e802;
                    let _e803 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e803;
                    let _e805 = projected[2u];
                    let _e806 = tapBias_1;
                    let _e808 = occluder_2;
                    let _e811 = lit_2;
                    lit_2 = (_e811 + select(1f, 0f, ((_e805 - _e806) > _e808)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e813 = i_6;
                    i_6 = (_e813 + 1i);
                }
            }
            let _e815 = lit_2;
            lit_2 = (_e815 * 0.0625f);
        }
    }
    let _e817 = lit_2;
    let _e818 = strength_1;
    return mix(1f, _e817, clamp(_e818, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e223 = (*s_4);
    param_80 = _e223;
    let _e224 = (*light_2);
    param_81 = _e224;
    let _e225 = (*index);
    param_82 = _e225;
    let _e226 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e226;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e218 = (*index_1);
    return (_e218 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e222 = (*distance_1);
    let _e223 = (*distance_1);
    attenuation = (1f / max((_e222 * _e223), 0.0001f));
    let _e227 = (*range_4);
    if (_e227 > 0f) {
        let _e229 = (*distance_1);
        let _e230 = (*range_4);
        ratio = (_e229 / _e230);
        let _e232 = ratio;
        let _e233 = ratio;
        let _e235 = ratio;
        let _e237 = ratio;
        window = clamp((1f - (((_e232 * _e233) * _e235) * _e237)), 0f, 1f);
        let _e241 = window;
        let _e242 = window;
        let _e244 = attenuation;
        attenuation = (_e244 * (_e241 * _e242));
    }
    let _e246 = attenuation;
    return _e246;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_24: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e234 = (*halfWidth);
    let _e235 = (*halfHeight);
    n_2 = cross(_e234, _e235);
    let _e237 = n_2;
    nLen = length(_e237);
    let _e239 = nLen;
    if (_e239 < 0.000000000001f) {
        let _e241 = (*centre);
        return _e241;
    }
    let _e242 = nLen;
    let _e243 = n_2;
    n_2 = (_e243 / vec3(_e242));
    let _e246 = (*centre);
    let _e247 = (*world_2);
    toPlane = (_e246 - _e247);
    let _e249 = (*mirror);
    let _e250 = n_2;
    denom = dot(_e249, _e250);
    let _e252 = denom;
    if (abs(_e252) < 0.00001f) {
        let _e255 = toPlane;
        let _e256 = n_2;
        let _e257 = toPlane;
        let _e258 = n_2;
        onPlane = (_e255 - (_e256 * dot(_e257, _e258)));
    } else {
        let _e262 = toPlane;
        let _e263 = n_2;
        let _e265 = denom;
        t_1 = (dot(_e262, _e263) / _e265);
        let _e267 = t_1;
        if (_e267 > 0f) {
            let _e269 = (*mirror);
            let _e270 = t_1;
            local_24 = (_e269 * _e270);
        } else {
            let _e272 = toPlane;
            let _e273 = n_2;
            let _e274 = toPlane;
            let _e275 = n_2;
            local_24 = (_e272 - (_e273 * dot(_e274, _e275)));
        }
        let _e279 = local_24;
        onPlane = _e279;
    }
    let _e280 = onPlane;
    let _e281 = toPlane;
    offset_2 = (_e280 - _e281);
    let _e283 = (*halfWidth);
    let _e284 = (*halfWidth);
    wLen2_ = max(dot(_e283, _e284), 0.000000000001f);
    let _e287 = (*halfHeight);
    let _e288 = (*halfHeight);
    hLen2_ = max(dot(_e287, _e288), 0.000000000001f);
    let _e291 = offset_2;
    let _e292 = (*halfWidth);
    let _e294 = wLen2_;
    u = clamp((dot(_e291, _e292) / _e294), -1f, 1f);
    let _e297 = offset_2;
    let _e298 = (*halfHeight);
    let _e300 = hLen2_;
    v = clamp((dot(_e297, _e298) / _e300), -1f, 1f);
    let _e303 = (*centre);
    let _e304 = (*halfWidth);
    let _e305 = u;
    let _e308 = (*halfHeight);
    let _e309 = v;
    return ((_e303 + (_e304 * _e305)) + (_e308 * _e309));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_25: f32;

    let _e226 = (*a_1);
    let _e227 = (*a_1);
    ua = (_e226 / vec3(max(length(_e227), 0.000000000001f)));
    let _e232 = (*b);
    let _e233 = (*b);
    ub = (_e232 / vec3(max(length(_e233), 0.000000000001f)));
    let _e238 = ua;
    let _e239 = ub;
    angle_1 = acos(clamp(dot(_e238, _e239), -1f, 1f));
    let _e243 = ua;
    let _e244 = ub;
    axis = cross(_e243, _e244);
    let _e246 = axis;
    len = length(_e246);
    let _e248 = len;
    if (_e248 > 0.000001f) {
        let _e250 = angle_1;
        let _e251 = axis;
        let _e252 = (*n_3);
        let _e255 = len;
        local_25 = ((_e250 * dot(_e251, _e252)) / _e255);
    } else {
        local_25 = 0f;
    }
    let _e257 = local_25;
    return _e257;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_26: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_27: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_28: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e240 = i_7;
        if (_e240 < 4i) {
            let _e242 = i_7;
            let _e244 = (*corners)[_e242];
            a_2 = _e244;
            let _e245 = i_7;
            if (_e245 == 3i) {
                local_26 = 0i;
            } else {
                let _e247 = i_7;
                local_26 = (_e247 + 1i);
            }
            let _e249 = local_26;
            let _e251 = (*corners)[_e249];
            b_1 = _e251;
            let _e252 = a_2;
            let _e253 = (*n_4);
            ha = dot(_e252, _e253);
            let _e255 = b_1;
            let _e256 = (*n_4);
            hb = dot(_e255, _e256);
            let _e258 = ha;
            let _e259 = hb;
            d_3 = (_e258 - _e259);
            let _e261 = a_2;
            let _e262 = b_1;
            let _e263 = a_2;
            let _e265 = d_3;
            if (abs(_e265) > 0.000000000001f) {
                let _e268 = ha;
                let _e269 = d_3;
                local_27 = (_e268 / _e269);
            } else {
                local_27 = 0f;
            }
            let _e271 = local_27;
            q = (_e261 + ((_e262 - _e263) * _e271));
            let _e274 = ha;
            aAbove = (_e274 > 0f);
            let _e276 = hb;
            bAbove = (_e276 > 0f);
            let _e278 = aAbove;
            let _e279 = bAbove;
            if (_e278 || _e279) {
                let _e281 = aAbove;
                let _e282 = a_2;
                let _e283 = q;
                let _e286 = bAbove;
                let _e287 = b_1;
                let _e288 = q;
                param_83 = select(_e283, _e282, vec3(_e281));
                param_84 = select(_e288, _e287, vec3(_e286));
                let _e291 = (*n_4);
                param_85 = _e291;
                let _e292 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_28 = _e292;
            } else {
                local_28 = 0f;
            }
            let _e293 = local_28;
            let _e294 = total;
            total = (_e294 + _e293);
            let _e296 = aAbove;
            let _e297 = bAbove;
            let _e300 = q;
            let _e301 = exit;
            exit = select(_e301, _e300, vec3((_e296 && !(_e297))));
            let _e304 = aAbove;
            let _e306 = bAbove;
            let _e308 = q;
            let _e309 = entry;
            entry = select(_e309, _e308, vec3((!(_e304) && _e306)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e312 = i_7;
            i_7 = (_e312 + 1i);
        }
    }
    let _e314 = exit;
    param_86 = _e314;
    let _e315 = entry;
    param_87 = _e315;
    let _e316 = (*n_4);
    param_88 = _e316;
    let _e317 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e318 = total;
    total = (_e318 + _e317);
    let _e320 = total;
    return max((-(_e320) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_29: f32;
    var local_30: f32;
    var local_31: f32;

    let _e223 = (*slot_1);
    let _e224 = (*slot_1);
    lane = (_e223 - ((_e224 / 4i) * 4i));
    let _e228 = lane;
    if (_e228 == 0i) {
        let _e231 = (*four)[0u];
        local_29 = _e231;
    } else {
        let _e232 = lane;
        if (_e232 == 1i) {
            let _e235 = (*four)[1u];
            local_30 = _e235;
        } else {
            let _e236 = lane;
            if (_e236 == 2i) {
                let _e239 = (*four)[2u];
                local_31 = _e239;
            } else {
                let _e241 = (*four)[3u];
                local_31 = _e241;
            }
            let _e242 = local_31;
            local_30 = _e242;
        }
        let _e243 = local_30;
        local_29 = _e243;
    }
    let _e244 = local_29;
    return _e244;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e220 = (*slot_2);
    let _e224 = light_list_info.scales[(_e220 / 4i)];
    param_89 = _e224;
    let _e225 = (*slot_2);
    param_90 = _e225;
    let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e226;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e222 = light_list_info.slot_rows[0i];
    let _e223 = (*row);
    a_3 = abs((_e222 - vec4(_e223)));
    let _e229 = light_list_info.slot_rows[1i];
    let _e230 = (*row);
    b_2 = abs((_e229 - vec4(_e230)));
    let _e235 = a_3[0u];
    let _e237 = a_3[1u];
    let _e240 = a_3[2u];
    let _e242 = a_3[3u];
    let _e246 = b_2[0u];
    let _e248 = b_2[1u];
    let _e251 = b_2[2u];
    let _e253 = b_2[3u];
    return (min(min(min(_e235, _e237), min(_e240, _e242)), min(min(_e246, _e248), min(_e251, _e253))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e220 = (*slot_3);
    let _e224 = light_list_info.indices[(_e220 / 4i)];
    param_91 = _e224;
    let _e225 = (*slot_3);
    param_92 = _e225;
    let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e226;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e219 = (*texel_2);
    let _e223 = light_list_info.list[1u];
    let _e225 = (*row_1);
    let _e229 = light_list_info.list[2u];
    let _e232 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e219 + 0.5f) * _e223), ((_e225 + 0.5f) * _e229)), 0f);
    return _e232;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e227 = g_cluster_offset;
    let _e228 = (*slot_4);
    entry_1 = (_e227 + f32(_e228));
    let _e231 = entry_1;
    row_2 = floor((_e231 / 16f));
    let _e234 = entry_1;
    let _e235 = row_2;
    within_1 = (_e234 - (_e235 * 16f));
    let _e238 = within_1;
    texel_3 = floor((_e238 / 4f));
    let _e243 = light_list_info.cluster_depth[3u];
    let _e244 = row_2;
    let _e246 = texel_3;
    param_93 = _e246;
    param_94 = (_e243 + _e244);
    let _e247 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e247;
    let _e248 = within_1;
    let _e249 = texel_3;
    let _e254 = four_1;
    param_95 = _e254;
    param_96 = i32(((_e248 - (_e249 * 4f)) + 0.5f));
    let _e255 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e255;
}

fn Clustered_u0028_() -> bool {
    let _e219 = light_list_info.cluster_grid[3u];
    return (_e219 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_32: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_33: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_34: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_35: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_36: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e271 = (*index_2);
    if (_e271 < 8i) {
        let _e273 = (*index_2);
        let _e276 = frag_info.light_position[_e273];
        position = _e276;
        let _e277 = (*index_2);
        let _e280 = frag_info.light_color[_e277];
        color_1 = _e280;
        let _e281 = (*index_2);
        let _e284 = frag_info.light_direction[_e281];
        direction = _e284;
        let _e285 = (*index_2);
        let _e288 = frag_info.light_cone[_e285];
        cone = _e288;
    } else {
        let _e289 = (*index_2);
        slot_5 = (_e289 - 8i);
        let _e291 = Clustered_u0028_();
        clustered = _e291;
        let _e292 = clustered;
        if _e292 {
            let _e293 = slot_5;
            param_97 = _e293;
            let _e294 = ClusterRow_u0028_i1_u003b((&param_97));
            local_32 = _e294;
        } else {
            let _e295 = slot_5;
            param_98 = _e295;
            let _e296 = LightListRow_u0028_i1_u003b((&param_98));
            local_32 = _e296;
        }
        let _e297 = local_32;
        listRow = _e297;
        let _e298 = listRow;
        let _e302 = light_list_info.list[2u];
        v_1 = ((_e298 + 0.5f) * _e302);
        let _e306 = light_list_info.list[1u];
        u_1 = _e306;
        let _e307 = u_1;
        let _e309 = v_1;
        let _e311 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e307), _e309), 0f);
        position = _e311;
        let _e312 = u_1;
        let _e314 = v_1;
        let _e316 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e312), _e314), 0f);
        color_1 = _e316;
        let _e317 = u_1;
        let _e319 = v_1;
        let _e321 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e317), _e319), 0f);
        direction = _e321;
        let _e322 = u_1;
        let _e324 = v_1;
        let _e326 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e322), _e324), 0f);
        cone = _e326;
        let _e327 = clustered;
        if _e327 {
            let _e328 = listRow;
            param_99 = _e328;
            let _e329 = InSlots_u0028_f1_u003b((&param_99));
            local_33 = select(1f, 0f, _e329);
        } else {
            let _e331 = slot_5;
            param_100 = _e331;
            let _e332 = LightListScale_u0028_i1_u003b((&param_100));
            local_33 = _e332;
        }
        let _e333 = local_33;
        let _e335 = color_1[3u];
        color_1[3u] = (_e335 * _e333);
    }
    let _e339 = position[3u];
    type_39 = _e339;
    let _e340 = type_39;
    if (_e340 > 15.5f) {
        let _e343 = (*s_5).n;
        light_3.l = _e343;
        let _e346 = (*s_5).n;
        light_3.h = _e346;
        light_3.radiance = vec3<f32>(0f, 0f, 0f);
        light_3.n_dot_l = 0f;
        light_3.n_dot_h = 0f;
        light_3.v_dot_h = 0f;
        let _e352 = light_3;
        return _e352;
    }
    let _e353 = type_39;
    if (_e353 > 2.5f) {
        let _e355 = direction;
        halfWidth_1 = _e355.xyz;
        let _e357 = cone;
        halfHeight_1 = _e357.xyz;
        let _e359 = position;
        let _e361 = v_world_position_1;
        toCentre = (_e359.xyz - _e361);
        let _e363 = toCentre;
        let _e364 = halfWidth_1;
        let _e366 = halfHeight_1;
        corners_1[0i] = ((_e363 - _e364) - _e366);
        let _e369 = toCentre;
        let _e370 = halfWidth_1;
        let _e372 = halfHeight_1;
        corners_1[1i] = ((_e369 + _e370) - _e372);
        let _e375 = toCentre;
        let _e376 = halfWidth_1;
        let _e378 = halfHeight_1;
        corners_1[2i] = ((_e375 + _e376) + _e378);
        let _e381 = toCentre;
        let _e382 = halfWidth_1;
        let _e384 = halfHeight_1;
        corners_1[3i] = ((_e381 - _e382) + _e384);
        let _e387 = toCentre;
        let _e388 = halfWidth_1;
        let _e389 = halfHeight_1;
        behind = (dot(_e387, cross(_e388, _e389)) >= 0f);
        let _e393 = behind;
        if _e393 {
            local_34 = 0f;
        } else {
            let _e394 = corners_1;
            param_101 = _e394;
            let _e396 = (*s_5).n;
            param_102 = _e396;
            let _e397 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_34 = _e397;
        }
        let _e398 = local_34;
        formFactor = _e398;
        let _e399 = halfWidth_1;
        let _e400 = halfHeight_1;
        area = (length(cross(_e399, _e400)) * 4f);
        let _e404 = area;
        if (_e404 > 0.000000001f) {
            let _e406 = area;
            local_35 = (1f / _e406);
        } else {
            local_35 = 0f;
        }
        let _e408 = local_35;
        radiance = _e408;
        let _e409 = toCentre;
        distance_2 = length(_e409);
        let _e412 = direction[3u];
        if (_e412 > 0f) {
            let _e414 = distance_2;
            let _e416 = direction[3u];
            ratio_1 = (_e414 / _e416);
            let _e418 = ratio_1;
            let _e419 = ratio_1;
            let _e421 = ratio_1;
            let _e423 = ratio_1;
            window_1 = clamp((1f - (((_e418 * _e419) * _e421) * _e423)), 0f, 1f);
            let _e427 = window_1;
            let _e428 = window_1;
            let _e430 = radiance;
            radiance = (_e430 * (_e427 * _e428));
        }
        let _e433 = (*s_5).v;
        let _e436 = (*s_5).n;
        mirror_1 = reflect(-(_e433), _e436);
        let _e438 = position;
        param_103 = _e438.xyz;
        let _e440 = halfWidth_1;
        param_104 = _e440;
        let _e441 = halfHeight_1;
        param_105 = _e441;
        let _e442 = v_world_position_1;
        param_106 = _e442;
        let _e443 = mirror_1;
        param_107 = _e443;
        let _e444 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e444;
        let _e445 = representative;
        let _e446 = v_world_position_1;
        toPoint = (_e445 - _e446);
        let _e448 = toPoint;
        pointDistance = length(_e448);
        let _e450 = pointDistance;
        if (_e450 > 0.000001f) {
            let _e452 = toPoint;
            let _e453 = pointDistance;
            local_36 = (_e452 / vec3(_e453));
        } else {
            let _e457 = (*s_5).n;
            local_36 = _e457;
        }
        let _e458 = local_36;
        light_3.l = _e458;
        let _e461 = light_3.l;
        let _e463 = (*s_5).v;
        light_3.h = normalize((_e461 + _e463));
        let _e467 = formFactor;
        light_3.n_dot_l = _e467;
        let _e470 = (*s_5).n;
        let _e472 = light_3.h;
        light_3.n_dot_h = max(dot(_e470, _e472), 0f);
        let _e477 = (*s_5).v;
        let _e479 = light_3.h;
        light_3.v_dot_h = max(dot(_e477, _e479), 0f);
        let _e483 = color_1;
        let _e486 = color_1[3u];
        let _e488 = radiance;
        light_3.radiance = ((_e483.xyz * _e486) * _e488);
        let _e491 = light_3;
        return _e491;
    }
    let _e492 = direction;
    aim = normalize(_e492.xyz);
    attenuation_1 = 1f;
    let _e495 = type_39;
    if (_e495 < 0.5f) {
        let _e497 = aim;
        light_3.l = -(_e497);
    } else {
        let _e500 = position;
        let _e502 = v_world_position_1;
        toLight_1 = (_e500.xyz - _e502);
        let _e504 = toLight_1;
        distance_3 = length(_e504);
        let _e506 = distance_3;
        if (_e506 < 0.000001f) {
            let _e509 = (*s_5).n;
            light_3.l = _e509;
            let _e512 = (*s_5).n;
            light_3.h = _e512;
            light_3.radiance = vec3<f32>(0f, 0f, 0f);
            light_3.n_dot_l = 0f;
            light_3.n_dot_h = 0f;
            light_3.v_dot_h = 0f;
            let _e518 = light_3;
            return _e518;
        }
        let _e519 = toLight_1;
        let _e520 = distance_3;
        light_3.l = (_e519 / vec3(_e520));
        let _e524 = distance_3;
        param_108 = _e524;
        let _e526 = direction[3u];
        param_109 = _e526;
        let _e527 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e527;
        let _e528 = type_39;
        if (_e528 > 1.5f) {
            let _e530 = aim;
            let _e532 = light_3.l;
            cosAngle = dot(_e530, -(_e532));
            let _e535 = cosAngle;
            let _e537 = cone[1u];
            let _e540 = cone[0u];
            let _e542 = cone[1u];
            ramp = clamp(((_e535 - _e537) / (_e540 - _e542)), 0f, 1f);
            let _e546 = ramp;
            let _e547 = ramp;
            let _e549 = attenuation_1;
            attenuation_1 = (_e549 * (_e546 * _e547));
        }
    }
    let _e552 = light_3.l;
    let _e554 = (*s_5).v;
    light_3.h = normalize((_e552 + _e554));
    let _e559 = (*s_5).n;
    let _e561 = light_3.l;
    light_3.n_dot_l = max(dot(_e559, _e561), 0f);
    let _e566 = (*s_5).n;
    let _e568 = light_3.h;
    light_3.n_dot_h = max(dot(_e566, _e568), 0f);
    let _e573 = (*s_5).v;
    let _e575 = light_3.h;
    light_3.v_dot_h = max(dot(_e573, _e575), 0f);
    let _e579 = color_1;
    let _e582 = color_1[3u];
    let _e584 = attenuation_1;
    light_3.radiance = ((_e579.xyz * _e582) * _e584);
    let _e587 = light_3;
    return _e587;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_37: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e232 = light_list_info.cluster_view_projection;
    let _e233 = (*world_3);
    clip_1 = (_e232 * vec4<f32>(_e233.x, _e233.y, _e233.z, 1f));
    let _e239 = clip_1;
    let _e242 = clip_1[3u];
    ndc_1 = (_e239.xy / vec2(max(_e242, 0.000001f)));
    let _e247 = light_list_info.cluster_grid;
    grid = _e247.xyz;
    let _e251 = light_list_info.cluster_depth[0u];
    near_1 = _e251;
    let _e253 = ndc_1[0u];
    let _e257 = grid[0u];
    let _e261 = grid[0u];
    tx = clamp(floor((((_e253 * 0.5f) + 0.5f) * _e257)), 0f, (_e261 - 1f));
    let _e265 = ndc_1[1u];
    let _e269 = grid[1u];
    let _e273 = grid[1u];
    ty = clamp(floor((((_e265 * 0.5f) + 0.5f) * _e269)), 0f, (_e273 - 1f));
    let _e277 = clip_1[3u];
    let _e278 = near_1;
    if (_e277 <= _e278) {
        local_37 = 0f;
    } else {
        let _e281 = clip_1[3u];
        let _e282 = near_1;
        let _e287 = light_list_info.cluster_depth[1u];
        let _e291 = grid[2u];
        local_37 = clamp(floor((log((_e281 / _e282)) * _e287)), 0f, (_e291 - 1f));
    }
    let _e294 = local_37;
    tz = _e294;
    let _e295 = tx;
    let _e296 = ty;
    let _e298 = grid[0u];
    let _e301 = tz;
    let _e303 = grid[0u];
    let _e306 = grid[1u];
    cell_1 = ((_e295 + (_e296 * _e298)) + ((_e301 * _e303) * _e306));
    let _e309 = cell_1;
    row_3 = floor((_e309 / 4f));
    let _e312 = cell_1;
    let _e313 = row_3;
    let _e318 = light_list_info.cluster_depth[2u];
    let _e319 = row_3;
    param_110 = (_e312 - (_e313 * 4f));
    param_111 = (_e318 + _e319);
    let _e321 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e321;
    let _e323 = header[0u];
    g_cluster_offset = _e323;
    let _e325 = header[1u];
    g_cluster_count = _e325;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e221 = light_list_info.list[0u];
    tail = _e221;
    let _e222 = Clustered_u0028_();
    if _e222 {
        let _e223 = v_world_position_1;
        param_112 = _e223;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e224 = g_cluster_count;
        tail = _e224;
    }
    let _e227 = frag_info.frame_params[1u];
    let _e231 = tail;
    return (clamp(i32((_e227 + 0.5f)), 0i, 8i) + clamp(i32((_e231 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_38: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e235 = LightCount_u0028_();
    count_1 = _e235;
    i_8 = 0i;
    loop {
        let _e236 = i_8;
        if (_e236 < 32i) {
            let _e238 = i_8;
            let _e239 = count_1;
            if (_e238 >= _e239) {
                break;
            }
            let _e241 = i_8;
            param_113 = _e241;
            let _e242 = (*s_6);
            param_114 = _e242;
            let _e243 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_113), (&param_114));
            light_4 = _e243;
            let _e245 = light_4.n_dot_l;
            if (_e245 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e247 = i_8;
            param_115 = _e247;
            let _e248 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e248 {
                let _e249 = (*s_6);
                param_116 = _e249;
                let _e250 = light_4;
                param_117 = _e250;
                let _e251 = i_8;
                param_118 = _e251;
                let _e252 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e253 = v_world_position_1;
                param_119 = _e253;
                let _e255 = (*s_6).n;
                param_120 = _e255;
                let _e256 = i_8;
                param_121 = _e256;
                let _e257 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_38 = (_e252 * _e257);
            } else {
                local_38 = 1f;
            }
            let _e259 = local_38;
            visibility = _e259;
            let _e260 = visibility;
            if (_e260 <= 0f) {
                continue;
            }
            let _e262 = (*s_6);
            param_122 = _e262;
            let _e263 = light_4;
            param_123 = _e263;
            let _e264 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e266 = light_4.radiance;
            let _e269 = light_4.n_dot_l;
            let _e271 = visibility;
            let _e273 = light_transmittance;
            let _e275 = total_1;
            total_1 = (_e275 + ((((_e264 * _e266) * _e269) * _e271) * _e273));
            continue;
        } else {
            break;
        }
        continuing {
            let _e277 = i_8;
            i_8 = (_e277 + 1i);
        }
    }
    let _e279 = total_1;
    return _e279;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_39: f32;
    var local_40: f32;

    let _e221 = OcclusionTarget_u0028_();
    target_ = _e221;
    let _e222 = target_;
    let _e224 = target_;
    if ((_e222 > 0.5f) && (_e224 < 1.5f)) {
        local_39 = 1f;
    } else {
        let _e228 = (*s_7).occlusion;
        local_39 = _e228;
    }
    let _e229 = local_39;
    local_40 = _e229;
    let _e230 = local_40;
    return _e230;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e218 = v_lightmap_uv_1;
    let _e219 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e218);
    texel_4 = _e219;
    let _e220 = texel_4;
    let _e223 = texel_4[3u];
    return ((_e220.xyz * _e223) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e219 = frag_info.target_origin[1u];
    return _e219;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_124: vec3<f32>;

    let _e220 = v_texcoord_1;
    let _e221 = MaterialLodBias_u0028_();
    let _e222 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e220, _e221);
    param_124 = _e222.xyz;
    let _e224 = SrgbToLinear_u0028_vf3_u003b((&param_124));
    emissive = _e224;
    let _e225 = emissive;
    let _e227 = frag_info.emissive;
    let _e232 = frag_info.material2_[3u];
    (*s_8).emissive = ((_e225 * _e227.xyz) * _e232);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e220 = v_texcoord_1;
    let _e221 = MaterialLodBias_u0028_();
    let _e222 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e220, _e221);
    occlusion = _e222.x;
    let _e226 = frag_info.material2_[2u];
    let _e227 = OcclusionTarget_u0028_();
    strength_2 = (_e226 - (2f * _e227));
    let _e230 = occlusion;
    let _e231 = strength_2;
    (*s_9).occlusion = mix(1f, _e230, clamp(_e231, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e222 = v_texcoord_1;
    let _e223 = MaterialLodBias_u0028_();
    let _e224 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e222, _e223);
    sampledTexel = _e224;
    let _e225 = v_tangent_1;
    t_2 = _e225.xyz;
    let _e227 = t_2;
    let _e229 = (*s_10).n;
    let _e231 = (*s_10).n;
    let _e232 = t_2;
    t_2 = (_e227 - (_e229 * dot(_e231, _e232)));
    let _e236 = t_2;
    let _e237 = t_2;
    if (dot(_e236, _e237) < 0.000000000001f) {
        return;
    }
    let _e240 = t_2;
    t_2 = normalize(_e240);
    let _e243 = (*s_10).n;
    let _e244 = t_2;
    let _e247 = v_tangent_1[3u];
    b_3 = (cross(_e243, _e244) * _e247);
    let _e249 = gl_FrontFacing_1;
    if !(_e249) {
        let _e251 = t_2;
        t_2 = -(_e251);
    }
    let _e253 = sampledTexel;
    sampled = ((_e253.xyz * 2f) - vec3(1f));
    let _e260 = frag_info.emissive[3u];
    if (_e260 > 0.5f) {
        let _e262 = sampled;
        let _e264 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e262.xy, _e264.xy)), 0f));
    }
    let _e273 = frag_info.material2_[1u];
    let _e274 = sampled;
    let _e276 = (_e274.xy * _e273);
    sampled[0u] = _e276.x;
    sampled[1u] = _e276.y;
    let _e281 = t_2;
    let _e283 = sampled[0u];
    let _e285 = b_3;
    let _e287 = sampled[1u];
    let _e291 = (*s_10).n;
    let _e293 = sampled[2u];
    (*s_10).n = normalize((((_e281 * _e283) + (_e285 * _e287)) + (_e291 * _e293)));
    let _e299 = (*s_10).n;
    let _e301 = (*s_10).v;
    (*s_10).n_dot_v = max(dot(_e299, _e301), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e218 = (*texel_5);
    let _e222 = irradiance_info.atlas;
    let _e225 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e218 + vec2(0.5f)) * _e222.xy), 0f);
    return _e225;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_125: vec2<f32>;
    var b_4: vec4<f32>;
    var param_126: vec2<f32>;
    var c_1: vec4<f32>;
    var param_127: vec2<f32>;
    var d_4: vec4<f32>;
    var param_128: vec2<f32>;

    let _e231 = (*uv_6);
    let _e232 = (*interior);
    at_1 = ((vec2(1f) + (_e231 * _e232)) - vec2(0.5f));
    let _e238 = at_1;
    low = floor(_e238);
    let _e240 = at_1;
    let _e241 = low;
    f = (_e240 - _e241);
    let _e243 = (*corner);
    let _e244 = low;
    param_125 = (_e243 + _e244);
    let _e246 = AtlasTexel_u0028_vf2_u003b((&param_125));
    a_4 = _e246;
    let _e247 = (*corner);
    let _e248 = low;
    param_126 = ((_e247 + _e248) + vec2<f32>(1f, 0f));
    let _e251 = AtlasTexel_u0028_vf2_u003b((&param_126));
    b_4 = _e251;
    let _e252 = (*corner);
    let _e253 = low;
    param_127 = ((_e252 + _e253) + vec2<f32>(0f, 1f));
    let _e256 = AtlasTexel_u0028_vf2_u003b((&param_127));
    c_1 = _e256;
    let _e257 = (*corner);
    let _e258 = low;
    param_128 = ((_e257 + _e258) + vec2<f32>(1f, 1f));
    let _e261 = AtlasTexel_u0028_vf2_u003b((&param_128));
    d_4 = _e261;
    let _e262 = a_4;
    let _e263 = b_4;
    let _e265 = f[0u];
    let _e268 = c_1;
    let _e269 = d_4;
    let _e271 = f[0u];
    let _e275 = f[1u];
    return mix(mix(_e262, _e263, vec4(_e265)), mix(_e268, _e269, vec4(_e271)), vec4(_e275));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e222 = (*direction_1)[0u];
    let _e225 = (*direction_1)[1u];
    let _e229 = (*direction_1)[2u];
    sum_1 = ((abs(_e222) + abs(_e225)) + abs(_e229));
    let _e232 = sum_1;
    if (_e232 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e234 = (*direction_1);
    let _e235 = sum_1;
    n_5 = (_e234 / vec3(_e235));
    let _e238 = n_5;
    xy = _e238.xy;
    let _e241 = n_5[2u];
    if (_e241 < 0f) {
        let _e244 = n_5[1u];
        let _e248 = n_5[0u];
        let _e253 = n_5[0u];
        let _e257 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e244)) * select(-1f, 1f, (_e248 >= 0f))), ((1f - abs(_e253)) * select(-1f, 1f, (_e257 >= 0f))));
    }
    let _e262 = xy;
    return ((_e262 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_129: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_130: vec3<f32>;
    var param_131: vec2<f32>;
    var param_132: f32;
    var param_133: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_134: vec3<f32>;
    var param_135: vec2<f32>;
    var param_136: f32;
    var param_137: vec2<f32>;
    var local_41: vec3<f32>;

    let _e264 = irradiance_info.origin;
    origin_2 = _e264.xyz;
    let _e267 = irradiance_info.spacing;
    spacing = _e267.xyz;
    let _e270 = irradiance_info.counts;
    counts = _e270.xyz;
    let _e274 = irradiance_info.tiles[0u];
    irradianceTile = _e274;
    let _e277 = irradiance_info.tiles[1u];
    depthTile = _e277;
    let _e280 = irradiance_info.tiles[2u];
    columns = _e280;
    let _e283 = irradiance_info.tiles[3u];
    momentsTop = _e283;
    let _e284 = (*normal_1);
    unit = normalize(_e284);
    let _e286 = (*world_4);
    let _e287 = unit;
    let _e290 = irradiance_info.spacing[3u];
    let _e293 = (*view_1);
    let _e296 = irradiance_info.counts[3u];
    biased = ((_e286 + (_e287 * _e290)) + (_e293 * _e296));
    let _e299 = biased;
    let _e300 = origin_2;
    let _e302 = spacing;
    grid_1 = ((_e299 - _e300) / _e302);
    let _e304 = grid_1;
    let _e306 = counts;
    base = clamp(floor(_e304), vec3<f32>(0f, 0f, 0f), (_e306 - vec3(2f)));
    let _e310 = grid_1;
    let _e311 = base;
    f_1 = clamp((_e310 - _e311), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e314 = corner_1;
        if (_e314 < 8i) {
            let _e316 = corner_1;
            let _e319 = corner_1;
            let _e324 = corner_1;
            offset_3 = vec3<f32>(f32((_e316 & 1i)), f32(((_e319 >> bitcast<u32>(1i)) & 1i)), f32(((_e324 >> bitcast<u32>(2i)) & 1i)));
            let _e330 = base;
            let _e331 = offset_3;
            cell_2 = (_e330 + _e331);
            let _e334 = cell_2[2u];
            let _e336 = counts[1u];
            let _e339 = cell_2[1u];
            let _e342 = counts[0u];
            let _e345 = cell_2[0u];
            probe = ((((_e334 * _e336) + _e339) * _e342) + _e345);
            let _e347 = probe;
            let _e348 = columns;
            let _e353 = probe;
            let _e354 = columns;
            tile_4 = vec2<f32>((_e347 - (floor((_e347 / _e348)) * _e348)), floor((_e353 / _e354)));
            let _e358 = tile_4;
            let _e359 = irradianceTile;
            irradianceCorner = (_e358 * (_e359 + 2f));
            let _e363 = tile_4[0u];
            let _e364 = depthTile;
            let _e367 = momentsTop;
            let _e369 = tile_4[1u];
            let _e370 = depthTile;
            momentCorner = vec2<f32>((_e363 * (_e364 + 2f)), (_e367 + (_e369 * (_e370 + 2f))));
            let _e375 = irradianceCorner;
            param_129 = (_e375 + vec2(1f));
            let _e378 = AtlasTexel_u0028_vf2_u003b((&param_129));
            if (_e378.w < 0.5f) {
                continue;
            }
            let _e381 = f_1;
            let _e383 = f_1;
            let _e384 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e381), _e383, _e384);
            let _e387 = trilinear[0u];
            let _e389 = trilinear[1u];
            let _e392 = trilinear[2u];
            weight_3 = max(((_e387 * _e389) * _e392), 0.001f);
            let _e395 = origin_2;
            let _e396 = spacing;
            let _e397 = cell_2;
            probePosition = (_e395 + (_e396 * _e397));
            let _e400 = probePosition;
            let _e401 = biased;
            toProbe = (_e400 - _e401);
            let _e403 = toProbe;
            distance_4 = length(_e403);
            let _e405 = distance_4;
            if (_e405 > 0.000001f) {
                let _e407 = toProbe;
                let _e408 = distance_4;
                direction_2 = (_e407 / vec3(_e408));
                let _e411 = unit;
                let _e412 = probePosition;
                let _e413 = (*world_4);
                facing = ((dot(_e411, normalize((_e412 - _e413))) * 0.5f) + 0.5f);
                let _e419 = facing;
                let _e420 = facing;
                probeWeight = ((_e419 * _e420) + 0.2f);
                let _e423 = direction_2;
                param_130 = -(_e423);
                let _e425 = ProbeOctahedral_u0028_vf3_u003b((&param_130));
                let _e426 = momentCorner;
                param_131 = _e426;
                let _e427 = depthTile;
                param_132 = _e427;
                param_133 = _e425;
                let _e428 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_131), (&param_132), (&param_133));
                moments_3 = _e428.xy;
                chebyshev = 1f;
                let _e430 = distance_4;
                let _e432 = moments_3[0u];
                if (_e430 > _e432) {
                    let _e435 = moments_3[1u];
                    let _e437 = moments_3[0u];
                    let _e439 = moments_3[0u];
                    variance_1 = max((_e435 - (_e437 * _e439)), 0.000001f);
                    let _e443 = distance_4;
                    let _e445 = moments_3[0u];
                    difference = (_e443 - _e445);
                    let _e447 = variance_1;
                    let _e448 = variance_1;
                    let _e449 = difference;
                    let _e450 = difference;
                    chebyshev = (_e447 / (_e448 + (_e449 * _e450)));
                    let _e454 = chebyshev;
                    let _e455 = chebyshev;
                    let _e457 = chebyshev;
                    chebyshev = ((_e454 * _e455) * _e457);
                }
                let _e459 = probeWeight;
                let _e460 = chebyshev;
                probeWeight = max((_e459 * max(_e460, 0.05f)), 0.000001f);
                let _e464 = probeWeight;
                if (_e464 < 0.2f) {
                    let _e466 = probeWeight;
                    let _e467 = probeWeight;
                    let _e470 = probeWeight;
                    probeWeight = (_e470 * ((_e466 * _e467) * 25f));
                }
                let _e472 = probeWeight;
                let _e473 = weight_3;
                weight_3 = (_e473 * _e472);
            }
            let _e475 = unit;
            param_134 = _e475;
            let _e476 = ProbeOctahedral_u0028_vf3_u003b((&param_134));
            let _e477 = irradianceCorner;
            param_135 = _e477;
            let _e478 = irradianceTile;
            param_136 = _e478;
            param_137 = _e476;
            let _e479 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_135), (&param_136), (&param_137));
            let _e481 = weight_3;
            let _e483 = total_2;
            total_2 = (_e483 + (_e479.xyz * _e481));
            let _e485 = weight_3;
            let _e486 = weights;
            weights = (_e486 + _e485);
            continue;
        } else {
            break;
        }
        continuing {
            let _e488 = corner_1;
            corner_1 = (_e488 + 1i);
        }
    }
    let _e490 = weights;
    if (_e490 > 0f) {
        let _e492 = total_2;
        let _e493 = weights;
        local_41 = (_e492 / vec3(_e493));
    } else {
        local_41 = vec3<f32>(0f, 0f, 0f);
    }
    let _e496 = local_41;
    return _e496;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e219 = irradiance_info.origin[3u];
    return (_e219 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: Surface;

    let _e224 = IrradianceEnabled_u0028_();
    if _e224 {
        let _e225 = v_world_position_1;
        param_138 = _e225;
        let _e227 = (*s_11).n;
        param_139 = _e227;
        let _e229 = (*s_11).v;
        param_140 = _e229;
        let _e230 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_138), (&param_139), (&param_140));
        let _e233 = frag_info.material[2u];
        (*s_11).ambient = (_e230 * _e233);
    }
    let _e236 = (*s_11);
    param_141 = _e236;
    ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    let _e237 = param_141;
    (*s_11) = _e237;
    let _e238 = (*s_11);
    param_142 = _e238;
    ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_142));
    let _e239 = param_142;
    (*s_11) = _e239;
    let _e240 = (*s_11);
    param_143 = _e240;
    ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_143));
    let _e241 = param_143;
    (*s_11) = _e241;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_42: vec3<f32>;

    let _e218 = Orthographic_u0028_();
    if _e218 {
        let _e220 = fog_info.forward;
        local_42 = -(_e220.xyz);
    } else {
        let _e224 = fog_info.eye;
        let _e226 = v_world_position_1;
        local_42 = normalize((_e224.xyz - _e226));
    }
    let _e229 = local_42;
    return _e229;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin_3: vec3<f32>;
    var cell_3: vec3<f32>;
    var p3_: vec3<f32>;

    let _e223 = (*cutoff);
    key_2 = (-2f - _e223);
    let _e225 = key_2;
    let _e228 = key_2;
    let _e230 = floor((_e228 / 128f));
    let _e235 = key_2;
    origin_3 = vec3<f32>(floor((_e225 / 16384f)), (_e230 - (floor((_e230 / 128f)) * 128f)), (_e235 - (floor((_e235 / 128f)) * 128f)));
    let _e241 = (*scenePosition);
    let _e244 = origin_3;
    let _e245 = (floor((_e241 * 16f)) + _e244);
    let _e246 = vec3(128f);
    cell_3 = (_e245 - (floor((_e245 / _e246)) * _e246));
    let _e251 = cell_3;
    p3_ = fract((_e251 * 0.1031f));
    let _e254 = p3_;
    let _e255 = p3_;
    let _e260 = p3_;
    p3_ = (_e260 + vec3(dot(_e254, (_e255.zyx + vec3(31.32f)))));
    let _e264 = p3_[0u];
    let _e266 = p3_[1u];
    let _e269 = p3_[2u];
    return fract(((_e264 + _e266) * _e269));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_12: Surface;
    var param_144: vec3<f32>;
    var param_145: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_146: vec3<f32>;
    var param_147: f32;

    let _e225 = v_texcoord_1;
    let _e226 = MaterialLodBias_u0028_();
    let _e227 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e225, _e226);
    texel_6 = _e227;
    let _e228 = texel_6;
    param_144 = _e228.xyz;
    let _e230 = SrgbToLinear_u0028_vf3_u003b((&param_144));
    let _e232 = frag_info.base_color;
    param_145 = _e232.xyz;
    let _e234 = SrgbToLinear_u0028_vf3_u003b((&param_145));
    let _e236 = v_color_1;
    s_12.albedo = ((_e230 * _e234) * _e236.xyz);
    let _e241 = texel_6[3u];
    let _e244 = frag_info.base_color[3u];
    let _e247 = v_color_1[3u];
    s_12.alpha = ((_e241 * _e244) * _e247);
    let _e251 = s_12.albedo;
    g_albedo = _e251;
    let _e254 = frag_info.material2_[0u];
    cutoff_1 = _e254;
    let _e255 = cutoff_1;
    if (_e255 > 1f) {
        let _e257 = cutoff_1;
        edge = (_e257 - 1f);
        let _e260 = s_12.alpha;
        let _e261 = edge;
        let _e264 = s_12.alpha;
        let _e265 = fwidth(_e264);
        s_12.alpha = clamp((((_e260 - _e261) / max(_e265, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e271 = cutoff_1;
        if (_e271 >= 0f) {
            let _e274 = s_12.alpha;
            let _e275 = cutoff_1;
            if (_e274 < _e275) {
                discard;
            }
            s_12.alpha = 1f;
        } else {
            let _e278 = cutoff_1;
            if (_e278 < -1.5f) {
                let _e281 = s_12.alpha;
                let _e282 = v_world_position_1;
                param_146 = _e282;
                let _e283 = cutoff_1;
                param_147 = _e283;
                let _e284 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_146), (&param_147));
                if (_e281 < _e284) {
                    discard;
                }
            }
        }
    }
    let _e286 = cutoff_1;
    let _e288 = cutoff_1;
    g_premultiply = ((_e286 < 0f) && (_e288 > -0.75f));
    let _e291 = v_normal_1;
    s_12.n = normalize(_e291);
    let _e294 = gl_FrontFacing_1;
    if !(_e294) {
        let _e297 = s_12.n;
        s_12.n = -(_e297);
    }
    let _e300 = TowardsEye_u0028_();
    s_12.v = _e300;
    let _e303 = s_12.n;
    let _e305 = s_12.v;
    s_12.n_dot_v = max(dot(_e303, _e305), 0.0001f);
    let _e311 = frag_info.material[0u];
    s_12.metallic = clamp(_e311, 0f, 1f);
    let _e316 = frag_info.material[1u];
    s_12.roughness = clamp(_e316, 0.02f, 1f);
    let _e320 = frag_info.ambient_ground;
    let _e323 = frag_info.ambient_sky;
    let _e327 = s_12.n[1u];
    let _e334 = frag_info.material[2u];
    s_12.ambient = (mix(_e320.xyz, _e323.xyz, vec3(((_e327 * 0.5f) + 0.5f))) * _e334);
    let _e339 = frag_info.frame_params[0u];
    s_12.exposure = max(_e339, 0f);
    s_12.occlusion = 1f;
    s_12.emissive = vec3<f32>(0f, 0f, 0f);
    let _e344 = s_12;
    return _e344;
}

fn main_1() {
    var s_13: Surface;
    var param_148: Surface;
    var ambient: vec3<f32>;
    var param_149: Surface;
    var lit_3: vec3<f32>;
    var param_150: Surface;
    var param_151: Surface;
    var param_152: Surface;
    var param_153: vec3<f32>;
    var param_154: vec3<f32>;
    var param_155: f32;
    var param_156: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e229 = ReadSurface_u0028_();
    s_13 = _e229;
    let _e230 = s_13;
    param_148 = _e230;
    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((&param_148));
    let _e231 = param_148;
    s_13 = _e231;
    let _e233 = s_13.albedo;
    let _e235 = s_13.ambient;
    let _e236 = SampleLightmap_u0028_();
    let _e239 = s_13;
    param_149 = _e239;
    let _e240 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_149));
    ambient = ((_e233 * (_e235 + _e236)) * _e240);
    let _e242 = s_13;
    param_150 = _e242;
    let _e243 = 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((&param_150));
    let _e244 = s_13;
    param_151 = _e244;
    let _e245 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_151));
    let _e247 = ambient;
    let _e250 = s_13.emissive;
    lit_3 = (((_e243 * _e245) + _e247) + _e250);
    let _e252 = s_13;
    param_152 = _e252;
    let _e253 = lit_3;
    param_153 = _e253;
    let _e254 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_152), (&param_153));
    if _e254 {
        return;
    }
    let _e255 = lit_3;
    param_154 = _e255;
    let _e257 = s_13.alpha;
    param_155 = _e257;
    let _e259 = s_13.roughness;
    param_156 = _e259;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_154), (&param_155), (&param_156));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'BlinnPhongDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e218 = v_world_position_1;
    let _e220 = fog_info.eye;
    let _e224 = fog_info.forward;
    return dot((_e218 - _e220.xyz), _e224.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e223 = ViewDepth_u0028_();
    z = abs(_e223);
    let _e225 = z;
    near = (_e225 / 5f);
    let _e227 = z;
    far = (_e227 / 200f);
    let _e229 = far;
    let _e230 = far;
    let _e232 = far;
    far3_ = ((_e229 * _e230) * _e232);
    let _e234 = (*alpha);
    let _e235 = near;
    let _e236 = near;
    let _e239 = far3_;
    let _e240 = far3_;
    return (_e234 * clamp((10f / ((0.00001f + (_e235 * _e236)) + (_e239 * _e240))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e227 = fog_info.forward[3u];
    mode = _e227;
    let _e228 = mode;
    if (_e228 > 0.5f) {
        let _e231 = frag_color[3u];
        alpha_1 = _e231;
        let _e232 = alpha_1;
        param = _e232;
        let _e233 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e233;
        let _e234 = frag_color;
        let _e236 = weight;
        let _e237 = (_e234.xyz * _e236);
        let _e238 = alpha_1;
        let _e239 = weight;
        accumulate = vec4<f32>(_e237.x, _e237.y, _e237.z, (_e238 * _e239));
        let _e245 = mode;
        let _e247 = mode;
        revealage = ((_e245 > 1.5f) && (_e247 < 2.5f));
        let _e250 = revealage;
        if _e250 {
            let _e251 = alpha_1;
            local = vec4(_e251);
        } else {
            let _e253 = accumulate;
            local = _e253;
        }
        let _e254 = local;
        frag_color = _e254;
        let _e255 = mode;
        if (_e255 > 2.5f) {
            let _e257 = alpha_1;
            frag_surface = vec4(_e257);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e221 = (*n)[0u];
    let _e224 = (*n)[1u];
    let _e228 = (*n)[2u];
    let _e231 = (*n);
    (*n) = (_e231 / vec3(((abs(_e221) + abs(_e224)) + abs(_e228))));
    let _e234 = (*n);
    e = _e234.xy;
    let _e237 = (*n)[2u];
    if (_e237 < 0f) {
        let _e239 = (*n);
        let _e245 = (*n)[0u];
        let _e249 = (*n)[1u];
        e = ((vec2(1f) - abs(_e239.yx)) * vec2<f32>(select(-1f, 1f, (_e245 >= 0f)), select(-1f, 1f, (_e249 >= 0f))));
    }
    let _e254 = e;
    return ((_e254 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e219 = (*linear);
    let _e221 = (*linear);
    let _e225 = (*linear);
    return mix((_e219 * 12.92f), ((pow(_e221, 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), _e225));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e222 = g_albedo;
    param_1 = clamp(_e222, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e224 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e224.x, _e224.y, _e224.z, 1f);
    let _e229 = g_debug_surface_on;
    if _e229 {
        let _e230 = g_debug_surface;
        let _e231 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e230.x, _e230.y, _e230.z, _e231);
        return;
    }
    let _e236 = v_normal_1;
    geometric = normalize(_e236);
    let _e238 = gl_FrontFacing_1;
    if !(_e238) {
        let _e240 = geometric;
        geometric = -(_e240);
    }
    let _e242 = geometric;
    param_2 = _e242;
    let _e243 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e244 = (*roughness);
    let _e246 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e243.x, _e243.y, clamp(_e244, 0f, 1f), _e246);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e220 = fog_info.projection[0u];
    return (_e220 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e219 = Orthographic_u0028_();
    if _e219 {
        let _e220 = ViewDepth_u0028_();
        local_1 = max(_e220, 0f);
    } else {
        let _e222 = v_world_position_1;
        let _e224 = fog_info.eye;
        local_1 = distance(_e222, _e224.xyz);
    }
    let _e227 = local_1;
    return _e227;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e226 = fog_info.fog[3u];
    density = _e226;
    let _e227 = density;
    if (_e227 <= 0f) {
        let _e229 = (*color);
        return _e229;
    }
    let _e230 = EyeDistance_u0028_();
    d = _e230;
    let _e233 = fog_info.eye[3u];
    falloff = _e233;
    let _e234 = falloff;
    if (_e234 > 0f) {
        let _e236 = falloff;
        let _e238 = v_world_position_1[1u];
        let _e241 = fog_info.eye[1u];
        k = (_e236 * (_e238 - _e241));
        let _e244 = k;
        if (abs(_e244) > 0.001f) {
            let _e247 = k;
            let _e251 = k;
            local_2 = ((1f - exp(-(_e247))) / _e251);
        } else {
            let _e253 = k;
            local_2 = (1f - (0.5f * _e253));
        }
        let _e256 = local_2;
        let _e257 = density;
        density = (_e257 * _e256);
    }
    let _e260 = fog_info.fog;
    let _e262 = (*color);
    let _e263 = density;
    let _e265 = d;
    return mix(_e260.xyz, _e262, vec3(clamp(exp((-(_e263) * _e265)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e224 = g_premultiply;
    let _e225 = (*alpha_2);
    weight_1 = select(1f, _e225, _e224);
    let _e227 = (*linearColor);
    param_3 = _e227;
    let _e228 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e229 = weight_1;
    let _e230 = (_e228 * _e229);
    let _e231 = (*alpha_2);
    let _e232 = g_pass_through;
    frag_color = vec4<f32>(_e230.x, _e230.y, _e230.z, (_e231 * (1f - _e232)));
    let _e239 = (*roughness_1);
    param_4 = _e239;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e219 = (*srgb);
    let _e222 = (*srgb);
    let _e227 = (*srgb);
    return mix((_e219 / vec3(12.92f)), pow(((_e222 + 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), _e227));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e221 = (*key);
    hue = fract(((_e221 * 0.618034f) + 0.13f));
    let _e225 = hue;
    k_1 = clamp((abs(((fract((vec3(_e225) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e238 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e238, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2648_: bool;

    let _e219 = (*c);
    let _e220 = (*c);
    let _e222 = any((_e219 != _e220));
    phi_2648_ = _e222;
    if !(_e222) {
        let _e224 = (*c);
        phi_2648_ = any((abs(_e224) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e229 = phi_2648_;
    return _e229;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2738_: bool;
    var phi_3006_: bool;

    let _e261 = gl_FragCoord_1[0u];
    let _e264 = frag_info.debug_view[1u];
    if (_e261 < _e264) {
        let _e268 = frag_info.debug_view[2u];
        local_3 = _e268;
    } else {
        let _e271 = frag_info.debug_view[0u];
        local_3 = _e271;
    }
    let _e272 = local_3;
    view = _e272;
    let _e273 = view;
    if (_e273 < 0.5f) {
        return false;
    }
    let _e275 = view;
    code = i32((_e275 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e278 = v_normal_1;
    geometric_n = normalize(_e278);
    let _e280 = v_tangent_1;
    let _e282 = geometric_n;
    let _e283 = geometric_n;
    let _e284 = v_tangent_1;
    tangent = (_e280.xyz - (_e282 * dot(_e283, _e284.xyz)));
    let _e289 = tangent;
    let _e290 = tangent;
    let _e292 = (dot(_e289, _e290) > 0.000000000001f);
    phi_2738_ = _e292;
    if _e292 {
        let _e294 = v_tangent_1[3u];
        phi_2738_ = (abs((abs(_e294) - 1f)) < 0.01f);
    }
    let _e300 = phi_2738_;
    tangent_usable = _e300;
    let _e303 = frag_info.debug_view[3u];
    identity = _e303;
    let _e304 = identity;
    identity_object = floor((_e304 / 8192f));
    let _e307 = identity;
    let _e308 = identity_object;
    identity_rest = (_e307 - (_e308 * 8192f));
    let _e311 = identity_rest;
    identity_material = floor((_e311 / 2f));
    let _e314 = identity_rest;
    let _e315 = identity_material;
    normal_mapped = ((_e314 - (_e315 * 2f)) > 0.5f);
    let _e319 = code;
    if (_e319 == 1i) {
        let _e322 = (*s).albedo;
        param_5 = clamp(_e322, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e324 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e324;
    } else {
        let _e325 = code;
        if (_e325 == 2i) {
            let _e328 = (*s).n;
            shown = ((_e328 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e331 = code;
            if (_e331 == 3i) {
                let _e334 = (*s).roughness;
                shown = vec3(clamp(_e334, 0f, 1f));
            } else {
                let _e337 = code;
                if (_e337 == 4i) {
                    let _e340 = (*s).metallic;
                    shown = vec3(clamp(_e340, 0f, 1f));
                } else {
                    let _e343 = code;
                    if (_e343 == 5i) {
                        let _e346 = (*s).occlusion;
                        shown = vec3(clamp(_e346, 0f, 1f));
                    } else {
                        let _e349 = code;
                        if (_e349 == 6i) {
                            let _e352 = (*s).emissive;
                            param_6 = clamp(_e352, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e354 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e354;
                        } else {
                            let _e355 = code;
                            if (_e355 == 7i) {
                                let _e357 = v_texcoord_1;
                                let _e358 = fract(_e357);
                                shown = vec3<f32>(_e358.x, _e358.y, 0f);
                            } else {
                                let _e362 = code;
                                if (_e362 == 8i) {
                                    let _e364 = (*lit);
                                    param_7 = clamp(_e364, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e366 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e366, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e368 = (*lit);
                                    param_8 = _e368;
                                    let _e369 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e369 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e370 = grey;
                                        local_4 = vec3((_e370 * 0.5f));
                                    }
                                    let _e373 = local_4;
                                    shown = _e373;
                                } else {
                                    let _e374 = code;
                                    if (_e374 == 9i) {
                                        let _e376 = tangent_usable;
                                        if _e376 {
                                            let _e377 = tangent;
                                            local_5 = ((normalize(_e377) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e381 = local_5;
                                        shown = _e381;
                                    } else {
                                        let _e382 = code;
                                        if (_e382 == 10i) {
                                            let _e384 = v_texcoord_1;
                                            uv = _e384;
                                            let _e385 = uv;
                                            cell = floor((_e385 * 8f));
                                            let _e389 = cell[0u];
                                            let _e391 = cell[1u];
                                            odd = (fract(((_e389 + _e391) * 0.5f)) * 2f);
                                            let _e396 = uv;
                                            within = fract(_e396);
                                            let _e398 = odd;
                                            let _e402 = within[0u];
                                            let _e406 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e398)) * vec3<f32>((0.55f + (0.45f * _e402)), (0.55f + (0.45f * _e406)), 0.85f));
                                        } else {
                                            let _e411 = code;
                                            if (_e411 == 11i) {
                                                let _e413 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e413));
                                            } else {
                                                let _e416 = code;
                                                if (_e416 == 12i) {
                                                    let _e418 = v_color_1;
                                                    param_9 = clamp(_e418.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e421 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e421;
                                                } else {
                                                    let _e422 = code;
                                                    let _e424 = code;
                                                    if ((_e422 == 13i) || (_e424 == 14i)) {
                                                        let _e427 = code;
                                                        let _e429 = identity_object;
                                                        let _e430 = identity_material;
                                                        key_1 = select(_e430, _e429, (_e427 == 13i));
                                                        let _e432 = key_1;
                                                        param_10 = _e432;
                                                        let _e433 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e435 = (*s).n_dot_v;
                                                        shown = (_e433 * (0.55f + (0.45f * _e435)));
                                                    } else {
                                                        let _e439 = code;
                                                        if (_e439 == 15i) {
                                                            let _e442 = (*s).albedo;
                                                            param_11 = clamp(_e442, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e444 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e444;
                                                            let _e445 = srgb_1;
                                                            luma = dot(_e445, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e448 = (*s).metallic;
                                                            metal = (_e448 > 0.5f);
                                                            let _e450 = metal;
                                                            let _e452 = luma;
                                                            if (!(_e450) && (_e452 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e455 = metal;
                                                                let _e456 = !(_e455);
                                                                phi_3006_ = _e456;
                                                                if _e456 {
                                                                    let _e458 = srgb_1[0u];
                                                                    let _e460 = srgb_1[1u];
                                                                    let _e462 = srgb_1[2u];
                                                                    phi_3006_ = (max(_e458, max(_e460, _e462)) > 0.9411765f);
                                                                }
                                                                let _e467 = phi_3006_;
                                                                if _e467 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e468 = metal;
                                                                    let _e469 = luma;
                                                                    if (_e468 && (_e469 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e472 = luma;
                                                                        local_8 = vec3(_e472);
                                                                    }
                                                                    let _e474 = local_8;
                                                                    local_7 = _e474;
                                                                }
                                                                let _e475 = local_7;
                                                                local_6 = _e475;
                                                            }
                                                            let _e476 = local_6;
                                                            shown = _e476;
                                                        } else {
                                                            let _e477 = code;
                                                            if (_e477 == 16i) {
                                                                let _e480 = (*s).metallic;
                                                                m = _e480;
                                                                let _e481 = m;
                                                                let _e483 = m;
                                                                if ((_e481 > 0.05f) && (_e483 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e486 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e486 > 0.5f)));
                                                                }
                                                                let _e490 = local_9;
                                                                shown = _e490;
                                                            } else {
                                                                let _e491 = code;
                                                                if (_e491 == 17i) {
                                                                    let _e493 = normal_mapped;
                                                                    if !(_e493) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e495 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e495));
                                                                    }
                                                                    let _e498 = local_10;
                                                                    shown = _e498;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e499 = g_premultiply;
    if _e499 {
        let _e501 = (*s).alpha;
        local_11 = _e501;
    } else {
        local_11 = 1f;
    }
    let _e502 = local_11;
    weight_2 = _e502;
    let _e503 = shown;
    param_12 = _e503;
    let _e504 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e505 = weight_2;
    let _e506 = (_e504 * _e505);
    let _e508 = (*s).alpha;
    frag_color = vec4<f32>(_e506.x, _e506.y, _e506.z, _e508);
    let _e514 = (*s).roughness;
    param_13 = _e514;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_12: f32;

    let _e221 = frag_info.material2_[2u];
    local_12 = floor((_e221 * 0.5f));
    let _e224 = local_12;
    return _e224;
}

fn DirectOcclusion_u0028_struct_u002d_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_1: ptr<function, Surface>) -> f32 {
    var local_13: f32;
    var local_14: f32;

    let _e221 = OcclusionTarget_u0028_();
    if (_e221 > 1.5f) {
        local_13 = 1f;
    } else {
        let _e224 = (*s_1).occlusion;
        local_13 = _e224;
    }
    let _e225 = local_13;
    local_14 = _e225;
    let _e226 = local_14;
    return _e226;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var shininess: f32;
    var specular: f32;

    let _e223 = (*s_2).roughness;
    shininess = mix(256f, 4f, _e223);
    let _e226 = (*light).n_dot_h;
    let _e227 = shininess;
    let _e231 = frag_info.material[3u];
    specular = (pow(_e226, _e227) * _e231);
    let _e234 = (*s_2).albedo;
    let _e235 = specular;
    return (_e234 + vec3(_e235));
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e219 = (*i);
    if (_e219 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e221 = (*i);
    if (_e221 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e223 = (*i);
    if (_e223 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e225 = (*i);
    if (_e225 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e227 = (*i);
    if (_e227 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e229 = (*i);
    if (_e229 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e231 = (*i);
    if (_e231 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e224 = (*i_1);
    param_14 = _e224;
    let _e225 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e225;
    let _e227 = p[0u];
    let _e228 = (*ca);
    let _e231 = p[1u];
    let _e232 = (*sa);
    let _e236 = p[0u];
    let _e237 = (*sa);
    let _e240 = p[1u];
    let _e241 = (*ca);
    let _e245 = (*radius);
    return (vec2<f32>(((_e227 * _e228) - (_e231 * _e232)), ((_e236 * _e237) + (_e240 * _e241))) * _e245);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_15: vec2<f32>;
    var atlas: vec2<f32>;

    let _e227 = point_shadow.params[0u];
    inset = _e227;
    let _e228 = (*uv_1);
    let _e229 = (*offset);
    let _e231 = inset;
    let _e232 = inset;
    local_15 = clamp((_e228 + _e229), vec2(_e231), vec2((1f - _e232)));
    let _e237 = local_15;
    let _e238 = (*tile);
    atlas = ((_e237 + _e238) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e243 = point_shadow.params3_[0u];
    if (_e243 > 0.5f) {
        let _e246 = atlas[1u];
        atlas[1u] = (1f - _e246);
    }
    let _e249 = atlas;
    let _e250 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e249, 0f);
    let _e252 = atlas;
    let _e253 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e252, 0f);
    let _e256 = (*range);
    return (min(_e250.x, _e253.x) * _e256);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e228 = (*uv_2);
    param_15 = _e228;
    let _e229 = (*offset_1);
    param_16 = _e229;
    let _e230 = (*tile_1);
    param_17 = _e230;
    let _e231 = (*range_1);
    param_18 = _e231;
    let _e232 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e232;
    let _e233 = stored;
    let _e234 = (*range_1);
    if (_e233 >= (_e234 * 0.999f)) {
        return 1f;
    }
    let _e237 = (*receiver);
    let _e238 = stored;
    return select(1f, 0f, (_e237 > _e238));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e249 = point_shadow.params2_[1u];
    lightRadius = _e249;
    let _e252 = point_shadow.params2_[0u];
    minRadius = _e252;
    let _e255 = point_shadow.params2_[2u];
    maxRadius = _e255;
    let _e256 = lightRadius;
    if (_e256 <= 0f) {
        let _e258 = (*uv_3);
        param_19 = _e258;
        param_20 = vec2<f32>(0f, 0f);
        let _e259 = (*tile_2);
        param_21 = _e259;
        let _e260 = (*range_2);
        param_22 = _e260;
        let _e261 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e261;
        let _e262 = minRadius;
        return _e262;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e263 = i_2;
        if (_e263 < 8i) {
            let _e265 = i_2;
            param_23 = _e265;
            let _e266 = (*ca_1);
            param_24 = _e266;
            let _e267 = (*sa_1);
            param_25 = _e267;
            let _e268 = maxRadius;
            param_26 = _e268;
            let _e269 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e270 = (*uv_3);
            param_27 = _e270;
            param_28 = _e269;
            let _e271 = (*tile_2);
            param_29 = _e271;
            let _e272 = (*range_2);
            param_30 = _e272;
            let _e273 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e273;
            let _e274 = stored_1;
            let _e275 = (*range_2);
            if (_e274 >= (_e275 * 0.999f)) {
                continue;
            }
            let _e278 = stored_1;
            let _e279 = (*receiver_1);
            if (_e278 >= _e279) {
                continue;
            }
            let _e281 = stored_1;
            let _e282 = sum;
            sum = (_e282 + _e281);
            let _e284 = count;
            count = (_e284 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e286 = i_2;
            i_2 = (_e286 + 1i);
        }
    }
    let _e288 = count;
    if (_e288 < 0.5f) {
        return -1f;
    }
    let _e290 = sum;
    let _e291 = count;
    blocker = max((_e290 / _e291), 0.0001f);
    let _e294 = blocker;
    (*blockerOut) = _e294;
    let _e295 = lightRadius;
    let _e296 = (*receiver_1);
    let _e297 = blocker;
    let _e301 = blocker;
    world = ((_e295 * max((_e296 - _e297), 0f)) / _e301);
    let _e303 = world;
    let _e304 = (*receiver_1);
    let _e306 = (*tanHalf);
    let _e309 = minRadius;
    let _e310 = maxRadius;
    return clamp((_e303 / ((2f * _e304) * _e306)), _e309, _e310);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_16: vec2<f32>;

    let _e220 = (*rows);
    if (_e220 > 0f) {
        let _e223 = gl_FragCoord_1[0u];
        let _e224 = (*rows);
        let _e226 = gl_FragCoord_1[1u];
        local_16 = vec2<f32>(_e223, (_e224 - _e226));
    } else {
        let _e229 = gl_FragCoord_1;
        local_16 = _e229.xy;
    }
    let _e231 = local_16;
    return _e231;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_17: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2335_: bool;
    var phi_2396_: bool;

    let _e272 = (*lightIndex);
    let _e276 = point_shadow.slots[_e272][0u];
    slot = i32((_e276 + 0.5f));
    let _e279 = (*lightIndex);
    let _e283 = point_shadow.slots[_e279][0u];
    if (_e283 < 0f) {
        return 1f;
    }
    let _e287 = point_shadow.params[2u];
    strength = _e287;
    let _e288 = strength;
    if (_e288 <= 0f) {
        return 1f;
    }
    let _e290 = slot;
    let _e293 = point_shadow.lights[_e290];
    let _e295 = (*world_1);
    toLight = (_e293.xyz - _e295);
    let _e297 = toLight;
    toLightLength = max(length(_e297), 0.000001f);
    let _e300 = (*normal);
    let _e301 = toLight;
    let _e302 = toLightLength;
    nDotL = max(dot(_e300, (_e301 / vec3(_e302))), 0.15f);
    let _e307 = nDotL;
    let _e308 = nDotL;
    let _e313 = nDotL;
    let _e314 = nDotL;
    slope = min((sqrt(max((1f - (_e307 * _e308)), 0f)) / (_e313 * _e314)), 8f);
    let _e318 = toLightLength;
    let _e320 = (*lightIndex);
    let _e324 = point_shadow.slots[_e320][2u];
    let _e329 = point_shadow.params3_[1u];
    texel = (((2f * _e318) * max(_e324, 0.0001f)) * _e329);
    let _e331 = (*world_1);
    let _e332 = (*normal);
    let _e333 = texel;
    let _e337 = point_shadow.params[3u];
    let _e339 = slope;
    origin = (_e331 + (((_e332 * _e333) * _e337) * (1f + _e339)));
    let _e343 = origin;
    let _e344 = slot;
    let _e347 = point_shadow.lights[_e344];
    toFragment = (_e343 - _e347.xyz);
    let _e350 = toFragment;
    distance_ = length(_e350);
    let _e352 = slot;
    let _e356 = point_shadow.lights[_e352][3u];
    range_3 = max(_e356, 0.0001f);
    let _e358 = distance_;
    let _e359 = range_3;
    if (_e358 >= _e359) {
        return 1f;
    }
    face = 0i;
    let _e361 = (*lightIndex);
    let _e365 = point_shadow.slots[_e361][1u];
    if (_e365 < 0.5f) {
        let _e367 = toFragment;
        a = abs(_e367);
        let _e370 = a[0u];
        let _e372 = a[1u];
        let _e373 = (_e370 >= _e372);
        phi_2335_ = _e373;
        if _e373 {
            let _e375 = a[0u];
            let _e377 = a[2u];
            phi_2335_ = (_e375 >= _e377);
        }
        let _e380 = phi_2335_;
        if _e380 {
            let _e382 = toFragment[0u];
            face = select(1i, 0i, (_e382 > 0f));
        } else {
            let _e386 = a[1u];
            let _e388 = a[2u];
            if (_e386 >= _e388) {
                let _e391 = toFragment[1u];
                face = select(3i, 2i, (_e391 > 0f));
            } else {
                let _e395 = toFragment[2u];
                face = select(5i, 4i, (_e395 > 0f));
            }
        }
    }
    let _e398 = slot;
    let _e400 = face;
    let _e404 = point_shadow.faces[((_e398 * 6i) + _e400)];
    let _e405 = origin;
    clip = (_e404 * vec4<f32>(_e405.x, _e405.y, _e405.z, 1f));
    let _e412 = clip[3u];
    if (_e412 <= 0f) {
        return 1f;
    }
    let _e414 = clip;
    let _e417 = clip[3u];
    ndc = (_e414.xy / vec2(_e417));
    let _e421 = ndc[0u];
    let _e423 = (abs(_e421) > 1f);
    phi_2396_ = _e423;
    if !(_e423) {
        let _e426 = ndc[1u];
        phi_2396_ = (abs(_e426) > 1f);
    }
    let _e430 = phi_2396_;
    if _e430 {
        return 1f;
    }
    let _e432 = ndc[0u];
    let _e436 = ndc[1u];
    uv_4 = vec2<f32>(((_e432 * 0.5f) + 0.5f), (0.5f - (_e436 * 0.5f)));
    let _e440 = face;
    let _e442 = slot;
    tile_3 = vec2<f32>(f32(_e440), f32(_e442));
    let _e445 = distance_;
    let _e448 = point_shadow.params[1u];
    receiver_2 = (_e445 - _e448);
    let _e452 = frag_info.target_origin[0u];
    param_31 = _e452;
    let _e453 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e453, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e458 = noise;
    angle = (_e458 * 6.2831855f);
    let _e460 = angle;
    ca_2 = cos(_e460);
    let _e462 = angle;
    sa_2 = sin(_e462);
    let _e464 = (*lightIndex);
    let _e468 = point_shadow.slots[_e464][2u];
    tanHalf_1 = max(_e468, 0.0001f);
    blocker_1 = -1f;
    let _e470 = uv_4;
    param_32 = _e470;
    let _e471 = tile_3;
    param_33 = _e471;
    let _e472 = range_3;
    param_34 = _e472;
    let _e473 = receiver_2;
    param_35 = _e473;
    let _e474 = ca_2;
    param_36 = _e474;
    let _e475 = sa_2;
    param_37 = _e475;
    let _e476 = tanHalf_1;
    param_38 = _e476;
    let _e477 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e478 = param_39;
    blocker_1 = _e478;
    radius_1 = _e477;
    let _e481 = point_shadow.params2_[3u];
    if (_e481 > 0.5f) {
        g_debug_surface_on = true;
        let _e483 = radius_1;
        if (_e483 < 0f) {
            local_17 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e485 = radius_1;
            let _e488 = point_shadow.params2_[2u];
            let _e492 = blocker_1;
            let _e493 = range_3;
            local_17 = vec3<f32>(clamp((_e485 / max(_e488, 0.000001f)), 0f, 1f), clamp((_e492 / _e493), 0f, 1f), 0f);
        }
        let _e497 = local_17;
        g_debug_surface = _e497;
    }
    let _e498 = radius_1;
    if (_e498 < 0f) {
        return 1f;
    }
    let _e500 = uv_4;
    param_40 = _e500;
    param_41 = vec2<f32>(0f, 0f);
    let _e501 = tile_3;
    param_42 = _e501;
    let _e502 = range_3;
    param_43 = _e502;
    let _e503 = receiver_2;
    param_44 = _e503;
    let _e504 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e504;
    let _e505 = radius_1;
    if (_e505 > 0f) {
        i_3 = 0i;
        loop {
            let _e507 = i_3;
            if (_e507 < 8i) {
                let _e509 = i_3;
                param_45 = _e509;
                let _e510 = ca_2;
                param_46 = _e510;
                let _e511 = sa_2;
                param_47 = _e511;
                let _e512 = radius_1;
                param_48 = _e512;
                let _e513 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e514 = uv_4;
                param_49 = _e514;
                param_50 = _e513;
                let _e515 = tile_3;
                param_51 = _e515;
                let _e516 = range_3;
                param_52 = _e516;
                let _e517 = receiver_2;
                param_53 = _e517;
                let _e518 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e519 = lit_1;
                lit_1 = (_e519 + _e518);
                continue;
            } else {
                break;
            }
            continuing {
                let _e521 = i_3;
                i_3 = (_e521 + 1i);
            }
        }
        let _e523 = lit_1;
        lit_1 = (_e523 * 0.11111111f);
    }
    let _e525 = lit_1;
    let _e526 = strength;
    return mix(1f, _e525, clamp(_e526, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e223 = (*i_4);
    let _e226 = (*n_1);
    r = sqrt(((f32(_e223) + 0.5f) / f32(_e226)));
    let _e230 = (*i_4);
    let _e233 = (*turn);
    theta = ((f32(_e230) * 2.3999631f) + _e233);
    let _e235 = r;
    let _e236 = theta;
    let _e238 = theta;
    return (vec2<f32>(cos(_e236), sin(_e238)) * _e235);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e222 = frag_info.target_origin[0u];
    param_54 = _e222;
    let _e223 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e226 = frag_info.target_origin[3u];
    at = (_e223 + vec2((5.588238f * max(_e226, 0f))));
    let _e231 = at;
    return fract((52.982918f * fract(dot(_e231, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_18: f32;

    let _e221 = (*mode_1);
    if (_e221 > 0.5f) {
        let _e223 = (*stored_2);
        local_18 = (1f - _e223);
    } else {
        let _e225 = (*stored_2);
        local_18 = _e225;
    }
    let _e226 = local_18;
    return _e226;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e227 = (*moments)[1u];
    let _e229 = (*moments)[0u];
    let _e231 = (*moments)[0u];
    let _e234 = (*minVariance);
    variance = max((_e227 - (_e229 * _e231)), _e234);
    let _e236 = (*t);
    let _e238 = (*moments)[0u];
    d_1 = (_e236 - _e238);
    let _e240 = variance;
    let _e241 = variance;
    let _e242 = d_1;
    let _e243 = d_1;
    pMax = (_e240 / (_e241 + (_e242 * _e243)));
    let _e247 = pMax;
    let _e248 = (*bleed);
    let _e250 = (*bleed);
    reduced = clamp(((_e247 - _e248) / max((1f - _e250), 0.0001f)), 0f, 1f);
    let _e255 = (*t);
    let _e257 = (*moments)[0u];
    let _e259 = reduced;
    return select(_e259, 1f, (_e255 <= _e257));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e220 = (*depth);
    d_2 = ((2f * clamp(_e220, 0f, 1f)) - 1f);
    let _e224 = d_2;
    let _e227 = d_2;
    return vec2<f32>(exp((40f * _e224)), -(exp((-5f * _e227))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e234 = (*depth_1);
    param_55 = _e234;
    let _e235 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e235;
    let _e236 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e236);
    let _e239 = scale[0u];
    let _e241 = scale[0u];
    let _e243 = (*moments_1);
    param_56 = _e243.xy;
    let _e246 = warped[0u];
    param_57 = _e246;
    param_58 = (_e239 * _e241);
    let _e247 = (*bleed_1);
    param_59 = _e247;
    let _e248 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e248;
    let _e250 = scale[1u];
    let _e252 = scale[1u];
    let _e254 = (*moments_1);
    param_60 = _e254.zw;
    let _e257 = warped[1u];
    param_61 = _e257;
    param_62 = (_e250 * _e252);
    let _e258 = (*bleed_1);
    param_63 = _e258;
    let _e259 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e259;
    let _e260 = positive;
    let _e261 = negative;
    return min(_e260, _e261);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e220 = (*depth_2);
    stored_3 = max((1f - _e220), 0.000061035156f);
    let _e223 = stored_3;
    return exp2((floor(log2(_e223)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_19: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_20: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_22: f32;
    var local_23: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3989_: bool;
    var phi_4000_: bool;
    var phi_4157_: bool;
    var phi_4164_: bool;
    var phi_4171_: bool;

    let _e299 = frag_info.shadow_params[3u];
    strength_1 = _e299;
    let _e300 = strength_1;
    if (_e300 <= 0f) {
        return 1f;
    }
    let _e302 = (*lightIndex_1);
    let _e305 = frag_info.frame_params[2u];
    if (_e302 != i32(floor((_e305 + 0.5f)))) {
        return 1f;
    }
    let _e312 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e312 + 0.5f));
    let _e315 = Orthographic_u0028_();
    if _e315 {
        let _e316 = ViewDepth_u0028_();
        local_19 = _e316;
    } else {
        let _e317 = v_world_position_1;
        let _e319 = frag_info.camera_position;
        local_19 = length((_e317 - _e319.xyz));
    }
    let _e323 = local_19;
    viewDistance = _e323;
    cascade = 0i;
    let _e324 = cascadeCount;
    let _e325 = (_e324 > 1i);
    phi_3989_ = _e325;
    if _e325 {
        let _e326 = viewDistance;
        let _e329 = frag_info.shadow_cascades[0u];
        phi_3989_ = (_e326 > _e329);
    }
    let _e332 = phi_3989_;
    if _e332 {
        cascade = 1i;
    }
    let _e333 = cascadeCount;
    let _e334 = (_e333 > 2i);
    phi_4000_ = _e334;
    if _e334 {
        let _e335 = viewDistance;
        let _e338 = frag_info.shadow_cascades[1u];
        phi_4000_ = (_e335 > _e338);
    }
    let _e341 = phi_4000_;
    if _e341 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e342 = attempt;
        if (_e342 < 3i) {
            let _e344 = cascade;
            let _e345 = attempt;
            which = (_e344 + _e345);
            let _e347 = which;
            let _e348 = cascadeCount;
            if (_e347 >= _e348) {
                break;
            }
            let _e350 = which;
            if (_e350 == 0i) {
                let _e353 = frag_info.shadow_matrix;
                local_20 = _e353;
            } else {
                let _e354 = which;
                if (_e354 == 1i) {
                    let _e357 = frag_info.shadow_matrix_far;
                    local_21 = _e357;
                } else {
                    let _e359 = frag_info.shadow_matrix_farthest;
                    local_21 = _e359;
                }
                let _e360 = local_21;
                local_20 = _e360;
            }
            let _e361 = local_20;
            matrix = _e361;
            let _e364 = matrix[0][0u];
            let _e367 = matrix[1][0u];
            let _e370 = matrix[2][0u];
            axisX = vec3<f32>(_e364, _e367, _e370);
            let _e374 = matrix[0][1u];
            let _e377 = matrix[1][1u];
            let _e380 = matrix[2][1u];
            axisY = vec3<f32>(_e374, _e377, _e380);
            let _e382 = axisX;
            rowX = max(length(_e382), 0.000001f);
            let _e385 = axisY;
            rowY = max(length(_e385), 0.000001f);
            let _e390 = frag_info.shadow_cascades[3u];
            let _e392 = rowX;
            texelMetres = ((2f * _e390) / _e392);
            let _e396 = frag_info.shadow_cascades[3u];
            let _e399 = (*s_3).n;
            let _e400 = axisX;
            let _e403 = rowX;
            let _e404 = rowX;
            let _e408 = (*s_3).n;
            let _e409 = axisY;
            let _e412 = rowY;
            let _e413 = rowY;
            reach = ((3f * _e396) * ((abs(dot(_e399, _e400)) / (_e403 * _e404)) + (abs(dot(_e408, _e409)) / (_e412 * _e413))));
            let _e420 = frag_info.shadow_params[2u];
            let _e421 = texelMetres;
            flatOffset = min(_e420, _e421);
            let _e423 = v_world_position_1;
            let _e425 = (*s_3).n;
            let _e426 = flatOffset;
            let _e427 = reach;
            origin_1 = (_e423 + (_e425 * (_e426 + _e427)));
            let _e431 = matrix;
            let _e432 = origin_1;
            lightSpace = (_e431 * vec4<f32>(_e432.x, _e432.y, _e432.z, 1f));
            let _e439 = lightSpace[3u];
            if (_e439 <= 0f) {
                continue;
            }
            let _e441 = lightSpace;
            let _e444 = lightSpace[3u];
            candidate = (_e441.xyz / vec3(_e444));
            let _e448 = candidate[0u];
            let _e452 = candidate[1u];
            inTile = vec2<f32>(((_e448 * 0.5f) + 0.5f), (0.5f - (_e452 * 0.5f)));
            let _e457 = inTile[0u];
            let _e458 = (_e457 < 0f);
            phi_4157_ = _e458;
            if !(_e458) {
                let _e461 = inTile[0u];
                phi_4157_ = (_e461 > 1f);
            }
            let _e464 = phi_4157_;
            phi_4164_ = _e464;
            if !(_e464) {
                let _e467 = inTile[1u];
                phi_4164_ = (_e467 < 0f);
            }
            let _e470 = phi_4164_;
            phi_4171_ = _e470;
            if !(_e470) {
                let _e473 = inTile[1u];
                phi_4171_ = (_e473 > 1f);
            }
            let _e476 = phi_4171_;
            if _e476 {
                continue;
            }
            let _e478 = candidate[2u];
            if (_e478 > 1f) {
                let _e480 = which;
                let _e481 = cascadeCount;
                if (_e480 < (_e481 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e486 = inTile[0u];
            let _e487 = which;
            let _e490 = cascadeCount;
            let _e494 = inTile[1u];
            uv_5 = vec2<f32>(((_e486 + f32(_e487)) / f32(_e490)), _e494);
            let _e496 = candidate;
            projected = _e496;
            let _e497 = which;
            cascade = _e497;
            let _e498 = texelMetres;
            cascadeTexel = _e498;
            let _e501 = matrix[0][2u];
            let _e504 = matrix[1][2u];
            let _e507 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e501, _e504, _e507)), 0.000001f));
            let _e513 = (*s_3).n;
            let _e516 = matrix[0][2u];
            let _e519 = matrix[1][2u];
            let _e522 = matrix[2][2u];
            let _e526 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e513, vec3<f32>(_e516, _e519, _e522))) * _e526), 0.1f, 1f);
            let _e529 = texelMetres;
            let _e530 = cosSlope;
            let _e531 = cosSlope;
            let _e537 = cosSlope;
            let _e539 = cascadeDepth;
            receiverSlope = (((_e529 * sqrt(max((1f - (_e530 * _e531)), 0f))) / _e537) / _e539);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e541 = attempt;
            attempt = (_e541 + 1i);
        }
    }
    let _e543 = found;
    if !(_e543) {
        return 1f;
    }
    let _e545 = cascade;
    if (_e545 == 0i) {
        let _e549 = frag_info.shadow_bias[0u];
        local_22 = _e549;
    } else {
        let _e550 = cascade;
        if (_e550 == 1i) {
            let _e554 = frag_info.shadow_bias[1u];
            local_23 = _e554;
        } else {
            let _e557 = frag_info.shadow_bias[2u];
            local_23 = _e557;
        }
        let _e558 = local_23;
        local_22 = _e558;
    }
    let _e559 = local_22;
    bias = _e559;
    let _e562 = frag_info.shadow_params[1u];
    storage_ = _e562;
    let _e563 = storage_;
    let _e565 = storage_;
    if ((_e563 > 0.5f) && (_e565 < 1.5f)) {
        let _e568 = bias;
        let _e570 = projected[2u];
        param_64 = _e570;
        let _e571 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e568, _e571);
    }
    let _e575 = frag_info.shadow_params[0u];
    let _e578 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e575, _e578);
    let _e580 = cascade;
    let _e582 = cascadeCount;
    let _e586 = texel_1;
    tileLo = (vec2<f32>((f32(_e580) / f32(_e582)), 0f) + (_e586 * 0.5f));
    let _e589 = cascade;
    let _e592 = cascadeCount;
    let _e596 = texel_1;
    tileHi = (vec2<f32>((f32((_e589 + 1i)) / f32(_e592)), 1f) - (_e596 * 0.5f));
    let _e601 = frag_info.shadow_bias[3u];
    if (_e601 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e603 = y;
            if (_e603 <= 1i) {
                x = -1i;
                loop {
                    let _e605 = x;
                    if (_e605 <= 1i) {
                        let _e607 = uv_5;
                        let _e608 = x;
                        let _e610 = y;
                        let _e613 = texel_1;
                        let _e616 = tileLo;
                        let _e617 = tileHi;
                        let _e619 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e607 + (vec2<f32>(f32(_e608), f32(_e610)) * _e613)), _e616, _e617), 0f);
                        let _e620 = stored_4;
                        stored_4 = (_e620 + _e619);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e622 = x;
                        x = (_e622 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e624 = y;
                y = (_e624 + 1i);
            }
        }
        let _e626 = stored_4;
        stored_4 = (_e626 * 0.11111111f);
        let _e629 = stored_4[1u];
        let _e632 = stored_4[2u];
        let _e635 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e629), (1f - _e632), _e635), vec3(0f), vec3(4f));
        let _e640 = through;
        let _e641 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e640, vec3(clamp(_e641, 0f, 1f)));
    }
    let _e647 = frag_info.ambient_ground[3u];
    softness = _e647;
    lit_2 = 0f;
    let _e648 = softness;
    if (_e648 < 0f) {
        let _e650 = uv_5;
        let _e651 = tileLo;
        let _e652 = tileHi;
        let _e654 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e650, _e651, _e652), 0f);
        moments_2 = _e654;
        let _e656 = projected[2u];
        let _e657 = bias;
        let _e659 = softness;
        let _e663 = moments_2;
        param_65 = _e663;
        param_66 = (_e656 - _e657);
        param_67 = clamp((-(_e659) - 1f), 0f, 0.95f);
        let _e664 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e664;
    } else {
        let _e665 = softness;
        if (_e665 <= 0f) {
            y_1 = -1i;
            loop {
                let _e667 = y_1;
                if (_e667 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e669 = x_1;
                        if (_e669 <= 1i) {
                            let _e671 = uv_5;
                            let _e672 = x_1;
                            let _e674 = y_1;
                            let _e677 = texel_1;
                            let _e680 = tileLo;
                            let _e681 = tileHi;
                            let _e683 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e671 + (vec2<f32>(f32(_e672), f32(_e674)) * _e677)), _e680, _e681), 0f);
                            param_68 = _e683.x;
                            let _e685 = storage_;
                            param_69 = _e685;
                            let _e686 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e686;
                            let _e688 = projected[2u];
                            let _e689 = bias;
                            let _e691 = occluder;
                            let _e694 = lit_2;
                            lit_2 = (_e694 + select(1f, 0f, ((_e688 - _e689) > _e691)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e696 = x_1;
                            x_1 = (_e696 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e698 = y_1;
                    y_1 = (_e698 + 1i);
                }
            }
            let _e700 = lit_2;
            lit_2 = (_e700 * 0.11111111f);
        } else {
            let _e702 = softness;
            spread = tan(min(_e702, 0.5f));
            let _e705 = ShadowNoise_u0028_();
            turn_1 = (_e705 * 6.2831855f);
            let _e707 = spread;
            let _e709 = projected[2u];
            let _e711 = cascadeDepth;
            let _e713 = cascadeTexel;
            searchRadius = clamp((((_e707 * _e709) * _e711) / _e713), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e716 = i_5;
                if (_e716 < 16i) {
                    let _e718 = i_5;
                    param_70 = _e718;
                    param_71 = 16i;
                    let _e719 = turn_1;
                    param_72 = _e719;
                    let _e720 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e720;
                    let _e721 = bias;
                    let _e722 = disc;
                    let _e724 = searchRadius;
                    let _e728 = receiverSlope;
                    tapBias = (_e721 + (max(((length(_e722) * _e724) - 1.5f), 0f) * _e728));
                    let _e731 = uv_5;
                    let _e732 = disc;
                    let _e733 = texel_1;
                    let _e735 = searchRadius;
                    let _e738 = tileLo;
                    let _e739 = tileHi;
                    let _e741 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e731 + ((_e732 * _e733) * _e735)), _e738, _e739), 0f);
                    param_73 = _e741.x;
                    let _e743 = storage_;
                    param_74 = _e743;
                    let _e744 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e744;
                    let _e746 = projected[2u];
                    let _e747 = tapBias;
                    let _e749 = occluder_1;
                    if ((_e746 - _e747) > _e749) {
                        let _e751 = occluder_1;
                        let _e752 = blockerSum;
                        blockerSum = (_e752 + _e751);
                        let _e754 = blockerCount;
                        blockerCount = (_e754 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e756 = i_5;
                    i_5 = (_e756 + 1i);
                }
            }
            let _e758 = blockerCount;
            if (_e758 <= 0f) {
                return 1f;
            }
            let _e761 = projected[2u];
            let _e762 = blockerSum;
            let _e763 = blockerCount;
            let _e767 = cascadeDepth;
            gap = (max((_e761 - (_e762 / _e763)), 0f) * _e767);
            let _e769 = spread;
            let _e770 = gap;
            let _e772 = cascadeTexel;
            radius_2 = clamp(((_e769 * _e770) / _e772), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e775 = i_6;
                if (_e775 < 16i) {
                    let _e777 = turn_1;
                    let _e779 = i_6;
                    param_75 = _e779;
                    param_76 = 16i;
                    param_77 = (_e777 + 1f);
                    let _e780 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e780;
                    let _e781 = bias;
                    let _e782 = disc_1;
                    let _e784 = radius_2;
                    let _e788 = receiverSlope;
                    tapBias_1 = (_e781 + (max(((length(_e782) * _e784) - 1.5f), 0f) * _e788));
                    let _e791 = uv_5;
                    let _e792 = disc_1;
                    let _e793 = texel_1;
                    let _e795 = radius_2;
                    let _e798 = tileLo;
                    let _e799 = tileHi;
                    let _e801 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e791 + ((_e792 * _e793) * _e795)), _e798, _e799), 0f);
                    param_78 = _e801.x;
                    let _e803 = storage_;
                    param_79 = _e803;
                    let _e804 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e804;
                    let _e806 = projected[2u];
                    let _e807 = tapBias_1;
                    let _e809 = occluder_2;
                    let _e812 = lit_2;
                    lit_2 = (_e812 + select(1f, 0f, ((_e806 - _e807) > _e809)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e814 = i_6;
                    i_6 = (_e814 + 1i);
                }
            }
            let _e816 = lit_2;
            lit_2 = (_e816 * 0.0625f);
        }
    }
    let _e818 = lit_2;
    let _e819 = strength_1;
    return mix(1f, _e818, clamp(_e819, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e224 = (*s_4);
    param_80 = _e224;
    let _e225 = (*light_2);
    param_81 = _e225;
    let _e226 = (*index);
    param_82 = _e226;
    let _e227 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e227;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e219 = (*index_1);
    return (_e219 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e223 = (*distance_1);
    let _e224 = (*distance_1);
    attenuation = (1f / max((_e223 * _e224), 0.0001f));
    let _e228 = (*range_4);
    if (_e228 > 0f) {
        let _e230 = (*distance_1);
        let _e231 = (*range_4);
        ratio = (_e230 / _e231);
        let _e233 = ratio;
        let _e234 = ratio;
        let _e236 = ratio;
        let _e238 = ratio;
        window = clamp((1f - (((_e233 * _e234) * _e236) * _e238)), 0f, 1f);
        let _e242 = window;
        let _e243 = window;
        let _e245 = attenuation;
        attenuation = (_e245 * (_e242 * _e243));
    }
    let _e247 = attenuation;
    return _e247;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_24: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e235 = (*halfWidth);
    let _e236 = (*halfHeight);
    n_2 = cross(_e235, _e236);
    let _e238 = n_2;
    nLen = length(_e238);
    let _e240 = nLen;
    if (_e240 < 0.000000000001f) {
        let _e242 = (*centre);
        return _e242;
    }
    let _e243 = nLen;
    let _e244 = n_2;
    n_2 = (_e244 / vec3(_e243));
    let _e247 = (*centre);
    let _e248 = (*world_2);
    toPlane = (_e247 - _e248);
    let _e250 = (*mirror);
    let _e251 = n_2;
    denom = dot(_e250, _e251);
    let _e253 = denom;
    if (abs(_e253) < 0.00001f) {
        let _e256 = toPlane;
        let _e257 = n_2;
        let _e258 = toPlane;
        let _e259 = n_2;
        onPlane = (_e256 - (_e257 * dot(_e258, _e259)));
    } else {
        let _e263 = toPlane;
        let _e264 = n_2;
        let _e266 = denom;
        t_1 = (dot(_e263, _e264) / _e266);
        let _e268 = t_1;
        if (_e268 > 0f) {
            let _e270 = (*mirror);
            let _e271 = t_1;
            local_24 = (_e270 * _e271);
        } else {
            let _e273 = toPlane;
            let _e274 = n_2;
            let _e275 = toPlane;
            let _e276 = n_2;
            local_24 = (_e273 - (_e274 * dot(_e275, _e276)));
        }
        let _e280 = local_24;
        onPlane = _e280;
    }
    let _e281 = onPlane;
    let _e282 = toPlane;
    offset_2 = (_e281 - _e282);
    let _e284 = (*halfWidth);
    let _e285 = (*halfWidth);
    wLen2_ = max(dot(_e284, _e285), 0.000000000001f);
    let _e288 = (*halfHeight);
    let _e289 = (*halfHeight);
    hLen2_ = max(dot(_e288, _e289), 0.000000000001f);
    let _e292 = offset_2;
    let _e293 = (*halfWidth);
    let _e295 = wLen2_;
    u = clamp((dot(_e292, _e293) / _e295), -1f, 1f);
    let _e298 = offset_2;
    let _e299 = (*halfHeight);
    let _e301 = hLen2_;
    v = clamp((dot(_e298, _e299) / _e301), -1f, 1f);
    let _e304 = (*centre);
    let _e305 = (*halfWidth);
    let _e306 = u;
    let _e309 = (*halfHeight);
    let _e310 = v;
    return ((_e304 + (_e305 * _e306)) + (_e309 * _e310));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_25: f32;

    let _e227 = (*a_1);
    let _e228 = (*a_1);
    ua = (_e227 / vec3(max(length(_e228), 0.000000000001f)));
    let _e233 = (*b);
    let _e234 = (*b);
    ub = (_e233 / vec3(max(length(_e234), 0.000000000001f)));
    let _e239 = ua;
    let _e240 = ub;
    angle_1 = acos(clamp(dot(_e239, _e240), -1f, 1f));
    let _e244 = ua;
    let _e245 = ub;
    axis = cross(_e244, _e245);
    let _e247 = axis;
    len = length(_e247);
    let _e249 = len;
    if (_e249 > 0.000001f) {
        let _e251 = angle_1;
        let _e252 = axis;
        let _e253 = (*n_3);
        let _e256 = len;
        local_25 = ((_e251 * dot(_e252, _e253)) / _e256);
    } else {
        local_25 = 0f;
    }
    let _e258 = local_25;
    return _e258;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_26: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_27: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_28: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e241 = i_7;
        if (_e241 < 4i) {
            let _e243 = i_7;
            let _e245 = (*corners)[_e243];
            a_2 = _e245;
            let _e246 = i_7;
            if (_e246 == 3i) {
                local_26 = 0i;
            } else {
                let _e248 = i_7;
                local_26 = (_e248 + 1i);
            }
            let _e250 = local_26;
            let _e252 = (*corners)[_e250];
            b_1 = _e252;
            let _e253 = a_2;
            let _e254 = (*n_4);
            ha = dot(_e253, _e254);
            let _e256 = b_1;
            let _e257 = (*n_4);
            hb = dot(_e256, _e257);
            let _e259 = ha;
            let _e260 = hb;
            d_3 = (_e259 - _e260);
            let _e262 = a_2;
            let _e263 = b_1;
            let _e264 = a_2;
            let _e266 = d_3;
            if (abs(_e266) > 0.000000000001f) {
                let _e269 = ha;
                let _e270 = d_3;
                local_27 = (_e269 / _e270);
            } else {
                local_27 = 0f;
            }
            let _e272 = local_27;
            q = (_e262 + ((_e263 - _e264) * _e272));
            let _e275 = ha;
            aAbove = (_e275 > 0f);
            let _e277 = hb;
            bAbove = (_e277 > 0f);
            let _e279 = aAbove;
            let _e280 = bAbove;
            if (_e279 || _e280) {
                let _e282 = aAbove;
                let _e283 = a_2;
                let _e284 = q;
                let _e287 = bAbove;
                let _e288 = b_1;
                let _e289 = q;
                param_83 = select(_e284, _e283, vec3(_e282));
                param_84 = select(_e289, _e288, vec3(_e287));
                let _e292 = (*n_4);
                param_85 = _e292;
                let _e293 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_28 = _e293;
            } else {
                local_28 = 0f;
            }
            let _e294 = local_28;
            let _e295 = total;
            total = (_e295 + _e294);
            let _e297 = aAbove;
            let _e298 = bAbove;
            let _e301 = q;
            let _e302 = exit;
            exit = select(_e302, _e301, vec3((_e297 && !(_e298))));
            let _e305 = aAbove;
            let _e307 = bAbove;
            let _e309 = q;
            let _e310 = entry;
            entry = select(_e310, _e309, vec3((!(_e305) && _e307)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e313 = i_7;
            i_7 = (_e313 + 1i);
        }
    }
    let _e315 = exit;
    param_86 = _e315;
    let _e316 = entry;
    param_87 = _e316;
    let _e317 = (*n_4);
    param_88 = _e317;
    let _e318 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e319 = total;
    total = (_e319 + _e318);
    let _e321 = total;
    return max((-(_e321) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_29: f32;
    var local_30: f32;
    var local_31: f32;

    let _e224 = (*slot_1);
    let _e225 = (*slot_1);
    lane = (_e224 - ((_e225 / 4i) * 4i));
    let _e229 = lane;
    if (_e229 == 0i) {
        let _e232 = (*four)[0u];
        local_29 = _e232;
    } else {
        let _e233 = lane;
        if (_e233 == 1i) {
            let _e236 = (*four)[1u];
            local_30 = _e236;
        } else {
            let _e237 = lane;
            if (_e237 == 2i) {
                let _e240 = (*four)[2u];
                local_31 = _e240;
            } else {
                let _e242 = (*four)[3u];
                local_31 = _e242;
            }
            let _e243 = local_31;
            local_30 = _e243;
        }
        let _e244 = local_30;
        local_29 = _e244;
    }
    let _e245 = local_29;
    return _e245;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e221 = (*slot_2);
    let _e225 = light_list_info.scales[(_e221 / 4i)];
    param_89 = _e225;
    let _e226 = (*slot_2);
    param_90 = _e226;
    let _e227 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e227;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e223 = light_list_info.slot_rows[0i];
    let _e224 = (*row);
    a_3 = abs((_e223 - vec4(_e224)));
    let _e230 = light_list_info.slot_rows[1i];
    let _e231 = (*row);
    b_2 = abs((_e230 - vec4(_e231)));
    let _e236 = a_3[0u];
    let _e238 = a_3[1u];
    let _e241 = a_3[2u];
    let _e243 = a_3[3u];
    let _e247 = b_2[0u];
    let _e249 = b_2[1u];
    let _e252 = b_2[2u];
    let _e254 = b_2[3u];
    return (min(min(min(_e236, _e238), min(_e241, _e243)), min(min(_e247, _e249), min(_e252, _e254))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e221 = (*slot_3);
    let _e225 = light_list_info.indices[(_e221 / 4i)];
    param_91 = _e225;
    let _e226 = (*slot_3);
    param_92 = _e226;
    let _e227 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e227;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e220 = (*texel_2);
    let _e224 = light_list_info.list[1u];
    let _e226 = (*row_1);
    let _e230 = light_list_info.list[2u];
    let _e233 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e220 + 0.5f) * _e224), ((_e226 + 0.5f) * _e230)), 0f);
    return _e233;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e228 = g_cluster_offset;
    let _e229 = (*slot_4);
    entry_1 = (_e228 + f32(_e229));
    let _e232 = entry_1;
    row_2 = floor((_e232 / 16f));
    let _e235 = entry_1;
    let _e236 = row_2;
    within_1 = (_e235 - (_e236 * 16f));
    let _e239 = within_1;
    texel_3 = floor((_e239 / 4f));
    let _e244 = light_list_info.cluster_depth[3u];
    let _e245 = row_2;
    let _e247 = texel_3;
    param_93 = _e247;
    param_94 = (_e244 + _e245);
    let _e248 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e248;
    let _e249 = within_1;
    let _e250 = texel_3;
    let _e255 = four_1;
    param_95 = _e255;
    param_96 = i32(((_e249 - (_e250 * 4f)) + 0.5f));
    let _e256 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e256;
}

fn Clustered_u0028_() -> bool {
    let _e220 = light_list_info.cluster_grid[3u];
    return (_e220 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_32: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_33: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_34: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_35: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_36: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e272 = (*index_2);
    if (_e272 < 8i) {
        let _e274 = (*index_2);
        let _e277 = frag_info.light_position[_e274];
        position = _e277;
        let _e278 = (*index_2);
        let _e281 = frag_info.light_color[_e278];
        color_1 = _e281;
        let _e282 = (*index_2);
        let _e285 = frag_info.light_direction[_e282];
        direction = _e285;
        let _e286 = (*index_2);
        let _e289 = frag_info.light_cone[_e286];
        cone = _e289;
    } else {
        let _e290 = (*index_2);
        slot_5 = (_e290 - 8i);
        let _e292 = Clustered_u0028_();
        clustered = _e292;
        let _e293 = clustered;
        if _e293 {
            let _e294 = slot_5;
            param_97 = _e294;
            let _e295 = ClusterRow_u0028_i1_u003b((&param_97));
            local_32 = _e295;
        } else {
            let _e296 = slot_5;
            param_98 = _e296;
            let _e297 = LightListRow_u0028_i1_u003b((&param_98));
            local_32 = _e297;
        }
        let _e298 = local_32;
        listRow = _e298;
        let _e299 = listRow;
        let _e303 = light_list_info.list[2u];
        v_1 = ((_e299 + 0.5f) * _e303);
        let _e307 = light_list_info.list[1u];
        u_1 = _e307;
        let _e308 = u_1;
        let _e310 = v_1;
        let _e312 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e308), _e310), 0f);
        position = _e312;
        let _e313 = u_1;
        let _e315 = v_1;
        let _e317 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e313), _e315), 0f);
        color_1 = _e317;
        let _e318 = u_1;
        let _e320 = v_1;
        let _e322 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e318), _e320), 0f);
        direction = _e322;
        let _e323 = u_1;
        let _e325 = v_1;
        let _e327 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e323), _e325), 0f);
        cone = _e327;
        let _e328 = clustered;
        if _e328 {
            let _e329 = listRow;
            param_99 = _e329;
            let _e330 = InSlots_u0028_f1_u003b((&param_99));
            local_33 = select(1f, 0f, _e330);
        } else {
            let _e332 = slot_5;
            param_100 = _e332;
            let _e333 = LightListScale_u0028_i1_u003b((&param_100));
            local_33 = _e333;
        }
        let _e334 = local_33;
        let _e336 = color_1[3u];
        color_1[3u] = (_e336 * _e334);
    }
    let _e340 = position[3u];
    type_39 = _e340;
    let _e341 = type_39;
    if (_e341 > 15.5f) {
        let _e344 = (*s_5).n;
        light_3.l = _e344;
        let _e347 = (*s_5).n;
        light_3.h = _e347;
        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 _e353 = light_3;
        return _e353;
    }
    let _e354 = type_39;
    if (_e354 > 2.5f) {
        let _e356 = direction;
        halfWidth_1 = _e356.xyz;
        let _e358 = cone;
        halfHeight_1 = _e358.xyz;
        let _e360 = position;
        let _e362 = v_world_position_1;
        toCentre = (_e360.xyz - _e362);
        let _e364 = toCentre;
        let _e365 = halfWidth_1;
        let _e367 = halfHeight_1;
        corners_1[0i] = ((_e364 - _e365) - _e367);
        let _e370 = toCentre;
        let _e371 = halfWidth_1;
        let _e373 = halfHeight_1;
        corners_1[1i] = ((_e370 + _e371) - _e373);
        let _e376 = toCentre;
        let _e377 = halfWidth_1;
        let _e379 = halfHeight_1;
        corners_1[2i] = ((_e376 + _e377) + _e379);
        let _e382 = toCentre;
        let _e383 = halfWidth_1;
        let _e385 = halfHeight_1;
        corners_1[3i] = ((_e382 - _e383) + _e385);
        let _e388 = toCentre;
        let _e389 = halfWidth_1;
        let _e390 = halfHeight_1;
        behind = (dot(_e388, cross(_e389, _e390)) >= 0f);
        let _e394 = behind;
        if _e394 {
            local_34 = 0f;
        } else {
            let _e395 = corners_1;
            param_101 = _e395;
            let _e397 = (*s_5).n;
            param_102 = _e397;
            let _e398 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_34 = _e398;
        }
        let _e399 = local_34;
        formFactor = _e399;
        let _e400 = halfWidth_1;
        let _e401 = halfHeight_1;
        area = (length(cross(_e400, _e401)) * 4f);
        let _e405 = area;
        if (_e405 > 0.000000001f) {
            let _e407 = area;
            local_35 = (1f / _e407);
        } else {
            local_35 = 0f;
        }
        let _e409 = local_35;
        radiance = _e409;
        let _e410 = toCentre;
        distance_2 = length(_e410);
        let _e413 = direction[3u];
        if (_e413 > 0f) {
            let _e415 = distance_2;
            let _e417 = direction[3u];
            ratio_1 = (_e415 / _e417);
            let _e419 = ratio_1;
            let _e420 = ratio_1;
            let _e422 = ratio_1;
            let _e424 = ratio_1;
            window_1 = clamp((1f - (((_e419 * _e420) * _e422) * _e424)), 0f, 1f);
            let _e428 = window_1;
            let _e429 = window_1;
            let _e431 = radiance;
            radiance = (_e431 * (_e428 * _e429));
        }
        let _e434 = (*s_5).v;
        let _e437 = (*s_5).n;
        mirror_1 = reflect(-(_e434), _e437);
        let _e439 = position;
        param_103 = _e439.xyz;
        let _e441 = halfWidth_1;
        param_104 = _e441;
        let _e442 = halfHeight_1;
        param_105 = _e442;
        let _e443 = v_world_position_1;
        param_106 = _e443;
        let _e444 = mirror_1;
        param_107 = _e444;
        let _e445 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e445;
        let _e446 = representative;
        let _e447 = v_world_position_1;
        toPoint = (_e446 - _e447);
        let _e449 = toPoint;
        pointDistance = length(_e449);
        let _e451 = pointDistance;
        if (_e451 > 0.000001f) {
            let _e453 = toPoint;
            let _e454 = pointDistance;
            local_36 = (_e453 / vec3(_e454));
        } else {
            let _e458 = (*s_5).n;
            local_36 = _e458;
        }
        let _e459 = local_36;
        light_3.l = _e459;
        let _e462 = light_3.l;
        let _e464 = (*s_5).v;
        light_3.h = normalize((_e462 + _e464));
        let _e468 = formFactor;
        light_3.n_dot_l = _e468;
        let _e471 = (*s_5).n;
        let _e473 = light_3.h;
        light_3.n_dot_h = max(dot(_e471, _e473), 0f);
        let _e478 = (*s_5).v;
        let _e480 = light_3.h;
        light_3.v_dot_h = max(dot(_e478, _e480), 0f);
        let _e484 = color_1;
        let _e487 = color_1[3u];
        let _e489 = radiance;
        light_3.radiance = ((_e484.xyz * _e487) * _e489);
        let _e492 = light_3;
        return _e492;
    }
    let _e493 = direction;
    aim = normalize(_e493.xyz);
    attenuation_1 = 1f;
    let _e496 = type_39;
    if (_e496 < 0.5f) {
        let _e498 = aim;
        light_3.l = -(_e498);
    } else {
        let _e501 = position;
        let _e503 = v_world_position_1;
        toLight_1 = (_e501.xyz - _e503);
        let _e505 = toLight_1;
        distance_3 = length(_e505);
        let _e507 = distance_3;
        if (_e507 < 0.000001f) {
            let _e510 = (*s_5).n;
            light_3.l = _e510;
            let _e513 = (*s_5).n;
            light_3.h = _e513;
            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 _e519 = light_3;
            return _e519;
        }
        let _e520 = toLight_1;
        let _e521 = distance_3;
        light_3.l = (_e520 / vec3(_e521));
        let _e525 = distance_3;
        param_108 = _e525;
        let _e527 = direction[3u];
        param_109 = _e527;
        let _e528 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e528;
        let _e529 = type_39;
        if (_e529 > 1.5f) {
            let _e531 = aim;
            let _e533 = light_3.l;
            cosAngle = dot(_e531, -(_e533));
            let _e536 = cosAngle;
            let _e538 = cone[1u];
            let _e541 = cone[0u];
            let _e543 = cone[1u];
            ramp = clamp(((_e536 - _e538) / (_e541 - _e543)), 0f, 1f);
            let _e547 = ramp;
            let _e548 = ramp;
            let _e550 = attenuation_1;
            attenuation_1 = (_e550 * (_e547 * _e548));
        }
    }
    let _e553 = light_3.l;
    let _e555 = (*s_5).v;
    light_3.h = normalize((_e553 + _e555));
    let _e560 = (*s_5).n;
    let _e562 = light_3.l;
    light_3.n_dot_l = max(dot(_e560, _e562), 0f);
    let _e567 = (*s_5).n;
    let _e569 = light_3.h;
    light_3.n_dot_h = max(dot(_e567, _e569), 0f);
    let _e574 = (*s_5).v;
    let _e576 = light_3.h;
    light_3.v_dot_h = max(dot(_e574, _e576), 0f);
    let _e580 = color_1;
    let _e583 = color_1[3u];
    let _e585 = attenuation_1;
    light_3.radiance = ((_e580.xyz * _e583) * _e585);
    let _e588 = light_3;
    return _e588;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_37: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e233 = light_list_info.cluster_view_projection;
    let _e234 = (*world_3);
    clip_1 = (_e233 * vec4<f32>(_e234.x, _e234.y, _e234.z, 1f));
    let _e240 = clip_1;
    let _e243 = clip_1[3u];
    ndc_1 = (_e240.xy / vec2(max(_e243, 0.000001f)));
    let _e248 = light_list_info.cluster_grid;
    grid = _e248.xyz;
    let _e252 = light_list_info.cluster_depth[0u];
    near_1 = _e252;
    let _e254 = ndc_1[0u];
    let _e258 = grid[0u];
    let _e262 = grid[0u];
    tx = clamp(floor((((_e254 * 0.5f) + 0.5f) * _e258)), 0f, (_e262 - 1f));
    let _e266 = ndc_1[1u];
    let _e270 = grid[1u];
    let _e274 = grid[1u];
    ty = clamp(floor((((_e266 * 0.5f) + 0.5f) * _e270)), 0f, (_e274 - 1f));
    let _e278 = clip_1[3u];
    let _e279 = near_1;
    if (_e278 <= _e279) {
        local_37 = 0f;
    } else {
        let _e282 = clip_1[3u];
        let _e283 = near_1;
        let _e288 = light_list_info.cluster_depth[1u];
        let _e292 = grid[2u];
        local_37 = clamp(floor((log((_e282 / _e283)) * _e288)), 0f, (_e292 - 1f));
    }
    let _e295 = local_37;
    tz = _e295;
    let _e296 = tx;
    let _e297 = ty;
    let _e299 = grid[0u];
    let _e302 = tz;
    let _e304 = grid[0u];
    let _e307 = grid[1u];
    cell_1 = ((_e296 + (_e297 * _e299)) + ((_e302 * _e304) * _e307));
    let _e310 = cell_1;
    row_3 = floor((_e310 / 4f));
    let _e313 = cell_1;
    let _e314 = row_3;
    let _e319 = light_list_info.cluster_depth[2u];
    let _e320 = row_3;
    param_110 = (_e313 - (_e314 * 4f));
    param_111 = (_e319 + _e320);
    let _e322 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e322;
    let _e324 = header[0u];
    g_cluster_offset = _e324;
    let _e326 = header[1u];
    g_cluster_count = _e326;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e222 = light_list_info.list[0u];
    tail = _e222;
    let _e223 = Clustered_u0028_();
    if _e223 {
        let _e224 = v_world_position_1;
        param_112 = _e224;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e225 = g_cluster_count;
        tail = _e225;
    }
    let _e228 = frag_info.frame_params[1u];
    let _e232 = tail;
    return (clamp(i32((_e228 + 0.5f)), 0i, 8i) + clamp(i32((_e232 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_38: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e236 = LightCount_u0028_();
    count_1 = _e236;
    i_8 = 0i;
    loop {
        let _e237 = i_8;
        if (_e237 < 32i) {
            let _e239 = i_8;
            let _e240 = count_1;
            if (_e239 >= _e240) {
                break;
            }
            let _e242 = i_8;
            param_113 = _e242;
            let _e243 = (*s_6);
            param_114 = _e243;
            let _e244 = 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((&param_113), (&param_114));
            light_4 = _e244;
            let _e246 = light_4.n_dot_l;
            if (_e246 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e248 = i_8;
            param_115 = _e248;
            let _e249 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e249 {
                let _e250 = (*s_6);
                param_116 = _e250;
                let _e251 = light_4;
                param_117 = _e251;
                let _e252 = i_8;
                param_118 = _e252;
                let _e253 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e254 = v_world_position_1;
                param_119 = _e254;
                let _e256 = (*s_6).n;
                param_120 = _e256;
                let _e257 = i_8;
                param_121 = _e257;
                let _e258 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_38 = (_e253 * _e258);
            } else {
                local_38 = 1f;
            }
            let _e260 = local_38;
            visibility = _e260;
            let _e261 = visibility;
            if (_e261 <= 0f) {
                continue;
            }
            let _e263 = (*s_6);
            param_122 = _e263;
            let _e264 = light_4;
            param_123 = _e264;
            let _e265 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e267 = light_4.radiance;
            let _e270 = light_4.n_dot_l;
            let _e272 = visibility;
            let _e274 = light_transmittance;
            let _e276 = total_1;
            total_1 = (_e276 + ((((_e265 * _e267) * _e270) * _e272) * _e274));
            continue;
        } else {
            break;
        }
        continuing {
            let _e278 = i_8;
            i_8 = (_e278 + 1i);
        }
    }
    let _e280 = total_1;
    return _e280;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_39: f32;
    var local_40: f32;

    let _e222 = OcclusionTarget_u0028_();
    target_ = _e222;
    let _e223 = target_;
    let _e225 = target_;
    if ((_e223 > 0.5f) && (_e225 < 1.5f)) {
        local_39 = 1f;
    } else {
        let _e229 = (*s_7).occlusion;
        local_39 = _e229;
    }
    let _e230 = local_39;
    local_40 = _e230;
    let _e231 = local_40;
    return _e231;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e219 = v_lightmap_uv_1;
    let _e220 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e219);
    texel_4 = _e220;
    let _e221 = texel_4;
    let _e224 = texel_4[3u];
    return ((_e221.xyz * _e224) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e220 = frag_info.target_origin[1u];
    return _e220;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e220 = v_texcoord_1;
    let _e221 = MaterialLodBias_u0028_();
    let _e222 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e220, _e221);
    orm = _e222.xyz;
    let _e225 = (*s_8).metallic;
    let _e227 = orm[2u];
    (*s_8).metallic = clamp((_e225 * _e227), 0f, 1f);
    let _e232 = (*s_8).roughness;
    let _e234 = orm[1u];
    (*s_8).roughness = clamp((_e232 * _e234), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_124: vec3<f32>;

    let _e221 = v_texcoord_1;
    let _e222 = MaterialLodBias_u0028_();
    let _e223 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e221, _e222);
    param_124 = _e223.xyz;
    let _e225 = SrgbToLinear_u0028_vf3_u003b((&param_124));
    emissive = _e225;
    let _e226 = emissive;
    let _e228 = frag_info.emissive;
    let _e233 = frag_info.material2_[3u];
    (*s_9).emissive = ((_e226 * _e228.xyz) * _e233);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e221 = v_texcoord_1;
    let _e222 = MaterialLodBias_u0028_();
    let _e223 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e221, _e222);
    occlusion = _e223.x;
    let _e227 = frag_info.material2_[2u];
    let _e228 = OcclusionTarget_u0028_();
    strength_2 = (_e227 - (2f * _e228));
    let _e231 = occlusion;
    let _e232 = strength_2;
    (*s_10).occlusion = mix(1f, _e231, clamp(_e232, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e223 = v_texcoord_1;
    let _e224 = MaterialLodBias_u0028_();
    let _e225 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e223, _e224);
    sampledTexel = _e225;
    let _e226 = v_tangent_1;
    t_2 = _e226.xyz;
    let _e228 = t_2;
    let _e230 = (*s_11).n;
    let _e232 = (*s_11).n;
    let _e233 = t_2;
    t_2 = (_e228 - (_e230 * dot(_e232, _e233)));
    let _e237 = t_2;
    let _e238 = t_2;
    if (dot(_e237, _e238) < 0.000000000001f) {
        return;
    }
    let _e241 = t_2;
    t_2 = normalize(_e241);
    let _e244 = (*s_11).n;
    let _e245 = t_2;
    let _e248 = v_tangent_1[3u];
    b_3 = (cross(_e244, _e245) * _e248);
    let _e250 = gl_FrontFacing_1;
    if !(_e250) {
        let _e252 = t_2;
        t_2 = -(_e252);
    }
    let _e254 = sampledTexel;
    sampled = ((_e254.xyz * 2f) - vec3(1f));
    let _e261 = frag_info.emissive[3u];
    if (_e261 > 0.5f) {
        let _e263 = sampled;
        let _e265 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e263.xy, _e265.xy)), 0f));
    }
    let _e274 = frag_info.material2_[1u];
    let _e275 = sampled;
    let _e277 = (_e275.xy * _e274);
    sampled[0u] = _e277.x;
    sampled[1u] = _e277.y;
    let _e282 = t_2;
    let _e284 = sampled[0u];
    let _e286 = b_3;
    let _e288 = sampled[1u];
    let _e292 = (*s_11).n;
    let _e294 = sampled[2u];
    (*s_11).n = normalize((((_e282 * _e284) + (_e286 * _e288)) + (_e292 * _e294)));
    let _e300 = (*s_11).n;
    let _e302 = (*s_11).v;
    (*s_11).n_dot_v = max(dot(_e300, _e302), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e219 = (*texel_5);
    let _e223 = irradiance_info.atlas;
    let _e226 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e219 + vec2(0.5f)) * _e223.xy), 0f);
    return _e226;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_125: vec2<f32>;
    var b_4: vec4<f32>;
    var param_126: vec2<f32>;
    var c_1: vec4<f32>;
    var param_127: vec2<f32>;
    var d_4: vec4<f32>;
    var param_128: vec2<f32>;

    let _e232 = (*uv_6);
    let _e233 = (*interior);
    at_1 = ((vec2(1f) + (_e232 * _e233)) - vec2(0.5f));
    let _e239 = at_1;
    low = floor(_e239);
    let _e241 = at_1;
    let _e242 = low;
    f = (_e241 - _e242);
    let _e244 = (*corner);
    let _e245 = low;
    param_125 = (_e244 + _e245);
    let _e247 = AtlasTexel_u0028_vf2_u003b((&param_125));
    a_4 = _e247;
    let _e248 = (*corner);
    let _e249 = low;
    param_126 = ((_e248 + _e249) + vec2<f32>(1f, 0f));
    let _e252 = AtlasTexel_u0028_vf2_u003b((&param_126));
    b_4 = _e252;
    let _e253 = (*corner);
    let _e254 = low;
    param_127 = ((_e253 + _e254) + vec2<f32>(0f, 1f));
    let _e257 = AtlasTexel_u0028_vf2_u003b((&param_127));
    c_1 = _e257;
    let _e258 = (*corner);
    let _e259 = low;
    param_128 = ((_e258 + _e259) + vec2<f32>(1f, 1f));
    let _e262 = AtlasTexel_u0028_vf2_u003b((&param_128));
    d_4 = _e262;
    let _e263 = a_4;
    let _e264 = b_4;
    let _e266 = f[0u];
    let _e269 = c_1;
    let _e270 = d_4;
    let _e272 = f[0u];
    let _e276 = f[1u];
    return mix(mix(_e263, _e264, vec4(_e266)), mix(_e269, _e270, vec4(_e272)), vec4(_e276));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e223 = (*direction_1)[0u];
    let _e226 = (*direction_1)[1u];
    let _e230 = (*direction_1)[2u];
    sum_1 = ((abs(_e223) + abs(_e226)) + abs(_e230));
    let _e233 = sum_1;
    if (_e233 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e235 = (*direction_1);
    let _e236 = sum_1;
    n_5 = (_e235 / vec3(_e236));
    let _e239 = n_5;
    xy = _e239.xy;
    let _e242 = n_5[2u];
    if (_e242 < 0f) {
        let _e245 = n_5[1u];
        let _e249 = n_5[0u];
        let _e254 = n_5[0u];
        let _e258 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e245)) * select(-1f, 1f, (_e249 >= 0f))), ((1f - abs(_e254)) * select(-1f, 1f, (_e258 >= 0f))));
    }
    let _e263 = xy;
    return ((_e263 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_129: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_130: vec3<f32>;
    var param_131: vec2<f32>;
    var param_132: f32;
    var param_133: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_134: vec3<f32>;
    var param_135: vec2<f32>;
    var param_136: f32;
    var param_137: vec2<f32>;
    var local_41: vec3<f32>;

    let _e265 = irradiance_info.origin;
    origin_2 = _e265.xyz;
    let _e268 = irradiance_info.spacing;
    spacing = _e268.xyz;
    let _e271 = irradiance_info.counts;
    counts = _e271.xyz;
    let _e275 = irradiance_info.tiles[0u];
    irradianceTile = _e275;
    let _e278 = irradiance_info.tiles[1u];
    depthTile = _e278;
    let _e281 = irradiance_info.tiles[2u];
    columns = _e281;
    let _e284 = irradiance_info.tiles[3u];
    momentsTop = _e284;
    let _e285 = (*normal_1);
    unit = normalize(_e285);
    let _e287 = (*world_4);
    let _e288 = unit;
    let _e291 = irradiance_info.spacing[3u];
    let _e294 = (*view_1);
    let _e297 = irradiance_info.counts[3u];
    biased = ((_e287 + (_e288 * _e291)) + (_e294 * _e297));
    let _e300 = biased;
    let _e301 = origin_2;
    let _e303 = spacing;
    grid_1 = ((_e300 - _e301) / _e303);
    let _e305 = grid_1;
    let _e307 = counts;
    base = clamp(floor(_e305), vec3<f32>(0f, 0f, 0f), (_e307 - vec3(2f)));
    let _e311 = grid_1;
    let _e312 = base;
    f_1 = clamp((_e311 - _e312), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e315 = corner_1;
        if (_e315 < 8i) {
            let _e317 = corner_1;
            let _e320 = corner_1;
            let _e325 = corner_1;
            offset_3 = vec3<f32>(f32((_e317 & 1i)), f32(((_e320 >> bitcast<u32>(1i)) & 1i)), f32(((_e325 >> bitcast<u32>(2i)) & 1i)));
            let _e331 = base;
            let _e332 = offset_3;
            cell_2 = (_e331 + _e332);
            let _e335 = cell_2[2u];
            let _e337 = counts[1u];
            let _e340 = cell_2[1u];
            let _e343 = counts[0u];
            let _e346 = cell_2[0u];
            probe = ((((_e335 * _e337) + _e340) * _e343) + _e346);
            let _e348 = probe;
            let _e349 = columns;
            let _e354 = probe;
            let _e355 = columns;
            tile_4 = vec2<f32>((_e348 - (floor((_e348 / _e349)) * _e349)), floor((_e354 / _e355)));
            let _e359 = tile_4;
            let _e360 = irradianceTile;
            irradianceCorner = (_e359 * (_e360 + 2f));
            let _e364 = tile_4[0u];
            let _e365 = depthTile;
            let _e368 = momentsTop;
            let _e370 = tile_4[1u];
            let _e371 = depthTile;
            momentCorner = vec2<f32>((_e364 * (_e365 + 2f)), (_e368 + (_e370 * (_e371 + 2f))));
            let _e376 = irradianceCorner;
            param_129 = (_e376 + vec2(1f));
            let _e379 = AtlasTexel_u0028_vf2_u003b((&param_129));
            if (_e379.w < 0.5f) {
                continue;
            }
            let _e382 = f_1;
            let _e384 = f_1;
            let _e385 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e382), _e384, _e385);
            let _e388 = trilinear[0u];
            let _e390 = trilinear[1u];
            let _e393 = trilinear[2u];
            weight_3 = max(((_e388 * _e390) * _e393), 0.001f);
            let _e396 = origin_2;
            let _e397 = spacing;
            let _e398 = cell_2;
            probePosition = (_e396 + (_e397 * _e398));
            let _e401 = probePosition;
            let _e402 = biased;
            toProbe = (_e401 - _e402);
            let _e404 = toProbe;
            distance_4 = length(_e404);
            let _e406 = distance_4;
            if (_e406 > 0.000001f) {
                let _e408 = toProbe;
                let _e409 = distance_4;
                direction_2 = (_e408 / vec3(_e409));
                let _e412 = unit;
                let _e413 = probePosition;
                let _e414 = (*world_4);
                facing = ((dot(_e412, normalize((_e413 - _e414))) * 0.5f) + 0.5f);
                let _e420 = facing;
                let _e421 = facing;
                probeWeight = ((_e420 * _e421) + 0.2f);
                let _e424 = direction_2;
                param_130 = -(_e424);
                let _e426 = ProbeOctahedral_u0028_vf3_u003b((&param_130));
                let _e427 = momentCorner;
                param_131 = _e427;
                let _e428 = depthTile;
                param_132 = _e428;
                param_133 = _e426;
                let _e429 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_131), (&param_132), (&param_133));
                moments_3 = _e429.xy;
                chebyshev = 1f;
                let _e431 = distance_4;
                let _e433 = moments_3[0u];
                if (_e431 > _e433) {
                    let _e436 = moments_3[1u];
                    let _e438 = moments_3[0u];
                    let _e440 = moments_3[0u];
                    variance_1 = max((_e436 - (_e438 * _e440)), 0.000001f);
                    let _e444 = distance_4;
                    let _e446 = moments_3[0u];
                    difference = (_e444 - _e446);
                    let _e448 = variance_1;
                    let _e449 = variance_1;
                    let _e450 = difference;
                    let _e451 = difference;
                    chebyshev = (_e448 / (_e449 + (_e450 * _e451)));
                    let _e455 = chebyshev;
                    let _e456 = chebyshev;
                    let _e458 = chebyshev;
                    chebyshev = ((_e455 * _e456) * _e458);
                }
                let _e460 = probeWeight;
                let _e461 = chebyshev;
                probeWeight = max((_e460 * max(_e461, 0.05f)), 0.000001f);
                let _e465 = probeWeight;
                if (_e465 < 0.2f) {
                    let _e467 = probeWeight;
                    let _e468 = probeWeight;
                    let _e471 = probeWeight;
                    probeWeight = (_e471 * ((_e467 * _e468) * 25f));
                }
                let _e473 = probeWeight;
                let _e474 = weight_3;
                weight_3 = (_e474 * _e473);
            }
            let _e476 = unit;
            param_134 = _e476;
            let _e477 = ProbeOctahedral_u0028_vf3_u003b((&param_134));
            let _e478 = irradianceCorner;
            param_135 = _e478;
            let _e479 = irradianceTile;
            param_136 = _e479;
            param_137 = _e477;
            let _e480 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_135), (&param_136), (&param_137));
            let _e482 = weight_3;
            let _e484 = total_2;
            total_2 = (_e484 + (_e480.xyz * _e482));
            let _e486 = weight_3;
            let _e487 = weights;
            weights = (_e487 + _e486);
            continue;
        } else {
            break;
        }
        continuing {
            let _e489 = corner_1;
            corner_1 = (_e489 + 1i);
        }
    }
    let _e491 = weights;
    if (_e491 > 0f) {
        let _e493 = total_2;
        let _e494 = weights;
        local_41 = (_e493 / vec3(_e494));
    } else {
        local_41 = vec3<f32>(0f, 0f, 0f);
    }
    let _e497 = local_41;
    return _e497;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e220 = irradiance_info.origin[3u];
    return (_e220 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: Surface;

    let _e225 = IrradianceEnabled_u0028_();
    if _e225 {
        let _e226 = v_world_position_1;
        param_138 = _e226;
        let _e228 = (*s_12).n;
        param_139 = _e228;
        let _e230 = (*s_12).v;
        param_140 = _e230;
        let _e231 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_138), (&param_139), (&param_140));
        let _e234 = frag_info.material[2u];
        (*s_12).ambient = (_e231 * _e234);
    }
    let _e237 = (*s_12);
    param_141 = _e237;
    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((&param_141));
    let _e238 = param_141;
    (*s_12) = _e238;
    let _e239 = (*s_12);
    param_142 = _e239;
    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((&param_142));
    let _e240 = param_142;
    (*s_12) = _e240;
    let _e241 = (*s_12);
    param_143 = _e241;
    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((&param_143));
    let _e242 = param_143;
    (*s_12) = _e242;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_42: vec3<f32>;

    let _e219 = Orthographic_u0028_();
    if _e219 {
        let _e221 = fog_info.forward;
        local_42 = -(_e221.xyz);
    } else {
        let _e225 = fog_info.eye;
        let _e227 = v_world_position_1;
        local_42 = normalize((_e225.xyz - _e227));
    }
    let _e230 = local_42;
    return _e230;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin_3: vec3<f32>;
    var cell_3: vec3<f32>;
    var p3_: vec3<f32>;

    let _e224 = (*cutoff);
    key_2 = (-2f - _e224);
    let _e226 = key_2;
    let _e229 = key_2;
    let _e231 = floor((_e229 / 128f));
    let _e236 = key_2;
    origin_3 = vec3<f32>(floor((_e226 / 16384f)), (_e231 - (floor((_e231 / 128f)) * 128f)), (_e236 - (floor((_e236 / 128f)) * 128f)));
    let _e242 = (*scenePosition);
    let _e245 = origin_3;
    let _e246 = (floor((_e242 * 16f)) + _e245);
    let _e247 = vec3(128f);
    cell_3 = (_e246 - (floor((_e246 / _e247)) * _e247));
    let _e252 = cell_3;
    p3_ = fract((_e252 * 0.1031f));
    let _e255 = p3_;
    let _e256 = p3_;
    let _e261 = p3_;
    p3_ = (_e261 + vec3(dot(_e255, (_e256.zyx + vec3(31.32f)))));
    let _e265 = p3_[0u];
    let _e267 = p3_[1u];
    let _e270 = p3_[2u];
    return fract(((_e265 + _e267) * _e270));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_13: Surface;
    var param_144: vec3<f32>;
    var param_145: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_146: vec3<f32>;
    var param_147: f32;

    let _e226 = v_texcoord_1;
    let _e227 = MaterialLodBias_u0028_();
    let _e228 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e226, _e227);
    texel_6 = _e228;
    let _e229 = texel_6;
    param_144 = _e229.xyz;
    let _e231 = SrgbToLinear_u0028_vf3_u003b((&param_144));
    let _e233 = frag_info.base_color;
    param_145 = _e233.xyz;
    let _e235 = SrgbToLinear_u0028_vf3_u003b((&param_145));
    let _e237 = v_color_1;
    s_13.albedo = ((_e231 * _e235) * _e237.xyz);
    let _e242 = texel_6[3u];
    let _e245 = frag_info.base_color[3u];
    let _e248 = v_color_1[3u];
    s_13.alpha = ((_e242 * _e245) * _e248);
    let _e252 = s_13.albedo;
    g_albedo = _e252;
    let _e255 = frag_info.material2_[0u];
    cutoff_1 = _e255;
    let _e256 = cutoff_1;
    if (_e256 > 1f) {
        let _e258 = cutoff_1;
        edge = (_e258 - 1f);
        let _e261 = s_13.alpha;
        let _e262 = edge;
        let _e265 = s_13.alpha;
        let _e266 = fwidth(_e265);
        s_13.alpha = clamp((((_e261 - _e262) / max(_e266, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e272 = cutoff_1;
        if (_e272 >= 0f) {
            let _e275 = s_13.alpha;
            let _e276 = cutoff_1;
            if (_e275 < _e276) {
                discard;
            }
            s_13.alpha = 1f;
        } else {
            let _e279 = cutoff_1;
            if (_e279 < -1.5f) {
                let _e282 = s_13.alpha;
                let _e283 = v_world_position_1;
                param_146 = _e283;
                let _e284 = cutoff_1;
                param_147 = _e284;
                let _e285 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_146), (&param_147));
                if (_e282 < _e285) {
                    discard;
                }
            }
        }
    }
    let _e287 = cutoff_1;
    let _e289 = cutoff_1;
    g_premultiply = ((_e287 < 0f) && (_e289 > -0.75f));
    let _e292 = v_normal_1;
    s_13.n = normalize(_e292);
    let _e295 = gl_FrontFacing_1;
    if !(_e295) {
        let _e298 = s_13.n;
        s_13.n = -(_e298);
    }
    let _e301 = TowardsEye_u0028_();
    s_13.v = _e301;
    let _e304 = s_13.n;
    let _e306 = s_13.v;
    s_13.n_dot_v = max(dot(_e304, _e306), 0.0001f);
    let _e312 = frag_info.material[0u];
    s_13.metallic = clamp(_e312, 0f, 1f);
    let _e317 = frag_info.material[1u];
    s_13.roughness = clamp(_e317, 0.02f, 1f);
    let _e321 = frag_info.ambient_ground;
    let _e324 = frag_info.ambient_sky;
    let _e328 = s_13.n[1u];
    let _e335 = frag_info.material[2u];
    s_13.ambient = (mix(_e321.xyz, _e324.xyz, vec3(((_e328 * 0.5f) + 0.5f))) * _e335);
    let _e340 = frag_info.frame_params[0u];
    s_13.exposure = max(_e340, 0f);
    s_13.occlusion = 1f;
    s_13.emissive = vec3<f32>(0f, 0f, 0f);
    let _e345 = s_13;
    return _e345;
}

fn main_1() {
    var s_14: Surface;
    var param_148: Surface;
    var param_149: Surface;
    var ambient: vec3<f32>;
    var param_150: Surface;
    var lit_3: vec3<f32>;
    var param_151: Surface;
    var param_152: Surface;
    var param_153: Surface;
    var param_154: vec3<f32>;
    var param_155: vec3<f32>;
    var param_156: f32;
    var param_157: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e231 = ReadSurface_u0028_();
    s_14 = _e231;
    let _e232 = s_14;
    param_148 = _e232;
    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((&param_148));
    let _e233 = param_148;
    s_14 = _e233;
    let _e234 = s_14;
    param_149 = _e234;
    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((&param_149));
    let _e235 = param_149;
    s_14 = _e235;
    let _e237 = s_14.albedo;
    let _e239 = s_14.ambient;
    let _e240 = SampleLightmap_u0028_();
    let _e243 = s_14;
    param_150 = _e243;
    let _e244 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_150));
    ambient = ((_e237 * (_e239 + _e240)) * _e244);
    let _e246 = s_14;
    param_151 = _e246;
    let _e247 = 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((&param_151));
    let _e248 = s_14;
    param_152 = _e248;
    let _e249 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_152));
    let _e251 = ambient;
    let _e254 = s_14.emissive;
    lit_3 = (((_e247 * _e249) + _e251) + _e254);
    let _e256 = s_14;
    param_153 = _e256;
    let _e257 = lit_3;
    param_154 = _e257;
    let _e258 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_153), (&param_154));
    if _e258 {
        return;
    }
    let _e259 = lit_3;
    param_155 = _e259;
    let _e261 = s_14.alpha;
    param_156 = _e261;
    let _e263 = s_14.roughness;
    param_157 = _e263;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_155), (&param_156), (&param_157));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(13)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(17)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var ltc_texture_smp: sampler;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(27)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(28)
var point_shadow_texture_smp: sampler;
@group(1) @binding(25)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(11)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var irradiance_texture_smp: sampler;
@group(1) @binding(15)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(23)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(21)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var normal_texture_smp: sampler;
@group(1) @binding(29)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(30)
var shadow_texture_smp: sampler;
@group(1) @binding(9)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(10)
var environment_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e237 = v_world_position_1;
    let _e239 = fog_info.eye;
    let _e243 = fog_info.forward;
    return dot((_e237 - _e239.xyz), _e243.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e242 = ViewDepth_u0028_();
    z = abs(_e242);
    let _e244 = z;
    near = (_e244 / 5f);
    let _e246 = z;
    far = (_e246 / 200f);
    let _e248 = far;
    let _e249 = far;
    let _e251 = far;
    far3_ = ((_e248 * _e249) * _e251);
    let _e253 = (*alpha);
    let _e254 = near;
    let _e255 = near;
    let _e258 = far3_;
    let _e259 = far3_;
    return (_e253 * clamp((10f / ((0.00001f + (_e254 * _e255)) + (_e258 * _e259))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e246 = fog_info.forward[3u];
    mode = _e246;
    let _e247 = mode;
    if (_e247 > 0.5f) {
        let _e250 = frag_color[3u];
        alpha_1 = _e250;
        let _e251 = alpha_1;
        param = _e251;
        let _e252 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e252;
        let _e253 = frag_color;
        let _e255 = weight;
        let _e256 = (_e253.xyz * _e255);
        let _e257 = alpha_1;
        let _e258 = weight;
        accumulate = vec4<f32>(_e256.x, _e256.y, _e256.z, (_e257 * _e258));
        let _e264 = mode;
        let _e266 = mode;
        revealage = ((_e264 > 1.5f) && (_e266 < 2.5f));
        let _e269 = revealage;
        if _e269 {
            let _e270 = alpha_1;
            local = vec4(_e270);
        } else {
            let _e272 = accumulate;
            local = _e272;
        }
        let _e273 = local;
        frag_color = _e273;
        let _e274 = mode;
        if (_e274 > 2.5f) {
            let _e276 = alpha_1;
            frag_surface = vec4(_e276);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e240 = (*n)[0u];
    let _e243 = (*n)[1u];
    let _e247 = (*n)[2u];
    let _e250 = (*n);
    (*n) = (_e250 / vec3(((abs(_e240) + abs(_e243)) + abs(_e247))));
    let _e253 = (*n);
    e = _e253.xy;
    let _e256 = (*n)[2u];
    if (_e256 < 0f) {
        let _e258 = (*n);
        let _e264 = (*n)[0u];
        let _e268 = (*n)[1u];
        e = ((vec2(1f) - abs(_e258.yx)) * vec2<f32>(select(-1f, 1f, (_e264 >= 0f)), select(-1f, 1f, (_e268 >= 0f))));
    }
    let _e273 = e;
    return ((_e273 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e238 = (*linear);
    let _e240 = (*linear);
    let _e244 = (*linear);
    return mix((_e238 * 12.92f), ((pow(_e240, 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), _e244));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e241 = g_albedo;
    param_1 = clamp(_e241, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e243 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e243.x, _e243.y, _e243.z, 1f);
    let _e248 = g_debug_surface_on;
    if _e248 {
        let _e249 = g_debug_surface;
        let _e250 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e249.x, _e249.y, _e249.z, _e250);
        return;
    }
    let _e255 = v_normal_1;
    geometric = normalize(_e255);
    let _e257 = gl_FrontFacing_1;
    if !(_e257) {
        let _e259 = geometric;
        geometric = -(_e259);
    }
    let _e261 = geometric;
    param_2 = _e261;
    let _e262 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e263 = (*roughness);
    let _e265 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e262.x, _e262.y, clamp(_e263, 0f, 1f), _e265);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e239 = fog_info.projection[0u];
    return (_e239 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e238 = Orthographic_u0028_();
    if _e238 {
        let _e239 = ViewDepth_u0028_();
        local_1 = max(_e239, 0f);
    } else {
        let _e241 = v_world_position_1;
        let _e243 = fog_info.eye;
        local_1 = distance(_e241, _e243.xyz);
    }
    let _e246 = local_1;
    return _e246;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e245 = fog_info.fog[3u];
    density = _e245;
    let _e246 = density;
    if (_e246 <= 0f) {
        let _e248 = (*color);
        return _e248;
    }
    let _e249 = EyeDistance_u0028_();
    d = _e249;
    let _e252 = fog_info.eye[3u];
    falloff = _e252;
    let _e253 = falloff;
    if (_e253 > 0f) {
        let _e255 = falloff;
        let _e257 = v_world_position_1[1u];
        let _e260 = fog_info.eye[1u];
        k = (_e255 * (_e257 - _e260));
        let _e263 = k;
        if (abs(_e263) > 0.001f) {
            let _e266 = k;
            let _e270 = k;
            local_2 = ((1f - exp(-(_e266))) / _e270);
        } else {
            let _e272 = k;
            local_2 = (1f - (0.5f * _e272));
        }
        let _e275 = local_2;
        let _e276 = density;
        density = (_e276 * _e275);
    }
    let _e279 = fog_info.fog;
    let _e281 = (*color);
    let _e282 = density;
    let _e284 = d;
    return mix(_e279.xyz, _e281, vec3(clamp(exp((-(_e282) * _e284)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e243 = g_premultiply;
    let _e244 = (*alpha_2);
    weight_1 = select(1f, _e244, _e243);
    let _e246 = (*linearColor);
    param_3 = _e246;
    let _e247 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e248 = weight_1;
    let _e249 = (_e247 * _e248);
    let _e250 = (*alpha_2);
    let _e251 = g_pass_through;
    frag_color = vec4<f32>(_e249.x, _e249.y, _e249.z, (_e250 * (1f - _e251)));
    let _e258 = (*roughness_1);
    param_4 = _e258;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e238 = (*srgb);
    let _e241 = (*srgb);
    let _e246 = (*srgb);
    return mix((_e238 / vec3(12.92f)), pow(((_e241 + 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), _e246));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e240 = (*key);
    hue = fract(((_e240 * 0.618034f) + 0.13f));
    let _e244 = hue;
    k_1 = clamp((abs(((fract((vec3(_e244) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e257 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e257, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2987_: bool;

    let _e238 = (*c);
    let _e239 = (*c);
    let _e241 = any((_e238 != _e239));
    phi_2987_ = _e241;
    if !(_e241) {
        let _e243 = (*c);
        phi_2987_ = any((abs(_e243) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e248 = phi_2987_;
    return _e248;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_3077_: bool;
    var phi_3345_: bool;

    let _e280 = gl_FragCoord_1[0u];
    let _e283 = frag_info.debug_view[1u];
    if (_e280 < _e283) {
        let _e287 = frag_info.debug_view[2u];
        local_3 = _e287;
    } else {
        let _e290 = frag_info.debug_view[0u];
        local_3 = _e290;
    }
    let _e291 = local_3;
    view = _e291;
    let _e292 = view;
    if (_e292 < 0.5f) {
        return false;
    }
    let _e294 = view;
    code = i32((_e294 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e297 = v_normal_1;
    geometric_n = normalize(_e297);
    let _e299 = v_tangent_1;
    let _e301 = geometric_n;
    let _e302 = geometric_n;
    let _e303 = v_tangent_1;
    tangent = (_e299.xyz - (_e301 * dot(_e302, _e303.xyz)));
    let _e308 = tangent;
    let _e309 = tangent;
    let _e311 = (dot(_e308, _e309) > 0.000000000001f);
    phi_3077_ = _e311;
    if _e311 {
        let _e313 = v_tangent_1[3u];
        phi_3077_ = (abs((abs(_e313) - 1f)) < 0.01f);
    }
    let _e319 = phi_3077_;
    tangent_usable = _e319;
    let _e322 = frag_info.debug_view[3u];
    identity = _e322;
    let _e323 = identity;
    identity_object = floor((_e323 / 8192f));
    let _e326 = identity;
    let _e327 = identity_object;
    identity_rest = (_e326 - (_e327 * 8192f));
    let _e330 = identity_rest;
    identity_material = floor((_e330 / 2f));
    let _e333 = identity_rest;
    let _e334 = identity_material;
    normal_mapped = ((_e333 - (_e334 * 2f)) > 0.5f);
    let _e338 = code;
    if (_e338 == 1i) {
        let _e341 = (*s).albedo;
        param_5 = clamp(_e341, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e343 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e343;
    } else {
        let _e344 = code;
        if (_e344 == 2i) {
            let _e347 = (*s).n;
            shown = ((_e347 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e350 = code;
            if (_e350 == 3i) {
                let _e353 = (*s).roughness;
                shown = vec3(clamp(_e353, 0f, 1f));
            } else {
                let _e356 = code;
                if (_e356 == 4i) {
                    let _e359 = (*s).metallic;
                    shown = vec3(clamp(_e359, 0f, 1f));
                } else {
                    let _e362 = code;
                    if (_e362 == 5i) {
                        let _e365 = (*s).occlusion;
                        shown = vec3(clamp(_e365, 0f, 1f));
                    } else {
                        let _e368 = code;
                        if (_e368 == 6i) {
                            let _e371 = (*s).emissive;
                            param_6 = clamp(_e371, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e373 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e373;
                        } else {
                            let _e374 = code;
                            if (_e374 == 7i) {
                                let _e376 = v_texcoord_1;
                                let _e377 = fract(_e376);
                                shown = vec3<f32>(_e377.x, _e377.y, 0f);
                            } else {
                                let _e381 = code;
                                if (_e381 == 8i) {
                                    let _e383 = (*lit);
                                    param_7 = clamp(_e383, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e385 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e385, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e387 = (*lit);
                                    param_8 = _e387;
                                    let _e388 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e388 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e389 = grey;
                                        local_4 = vec3((_e389 * 0.5f));
                                    }
                                    let _e392 = local_4;
                                    shown = _e392;
                                } else {
                                    let _e393 = code;
                                    if (_e393 == 9i) {
                                        let _e395 = tangent_usable;
                                        if _e395 {
                                            let _e396 = tangent;
                                            local_5 = ((normalize(_e396) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e400 = local_5;
                                        shown = _e400;
                                    } else {
                                        let _e401 = code;
                                        if (_e401 == 10i) {
                                            let _e403 = v_texcoord_1;
                                            uv = _e403;
                                            let _e404 = uv;
                                            cell = floor((_e404 * 8f));
                                            let _e408 = cell[0u];
                                            let _e410 = cell[1u];
                                            odd = (fract(((_e408 + _e410) * 0.5f)) * 2f);
                                            let _e415 = uv;
                                            within = fract(_e415);
                                            let _e417 = odd;
                                            let _e421 = within[0u];
                                            let _e425 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e417)) * vec3<f32>((0.55f + (0.45f * _e421)), (0.55f + (0.45f * _e425)), 0.85f));
                                        } else {
                                            let _e430 = code;
                                            if (_e430 == 11i) {
                                                let _e432 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e432));
                                            } else {
                                                let _e435 = code;
                                                if (_e435 == 12i) {
                                                    let _e437 = v_color_1;
                                                    param_9 = clamp(_e437.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e440 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e440;
                                                } else {
                                                    let _e441 = code;
                                                    let _e443 = code;
                                                    if ((_e441 == 13i) || (_e443 == 14i)) {
                                                        let _e446 = code;
                                                        let _e448 = identity_object;
                                                        let _e449 = identity_material;
                                                        key_1 = select(_e449, _e448, (_e446 == 13i));
                                                        let _e451 = key_1;
                                                        param_10 = _e451;
                                                        let _e452 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e454 = (*s).n_dot_v;
                                                        shown = (_e452 * (0.55f + (0.45f * _e454)));
                                                    } else {
                                                        let _e458 = code;
                                                        if (_e458 == 15i) {
                                                            let _e461 = (*s).albedo;
                                                            param_11 = clamp(_e461, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e463 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e463;
                                                            let _e464 = srgb_1;
                                                            luma = dot(_e464, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e467 = (*s).metallic;
                                                            metal = (_e467 > 0.5f);
                                                            let _e469 = metal;
                                                            let _e471 = luma;
                                                            if (!(_e469) && (_e471 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e474 = metal;
                                                                let _e475 = !(_e474);
                                                                phi_3345_ = _e475;
                                                                if _e475 {
                                                                    let _e477 = srgb_1[0u];
                                                                    let _e479 = srgb_1[1u];
                                                                    let _e481 = srgb_1[2u];
                                                                    phi_3345_ = (max(_e477, max(_e479, _e481)) > 0.9411765f);
                                                                }
                                                                let _e486 = phi_3345_;
                                                                if _e486 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e487 = metal;
                                                                    let _e488 = luma;
                                                                    if (_e487 && (_e488 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e491 = luma;
                                                                        local_8 = vec3(_e491);
                                                                    }
                                                                    let _e493 = local_8;
                                                                    local_7 = _e493;
                                                                }
                                                                let _e494 = local_7;
                                                                local_6 = _e494;
                                                            }
                                                            let _e495 = local_6;
                                                            shown = _e495;
                                                        } else {
                                                            let _e496 = code;
                                                            if (_e496 == 16i) {
                                                                let _e499 = (*s).metallic;
                                                                m = _e499;
                                                                let _e500 = m;
                                                                let _e502 = m;
                                                                if ((_e500 > 0.05f) && (_e502 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e505 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e505 > 0.5f)));
                                                                }
                                                                let _e509 = local_9;
                                                                shown = _e509;
                                                            } else {
                                                                let _e510 = code;
                                                                if (_e510 == 17i) {
                                                                    let _e512 = normal_mapped;
                                                                    if !(_e512) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e514 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e514));
                                                                    }
                                                                    let _e517 = local_10;
                                                                    shown = _e517;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e518 = g_premultiply;
    if _e518 {
        let _e520 = (*s).alpha;
        local_11 = _e520;
    } else {
        local_11 = 1f;
    }
    let _e521 = local_11;
    weight_2 = _e521;
    let _e522 = shown;
    param_12 = _e522;
    let _e523 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e524 = weight_2;
    let _e525 = (_e523 * _e524);
    let _e527 = (*s).alpha;
    frag_color = vec4<f32>(_e525.x, _e525.y, _e525.z, _e527);
    let _e533 = (*s).roughness;
    param_13 = _e533;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m_1: f32;
    var g: f32;

    let _e241 = (*mu);
    m_1 = (1f - _e241);
    let _e243 = m_1;
    let _e244 = m_1;
    let _e245 = m_1;
    let _e246 = m_1;
    g = (_e243 * (0.05710853f + (_e244 * (0.49188188f + (_e245 * (-0.33218145f + (_e246 * 0.071443f)))))));
    let _e254 = (*r);
    let _e255 = g;
    let _e258 = (*r);
    return ((1f + (_e254 * _e255)) / (1f + (0.2877934f * _e258)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e239 = (*rho);
    let _e240 = (*rho);
    let _e242 = (*average);
    let _e244 = (*rho);
    let _e245 = (*average);
    return (((_e239 * _e240) * _e242) / (vec3<f32>(1f, 1f, 1f) - (_e244 * (1f - _e245))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e238 = (*r_1);
    let _e241 = (*r_1);
    return ((1f + (0.07248821f * _e238)) / (1f + (0.2877934f * _e241)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s_1: f32;
    var s_over_t: f32;
    var local_12: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_14: f32;
    var multi: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: f32;
    var param_17: f32;
    var param_18: f32;
    var param_19: f32;
    var param_20: f32;

    let _e256 = (*l_dot_v);
    let _e257 = (*mu_i);
    let _e258 = (*mu_o);
    s_1 = (_e256 - (_e257 * _e258));
    let _e261 = s_1;
    if (_e261 > 0f) {
        let _e263 = s_1;
        let _e264 = (*mu_i);
        let _e265 = (*mu_o);
        local_12 = (_e263 / max(_e264, _e265));
    } else {
        let _e268 = s_1;
        local_12 = _e268;
    }
    let _e269 = local_12;
    s_over_t = _e269;
    let _e270 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e270)));
    let _e274 = (*rho_1);
    let _e275 = af;
    let _e276 = (*r_2);
    let _e277 = s_over_t;
    single = (_e274 * (_e275 * (1f + (_e276 * _e277))));
    let _e282 = (*r_2);
    param_14 = _e282;
    let _e283 = FonAverage_u0028_f1_u003b((&param_14));
    average_1 = _e283;
    let _e284 = (*rho_1);
    param_15 = _e284;
    let _e285 = average_1;
    param_16 = _e285;
    let _e286 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_15), (&param_16));
    let _e287 = (*mu_o);
    param_17 = _e287;
    let _e288 = (*r_2);
    param_18 = _e288;
    let _e289 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_17), (&param_18));
    let _e292 = (*mu_i);
    param_19 = _e292;
    let _e293 = (*r_2);
    param_20 = _e293;
    let _e294 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_19), (&param_20));
    let _e298 = average_1;
    multi = (_e286 * ((max((1f - _e289), 0.0000001f) * max((1f - _e294), 0.0000001f)) / max((1f - _e298), 0.0000001f)));
    let _e303 = single;
    let _e304 = multi;
    return ((_e303 + _e304) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e239 = frag_info.ambient_sky[3u];
    return (_e239 > 0.5f);
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e241 = (*x);
    let _e242 = (*y);
    inTable = ((vec2<f32>(_e241, _e242) * 0.984375f) + vec2(0.0078125f));
    let _e248 = inTable[0u];
    let _e250 = inTable[1u];
    let _e251 = (*table);
    return vec2<f32>(_e248, ((_e250 + _e251) * 0.5f));
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_21: f32;
    var param_22: f32;
    var param_23: f32;

    let _e243 = (*roughness_2);
    let _e245 = (*n_dot_v);
    param_21 = clamp(_e243, 0f, 1f);
    param_22 = sqrt(clamp((1f - _e245), 0f, 1f));
    param_23 = 1f;
    let _e249 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_21), (&param_22), (&param_23));
    let _e250 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e249, 0f);
    dfg = _e250.xy;
    let _e253 = dfg[0u];
    let _e255 = dfg[1u];
    let _e258 = dfg[1u];
    return vec2<f32>((_e253 - _e255), _e258);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_2: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_24: f32;
    var param_25: f32;
    var ess: f32;

    let _e244 = (*s_2).roughness;
    param_24 = max(_e244, 0.045f);
    let _e247 = (*s_2).n_dot_v;
    param_25 = _e247;
    let _e248 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_24), (&param_25));
    ab = _e248;
    let _e250 = ab[0u];
    let _e252 = ab[1u];
    ess = max((_e250 + _e252), 0.0001f);
    let _e255 = (*f0_);
    let _e256 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e255 * ((1f / _e256) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e239 = frag_info.target_origin[2u];
    return (_e239 > 0.5f);
}

fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f: f32;

    let _e240 = (*v_dot_h);
    f = pow((1f - _e240), 5f);
    let _e243 = (*f0_1);
    let _e244 = (*f0_1);
    let _e246 = f;
    return (_e243 + ((vec3<f32>(1f, 1f, 1f) - _e244) * _e246));
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e243 = (*alpha_3);
    let _e244 = (*alpha_3);
    a2_ = (_e243 * _e244);
    let _e246 = (*n_dot_l);
    let _e247 = (*n_dot_v_1);
    let _e248 = (*n_dot_v_1);
    let _e250 = a2_;
    let _e253 = a2_;
    lambda_v = (_e246 * sqrt((((_e247 * _e248) * (1f - _e250)) + _e253)));
    let _e257 = (*n_dot_v_1);
    let _e258 = (*n_dot_l);
    let _e259 = (*n_dot_l);
    let _e261 = a2_;
    let _e264 = a2_;
    lambda_l = (_e257 * sqrt((((_e258 * _e259) * (1f - _e261)) + _e264)));
    let _e268 = lambda_v;
    let _e269 = lambda_l;
    return (0.5f / max((_e268 + _e269), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_2: f32;

    let _e241 = (*n_dot_h);
    let _e242 = (*alpha_4);
    a = (_e241 * _e242);
    let _e244 = (*alpha_4);
    let _e245 = (*n_dot_h);
    let _e246 = (*n_dot_h);
    let _e249 = a;
    let _e250 = a;
    k_2 = (_e244 / max(((1f - (_e245 * _e246)) + (_e249 * _e250)), 0.0000001f));
    let _e255 = k_2;
    let _e256 = k_2;
    return ((_e255 * _e256) * 0.31830987f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_3: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var lobe: f32;
    var alpha_5: f32;
    var f0_2: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_1: f32;
    var param_26: f32;
    var param_27: f32;
    var vis: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var f_1: vec3<f32>;
    var param_31: vec3<f32>;
    var param_32: f32;
    var specular: vec3<f32>;
    var param_33: vec3<f32>;
    var param_34: Surface;
    var diffuse: vec3<f32>;
    var param_35: vec3<f32>;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;

    let _e263 = (*s_3).roughness;
    lobe = max(_e263, 0.045f);
    let _e265 = lobe;
    let _e266 = lobe;
    alpha_5 = (_e265 * _e266);
    let _e269 = (*s_3).albedo;
    let _e271 = (*s_3).metallic;
    f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e269, vec3(_e271));
    let _e275 = (*s_3).albedo;
    let _e277 = (*s_3).metallic;
    diffuseColor = (_e275 * (1f - _e277));
    let _e281 = (*light).n_dot_h;
    param_26 = _e281;
    let _e282 = alpha_5;
    param_27 = _e282;
    let _e283 = D_GGX_u0028_f1_u003b_f1_u003b((&param_26), (&param_27));
    d_1 = _e283;
    let _e285 = (*s_3).n_dot_v;
    param_28 = _e285;
    let _e287 = (*light).n_dot_l;
    param_29 = _e287;
    let _e288 = alpha_5;
    param_30 = _e288;
    let _e289 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_28), (&param_29), (&param_30));
    vis = _e289;
    let _e290 = f0_2;
    param_31 = _e290;
    let _e292 = (*light).v_dot_h;
    param_32 = _e292;
    let _e293 = F_Schlick_u0028_vf3_u003b_f1_u003b((&param_31), (&param_32));
    f_1 = _e293;
    let _e294 = d_1;
    let _e295 = vis;
    let _e297 = f_1;
    let _e301 = frag_info.material[3u];
    specular = ((_e297 * (_e294 * _e295)) * _e301);
    let _e304 = (*light).integrated;
    if (_e304 > 0.5f) {
        let _e308 = (*light).ltc[0u];
        let _e309 = f0_2;
        let _e312 = (*light).ltc[1u];
        let _e314 = f0_2;
        let _e319 = (*light).ltc[2u];
        let _e325 = frag_info.material[3u];
        let _e328 = (*light).n_dot_l;
        specular = (((((_e309 * _e312) + ((vec3(1f) - _e314) * _e319)) * _e308) * _e325) / vec3(max(_e328, 0.000001f)));
    }
    let _e332 = EnergyCompensation_u0028_();
    if _e332 {
        let _e333 = f0_2;
        param_33 = _e333;
        let _e334 = (*s_3);
        param_34 = _e334;
        let _e335 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_33), (&param_34));
        let _e336 = specular;
        specular = (_e336 * _e335);
    }
    let _e338 = diffuseColor;
    let _e339 = f_1;
    diffuse = ((_e338 * (vec3<f32>(1f, 1f, 1f) - _e339)) / vec3(3.1415927f));
    let _e344 = EonDiffuse_u0028_();
    if _e344 {
        let _e346 = (*s_3).n;
        let _e348 = (*light).l;
        let _e352 = (*light).l;
        let _e354 = (*s_3).v;
        let _e356 = diffuseColor;
        param_35 = _e356;
        let _e358 = (*s_3).roughness;
        param_36 = _e358;
        param_37 = clamp(dot(_e346, _e348), 0.0001f, 1f);
        let _e360 = (*s_3).n_dot_v;
        param_38 = _e360;
        param_39 = dot(_e352, _e354);
        let _e361 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
        let _e362 = f_1;
        diffuse = (_e361 * (vec3<f32>(1f, 1f, 1f) - _e362));
    }
    let _e365 = diffuse;
    let _e366 = specular;
    return ((_e365 + _e366) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e238 = (*i);
    if (_e238 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e240 = (*i);
    if (_e240 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e242 = (*i);
    if (_e242 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e244 = (*i);
    if (_e244 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e246 = (*i);
    if (_e246 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e248 = (*i);
    if (_e248 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e250 = (*i);
    if (_e250 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_40: i32;

    let _e243 = (*i_1);
    param_40 = _e243;
    let _e244 = PointShadowDiskTap_u0028_i1_u003b((&param_40));
    p = _e244;
    let _e246 = p[0u];
    let _e247 = (*ca);
    let _e250 = p[1u];
    let _e251 = (*sa);
    let _e255 = p[0u];
    let _e256 = (*sa);
    let _e259 = p[1u];
    let _e260 = (*ca);
    let _e264 = (*radius);
    return (vec2<f32>(((_e246 * _e247) - (_e250 * _e251)), ((_e255 * _e256) + (_e259 * _e260))) * _e264);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_13: vec2<f32>;
    var atlas: vec2<f32>;

    let _e246 = point_shadow.params[0u];
    inset = _e246;
    let _e247 = (*uv_1);
    let _e248 = (*offset);
    let _e250 = inset;
    let _e251 = inset;
    local_13 = clamp((_e247 + _e248), vec2(_e250), vec2((1f - _e251)));
    let _e256 = local_13;
    let _e257 = (*tile);
    atlas = ((_e256 + _e257) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e262 = point_shadow.params3_[0u];
    if (_e262 > 0.5f) {
        let _e265 = atlas[1u];
        atlas[1u] = (1f - _e265);
    }
    let _e268 = atlas;
    let _e269 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e268, 0f);
    let _e271 = atlas;
    let _e272 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e271, 0f);
    let _e275 = (*range);
    return (min(_e269.x, _e272.x) * _e275);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: vec2<f32>;
    var param_44: f32;

    let _e247 = (*uv_2);
    param_41 = _e247;
    let _e248 = (*offset_1);
    param_42 = _e248;
    let _e249 = (*tile_1);
    param_43 = _e249;
    let _e250 = (*range_1);
    param_44 = _e250;
    let _e251 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_41), (&param_42), (&param_43), (&param_44));
    stored = _e251;
    let _e252 = stored;
    let _e253 = (*range_1);
    if (_e252 >= (_e253 * 0.999f)) {
        return 1f;
    }
    let _e256 = (*receiver);
    let _e257 = stored;
    return select(1f, 0f, (_e256 > _e257));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_45: vec2<f32>;
    var param_46: vec2<f32>;
    var param_47: vec2<f32>;
    var param_48: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_49: i32;
    var param_50: f32;
    var param_51: f32;
    var param_52: f32;
    var param_53: vec2<f32>;
    var param_54: vec2<f32>;
    var param_55: vec2<f32>;
    var param_56: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e268 = point_shadow.params2_[1u];
    lightRadius = _e268;
    let _e271 = point_shadow.params2_[0u];
    minRadius = _e271;
    let _e274 = point_shadow.params2_[2u];
    maxRadius = _e274;
    let _e275 = lightRadius;
    if (_e275 <= 0f) {
        let _e277 = (*uv_3);
        param_45 = _e277;
        param_46 = vec2<f32>(0f, 0f);
        let _e278 = (*tile_2);
        param_47 = _e278;
        let _e279 = (*range_2);
        param_48 = _e279;
        let _e280 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
        (*blockerOut) = _e280;
        let _e281 = minRadius;
        return _e281;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e282 = i_2;
        if (_e282 < 8i) {
            let _e284 = i_2;
            param_49 = _e284;
            let _e285 = (*ca_1);
            param_50 = _e285;
            let _e286 = (*sa_1);
            param_51 = _e286;
            let _e287 = maxRadius;
            param_52 = _e287;
            let _e288 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52));
            let _e289 = (*uv_3);
            param_53 = _e289;
            param_54 = _e288;
            let _e290 = (*tile_2);
            param_55 = _e290;
            let _e291 = (*range_2);
            param_56 = _e291;
            let _e292 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
            stored_1 = _e292;
            let _e293 = stored_1;
            let _e294 = (*range_2);
            if (_e293 >= (_e294 * 0.999f)) {
                continue;
            }
            let _e297 = stored_1;
            let _e298 = (*receiver_1);
            if (_e297 >= _e298) {
                continue;
            }
            let _e300 = stored_1;
            let _e301 = sum;
            sum = (_e301 + _e300);
            let _e303 = count;
            count = (_e303 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e305 = i_2;
            i_2 = (_e305 + 1i);
        }
    }
    let _e307 = count;
    if (_e307 < 0.5f) {
        return -1f;
    }
    let _e309 = sum;
    let _e310 = count;
    blocker = max((_e309 / _e310), 0.0001f);
    let _e313 = blocker;
    (*blockerOut) = _e313;
    let _e314 = lightRadius;
    let _e315 = (*receiver_1);
    let _e316 = blocker;
    let _e320 = blocker;
    world = ((_e314 * max((_e315 - _e316), 0f)) / _e320);
    let _e322 = world;
    let _e323 = (*receiver_1);
    let _e325 = (*tanHalf);
    let _e328 = minRadius;
    let _e329 = maxRadius;
    return clamp((_e322 / ((2f * _e323) * _e325)), _e328, _e329);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_14: vec2<f32>;

    let _e239 = (*rows);
    if (_e239 > 0f) {
        let _e242 = gl_FragCoord_1[0u];
        let _e243 = (*rows);
        let _e245 = gl_FragCoord_1[1u];
        local_14 = vec2<f32>(_e242, (_e243 - _e245));
    } else {
        let _e248 = gl_FragCoord_1;
        local_14 = _e248.xy;
    }
    let _e250 = local_14;
    return _e250;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_1: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_57: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_58: vec2<f32>;
    var param_59: vec2<f32>;
    var param_60: f32;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;
    var param_64: f32;
    var param_65: f32;
    var local_15: vec3<f32>;
    var lit_1: f32;
    var param_66: vec2<f32>;
    var param_67: vec2<f32>;
    var param_68: vec2<f32>;
    var param_69: f32;
    var param_70: f32;
    var i_3: i32;
    var param_71: i32;
    var param_72: f32;
    var param_73: f32;
    var param_74: f32;
    var param_75: vec2<f32>;
    var param_76: vec2<f32>;
    var param_77: vec2<f32>;
    var param_78: f32;
    var param_79: f32;
    var phi_2676_: bool;
    var phi_2737_: bool;

    let _e291 = (*lightIndex);
    let _e295 = point_shadow.slots[_e291][0u];
    slot = i32((_e295 + 0.5f));
    let _e298 = (*lightIndex);
    let _e302 = point_shadow.slots[_e298][0u];
    if (_e302 < 0f) {
        return 1f;
    }
    let _e306 = point_shadow.params[2u];
    strength = _e306;
    let _e307 = strength;
    if (_e307 <= 0f) {
        return 1f;
    }
    let _e309 = slot;
    let _e312 = point_shadow.lights[_e309];
    let _e314 = (*world_1);
    toLight = (_e312.xyz - _e314);
    let _e316 = toLight;
    toLightLength = max(length(_e316), 0.000001f);
    let _e319 = (*normal);
    let _e320 = toLight;
    let _e321 = toLightLength;
    nDotL = max(dot(_e319, (_e320 / vec3(_e321))), 0.15f);
    let _e326 = nDotL;
    let _e327 = nDotL;
    let _e332 = nDotL;
    let _e333 = nDotL;
    slope = min((sqrt(max((1f - (_e326 * _e327)), 0f)) / (_e332 * _e333)), 8f);
    let _e337 = toLightLength;
    let _e339 = (*lightIndex);
    let _e343 = point_shadow.slots[_e339][2u];
    let _e348 = point_shadow.params3_[1u];
    texel = (((2f * _e337) * max(_e343, 0.0001f)) * _e348);
    let _e350 = (*world_1);
    let _e351 = (*normal);
    let _e352 = texel;
    let _e356 = point_shadow.params[3u];
    let _e358 = slope;
    origin = (_e350 + (((_e351 * _e352) * _e356) * (1f + _e358)));
    let _e362 = origin;
    let _e363 = slot;
    let _e366 = point_shadow.lights[_e363];
    toFragment = (_e362 - _e366.xyz);
    let _e369 = toFragment;
    distance_ = length(_e369);
    let _e371 = slot;
    let _e375 = point_shadow.lights[_e371][3u];
    range_3 = max(_e375, 0.0001f);
    let _e377 = distance_;
    let _e378 = range_3;
    if (_e377 >= _e378) {
        return 1f;
    }
    face = 0i;
    let _e380 = (*lightIndex);
    let _e384 = point_shadow.slots[_e380][1u];
    if (_e384 < 0.5f) {
        let _e386 = toFragment;
        a_1 = abs(_e386);
        let _e389 = a_1[0u];
        let _e391 = a_1[1u];
        let _e392 = (_e389 >= _e391);
        phi_2676_ = _e392;
        if _e392 {
            let _e394 = a_1[0u];
            let _e396 = a_1[2u];
            phi_2676_ = (_e394 >= _e396);
        }
        let _e399 = phi_2676_;
        if _e399 {
            let _e401 = toFragment[0u];
            face = select(1i, 0i, (_e401 > 0f));
        } else {
            let _e405 = a_1[1u];
            let _e407 = a_1[2u];
            if (_e405 >= _e407) {
                let _e410 = toFragment[1u];
                face = select(3i, 2i, (_e410 > 0f));
            } else {
                let _e414 = toFragment[2u];
                face = select(5i, 4i, (_e414 > 0f));
            }
        }
    }
    let _e417 = slot;
    let _e419 = face;
    let _e423 = point_shadow.faces[((_e417 * 6i) + _e419)];
    let _e424 = origin;
    clip = (_e423 * vec4<f32>(_e424.x, _e424.y, _e424.z, 1f));
    let _e431 = clip[3u];
    if (_e431 <= 0f) {
        return 1f;
    }
    let _e433 = clip;
    let _e436 = clip[3u];
    ndc = (_e433.xy / vec2(_e436));
    let _e440 = ndc[0u];
    let _e442 = (abs(_e440) > 1f);
    phi_2737_ = _e442;
    if !(_e442) {
        let _e445 = ndc[1u];
        phi_2737_ = (abs(_e445) > 1f);
    }
    let _e449 = phi_2737_;
    if _e449 {
        return 1f;
    }
    let _e451 = ndc[0u];
    let _e455 = ndc[1u];
    uv_4 = vec2<f32>(((_e451 * 0.5f) + 0.5f), (0.5f - (_e455 * 0.5f)));
    let _e459 = face;
    let _e461 = slot;
    tile_3 = vec2<f32>(f32(_e459), f32(_e461));
    let _e464 = distance_;
    let _e467 = point_shadow.params[1u];
    receiver_2 = (_e464 - _e467);
    let _e471 = frag_info.target_origin[0u];
    param_57 = _e471;
    let _e472 = FragCoordFromTop_u0028_f1_u003b((&param_57));
    noise = fract((52.982918f * fract(dot(_e472, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e477 = noise;
    angle = (_e477 * 6.2831855f);
    let _e479 = angle;
    ca_2 = cos(_e479);
    let _e481 = angle;
    sa_2 = sin(_e481);
    let _e483 = (*lightIndex);
    let _e487 = point_shadow.slots[_e483][2u];
    tanHalf_1 = max(_e487, 0.0001f);
    blocker_1 = -1f;
    let _e489 = uv_4;
    param_58 = _e489;
    let _e490 = tile_3;
    param_59 = _e490;
    let _e491 = range_3;
    param_60 = _e491;
    let _e492 = receiver_2;
    param_61 = _e492;
    let _e493 = ca_2;
    param_62 = _e493;
    let _e494 = sa_2;
    param_63 = _e494;
    let _e495 = tanHalf_1;
    param_64 = _e495;
    let _e496 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_58), (&param_59), (&param_60), (&param_61), (&param_62), (&param_63), (&param_64), (&param_65));
    let _e497 = param_65;
    blocker_1 = _e497;
    radius_1 = _e496;
    let _e500 = point_shadow.params2_[3u];
    if (_e500 > 0.5f) {
        g_debug_surface_on = true;
        let _e502 = radius_1;
        if (_e502 < 0f) {
            local_15 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e504 = radius_1;
            let _e507 = point_shadow.params2_[2u];
            let _e511 = blocker_1;
            let _e512 = range_3;
            local_15 = vec3<f32>(clamp((_e504 / max(_e507, 0.000001f)), 0f, 1f), clamp((_e511 / _e512), 0f, 1f), 0f);
        }
        let _e516 = local_15;
        g_debug_surface = _e516;
    }
    let _e517 = radius_1;
    if (_e517 < 0f) {
        return 1f;
    }
    let _e519 = uv_4;
    param_66 = _e519;
    param_67 = vec2<f32>(0f, 0f);
    let _e520 = tile_3;
    param_68 = _e520;
    let _e521 = range_3;
    param_69 = _e521;
    let _e522 = receiver_2;
    param_70 = _e522;
    let _e523 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_66), (&param_67), (&param_68), (&param_69), (&param_70));
    lit_1 = _e523;
    let _e524 = radius_1;
    if (_e524 > 0f) {
        i_3 = 0i;
        loop {
            let _e526 = i_3;
            if (_e526 < 8i) {
                let _e528 = i_3;
                param_71 = _e528;
                let _e529 = ca_2;
                param_72 = _e529;
                let _e530 = sa_2;
                param_73 = _e530;
                let _e531 = radius_1;
                param_74 = _e531;
                let _e532 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_71), (&param_72), (&param_73), (&param_74));
                let _e533 = uv_4;
                param_75 = _e533;
                param_76 = _e532;
                let _e534 = tile_3;
                param_77 = _e534;
                let _e535 = range_3;
                param_78 = _e535;
                let _e536 = receiver_2;
                param_79 = _e536;
                let _e537 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_75), (&param_76), (&param_77), (&param_78), (&param_79));
                let _e538 = lit_1;
                lit_1 = (_e538 + _e537);
                continue;
            } else {
                break;
            }
            continuing {
                let _e540 = i_3;
                i_3 = (_e540 + 1i);
            }
        }
        let _e542 = lit_1;
        lit_1 = (_e542 * 0.11111111f);
    }
    let _e544 = lit_1;
    let _e545 = strength;
    return mix(1f, _e544, clamp(_e545, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e242 = (*i_4);
    let _e245 = (*n_1);
    r_3 = sqrt(((f32(_e242) + 0.5f) / f32(_e245)));
    let _e249 = (*i_4);
    let _e252 = (*turn);
    theta = ((f32(_e249) * 2.3999631f) + _e252);
    let _e254 = r_3;
    let _e255 = theta;
    let _e257 = theta;
    return (vec2<f32>(cos(_e255), sin(_e257)) * _e254);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_80: f32;

    let _e241 = frag_info.target_origin[0u];
    param_80 = _e241;
    let _e242 = FragCoordFromTop_u0028_f1_u003b((&param_80));
    let _e245 = frag_info.target_origin[3u];
    at = (_e242 + vec2((5.588238f * max(_e245, 0f))));
    let _e250 = at;
    return fract((52.982918f * fract(dot(_e250, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_16: f32;

    let _e240 = (*mode_1);
    if (_e240 > 0.5f) {
        let _e242 = (*stored_2);
        local_16 = (1f - _e242);
    } else {
        let _e244 = (*stored_2);
        local_16 = _e244;
    }
    let _e245 = local_16;
    return _e245;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_2: f32;
    var pMax: f32;
    var reduced: f32;

    let _e246 = (*moments)[1u];
    let _e248 = (*moments)[0u];
    let _e250 = (*moments)[0u];
    let _e253 = (*minVariance);
    variance = max((_e246 - (_e248 * _e250)), _e253);
    let _e255 = (*t);
    let _e257 = (*moments)[0u];
    d_2 = (_e255 - _e257);
    let _e259 = variance;
    let _e260 = variance;
    let _e261 = d_2;
    let _e262 = d_2;
    pMax = (_e259 / (_e260 + (_e261 * _e262)));
    let _e266 = pMax;
    let _e267 = (*bleed);
    let _e269 = (*bleed);
    reduced = clamp(((_e266 - _e267) / max((1f - _e269), 0.0001f)), 0f, 1f);
    let _e274 = (*t);
    let _e276 = (*moments)[0u];
    let _e278 = reduced;
    return select(_e278, 1f, (_e274 <= _e276));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_3: f32;

    let _e239 = (*depth);
    d_3 = ((2f * clamp(_e239, 0f, 1f)) - 1f);
    let _e243 = d_3;
    let _e246 = d_3;
    return vec2<f32>(exp((40f * _e243)), -(exp((-5f * _e246))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_81: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_82: vec2<f32>;
    var param_83: f32;
    var param_84: f32;
    var param_85: f32;
    var negative: f32;
    var param_86: vec2<f32>;
    var param_87: f32;
    var param_88: f32;
    var param_89: f32;

    let _e253 = (*depth_1);
    param_81 = _e253;
    let _e254 = EvsmWarp_u0028_f1_u003b((&param_81));
    warped = _e254;
    let _e255 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e255);
    let _e258 = scale[0u];
    let _e260 = scale[0u];
    let _e262 = (*moments_1);
    param_82 = _e262.xy;
    let _e265 = warped[0u];
    param_83 = _e265;
    param_84 = (_e258 * _e260);
    let _e266 = (*bleed_1);
    param_85 = _e266;
    let _e267 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_82), (&param_83), (&param_84), (&param_85));
    positive = _e267;
    let _e269 = scale[1u];
    let _e271 = scale[1u];
    let _e273 = (*moments_1);
    param_86 = _e273.zw;
    let _e276 = warped[1u];
    param_87 = _e276;
    param_88 = (_e269 * _e271);
    let _e277 = (*bleed_1);
    param_89 = _e277;
    let _e278 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_86), (&param_87), (&param_88), (&param_89));
    negative = _e278;
    let _e279 = positive;
    let _e280 = negative;
    return min(_e279, _e280);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e239 = (*depth_2);
    stored_3 = max((1f - _e239), 0.000061035156f);
    let _e242 = stored_3;
    return exp2((floor(log2(_e242)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_17: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_18: mat4x4<f32>;
    var local_19: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_20: f32;
    var local_21: f32;
    var storage_: f32;
    var param_90: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_91: vec4<f32>;
    var param_92: f32;
    var param_93: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_94: f32;
    var param_95: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_96: i32;
    var param_97: i32;
    var param_98: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_99: f32;
    var param_100: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_101: i32;
    var param_102: i32;
    var param_103: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_104: f32;
    var param_105: f32;
    var phi_4328_: bool;
    var phi_4339_: bool;
    var phi_4496_: bool;
    var phi_4503_: bool;
    var phi_4510_: bool;

    let _e318 = frag_info.shadow_params[3u];
    strength_1 = _e318;
    let _e319 = strength_1;
    if (_e319 <= 0f) {
        return 1f;
    }
    let _e321 = (*lightIndex_1);
    let _e324 = frag_info.frame_params[2u];
    if (_e321 != i32(floor((_e324 + 0.5f)))) {
        return 1f;
    }
    let _e331 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e331 + 0.5f));
    let _e334 = Orthographic_u0028_();
    if _e334 {
        let _e335 = ViewDepth_u0028_();
        local_17 = _e335;
    } else {
        let _e336 = v_world_position_1;
        let _e338 = frag_info.camera_position;
        local_17 = length((_e336 - _e338.xyz));
    }
    let _e342 = local_17;
    viewDistance = _e342;
    cascade = 0i;
    let _e343 = cascadeCount;
    let _e344 = (_e343 > 1i);
    phi_4328_ = _e344;
    if _e344 {
        let _e345 = viewDistance;
        let _e348 = frag_info.shadow_cascades[0u];
        phi_4328_ = (_e345 > _e348);
    }
    let _e351 = phi_4328_;
    if _e351 {
        cascade = 1i;
    }
    let _e352 = cascadeCount;
    let _e353 = (_e352 > 2i);
    phi_4339_ = _e353;
    if _e353 {
        let _e354 = viewDistance;
        let _e357 = frag_info.shadow_cascades[1u];
        phi_4339_ = (_e354 > _e357);
    }
    let _e360 = phi_4339_;
    if _e360 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e361 = attempt;
        if (_e361 < 3i) {
            let _e363 = cascade;
            let _e364 = attempt;
            which = (_e363 + _e364);
            let _e366 = which;
            let _e367 = cascadeCount;
            if (_e366 >= _e367) {
                break;
            }
            let _e369 = which;
            if (_e369 == 0i) {
                let _e372 = frag_info.shadow_matrix;
                local_18 = _e372;
            } else {
                let _e373 = which;
                if (_e373 == 1i) {
                    let _e376 = frag_info.shadow_matrix_far;
                    local_19 = _e376;
                } else {
                    let _e378 = frag_info.shadow_matrix_farthest;
                    local_19 = _e378;
                }
                let _e379 = local_19;
                local_18 = _e379;
            }
            let _e380 = local_18;
            matrix = _e380;
            let _e383 = matrix[0][0u];
            let _e386 = matrix[1][0u];
            let _e389 = matrix[2][0u];
            axisX = vec3<f32>(_e383, _e386, _e389);
            let _e393 = matrix[0][1u];
            let _e396 = matrix[1][1u];
            let _e399 = matrix[2][1u];
            axisY = vec3<f32>(_e393, _e396, _e399);
            let _e401 = axisX;
            rowX = max(length(_e401), 0.000001f);
            let _e404 = axisY;
            rowY = max(length(_e404), 0.000001f);
            let _e409 = frag_info.shadow_cascades[3u];
            let _e411 = rowX;
            texelMetres = ((2f * _e409) / _e411);
            let _e415 = frag_info.shadow_cascades[3u];
            let _e418 = (*s_4).n;
            let _e419 = axisX;
            let _e422 = rowX;
            let _e423 = rowX;
            let _e427 = (*s_4).n;
            let _e428 = axisY;
            let _e431 = rowY;
            let _e432 = rowY;
            reach = ((3f * _e415) * ((abs(dot(_e418, _e419)) / (_e422 * _e423)) + (abs(dot(_e427, _e428)) / (_e431 * _e432))));
            let _e439 = frag_info.shadow_params[2u];
            let _e440 = texelMetres;
            flatOffset = min(_e439, _e440);
            let _e442 = v_world_position_1;
            let _e444 = (*s_4).n;
            let _e445 = flatOffset;
            let _e446 = reach;
            origin_1 = (_e442 + (_e444 * (_e445 + _e446)));
            let _e450 = matrix;
            let _e451 = origin_1;
            lightSpace = (_e450 * vec4<f32>(_e451.x, _e451.y, _e451.z, 1f));
            let _e458 = lightSpace[3u];
            if (_e458 <= 0f) {
                continue;
            }
            let _e460 = lightSpace;
            let _e463 = lightSpace[3u];
            candidate = (_e460.xyz / vec3(_e463));
            let _e467 = candidate[0u];
            let _e471 = candidate[1u];
            inTile = vec2<f32>(((_e467 * 0.5f) + 0.5f), (0.5f - (_e471 * 0.5f)));
            let _e476 = inTile[0u];
            let _e477 = (_e476 < 0f);
            phi_4496_ = _e477;
            if !(_e477) {
                let _e480 = inTile[0u];
                phi_4496_ = (_e480 > 1f);
            }
            let _e483 = phi_4496_;
            phi_4503_ = _e483;
            if !(_e483) {
                let _e486 = inTile[1u];
                phi_4503_ = (_e486 < 0f);
            }
            let _e489 = phi_4503_;
            phi_4510_ = _e489;
            if !(_e489) {
                let _e492 = inTile[1u];
                phi_4510_ = (_e492 > 1f);
            }
            let _e495 = phi_4510_;
            if _e495 {
                continue;
            }
            let _e497 = candidate[2u];
            if (_e497 > 1f) {
                let _e499 = which;
                let _e500 = cascadeCount;
                if (_e499 < (_e500 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e505 = inTile[0u];
            let _e506 = which;
            let _e509 = cascadeCount;
            let _e513 = inTile[1u];
            uv_5 = vec2<f32>(((_e505 + f32(_e506)) / f32(_e509)), _e513);
            let _e515 = candidate;
            projected = _e515;
            let _e516 = which;
            cascade = _e516;
            let _e517 = texelMetres;
            cascadeTexel = _e517;
            let _e520 = matrix[0][2u];
            let _e523 = matrix[1][2u];
            let _e526 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e520, _e523, _e526)), 0.000001f));
            let _e532 = (*s_4).n;
            let _e535 = matrix[0][2u];
            let _e538 = matrix[1][2u];
            let _e541 = matrix[2][2u];
            let _e545 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e532, vec3<f32>(_e535, _e538, _e541))) * _e545), 0.1f, 1f);
            let _e548 = texelMetres;
            let _e549 = cosSlope;
            let _e550 = cosSlope;
            let _e556 = cosSlope;
            let _e558 = cascadeDepth;
            receiverSlope = (((_e548 * sqrt(max((1f - (_e549 * _e550)), 0f))) / _e556) / _e558);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e560 = attempt;
            attempt = (_e560 + 1i);
        }
    }
    let _e562 = found;
    if !(_e562) {
        return 1f;
    }
    let _e564 = cascade;
    if (_e564 == 0i) {
        let _e568 = frag_info.shadow_bias[0u];
        local_20 = _e568;
    } else {
        let _e569 = cascade;
        if (_e569 == 1i) {
            let _e573 = frag_info.shadow_bias[1u];
            local_21 = _e573;
        } else {
            let _e576 = frag_info.shadow_bias[2u];
            local_21 = _e576;
        }
        let _e577 = local_21;
        local_20 = _e577;
    }
    let _e578 = local_20;
    bias = _e578;
    let _e581 = frag_info.shadow_params[1u];
    storage_ = _e581;
    let _e582 = storage_;
    let _e584 = storage_;
    if ((_e582 > 0.5f) && (_e584 < 1.5f)) {
        let _e587 = bias;
        let _e589 = projected[2u];
        param_90 = _e589;
        let _e590 = ShadowStoredStep_u0028_f1_u003b((&param_90));
        bias = max(_e587, _e590);
    }
    let _e594 = frag_info.shadow_params[0u];
    let _e597 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e594, _e597);
    let _e599 = cascade;
    let _e601 = cascadeCount;
    let _e605 = texel_1;
    tileLo = (vec2<f32>((f32(_e599) / f32(_e601)), 0f) + (_e605 * 0.5f));
    let _e608 = cascade;
    let _e611 = cascadeCount;
    let _e615 = texel_1;
    tileHi = (vec2<f32>((f32((_e608 + 1i)) / f32(_e611)), 1f) - (_e615 * 0.5f));
    let _e620 = frag_info.shadow_bias[3u];
    if (_e620 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e622 = y_1;
            if (_e622 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e624 = x_1;
                    if (_e624 <= 1i) {
                        let _e626 = uv_5;
                        let _e627 = x_1;
                        let _e629 = y_1;
                        let _e632 = texel_1;
                        let _e635 = tileLo;
                        let _e636 = tileHi;
                        let _e638 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e626 + (vec2<f32>(f32(_e627), f32(_e629)) * _e632)), _e635, _e636), 0f);
                        let _e639 = stored_4;
                        stored_4 = (_e639 + _e638);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e641 = x_1;
                        x_1 = (_e641 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e643 = y_1;
                y_1 = (_e643 + 1i);
            }
        }
        let _e645 = stored_4;
        stored_4 = (_e645 * 0.11111111f);
        let _e648 = stored_4[1u];
        let _e651 = stored_4[2u];
        let _e654 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e648), (1f - _e651), _e654), vec3(0f), vec3(4f));
        let _e659 = through;
        let _e660 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e659, vec3(clamp(_e660, 0f, 1f)));
    }
    let _e666 = frag_info.ambient_ground[3u];
    softness = _e666;
    lit_2 = 0f;
    let _e667 = softness;
    if (_e667 < 0f) {
        let _e669 = uv_5;
        let _e670 = tileLo;
        let _e671 = tileHi;
        let _e673 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e669, _e670, _e671), 0f);
        moments_2 = _e673;
        let _e675 = projected[2u];
        let _e676 = bias;
        let _e678 = softness;
        let _e682 = moments_2;
        param_91 = _e682;
        param_92 = (_e675 - _e676);
        param_93 = clamp((-(_e678) - 1f), 0f, 0.95f);
        let _e683 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_91), (&param_92), (&param_93));
        lit_2 = _e683;
    } else {
        let _e684 = softness;
        if (_e684 <= 0f) {
            y_2 = -1i;
            loop {
                let _e686 = y_2;
                if (_e686 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e688 = x_2;
                        if (_e688 <= 1i) {
                            let _e690 = uv_5;
                            let _e691 = x_2;
                            let _e693 = y_2;
                            let _e696 = texel_1;
                            let _e699 = tileLo;
                            let _e700 = tileHi;
                            let _e702 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e690 + (vec2<f32>(f32(_e691), f32(_e693)) * _e696)), _e699, _e700), 0f);
                            param_94 = _e702.x;
                            let _e704 = storage_;
                            param_95 = _e704;
                            let _e705 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_94), (&param_95));
                            occluder = _e705;
                            let _e707 = projected[2u];
                            let _e708 = bias;
                            let _e710 = occluder;
                            let _e713 = lit_2;
                            lit_2 = (_e713 + select(1f, 0f, ((_e707 - _e708) > _e710)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e715 = x_2;
                            x_2 = (_e715 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e717 = y_2;
                    y_2 = (_e717 + 1i);
                }
            }
            let _e719 = lit_2;
            lit_2 = (_e719 * 0.11111111f);
        } else {
            let _e721 = softness;
            spread = tan(min(_e721, 0.5f));
            let _e724 = ShadowNoise_u0028_();
            turn_1 = (_e724 * 6.2831855f);
            let _e726 = spread;
            let _e728 = projected[2u];
            let _e730 = cascadeDepth;
            let _e732 = cascadeTexel;
            searchRadius = clamp((((_e726 * _e728) * _e730) / _e732), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e735 = i_5;
                if (_e735 < 16i) {
                    let _e737 = i_5;
                    param_96 = _e737;
                    param_97 = 16i;
                    let _e738 = turn_1;
                    param_98 = _e738;
                    let _e739 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_96), (&param_97), (&param_98));
                    disc = _e739;
                    let _e740 = bias;
                    let _e741 = disc;
                    let _e743 = searchRadius;
                    let _e747 = receiverSlope;
                    tapBias = (_e740 + (max(((length(_e741) * _e743) - 1.5f), 0f) * _e747));
                    let _e750 = uv_5;
                    let _e751 = disc;
                    let _e752 = texel_1;
                    let _e754 = searchRadius;
                    let _e757 = tileLo;
                    let _e758 = tileHi;
                    let _e760 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e750 + ((_e751 * _e752) * _e754)), _e757, _e758), 0f);
                    param_99 = _e760.x;
                    let _e762 = storage_;
                    param_100 = _e762;
                    let _e763 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
                    occluder_1 = _e763;
                    let _e765 = projected[2u];
                    let _e766 = tapBias;
                    let _e768 = occluder_1;
                    if ((_e765 - _e766) > _e768) {
                        let _e770 = occluder_1;
                        let _e771 = blockerSum;
                        blockerSum = (_e771 + _e770);
                        let _e773 = blockerCount;
                        blockerCount = (_e773 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e775 = i_5;
                    i_5 = (_e775 + 1i);
                }
            }
            let _e777 = blockerCount;
            if (_e777 <= 0f) {
                return 1f;
            }
            let _e780 = projected[2u];
            let _e781 = blockerSum;
            let _e782 = blockerCount;
            let _e786 = cascadeDepth;
            gap = (max((_e780 - (_e781 / _e782)), 0f) * _e786);
            let _e788 = spread;
            let _e789 = gap;
            let _e791 = cascadeTexel;
            radius_2 = clamp(((_e788 * _e789) / _e791), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e794 = i_6;
                if (_e794 < 16i) {
                    let _e796 = turn_1;
                    let _e798 = i_6;
                    param_101 = _e798;
                    param_102 = 16i;
                    param_103 = (_e796 + 1f);
                    let _e799 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_101), (&param_102), (&param_103));
                    disc_1 = _e799;
                    let _e800 = bias;
                    let _e801 = disc_1;
                    let _e803 = radius_2;
                    let _e807 = receiverSlope;
                    tapBias_1 = (_e800 + (max(((length(_e801) * _e803) - 1.5f), 0f) * _e807));
                    let _e810 = uv_5;
                    let _e811 = disc_1;
                    let _e812 = texel_1;
                    let _e814 = radius_2;
                    let _e817 = tileLo;
                    let _e818 = tileHi;
                    let _e820 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e810 + ((_e811 * _e812) * _e814)), _e817, _e818), 0f);
                    param_104 = _e820.x;
                    let _e822 = storage_;
                    param_105 = _e822;
                    let _e823 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_104), (&param_105));
                    occluder_2 = _e823;
                    let _e825 = projected[2u];
                    let _e826 = tapBias_1;
                    let _e828 = occluder_2;
                    let _e831 = lit_2;
                    lit_2 = (_e831 + select(1f, 0f, ((_e825 - _e826) > _e828)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e833 = i_6;
                    i_6 = (_e833 + 1i);
                }
            }
            let _e835 = lit_2;
            lit_2 = (_e835 * 0.0625f);
        }
    }
    let _e837 = lit_2;
    let _e838 = strength_1;
    return mix(1f, _e837, clamp(_e838, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_106: Surface;
    var param_107: LightSample;
    var param_108: i32;

    let _e243 = (*s_5);
    param_106 = _e243;
    let _e244 = (*light_2);
    param_107 = _e244;
    let _e245 = (*index);
    param_108 = _e245;
    let _e246 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
    return _e246;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e238 = (*index_1);
    return (_e238 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e242 = (*distance_1);
    let _e243 = (*distance_1);
    attenuation = (1f / max((_e242 * _e243), 0.0001f));
    let _e247 = (*range_4);
    if (_e247 > 0f) {
        let _e249 = (*distance_1);
        let _e250 = (*range_4);
        ratio = (_e249 / _e250);
        let _e252 = ratio;
        let _e253 = ratio;
        let _e255 = ratio;
        let _e257 = ratio;
        window = clamp((1f - (((_e252 * _e253) * _e255) * _e257)), 0f, 1f);
        let _e261 = window;
        let _e262 = window;
        let _e264 = attenuation;
        attenuation = (_e264 * (_e261 * _e262));
    }
    let _e266 = attenuation;
    return _e266;
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle_1: f32;
    var local_22: vec3<f32>;

    let _e243 = (*a_2);
    let _e244 = (*b);
    axis = cross(_e243, _e244);
    let _e246 = axis;
    len = length(_e246);
    let _e248 = (*a_2);
    let _e249 = (*b);
    angle_1 = acos(clamp(dot(_e248, _e249), -1f, 1f));
    let _e253 = len;
    if (_e253 > 0.000001f) {
        let _e255 = axis;
        let _e256 = angle_1;
        let _e257 = len;
        local_22 = (_e255 * (_e256 / (_e257 * 6.2831855f)));
    } else {
        local_22 = vec3<f32>(0f, 0f, 0f);
    }
    let _e261 = local_22;
    return _e261;
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_3: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv_6: vec2<f32>;
    var inverse: vec4<f32>;
    var param_109: f32;
    var param_110: f32;
    var param_111: f32;
    var fit: vec4<f32>;
    var param_112: f32;
    var param_113: f32;
    var param_114: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_23: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i_7: i32;
    var p_1: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f_2: vec3<f32>;
    var param_115: vec3<f32>;
    var param_116: vec3<f32>;
    var param_117: vec3<f32>;
    var param_118: vec3<f32>;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: vec3<f32>;
    var param_122: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_24: f32;
    var sphere: f32;
    var param_123: f32;
    var param_124: f32;
    var param_125: f32;

    let _e275 = (*roughness_3);
    let _e277 = (*n_2);
    let _e278 = (*v);
    uv_6 = vec2<f32>(clamp(_e275, 0f, 1f), sqrt(clamp((1f - dot(_e277, _e278)), 0f, 1f)));
    let _e285 = uv_6[0u];
    param_109 = _e285;
    let _e287 = uv_6[1u];
    param_110 = _e287;
    param_111 = 0f;
    let _e288 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_109), (&param_110), (&param_111));
    let _e289 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e288, 0f);
    inverse = _e289;
    let _e291 = uv_6[0u];
    param_112 = _e291;
    let _e293 = uv_6[1u];
    param_113 = _e293;
    param_114 = 1f;
    let _e294 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_112), (&param_113), (&param_114));
    let _e295 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e294, 0f);
    fit = _e295;
    let _e296 = (*v);
    let _e297 = (*n_2);
    let _e298 = (*v);
    let _e299 = (*n_2);
    along = (_e296 - (_e297 * dot(_e298, _e299)));
    let _e303 = along;
    alongLength = length(_e303);
    let _e305 = alongLength;
    if (_e305 > 0.00001f) {
        let _e307 = along;
        let _e308 = alongLength;
        local_23 = (_e307 / vec3(_e308));
    } else {
        let _e311 = (*n_2);
        let _e313 = (*n_2)[2u];
        local_23 = normalize(cross(_e311, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e313) < 0.999f)))));
    }
    let _e320 = local_23;
    t1_ = _e320;
    let _e321 = (*n_2);
    let _e322 = t1_;
    t2_ = cross(_e321, _e322);
    let _e325 = inverse[0u];
    let _e327 = inverse[1u];
    let _e328 = vec3<f32>(_e325, 0f, _e327);
    let _e330 = inverse[2u];
    let _e332 = inverse[3u];
    let _e333 = vec3<f32>(_e330, 0f, _e332);
    minv = mat3x3<f32>(vec3<f32>(_e328.x, _e328.y, _e328.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e333.x, _e333.y, _e333.z));
    i_7 = 0i;
    loop {
        let _e347 = i_7;
        if (_e347 < 4i) {
            let _e349 = i_7;
            let _e351 = (*corners)[_e349];
            p_1 = _e351;
            let _e352 = i_7;
            let _e353 = minv;
            let _e354 = p_1;
            let _e355 = t1_;
            let _e357 = p_1;
            let _e358 = t2_;
            let _e360 = p_1;
            let _e361 = (*n_2);
            l[_e352] = normalize((_e353 * vec3<f32>(dot(_e354, _e355), dot(_e357, _e358), dot(_e360, _e361))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e367 = i_7;
            i_7 = (_e367 + 1i);
        }
    }
    let _e370 = l[0i];
    param_115 = _e370;
    let _e372 = l[1i];
    param_116 = _e372;
    let _e373 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_115), (&param_116));
    let _e375 = l[1i];
    param_117 = _e375;
    let _e377 = l[2i];
    param_118 = _e377;
    let _e378 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_117), (&param_118));
    let _e381 = l[2i];
    param_119 = _e381;
    let _e383 = l[3i];
    param_120 = _e383;
    let _e384 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_119), (&param_120));
    let _e387 = l[3i];
    param_121 = _e387;
    let _e389 = l[0i];
    param_122 = _e389;
    let _e390 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_121), (&param_122));
    f_2 = -((((_e373 + _e378) + _e384) + _e390));
    let _e393 = f_2;
    len_1 = length(_e393);
    let _e395 = len_1;
    if (_e395 > 0.000000001f) {
        let _e398 = f_2[2u];
        let _e399 = len_1;
        local_24 = (_e398 / _e399);
    } else {
        local_24 = 0f;
    }
    let _e401 = local_24;
    z_1 = _e401;
    let _e402 = z_1;
    let _e405 = len_1;
    param_123 = ((_e402 * 0.5f) + 0.5f);
    param_124 = clamp(_e405, 0f, 1f);
    param_125 = 1f;
    let _e407 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_123), (&param_124), (&param_125));
    let _e408 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e407, 0f);
    sphere = _e408.w;
    let _e410 = len_1;
    let _e411 = sphere;
    let _e415 = fit[0u];
    let _e417 = fit[1u];
    return vec3<f32>(max((_e410 * _e411), 0f), _e415, _e417);
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_25: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e254 = (*halfWidth);
    let _e255 = (*halfHeight);
    n_3 = cross(_e254, _e255);
    let _e257 = n_3;
    nLen = length(_e257);
    let _e259 = nLen;
    if (_e259 < 0.000000000001f) {
        let _e261 = (*centre);
        return _e261;
    }
    let _e262 = nLen;
    let _e263 = n_3;
    n_3 = (_e263 / vec3(_e262));
    let _e266 = (*centre);
    let _e267 = (*world_2);
    toPlane = (_e266 - _e267);
    let _e269 = (*mirror);
    let _e270 = n_3;
    denom = dot(_e269, _e270);
    let _e272 = denom;
    if (abs(_e272) < 0.00001f) {
        let _e275 = toPlane;
        let _e276 = n_3;
        let _e277 = toPlane;
        let _e278 = n_3;
        onPlane = (_e275 - (_e276 * dot(_e277, _e278)));
    } else {
        let _e282 = toPlane;
        let _e283 = n_3;
        let _e285 = denom;
        t_1 = (dot(_e282, _e283) / _e285);
        let _e287 = t_1;
        if (_e287 > 0f) {
            let _e289 = (*mirror);
            let _e290 = t_1;
            local_25 = (_e289 * _e290);
        } else {
            let _e292 = toPlane;
            let _e293 = n_3;
            let _e294 = toPlane;
            let _e295 = n_3;
            local_25 = (_e292 - (_e293 * dot(_e294, _e295)));
        }
        let _e299 = local_25;
        onPlane = _e299;
    }
    let _e300 = onPlane;
    let _e301 = toPlane;
    offset_2 = (_e300 - _e301);
    let _e303 = (*halfWidth);
    let _e304 = (*halfWidth);
    wLen2_ = max(dot(_e303, _e304), 0.000000000001f);
    let _e307 = (*halfHeight);
    let _e308 = (*halfHeight);
    hLen2_ = max(dot(_e307, _e308), 0.000000000001f);
    let _e311 = offset_2;
    let _e312 = (*halfWidth);
    let _e314 = wLen2_;
    u = clamp((dot(_e311, _e312) / _e314), -1f, 1f);
    let _e317 = offset_2;
    let _e318 = (*halfHeight);
    let _e320 = hLen2_;
    v_1 = clamp((dot(_e317, _e318) / _e320), -1f, 1f);
    let _e323 = (*centre);
    let _e324 = (*halfWidth);
    let _e325 = u;
    let _e328 = (*halfHeight);
    let _e329 = v_1;
    return ((_e323 + (_e324 * _e325)) + (_e328 * _e329));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_26: f32;

    let _e246 = (*a_3);
    let _e247 = (*a_3);
    ua = (_e246 / vec3(max(length(_e247), 0.000000000001f)));
    let _e252 = (*b_1);
    let _e253 = (*b_1);
    ub = (_e252 / vec3(max(length(_e253), 0.000000000001f)));
    let _e258 = ua;
    let _e259 = ub;
    angle_2 = acos(clamp(dot(_e258, _e259), -1f, 1f));
    let _e263 = ua;
    let _e264 = ub;
    axis_1 = cross(_e263, _e264);
    let _e266 = axis_1;
    len_2 = length(_e266);
    let _e268 = len_2;
    if (_e268 > 0.000001f) {
        let _e270 = angle_2;
        let _e271 = axis_1;
        let _e272 = (*n_4);
        let _e275 = len_2;
        local_26 = ((_e270 * dot(_e271, _e272)) / _e275);
    } else {
        local_26 = 0f;
    }
    let _e277 = local_26;
    return _e277;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_27: i32;
    var ha: f32;
    var hb: f32;
    var d_4: f32;
    var q: vec3<f32>;
    var local_28: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_29: f32;
    var param_126: vec3<f32>;
    var param_127: vec3<f32>;
    var param_128: vec3<f32>;
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e260 = i_8;
        if (_e260 < 4i) {
            let _e262 = i_8;
            let _e264 = (*corners_1)[_e262];
            a_4 = _e264;
            let _e265 = i_8;
            if (_e265 == 3i) {
                local_27 = 0i;
            } else {
                let _e267 = i_8;
                local_27 = (_e267 + 1i);
            }
            let _e269 = local_27;
            let _e271 = (*corners_1)[_e269];
            b_2 = _e271;
            let _e272 = a_4;
            let _e273 = (*n_5);
            ha = dot(_e272, _e273);
            let _e275 = b_2;
            let _e276 = (*n_5);
            hb = dot(_e275, _e276);
            let _e278 = ha;
            let _e279 = hb;
            d_4 = (_e278 - _e279);
            let _e281 = a_4;
            let _e282 = b_2;
            let _e283 = a_4;
            let _e285 = d_4;
            if (abs(_e285) > 0.000000000001f) {
                let _e288 = ha;
                let _e289 = d_4;
                local_28 = (_e288 / _e289);
            } else {
                local_28 = 0f;
            }
            let _e291 = local_28;
            q = (_e281 + ((_e282 - _e283) * _e291));
            let _e294 = ha;
            aAbove = (_e294 > 0f);
            let _e296 = hb;
            bAbove = (_e296 > 0f);
            let _e298 = aAbove;
            let _e299 = bAbove;
            if (_e298 || _e299) {
                let _e301 = aAbove;
                let _e302 = a_4;
                let _e303 = q;
                let _e306 = bAbove;
                let _e307 = b_2;
                let _e308 = q;
                param_126 = select(_e303, _e302, vec3(_e301));
                param_127 = select(_e308, _e307, vec3(_e306));
                let _e311 = (*n_5);
                param_128 = _e311;
                let _e312 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_126), (&param_127), (&param_128));
                local_29 = _e312;
            } else {
                local_29 = 0f;
            }
            let _e313 = local_29;
            let _e314 = total;
            total = (_e314 + _e313);
            let _e316 = aAbove;
            let _e317 = bAbove;
            let _e320 = q;
            let _e321 = exit;
            exit = select(_e321, _e320, vec3((_e316 && !(_e317))));
            let _e324 = aAbove;
            let _e326 = bAbove;
            let _e328 = q;
            let _e329 = entry;
            entry = select(_e329, _e328, vec3((!(_e324) && _e326)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e332 = i_8;
            i_8 = (_e332 + 1i);
        }
    }
    let _e334 = exit;
    param_129 = _e334;
    let _e335 = entry;
    param_130 = _e335;
    let _e336 = (*n_5);
    param_131 = _e336;
    let _e337 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
    let _e338 = total;
    total = (_e338 + _e337);
    let _e340 = total;
    return max((-(_e340) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_30: f32;
    var local_31: f32;
    var local_32: f32;

    let _e243 = (*slot_1);
    let _e244 = (*slot_1);
    lane = (_e243 - ((_e244 / 4i) * 4i));
    let _e248 = lane;
    if (_e248 == 0i) {
        let _e251 = (*four)[0u];
        local_30 = _e251;
    } else {
        let _e252 = lane;
        if (_e252 == 1i) {
            let _e255 = (*four)[1u];
            local_31 = _e255;
        } else {
            let _e256 = lane;
            if (_e256 == 2i) {
                let _e259 = (*four)[2u];
                local_32 = _e259;
            } else {
                let _e261 = (*four)[3u];
                local_32 = _e261;
            }
            let _e262 = local_32;
            local_31 = _e262;
        }
        let _e263 = local_31;
        local_30 = _e263;
    }
    let _e264 = local_30;
    return _e264;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_132: vec4<f32>;
    var param_133: i32;

    let _e240 = (*slot_2);
    let _e244 = light_list_info.scales[(_e240 / 4i)];
    param_132 = _e244;
    let _e245 = (*slot_2);
    param_133 = _e245;
    let _e246 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_132), (&param_133));
    return _e246;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e242 = light_list_info.slot_rows[0i];
    let _e243 = (*row);
    a_5 = abs((_e242 - vec4(_e243)));
    let _e249 = light_list_info.slot_rows[1i];
    let _e250 = (*row);
    b_3 = abs((_e249 - vec4(_e250)));
    let _e255 = a_5[0u];
    let _e257 = a_5[1u];
    let _e260 = a_5[2u];
    let _e262 = a_5[3u];
    let _e266 = b_3[0u];
    let _e268 = b_3[1u];
    let _e271 = b_3[2u];
    let _e273 = b_3[3u];
    return (min(min(min(_e255, _e257), min(_e260, _e262)), min(min(_e266, _e268), min(_e271, _e273))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_134: vec4<f32>;
    var param_135: i32;

    let _e240 = (*slot_3);
    let _e244 = light_list_info.indices[(_e240 / 4i)];
    param_134 = _e244;
    let _e245 = (*slot_3);
    param_135 = _e245;
    let _e246 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_134), (&param_135));
    return _e246;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e239 = (*texel_2);
    let _e243 = light_list_info.list[1u];
    let _e245 = (*row_1);
    let _e249 = light_list_info.list[2u];
    let _e252 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e239 + 0.5f) * _e243), ((_e245 + 0.5f) * _e249)), 0f);
    return _e252;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_136: f32;
    var param_137: f32;
    var param_138: vec4<f32>;
    var param_139: i32;

    let _e247 = g_cluster_offset;
    let _e248 = (*slot_4);
    entry_1 = (_e247 + f32(_e248));
    let _e251 = entry_1;
    row_2 = floor((_e251 / 16f));
    let _e254 = entry_1;
    let _e255 = row_2;
    within_1 = (_e254 - (_e255 * 16f));
    let _e258 = within_1;
    texel_3 = floor((_e258 / 4f));
    let _e263 = light_list_info.cluster_depth[3u];
    let _e264 = row_2;
    let _e266 = texel_3;
    param_136 = _e266;
    param_137 = (_e263 + _e264);
    let _e267 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_136), (&param_137));
    four_1 = _e267;
    let _e268 = within_1;
    let _e269 = texel_3;
    let _e274 = four_1;
    param_138 = _e274;
    param_139 = i32(((_e268 - (_e269 * 4f)) + 0.5f));
    let _e275 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_138), (&param_139));
    return _e275;
}

fn Clustered_u0028_() -> bool {
    let _e239 = light_list_info.cluster_grid[3u];
    return (_e239 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_6: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_33: f32;
    var param_140: i32;
    var param_141: i32;
    var v_2: f32;
    var u_1: f32;
    var local_34: f32;
    var param_142: f32;
    var param_143: i32;
    var type_42: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_35: f32;
    var param_144: array<vec3<f32>, 4>;
    var param_145: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_36: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_146: vec3<f32>;
    var param_147: vec3<f32>;
    var param_148: vec3<f32>;
    var param_149: vec3<f32>;
    var param_150: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_37: vec3<f32>;
    var param_151: vec3<f32>;
    var param_152: vec3<f32>;
    var param_153: f32;
    var param_154: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_155: f32;
    var param_156: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e295 = (*index_2);
    if (_e295 < 8i) {
        let _e297 = (*index_2);
        let _e300 = frag_info.light_position[_e297];
        position = _e300;
        let _e301 = (*index_2);
        let _e304 = frag_info.light_color[_e301];
        color_1 = _e304;
        let _e305 = (*index_2);
        let _e308 = frag_info.light_direction[_e305];
        direction = _e308;
        let _e309 = (*index_2);
        let _e312 = frag_info.light_cone[_e309];
        cone = _e312;
    } else {
        let _e313 = (*index_2);
        slot_5 = (_e313 - 8i);
        let _e315 = Clustered_u0028_();
        clustered = _e315;
        let _e316 = clustered;
        if _e316 {
            let _e317 = slot_5;
            param_140 = _e317;
            let _e318 = ClusterRow_u0028_i1_u003b((&param_140));
            local_33 = _e318;
        } else {
            let _e319 = slot_5;
            param_141 = _e319;
            let _e320 = LightListRow_u0028_i1_u003b((&param_141));
            local_33 = _e320;
        }
        let _e321 = local_33;
        listRow = _e321;
        let _e322 = listRow;
        let _e326 = light_list_info.list[2u];
        v_2 = ((_e322 + 0.5f) * _e326);
        let _e330 = light_list_info.list[1u];
        u_1 = _e330;
        let _e331 = u_1;
        let _e333 = v_2;
        let _e335 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e331), _e333), 0f);
        position = _e335;
        let _e336 = u_1;
        let _e338 = v_2;
        let _e340 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e336), _e338), 0f);
        color_1 = _e340;
        let _e341 = u_1;
        let _e343 = v_2;
        let _e345 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e341), _e343), 0f);
        direction = _e345;
        let _e346 = u_1;
        let _e348 = v_2;
        let _e350 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e346), _e348), 0f);
        cone = _e350;
        let _e351 = clustered;
        if _e351 {
            let _e352 = listRow;
            param_142 = _e352;
            let _e353 = InSlots_u0028_f1_u003b((&param_142));
            local_34 = select(1f, 0f, _e353);
        } else {
            let _e355 = slot_5;
            param_143 = _e355;
            let _e356 = LightListScale_u0028_i1_u003b((&param_143));
            local_34 = _e356;
        }
        let _e357 = local_34;
        let _e359 = color_1[3u];
        color_1[3u] = (_e359 * _e357);
    }
    let _e363 = position[3u];
    type_42 = _e363;
    let _e364 = type_42;
    if (_e364 > 15.5f) {
        let _e367 = (*s_6).n;
        light_3.l = _e367;
        let _e370 = (*s_6).n;
        light_3.h = _e370;
        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 _e376 = light_3;
        return _e376;
    }
    let _e377 = type_42;
    if (_e377 > 2.5f) {
        let _e379 = direction;
        halfWidth_1 = _e379.xyz;
        let _e381 = cone;
        halfHeight_1 = _e381.xyz;
        let _e383 = position;
        let _e385 = v_world_position_1;
        toCentre = (_e383.xyz - _e385);
        let _e387 = toCentre;
        let _e388 = halfWidth_1;
        let _e390 = halfHeight_1;
        corners_2[0i] = ((_e387 - _e388) - _e390);
        let _e393 = toCentre;
        let _e394 = halfWidth_1;
        let _e396 = halfHeight_1;
        corners_2[1i] = ((_e393 + _e394) - _e396);
        let _e399 = toCentre;
        let _e400 = halfWidth_1;
        let _e402 = halfHeight_1;
        corners_2[2i] = ((_e399 + _e400) + _e402);
        let _e405 = toCentre;
        let _e406 = halfWidth_1;
        let _e408 = halfHeight_1;
        corners_2[3i] = ((_e405 - _e406) + _e408);
        let _e411 = toCentre;
        let _e412 = halfWidth_1;
        let _e413 = halfHeight_1;
        behind = (dot(_e411, cross(_e412, _e413)) >= 0f);
        let _e417 = behind;
        if _e417 {
            local_35 = 0f;
        } else {
            let _e418 = corners_2;
            param_144 = _e418;
            let _e420 = (*s_6).n;
            param_145 = _e420;
            let _e421 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_144), (&param_145));
            local_35 = _e421;
        }
        let _e422 = local_35;
        formFactor = _e422;
        let _e423 = halfWidth_1;
        let _e424 = halfHeight_1;
        area = (length(cross(_e423, _e424)) * 4f);
        let _e428 = area;
        if (_e428 > 0.000000001f) {
            let _e430 = area;
            local_36 = (1f / _e430);
        } else {
            local_36 = 0f;
        }
        let _e432 = local_36;
        radiance = _e432;
        let _e433 = toCentre;
        distance_2 = length(_e433);
        let _e436 = direction[3u];
        if (_e436 > 0f) {
            let _e438 = distance_2;
            let _e440 = direction[3u];
            ratio_1 = (_e438 / _e440);
            let _e442 = ratio_1;
            let _e443 = ratio_1;
            let _e445 = ratio_1;
            let _e447 = ratio_1;
            window_1 = clamp((1f - (((_e442 * _e443) * _e445) * _e447)), 0f, 1f);
            let _e451 = window_1;
            let _e452 = window_1;
            let _e454 = radiance;
            radiance = (_e454 * (_e451 * _e452));
        }
        let _e457 = (*s_6).v;
        let _e460 = (*s_6).n;
        mirror_1 = reflect(-(_e457), _e460);
        let _e462 = position;
        param_146 = _e462.xyz;
        let _e464 = halfWidth_1;
        param_147 = _e464;
        let _e465 = halfHeight_1;
        param_148 = _e465;
        let _e466 = v_world_position_1;
        param_149 = _e466;
        let _e467 = mirror_1;
        param_150 = _e467;
        let _e468 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_146), (&param_147), (&param_148), (&param_149), (&param_150));
        representative = _e468;
        let _e469 = representative;
        let _e470 = v_world_position_1;
        toPoint = (_e469 - _e470);
        let _e472 = toPoint;
        pointDistance = length(_e472);
        let _e474 = pointDistance;
        if (_e474 > 0.000001f) {
            let _e476 = toPoint;
            let _e477 = pointDistance;
            local_37 = (_e476 / vec3(_e477));
        } else {
            let _e481 = (*s_6).n;
            local_37 = _e481;
        }
        let _e482 = local_37;
        light_3.l = _e482;
        let _e485 = light_3.l;
        let _e487 = (*s_6).v;
        light_3.h = normalize((_e485 + _e487));
        let _e491 = formFactor;
        light_3.n_dot_l = _e491;
        let _e494 = (*s_6).n;
        let _e496 = light_3.h;
        light_3.n_dot_h = max(dot(_e494, _e496), 0f);
        let _e501 = (*s_6).v;
        let _e503 = light_3.h;
        light_3.v_dot_h = max(dot(_e501, _e503), 0f);
        let _e507 = color_1;
        let _e510 = color_1[3u];
        let _e512 = radiance;
        light_3.radiance = ((_e507.xyz * _e510) * _e512);
        light_3.integrated = 1f;
        let _e517 = (*s_6).n;
        param_151 = _e517;
        let _e519 = (*s_6).v;
        param_152 = _e519;
        let _e521 = (*s_6).roughness;
        param_153 = _e521;
        let _e522 = corners_2;
        param_154 = _e522;
        let _e523 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_151), (&param_152), (&param_153), (&param_154));
        light_3.ltc = _e523;
        let _e525 = light_3;
        return _e525;
    }
    let _e526 = direction;
    aim = normalize(_e526.xyz);
    attenuation_1 = 1f;
    let _e529 = type_42;
    if (_e529 < 0.5f) {
        let _e531 = aim;
        light_3.l = -(_e531);
    } else {
        let _e534 = position;
        let _e536 = v_world_position_1;
        toLight_1 = (_e534.xyz - _e536);
        let _e538 = toLight_1;
        distance_3 = length(_e538);
        let _e540 = distance_3;
        if (_e540 < 0.000001f) {
            let _e543 = (*s_6).n;
            light_3.l = _e543;
            let _e546 = (*s_6).n;
            light_3.h = _e546;
            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 _e552 = light_3;
            return _e552;
        }
        let _e553 = toLight_1;
        let _e554 = distance_3;
        light_3.l = (_e553 / vec3(_e554));
        let _e558 = distance_3;
        param_155 = _e558;
        let _e560 = direction[3u];
        param_156 = _e560;
        let _e561 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_155), (&param_156));
        attenuation_1 = _e561;
        let _e562 = type_42;
        if (_e562 > 1.5f) {
            let _e564 = aim;
            let _e566 = light_3.l;
            cosAngle = dot(_e564, -(_e566));
            let _e569 = cosAngle;
            let _e571 = cone[1u];
            let _e574 = cone[0u];
            let _e576 = cone[1u];
            ramp = clamp(((_e569 - _e571) / (_e574 - _e576)), 0f, 1f);
            let _e580 = ramp;
            let _e581 = ramp;
            let _e583 = attenuation_1;
            attenuation_1 = (_e583 * (_e580 * _e581));
        }
    }
    let _e586 = light_3.l;
    let _e588 = (*s_6).v;
    light_3.h = normalize((_e586 + _e588));
    let _e593 = (*s_6).n;
    let _e595 = light_3.l;
    light_3.n_dot_l = max(dot(_e593, _e595), 0f);
    let _e600 = (*s_6).n;
    let _e602 = light_3.h;
    light_3.n_dot_h = max(dot(_e600, _e602), 0f);
    let _e607 = (*s_6).v;
    let _e609 = light_3.h;
    light_3.v_dot_h = max(dot(_e607, _e609), 0f);
    let _e613 = color_1;
    let _e616 = color_1[3u];
    let _e618 = attenuation_1;
    light_3.radiance = ((_e613.xyz * _e616) * _e618);
    let _e621 = light_3;
    return _e621;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_38: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_157: f32;
    var param_158: f32;

    let _e252 = light_list_info.cluster_view_projection;
    let _e253 = (*world_3);
    clip_1 = (_e252 * vec4<f32>(_e253.x, _e253.y, _e253.z, 1f));
    let _e259 = clip_1;
    let _e262 = clip_1[3u];
    ndc_1 = (_e259.xy / vec2(max(_e262, 0.000001f)));
    let _e267 = light_list_info.cluster_grid;
    grid = _e267.xyz;
    let _e271 = light_list_info.cluster_depth[0u];
    near_1 = _e271;
    let _e273 = ndc_1[0u];
    let _e277 = grid[0u];
    let _e281 = grid[0u];
    tx = clamp(floor((((_e273 * 0.5f) + 0.5f) * _e277)), 0f, (_e281 - 1f));
    let _e285 = ndc_1[1u];
    let _e289 = grid[1u];
    let _e293 = grid[1u];
    ty = clamp(floor((((_e285 * 0.5f) + 0.5f) * _e289)), 0f, (_e293 - 1f));
    let _e297 = clip_1[3u];
    let _e298 = near_1;
    if (_e297 <= _e298) {
        local_38 = 0f;
    } else {
        let _e301 = clip_1[3u];
        let _e302 = near_1;
        let _e307 = light_list_info.cluster_depth[1u];
        let _e311 = grid[2u];
        local_38 = clamp(floor((log((_e301 / _e302)) * _e307)), 0f, (_e311 - 1f));
    }
    let _e314 = local_38;
    tz = _e314;
    let _e315 = tx;
    let _e316 = ty;
    let _e318 = grid[0u];
    let _e321 = tz;
    let _e323 = grid[0u];
    let _e326 = grid[1u];
    cell_1 = ((_e315 + (_e316 * _e318)) + ((_e321 * _e323) * _e326));
    let _e329 = cell_1;
    row_3 = floor((_e329 / 4f));
    let _e332 = cell_1;
    let _e333 = row_3;
    let _e338 = light_list_info.cluster_depth[2u];
    let _e339 = row_3;
    param_157 = (_e332 - (_e333 * 4f));
    param_158 = (_e338 + _e339);
    let _e341 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_157), (&param_158));
    header = _e341;
    let _e343 = header[0u];
    g_cluster_offset = _e343;
    let _e345 = header[1u];
    g_cluster_count = _e345;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_159: vec3<f32>;

    let _e241 = light_list_info.list[0u];
    tail = _e241;
    let _e242 = Clustered_u0028_();
    if _e242 {
        let _e243 = v_world_position_1;
        param_159 = _e243;
        FindCluster_u0028_vf3_u003b((&param_159));
        let _e244 = g_cluster_count;
        tail = _e244;
    }
    let _e247 = frag_info.frame_params[1u];
    let _e251 = tail;
    return (clamp(i32((_e247 + 0.5f)), 0i, 8i) + clamp(i32((_e251 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_4: LightSample;
    var param_160: i32;
    var param_161: Surface;
    var visibility: f32;
    var param_162: i32;
    var local_39: f32;
    var param_163: Surface;
    var param_164: LightSample;
    var param_165: i32;
    var param_166: vec3<f32>;
    var param_167: vec3<f32>;
    var param_168: i32;
    var param_169: Surface;
    var param_170: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e255 = LightCount_u0028_();
    count_1 = _e255;
    i_9 = 0i;
    loop {
        let _e256 = i_9;
        if (_e256 < 32i) {
            let _e258 = i_9;
            let _e259 = count_1;
            if (_e258 >= _e259) {
                break;
            }
            let _e261 = i_9;
            param_160 = _e261;
            let _e262 = (*s_7);
            param_161 = _e262;
            let _e263 = 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((&param_160), (&param_161));
            light_4 = _e263;
            let _e265 = light_4.n_dot_l;
            if (_e265 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e267 = i_9;
            param_162 = _e267;
            let _e268 = LightHasShadow_u0028_i1_u003b((&param_162));
            if _e268 {
                let _e269 = (*s_7);
                param_163 = _e269;
                let _e270 = light_4;
                param_164 = _e270;
                let _e271 = i_9;
                param_165 = _e271;
                let _e272 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_163), (&param_164), (&param_165));
                let _e273 = v_world_position_1;
                param_166 = _e273;
                let _e275 = (*s_7).n;
                param_167 = _e275;
                let _e276 = i_9;
                param_168 = _e276;
                let _e277 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_166), (&param_167), (&param_168));
                local_39 = (_e272 * _e277);
            } else {
                local_39 = 1f;
            }
            let _e279 = local_39;
            visibility = _e279;
            let _e280 = visibility;
            if (_e280 <= 0f) {
                continue;
            }
            let _e282 = (*s_7);
            param_169 = _e282;
            let _e283 = light_4;
            param_170 = _e283;
            let _e284 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_169), (&param_170));
            let _e286 = light_4.radiance;
            let _e289 = light_4.n_dot_l;
            let _e291 = visibility;
            let _e293 = light_transmittance;
            let _e295 = total_1;
            total_1 = (_e295 + ((((_e284 * _e286) * _e289) * _e291) * _e293));
            continue;
        } else {
            break;
        }
        continuing {
            let _e297 = i_9;
            i_9 = (_e297 + 1i);
        }
    }
    let _e299 = total_1;
    return _e299;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e238 = v_lightmap_uv_1;
    let _e239 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e238);
    texel_4 = _e239;
    let _e240 = texel_4;
    let _e243 = texel_4[3u];
    return ((_e240.xyz * _e243) * 8f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_40: f32;

    let _e240 = frag_info.material2_[2u];
    local_40 = floor((_e240 * 0.5f));
    let _e243 = local_40;
    return _e243;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_41: f32;
    var local_42: f32;

    let _e241 = OcclusionTarget_u0028_();
    target_ = _e241;
    let _e242 = target_;
    let _e244 = target_;
    if ((_e242 > 0.5f) && (_e244 < 1.5f)) {
        local_41 = 1f;
    } else {
        let _e248 = (*s_8).occlusion;
        local_41 = _e248;
    }
    let _e249 = local_41;
    local_42 = _e249;
    let _e250 = local_42;
    return _e250;
}

fn DirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var local_43: f32;
    var local_44: f32;

    let _e240 = OcclusionTarget_u0028_();
    if (_e240 > 1.5f) {
        local_43 = 1f;
    } else {
        let _e243 = (*s_9).occlusion;
        local_43 = _e243;
    }
    let _e244 = local_43;
    local_44 = _e244;
    let _e245 = local_44;
    return _e245;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_171: f32;
    var param_172: f32;
    var param_173: f32;
    var param_174: vec3<f32>;
    var param_175: f32;

    let _e246 = (*mu_1);
    param_171 = _e246;
    let _e247 = (*r_4);
    param_172 = _e247;
    let _e248 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_171), (&param_172));
    e_1 = _e248;
    let _e249 = (*rho_2);
    let _e250 = e_1;
    let _e252 = (*r_4);
    param_173 = _e252;
    let _e253 = FonAverage_u0028_f1_u003b((&param_173));
    let _e254 = (*rho_2);
    param_174 = _e254;
    param_175 = _e253;
    let _e255 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_174), (&param_175));
    let _e256 = e_1;
    return ((_e249 * _e250) + (_e255 * (1f - _e256)));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e239 = frag_info.target_origin[1u];
    return _e239;
}

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_10: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e239 = v_texcoord_1;
    let _e240 = MaterialLodBias_u0028_();
    let _e241 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e239, _e240);
    orm = _e241.xyz;
    let _e244 = (*s_10).metallic;
    let _e246 = orm[2u];
    (*s_10).metallic = clamp((_e244 * _e246), 0f, 1f);
    let _e251 = (*s_10).roughness;
    let _e253 = orm[1u];
    (*s_10).roughness = clamp((_e251 * _e253), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_176: vec3<f32>;

    let _e240 = v_texcoord_1;
    let _e241 = MaterialLodBias_u0028_();
    let _e242 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e240, _e241);
    param_176 = _e242.xyz;
    let _e244 = SrgbToLinear_u0028_vf3_u003b((&param_176));
    emissive = _e244;
    let _e245 = emissive;
    let _e247 = frag_info.emissive;
    let _e252 = frag_info.material2_[3u];
    (*s_11).emissive = ((_e245 * _e247.xyz) * _e252);
    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_12: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e240 = v_texcoord_1;
    let _e241 = MaterialLodBias_u0028_();
    let _e242 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e240, _e241);
    occlusion = _e242.x;
    let _e246 = frag_info.material2_[2u];
    let _e247 = OcclusionTarget_u0028_();
    strength_2 = (_e246 - (2f * _e247));
    let _e250 = occlusion;
    let _e251 = strength_2;
    (*s_12).occlusion = mix(1f, _e250, clamp(_e251, 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_13: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_4: vec3<f32>;
    var sampled: vec3<f32>;

    let _e242 = v_texcoord_1;
    let _e243 = MaterialLodBias_u0028_();
    let _e244 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e242, _e243);
    sampledTexel = _e244;
    let _e245 = v_tangent_1;
    t_2 = _e245.xyz;
    let _e247 = t_2;
    let _e249 = (*s_13).n;
    let _e251 = (*s_13).n;
    let _e252 = t_2;
    t_2 = (_e247 - (_e249 * dot(_e251, _e252)));
    let _e256 = t_2;
    let _e257 = t_2;
    if (dot(_e256, _e257) < 0.000000000001f) {
        return;
    }
    let _e260 = t_2;
    t_2 = normalize(_e260);
    let _e263 = (*s_13).n;
    let _e264 = t_2;
    let _e267 = v_tangent_1[3u];
    b_4 = (cross(_e263, _e264) * _e267);
    let _e269 = gl_FrontFacing_1;
    if !(_e269) {
        let _e271 = t_2;
        t_2 = -(_e271);
    }
    let _e273 = sampledTexel;
    sampled = ((_e273.xyz * 2f) - vec3(1f));
    let _e280 = frag_info.emissive[3u];
    if (_e280 > 0.5f) {
        let _e282 = sampled;
        let _e284 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e282.xy, _e284.xy)), 0f));
    }
    let _e293 = frag_info.material2_[1u];
    let _e294 = sampled;
    let _e296 = (_e294.xy * _e293);
    sampled[0u] = _e296.x;
    sampled[1u] = _e296.y;
    let _e301 = t_2;
    let _e303 = sampled[0u];
    let _e305 = b_4;
    let _e307 = sampled[1u];
    let _e311 = (*s_13).n;
    let _e313 = sampled[2u];
    (*s_13).n = normalize((((_e301 * _e303) + (_e305 * _e307)) + (_e311 * _e313)));
    let _e319 = (*s_13).n;
    let _e321 = (*s_13).v;
    (*s_13).n_dot_v = max(dot(_e319, _e321), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e238 = (*texel_5);
    let _e242 = irradiance_info.atlas;
    let _e245 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e238 + vec2(0.5f)) * _e242.xy), 0f);
    return _e245;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_7: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f_3: vec2<f32>;
    var a_6: vec4<f32>;
    var param_177: vec2<f32>;
    var b_5: vec4<f32>;
    var param_178: vec2<f32>;
    var c_1: vec4<f32>;
    var param_179: vec2<f32>;
    var d_5: vec4<f32>;
    var param_180: vec2<f32>;

    let _e251 = (*uv_7);
    let _e252 = (*interior);
    at_1 = ((vec2(1f) + (_e251 * _e252)) - vec2(0.5f));
    let _e258 = at_1;
    low = floor(_e258);
    let _e260 = at_1;
    let _e261 = low;
    f_3 = (_e260 - _e261);
    let _e263 = (*corner);
    let _e264 = low;
    param_177 = (_e263 + _e264);
    let _e266 = AtlasTexel_u0028_vf2_u003b((&param_177));
    a_6 = _e266;
    let _e267 = (*corner);
    let _e268 = low;
    param_178 = ((_e267 + _e268) + vec2<f32>(1f, 0f));
    let _e271 = AtlasTexel_u0028_vf2_u003b((&param_178));
    b_5 = _e271;
    let _e272 = (*corner);
    let _e273 = low;
    param_179 = ((_e272 + _e273) + vec2<f32>(0f, 1f));
    let _e276 = AtlasTexel_u0028_vf2_u003b((&param_179));
    c_1 = _e276;
    let _e277 = (*corner);
    let _e278 = low;
    param_180 = ((_e277 + _e278) + vec2<f32>(1f, 1f));
    let _e281 = AtlasTexel_u0028_vf2_u003b((&param_180));
    d_5 = _e281;
    let _e282 = a_6;
    let _e283 = b_5;
    let _e285 = f_3[0u];
    let _e288 = c_1;
    let _e289 = d_5;
    let _e291 = f_3[0u];
    let _e295 = f_3[1u];
    return mix(mix(_e282, _e283, vec4(_e285)), mix(_e288, _e289, vec4(_e291)), vec4(_e295));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e242 = (*direction_1)[0u];
    let _e245 = (*direction_1)[1u];
    let _e249 = (*direction_1)[2u];
    sum_1 = ((abs(_e242) + abs(_e245)) + abs(_e249));
    let _e252 = sum_1;
    if (_e252 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e254 = (*direction_1);
    let _e255 = sum_1;
    n_6 = (_e254 / vec3(_e255));
    let _e258 = n_6;
    xy = _e258.xy;
    let _e261 = n_6[2u];
    if (_e261 < 0f) {
        let _e264 = n_6[1u];
        let _e268 = n_6[0u];
        let _e273 = n_6[0u];
        let _e277 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e264)) * select(-1f, 1f, (_e268 >= 0f))), ((1f - abs(_e273)) * select(-1f, 1f, (_e277 >= 0f))));
    }
    let _e282 = xy;
    return ((_e282 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_4: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_181: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_182: vec3<f32>;
    var param_183: vec2<f32>;
    var param_184: f32;
    var param_185: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_186: vec3<f32>;
    var param_187: vec2<f32>;
    var param_188: f32;
    var param_189: vec2<f32>;
    var local_45: vec3<f32>;

    let _e284 = irradiance_info.origin;
    origin_2 = _e284.xyz;
    let _e287 = irradiance_info.spacing;
    spacing = _e287.xyz;
    let _e290 = irradiance_info.counts;
    counts = _e290.xyz;
    let _e294 = irradiance_info.tiles[0u];
    irradianceTile = _e294;
    let _e297 = irradiance_info.tiles[1u];
    depthTile = _e297;
    let _e300 = irradiance_info.tiles[2u];
    columns = _e300;
    let _e303 = irradiance_info.tiles[3u];
    momentsTop = _e303;
    let _e304 = (*normal_1);
    unit = normalize(_e304);
    let _e306 = (*world_4);
    let _e307 = unit;
    let _e310 = irradiance_info.spacing[3u];
    let _e313 = (*view_1);
    let _e316 = irradiance_info.counts[3u];
    biased = ((_e306 + (_e307 * _e310)) + (_e313 * _e316));
    let _e319 = biased;
    let _e320 = origin_2;
    let _e322 = spacing;
    grid_1 = ((_e319 - _e320) / _e322);
    let _e324 = grid_1;
    let _e326 = counts;
    base = clamp(floor(_e324), vec3<f32>(0f, 0f, 0f), (_e326 - vec3(2f)));
    let _e330 = grid_1;
    let _e331 = base;
    f_4 = clamp((_e330 - _e331), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e334 = corner_1;
        if (_e334 < 8i) {
            let _e336 = corner_1;
            let _e339 = corner_1;
            let _e344 = corner_1;
            offset_3 = vec3<f32>(f32((_e336 & 1i)), f32(((_e339 >> bitcast<u32>(1i)) & 1i)), f32(((_e344 >> bitcast<u32>(2i)) & 1i)));
            let _e350 = base;
            let _e351 = offset_3;
            cell_2 = (_e350 + _e351);
            let _e354 = cell_2[2u];
            let _e356 = counts[1u];
            let _e359 = cell_2[1u];
            let _e362 = counts[0u];
            let _e365 = cell_2[0u];
            probe = ((((_e354 * _e356) + _e359) * _e362) + _e365);
            let _e367 = probe;
            let _e368 = columns;
            let _e373 = probe;
            let _e374 = columns;
            tile_4 = vec2<f32>((_e367 - (floor((_e367 / _e368)) * _e368)), floor((_e373 / _e374)));
            let _e378 = tile_4;
            let _e379 = irradianceTile;
            irradianceCorner = (_e378 * (_e379 + 2f));
            let _e383 = tile_4[0u];
            let _e384 = depthTile;
            let _e387 = momentsTop;
            let _e389 = tile_4[1u];
            let _e390 = depthTile;
            momentCorner = vec2<f32>((_e383 * (_e384 + 2f)), (_e387 + (_e389 * (_e390 + 2f))));
            let _e395 = irradianceCorner;
            param_181 = (_e395 + vec2(1f));
            let _e398 = AtlasTexel_u0028_vf2_u003b((&param_181));
            if (_e398.w < 0.5f) {
                continue;
            }
            let _e401 = f_4;
            let _e403 = f_4;
            let _e404 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e401), _e403, _e404);
            let _e407 = trilinear[0u];
            let _e409 = trilinear[1u];
            let _e412 = trilinear[2u];
            weight_3 = max(((_e407 * _e409) * _e412), 0.001f);
            let _e415 = origin_2;
            let _e416 = spacing;
            let _e417 = cell_2;
            probePosition = (_e415 + (_e416 * _e417));
            let _e420 = probePosition;
            let _e421 = biased;
            toProbe = (_e420 - _e421);
            let _e423 = toProbe;
            distance_4 = length(_e423);
            let _e425 = distance_4;
            if (_e425 > 0.000001f) {
                let _e427 = toProbe;
                let _e428 = distance_4;
                direction_2 = (_e427 / vec3(_e428));
                let _e431 = unit;
                let _e432 = probePosition;
                let _e433 = (*world_4);
                facing = ((dot(_e431, normalize((_e432 - _e433))) * 0.5f) + 0.5f);
                let _e439 = facing;
                let _e440 = facing;
                probeWeight = ((_e439 * _e440) + 0.2f);
                let _e443 = direction_2;
                param_182 = -(_e443);
                let _e445 = ProbeOctahedral_u0028_vf3_u003b((&param_182));
                let _e446 = momentCorner;
                param_183 = _e446;
                let _e447 = depthTile;
                param_184 = _e447;
                param_185 = _e445;
                let _e448 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_183), (&param_184), (&param_185));
                moments_3 = _e448.xy;
                chebyshev = 1f;
                let _e450 = distance_4;
                let _e452 = moments_3[0u];
                if (_e450 > _e452) {
                    let _e455 = moments_3[1u];
                    let _e457 = moments_3[0u];
                    let _e459 = moments_3[0u];
                    variance_1 = max((_e455 - (_e457 * _e459)), 0.000001f);
                    let _e463 = distance_4;
                    let _e465 = moments_3[0u];
                    difference = (_e463 - _e465);
                    let _e467 = variance_1;
                    let _e468 = variance_1;
                    let _e469 = difference;
                    let _e470 = difference;
                    chebyshev = (_e467 / (_e468 + (_e469 * _e470)));
                    let _e474 = chebyshev;
                    let _e475 = chebyshev;
                    let _e477 = chebyshev;
                    chebyshev = ((_e474 * _e475) * _e477);
                }
                let _e479 = probeWeight;
                let _e480 = chebyshev;
                probeWeight = max((_e479 * max(_e480, 0.05f)), 0.000001f);
                let _e484 = probeWeight;
                if (_e484 < 0.2f) {
                    let _e486 = probeWeight;
                    let _e487 = probeWeight;
                    let _e490 = probeWeight;
                    probeWeight = (_e490 * ((_e486 * _e487) * 25f));
                }
                let _e492 = probeWeight;
                let _e493 = weight_3;
                weight_3 = (_e493 * _e492);
            }
            let _e495 = unit;
            param_186 = _e495;
            let _e496 = ProbeOctahedral_u0028_vf3_u003b((&param_186));
            let _e497 = irradianceCorner;
            param_187 = _e497;
            let _e498 = irradianceTile;
            param_188 = _e498;
            param_189 = _e496;
            let _e499 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_187), (&param_188), (&param_189));
            let _e501 = weight_3;
            let _e503 = total_2;
            total_2 = (_e503 + (_e499.xyz * _e501));
            let _e505 = weight_3;
            let _e506 = weights;
            weights = (_e506 + _e505);
            continue;
        } else {
            break;
        }
        continuing {
            let _e508 = corner_1;
            corner_1 = (_e508 + 1i);
        }
    }
    let _e510 = weights;
    if (_e510 > 0f) {
        let _e512 = total_2;
        let _e513 = weights;
        local_45 = (_e512 / vec3(_e513));
    } else {
        local_45 = vec3<f32>(0f, 0f, 0f);
    }
    let _e516 = local_45;
    return _e516;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e239 = irradiance_info.origin[3u];
    return (_e239 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_14: ptr<function, Surface>) {
    var param_190: vec3<f32>;
    var param_191: vec3<f32>;
    var param_192: vec3<f32>;
    var param_193: Surface;
    var param_194: Surface;
    var param_195: Surface;

    let _e244 = IrradianceEnabled_u0028_();
    if _e244 {
        let _e245 = v_world_position_1;
        param_190 = _e245;
        let _e247 = (*s_14).n;
        param_191 = _e247;
        let _e249 = (*s_14).v;
        param_192 = _e249;
        let _e250 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_190), (&param_191), (&param_192));
        let _e253 = frag_info.material[2u];
        (*s_14).ambient = (_e250 * _e253);
    }
    let _e256 = (*s_14);
    param_193 = _e256;
    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((&param_193));
    let _e257 = param_193;
    (*s_14) = _e257;
    let _e258 = (*s_14);
    param_194 = _e258;
    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((&param_194));
    let _e259 = param_194;
    (*s_14) = _e259;
    let _e260 = (*s_14);
    param_195 = _e260;
    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((&param_195));
    let _e261 = param_195;
    (*s_14) = _e261;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_46: vec3<f32>;

    let _e238 = Orthographic_u0028_();
    if _e238 {
        let _e240 = fog_info.forward;
        local_46 = -(_e240.xyz);
    } else {
        let _e244 = fog_info.eye;
        let _e246 = v_world_position_1;
        local_46 = normalize((_e244.xyz - _e246));
    }
    let _e249 = local_46;
    return _e249;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin_3: vec3<f32>;
    var cell_3: vec3<f32>;
    var p3_: vec3<f32>;

    let _e243 = (*cutoff);
    key_2 = (-2f - _e243);
    let _e245 = key_2;
    let _e248 = key_2;
    let _e250 = floor((_e248 / 128f));
    let _e255 = key_2;
    origin_3 = vec3<f32>(floor((_e245 / 16384f)), (_e250 - (floor((_e250 / 128f)) * 128f)), (_e255 - (floor((_e255 / 128f)) * 128f)));
    let _e261 = (*scenePosition);
    let _e264 = origin_3;
    let _e265 = (floor((_e261 * 16f)) + _e264);
    let _e266 = vec3(128f);
    cell_3 = (_e265 - (floor((_e265 / _e266)) * _e266));
    let _e271 = cell_3;
    p3_ = fract((_e271 * 0.1031f));
    let _e274 = p3_;
    let _e275 = p3_;
    let _e280 = p3_;
    p3_ = (_e280 + vec3(dot(_e274, (_e275.zyx + vec3(31.32f)))));
    let _e284 = p3_[0u];
    let _e286 = p3_[1u];
    let _e289 = p3_[2u];
    return fract(((_e284 + _e286) * _e289));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_15: Surface;
    var param_196: vec3<f32>;
    var param_197: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_198: vec3<f32>;
    var param_199: f32;

    let _e245 = v_texcoord_1;
    let _e246 = MaterialLodBias_u0028_();
    let _e247 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e245, _e246);
    texel_6 = _e247;
    let _e248 = texel_6;
    param_196 = _e248.xyz;
    let _e250 = SrgbToLinear_u0028_vf3_u003b((&param_196));
    let _e252 = frag_info.base_color;
    param_197 = _e252.xyz;
    let _e254 = SrgbToLinear_u0028_vf3_u003b((&param_197));
    let _e256 = v_color_1;
    s_15.albedo = ((_e250 * _e254) * _e256.xyz);
    let _e261 = texel_6[3u];
    let _e264 = frag_info.base_color[3u];
    let _e267 = v_color_1[3u];
    s_15.alpha = ((_e261 * _e264) * _e267);
    let _e271 = s_15.albedo;
    g_albedo = _e271;
    let _e274 = frag_info.material2_[0u];
    cutoff_1 = _e274;
    let _e275 = cutoff_1;
    if (_e275 > 1f) {
        let _e277 = cutoff_1;
        edge = (_e277 - 1f);
        let _e280 = s_15.alpha;
        let _e281 = edge;
        let _e284 = s_15.alpha;
        let _e285 = fwidth(_e284);
        s_15.alpha = clamp((((_e280 - _e281) / max(_e285, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e291 = cutoff_1;
        if (_e291 >= 0f) {
            let _e294 = s_15.alpha;
            let _e295 = cutoff_1;
            if (_e294 < _e295) {
                discard;
            }
            s_15.alpha = 1f;
        } else {
            let _e298 = cutoff_1;
            if (_e298 < -1.5f) {
                let _e301 = s_15.alpha;
                let _e302 = v_world_position_1;
                param_198 = _e302;
                let _e303 = cutoff_1;
                param_199 = _e303;
                let _e304 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_198), (&param_199));
                if (_e301 < _e304) {
                    discard;
                }
            }
        }
    }
    let _e306 = cutoff_1;
    let _e308 = cutoff_1;
    g_premultiply = ((_e306 < 0f) && (_e308 > -0.75f));
    let _e311 = v_normal_1;
    s_15.n = normalize(_e311);
    let _e314 = gl_FrontFacing_1;
    if !(_e314) {
        let _e317 = s_15.n;
        s_15.n = -(_e317);
    }
    let _e320 = TowardsEye_u0028_();
    s_15.v = _e320;
    let _e323 = s_15.n;
    let _e325 = s_15.v;
    s_15.n_dot_v = max(dot(_e323, _e325), 0.0001f);
    let _e331 = frag_info.material[0u];
    s_15.metallic = clamp(_e331, 0f, 1f);
    let _e336 = frag_info.material[1u];
    s_15.roughness = clamp(_e336, 0.02f, 1f);
    let _e340 = frag_info.ambient_ground;
    let _e343 = frag_info.ambient_sky;
    let _e347 = s_15.n[1u];
    let _e354 = frag_info.material[2u];
    s_15.ambient = (mix(_e340.xyz, _e343.xyz, vec3(((_e347 * 0.5f) + 0.5f))) * _e354);
    let _e359 = frag_info.frame_params[0u];
    s_15.exposure = max(_e359, 0f);
    s_15.occlusion = 1f;
    s_15.emissive = vec3<f32>(0f, 0f, 0f);
    let _e364 = s_15;
    return _e364;
}

fn main_1() {
    var s_16: Surface;
    var param_200: Surface;
    var param_201: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_202: vec3<f32>;
    var param_203: f32;
    var param_204: f32;
    var directOcclusion: f32;
    var param_205: Surface;
    var indirectOcclusion: f32;
    var param_206: Surface;
    var ambient: vec3<f32>;
    var levels: f32;
    var f0_3: vec3<f32>;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_1: vec2<f32>;
    var param_207: f32;
    var param_208: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var lit_3: vec3<f32>;
    var param_209: Surface;
    var param_210: Surface;
    var param_211: vec3<f32>;
    var param_212: vec3<f32>;
    var param_213: f32;
    var param_214: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e270 = ReadSurface_u0028_();
    s_16 = _e270;
    let _e271 = s_16;
    param_200 = _e271;
    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((&param_200));
    let _e272 = param_200;
    s_16 = _e272;
    let _e273 = s_16;
    param_201 = _e273;
    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((&param_201));
    let _e274 = param_201;
    s_16 = _e274;
    let _e276 = s_16.metallic;
    metallic = clamp(_e276, 0f, 1f);
    let _e279 = s_16.albedo;
    let _e280 = metallic;
    diffuseColor_1 = (_e279 * (1f - _e280));
    let _e283 = EonDiffuse_u0028_();
    if _e283 {
        let _e284 = diffuseColor_1;
        param_202 = _e284;
        let _e286 = s_16.roughness;
        param_203 = _e286;
        let _e288 = s_16.n_dot_v;
        param_204 = _e288;
        let _e289 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_202), (&param_203), (&param_204));
        diffuseColor_1 = _e289;
    }
    let _e290 = s_16;
    param_205 = _e290;
    let _e291 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_205));
    directOcclusion = _e291;
    let _e292 = s_16;
    param_206 = _e292;
    let _e293 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_206));
    indirectOcclusion = _e293;
    let _e294 = diffuseColor_1;
    let _e296 = s_16.ambient;
    let _e298 = indirectOcclusion;
    ambient = ((_e294 * _e296) * _e298);
    let _e302 = frag_info.frame_params[3u];
    levels = _e302;
    let _e303 = levels;
    if (_e303 > 0f) {
        let _e306 = s_16.albedo;
        let _e307 = metallic;
        f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e306, vec3(_e307));
        let _e311 = s_16.v;
        let _e314 = s_16.n;
        reflected = reflect(-(_e311), _e314);
        let _e317 = s_16.n;
        let _e318 = levels;
        let _e319 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e317, _e318);
        irradiance = _e319.xyz;
        let _e321 = reflected;
        let _e323 = s_16.roughness;
        let _e324 = levels;
        let _e326 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e321, (_e323 * _e324));
        prefiltered = _e326.xyz;
        let _e329 = s_16.roughness;
        param_207 = _e329;
        let _e331 = s_16.n_dot_v;
        param_208 = _e331;
        let _e332 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_207), (&param_208));
        ab_1 = _e332;
        let _e333 = f0_3;
        let _e335 = ab_1[0u];
        let _e338 = ab_1[1u];
        single_1 = ((_e333 * _e335) + vec3(_e338));
        let _e341 = prefiltered;
        let _e342 = single_1;
        specular_1 = (_e341 * _e342);
        let _e344 = EnergyCompensation_u0028_();
        if _e344 {
            let _e346 = ab_1[0u];
            let _e348 = ab_1[1u];
            missed = (1f - (_e346 + _e348));
            let _e351 = f0_3;
            let _e352 = f0_3;
            average_2 = (_e351 + ((vec3<f32>(1f, 1f, 1f) - _e352) / vec3(21f)));
            let _e357 = single_1;
            let _e358 = average_2;
            let _e360 = missed;
            let _e361 = average_2;
            multiple = ((_e357 * _e358) / (vec3<f32>(1f, 1f, 1f) - (_e361 * _e360)));
            let _e365 = multiple;
            let _e366 = missed;
            let _e368 = irradiance;
            let _e370 = specular_1;
            specular_1 = (_e370 + ((_e365 * _e366) * _e368));
        }
        let _e372 = diffuseColor_1;
        let _e373 = irradiance;
        let _e375 = specular_1;
        let _e379 = frag_info.material[2u];
        let _e381 = indirectOcclusion;
        ambient = ((((_e372 * _e373) + _e375) * _e379) * _e381);
    }
    let _e383 = diffuseColor_1;
    let _e384 = SampleLightmap_u0028_();
    let _e386 = indirectOcclusion;
    let _e388 = ambient;
    ambient = (_e388 + ((_e383 * _e384) * _e386));
    let _e390 = s_16;
    param_209 = _e390;
    let _e391 = 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((&param_209));
    let _e392 = directOcclusion;
    let _e394 = ambient;
    let _e397 = s_16.emissive;
    lit_3 = (((_e391 * _e392) + _e394) + _e397);
    let _e399 = s_16;
    param_210 = _e399;
    let _e400 = lit_3;
    param_211 = _e400;
    let _e401 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_210), (&param_211));
    if _e401 {
        return;
    }
    let _e402 = lit_3;
    param_212 = _e402;
    let _e404 = s_16.alpha;
    param_213 = _e404;
    let _e406 = s_16.roughness;
    param_214 = _e406;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_212), (&param_213), (&param_214));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 27,
          samplerBinding: 28,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 29,
          samplerBinding: 30,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrLayeredDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct LayerInfo {
    specular: vec4<f32>,
    coat: vec4<f32>,
    sheen: vec4<f32>,
    anisotropy: vec4<f32>,
    transmission: vec4<f32>,
    attenuation: vec4<f32>,
    iridescence: vec4<f32>,
    uv_transform: array<vec4<f32>, 10>,
    scene_color: vec4<f32>,
    scene_viewport: vec4<f32>,
    scene_levels: array<vec4<f32>, 6>,
    scene_view_projection: mat4x4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
var<private> g_f0_dielectric: vec3<f32>;
var<private> g_f90_: f32;
var<private> g_coat: f32;
var<private> g_coat_roughness: f32;
var<private> g_coat_n: vec3<f32>;
var<private> g_coat_n_dot_v: f32;
var<private> g_coat_through: f32;
var<private> g_sheen: vec3<f32>;
var<private> g_sheen_roughness: f32;
var<private> g_sheen_albedo: f32;
var<private> g_sheen_scale: f32;
var<private> g_aniso: f32;
var<private> g_aniso_t: vec3<f32>;
var<private> g_aniso_b: vec3<f32>;
var<private> g_transmission: f32;
var<private> g_thickness: f32;
var<private> g_transmittance: vec3<f32>;
var<private> g_iridescence: f32;
var<private> g_irid_fresnel: vec3<f32>;
var<private> g_pane: bool;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(16)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(6)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var base_color_texture_smp: sampler;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(20)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var ltc_texture_smp: sampler;
var<private> g_rect_corners: array<vec3<f32>, 4>;
@group(1) @binding(5)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(30)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(31)
var point_shadow_texture_smp: sampler;
@group(1) @binding(28)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(29)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(14)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var irradiance_texture_smp: sampler;
@group(1) @binding(18)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(22)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(26)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(27)
var occlusion_texture_smp: sampler;
@group(1) @binding(10)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var emissive_texture_smp: sampler;
@group(1) @binding(24)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var normal_texture_smp: sampler;
@group(1) @binding(34)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(35)
var shadow_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(3)
var<uniform> layer_info: LayerInfo;
@group(1) @binding(8)
var coat_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var coat_texture_smp: sampler;
@group(1) @binding(36)
var sheen_texture_tex: texture_2d<f32>;
@group(1) @binding(37)
var sheen_texture_smp: sampler;
@group(1) @binding(12)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(13)
var environment_texture_smp: sampler;
@group(1) @binding(32)
var scene_color_texture_tex: texture_2d<f32>;
@group(1) @binding(33)
var scene_color_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e304 = v_world_position_1;
    let _e306 = fog_info.eye;
    let _e310 = fog_info.forward;
    return dot((_e304 - _e306.xyz), _e310.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e309 = ViewDepth_u0028_();
    z = abs(_e309);
    let _e311 = z;
    near = (_e311 / 5f);
    let _e313 = z;
    far = (_e313 / 200f);
    let _e315 = far;
    let _e316 = far;
    let _e318 = far;
    far3_ = ((_e315 * _e316) * _e318);
    let _e320 = (*alpha);
    let _e321 = near;
    let _e322 = near;
    let _e325 = far3_;
    let _e326 = far3_;
    return (_e320 * clamp((10f / ((0.00001f + (_e321 * _e322)) + (_e325 * _e326))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e313 = fog_info.forward[3u];
    mode = _e313;
    let _e314 = mode;
    if (_e314 > 0.5f) {
        let _e317 = frag_color[3u];
        alpha_1 = _e317;
        let _e318 = alpha_1;
        param = _e318;
        let _e319 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e319;
        let _e320 = frag_color;
        let _e322 = weight;
        let _e323 = (_e320.xyz * _e322);
        let _e324 = alpha_1;
        let _e325 = weight;
        accumulate = vec4<f32>(_e323.x, _e323.y, _e323.z, (_e324 * _e325));
        let _e331 = mode;
        let _e333 = mode;
        revealage = ((_e331 > 1.5f) && (_e333 < 2.5f));
        let _e336 = revealage;
        if _e336 {
            let _e337 = alpha_1;
            local = vec4(_e337);
        } else {
            let _e339 = accumulate;
            local = _e339;
        }
        let _e340 = local;
        frag_color = _e340;
        let _e341 = mode;
        if (_e341 > 2.5f) {
            let _e343 = alpha_1;
            frag_surface = vec4(_e343);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e307 = (*n)[0u];
    let _e310 = (*n)[1u];
    let _e314 = (*n)[2u];
    let _e317 = (*n);
    (*n) = (_e317 / vec3(((abs(_e307) + abs(_e310)) + abs(_e314))));
    let _e320 = (*n);
    e = _e320.xy;
    let _e323 = (*n)[2u];
    if (_e323 < 0f) {
        let _e325 = (*n);
        let _e331 = (*n)[0u];
        let _e335 = (*n)[1u];
        e = ((vec2(1f) - abs(_e325.yx)) * vec2<f32>(select(-1f, 1f, (_e331 >= 0f)), select(-1f, 1f, (_e335 >= 0f))));
    }
    let _e340 = e;
    return ((_e340 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e305 = (*linear);
    let _e307 = (*linear);
    let _e311 = (*linear);
    return mix((_e305 * 12.92f), ((pow(_e307, 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), _e311));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e308 = g_albedo;
    param_1 = clamp(_e308, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e310 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e310.x, _e310.y, _e310.z, 1f);
    let _e315 = g_debug_surface_on;
    if _e315 {
        let _e316 = g_debug_surface;
        let _e317 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e316.x, _e316.y, _e316.z, _e317);
        return;
    }
    let _e322 = v_normal_1;
    geometric = normalize(_e322);
    let _e324 = gl_FrontFacing_1;
    if !(_e324) {
        let _e326 = geometric;
        geometric = -(_e326);
    }
    let _e328 = geometric;
    param_2 = _e328;
    let _e329 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e330 = (*roughness);
    let _e332 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e329.x, _e329.y, clamp(_e330, 0f, 1f), _e332);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e306 = fog_info.projection[0u];
    return (_e306 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e305 = Orthographic_u0028_();
    if _e305 {
        let _e306 = ViewDepth_u0028_();
        local_1 = max(_e306, 0f);
    } else {
        let _e308 = v_world_position_1;
        let _e310 = fog_info.eye;
        local_1 = distance(_e308, _e310.xyz);
    }
    let _e313 = local_1;
    return _e313;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e312 = fog_info.fog[3u];
    density = _e312;
    let _e313 = density;
    if (_e313 <= 0f) {
        let _e315 = (*color);
        return _e315;
    }
    let _e316 = EyeDistance_u0028_();
    d = _e316;
    let _e319 = fog_info.eye[3u];
    falloff = _e319;
    let _e320 = falloff;
    if (_e320 > 0f) {
        let _e322 = falloff;
        let _e324 = v_world_position_1[1u];
        let _e327 = fog_info.eye[1u];
        k = (_e322 * (_e324 - _e327));
        let _e330 = k;
        if (abs(_e330) > 0.001f) {
            let _e333 = k;
            let _e337 = k;
            local_2 = ((1f - exp(-(_e333))) / _e337);
        } else {
            let _e339 = k;
            local_2 = (1f - (0.5f * _e339));
        }
        let _e342 = local_2;
        let _e343 = density;
        density = (_e343 * _e342);
    }
    let _e346 = fog_info.fog;
    let _e348 = (*color);
    let _e349 = density;
    let _e351 = d;
    return mix(_e346.xyz, _e348, vec3(clamp(exp((-(_e349) * _e351)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e310 = g_premultiply;
    let _e311 = (*alpha_2);
    weight_1 = select(1f, _e311, _e310);
    let _e313 = (*linearColor);
    param_3 = _e313;
    let _e314 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e315 = weight_1;
    let _e316 = (_e314 * _e315);
    let _e317 = (*alpha_2);
    let _e318 = g_pass_through;
    frag_color = vec4<f32>(_e316.x, _e316.y, _e316.z, (_e317 * (1f - _e318)));
    let _e325 = (*roughness_1);
    param_4 = _e325;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e305 = (*srgb);
    let _e308 = (*srgb);
    let _e313 = (*srgb);
    return mix((_e305 / vec3(12.92f)), pow(((_e308 + 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), _e313));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e307 = (*key);
    hue = fract(((_e307 * 0.618034f) + 0.13f));
    let _e311 = hue;
    k_1 = clamp((abs(((fract((vec3(_e311) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e324 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e324, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_3100_: bool;

    let _e305 = (*c);
    let _e306 = (*c);
    let _e308 = any((_e305 != _e306));
    phi_3100_ = _e308;
    if !(_e308) {
        let _e310 = (*c);
        phi_3100_ = any((abs(_e310) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e315 = phi_3100_;
    return _e315;
}

fn MapUv_u0028_i1_u003b(slot: ptr<function, i32>) -> vec2<f32> {
    var uvw: vec3<f32>;

    let _e306 = v_texcoord_1;
    uvw = vec3<f32>(_e306.x, _e306.y, 1f);
    let _e310 = (*slot);
    let _e314 = layer_info.uv_transform[(_e310 * 2i)];
    let _e316 = uvw;
    let _e318 = (*slot);
    let _e323 = layer_info.uv_transform[((_e318 * 2i) + 1i)];
    let _e325 = uvw;
    return vec2<f32>(dot(_e314.xyz, _e316), dot(_e323.xyz, _e325));
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var param_7: i32;
    var grey: f32;
    var param_8: vec3<f32>;
    var param_9: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var param_10: i32;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_11: vec3<f32>;
    var key_1: f32;
    var param_12: f32;
    var srgb_1: vec3<f32>;
    var param_13: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_14: vec3<f32>;
    var param_15: f32;
    var phi_3190_: bool;
    var phi_3460_: bool;

    let _e349 = gl_FragCoord_1[0u];
    let _e352 = frag_info.debug_view[1u];
    if (_e349 < _e352) {
        let _e356 = frag_info.debug_view[2u];
        local_3 = _e356;
    } else {
        let _e359 = frag_info.debug_view[0u];
        local_3 = _e359;
    }
    let _e360 = local_3;
    view = _e360;
    let _e361 = view;
    if (_e361 < 0.5f) {
        return false;
    }
    let _e363 = view;
    code = i32((_e363 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e366 = v_normal_1;
    geometric_n = normalize(_e366);
    let _e368 = v_tangent_1;
    let _e370 = geometric_n;
    let _e371 = geometric_n;
    let _e372 = v_tangent_1;
    tangent = (_e368.xyz - (_e370 * dot(_e371, _e372.xyz)));
    let _e377 = tangent;
    let _e378 = tangent;
    let _e380 = (dot(_e377, _e378) > 0.000000000001f);
    phi_3190_ = _e380;
    if _e380 {
        let _e382 = v_tangent_1[3u];
        phi_3190_ = (abs((abs(_e382) - 1f)) < 0.01f);
    }
    let _e388 = phi_3190_;
    tangent_usable = _e388;
    let _e391 = frag_info.debug_view[3u];
    identity = _e391;
    let _e392 = identity;
    identity_object = floor((_e392 / 8192f));
    let _e395 = identity;
    let _e396 = identity_object;
    identity_rest = (_e395 - (_e396 * 8192f));
    let _e399 = identity_rest;
    identity_material = floor((_e399 / 2f));
    let _e402 = identity_rest;
    let _e403 = identity_material;
    normal_mapped = ((_e402 - (_e403 * 2f)) > 0.5f);
    let _e407 = code;
    if (_e407 == 1i) {
        let _e410 = (*s).albedo;
        param_5 = clamp(_e410, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e412 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e412;
    } else {
        let _e413 = code;
        if (_e413 == 2i) {
            let _e416 = (*s).n;
            shown = ((_e416 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e419 = code;
            if (_e419 == 3i) {
                let _e422 = (*s).roughness;
                shown = vec3(clamp(_e422, 0f, 1f));
            } else {
                let _e425 = code;
                if (_e425 == 4i) {
                    let _e428 = (*s).metallic;
                    shown = vec3(clamp(_e428, 0f, 1f));
                } else {
                    let _e431 = code;
                    if (_e431 == 5i) {
                        let _e434 = (*s).occlusion;
                        shown = vec3(clamp(_e434, 0f, 1f));
                    } else {
                        let _e437 = code;
                        if (_e437 == 6i) {
                            let _e440 = (*s).emissive;
                            param_6 = clamp(_e440, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e442 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e442;
                        } else {
                            let _e443 = code;
                            if (_e443 == 7i) {
                                param_7 = 0i;
                                let _e445 = MapUv_u0028_i1_u003b((&param_7));
                                let _e446 = fract(_e445);
                                shown = vec3<f32>(_e446.x, _e446.y, 0f);
                            } else {
                                let _e450 = code;
                                if (_e450 == 8i) {
                                    let _e452 = (*lit);
                                    param_8 = clamp(_e452, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e454 = LinearToSrgb_u0028_vf3_u003b((&param_8));
                                    grey = dot(_e454, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e456 = (*lit);
                                    param_9 = _e456;
                                    let _e457 = NonFinite_u0028_vf3_u003b((&param_9));
                                    if _e457 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e458 = grey;
                                        local_4 = vec3((_e458 * 0.5f));
                                    }
                                    let _e461 = local_4;
                                    shown = _e461;
                                } else {
                                    let _e462 = code;
                                    if (_e462 == 9i) {
                                        let _e464 = tangent_usable;
                                        if _e464 {
                                            let _e465 = tangent;
                                            local_5 = ((normalize(_e465) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e469 = local_5;
                                        shown = _e469;
                                    } else {
                                        let _e470 = code;
                                        if (_e470 == 10i) {
                                            param_10 = 0i;
                                            let _e472 = MapUv_u0028_i1_u003b((&param_10));
                                            uv = _e472;
                                            let _e473 = uv;
                                            cell = floor((_e473 * 8f));
                                            let _e477 = cell[0u];
                                            let _e479 = cell[1u];
                                            odd = (fract(((_e477 + _e479) * 0.5f)) * 2f);
                                            let _e484 = uv;
                                            within = fract(_e484);
                                            let _e486 = odd;
                                            let _e490 = within[0u];
                                            let _e494 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e486)) * vec3<f32>((0.55f + (0.45f * _e490)), (0.55f + (0.45f * _e494)), 0.85f));
                                        } else {
                                            let _e499 = code;
                                            if (_e499 == 11i) {
                                                let _e501 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e501));
                                            } else {
                                                let _e504 = code;
                                                if (_e504 == 12i) {
                                                    let _e506 = v_color_1;
                                                    param_11 = clamp(_e506.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e509 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                    shown = _e509;
                                                } else {
                                                    let _e510 = code;
                                                    let _e512 = code;
                                                    if ((_e510 == 13i) || (_e512 == 14i)) {
                                                        let _e515 = code;
                                                        let _e517 = identity_object;
                                                        let _e518 = identity_material;
                                                        key_1 = select(_e518, _e517, (_e515 == 13i));
                                                        let _e520 = key_1;
                                                        param_12 = _e520;
                                                        let _e521 = DebugIdentityColour_u0028_f1_u003b((&param_12));
                                                        let _e523 = (*s).n_dot_v;
                                                        shown = (_e521 * (0.55f + (0.45f * _e523)));
                                                    } else {
                                                        let _e527 = code;
                                                        if (_e527 == 15i) {
                                                            let _e530 = (*s).albedo;
                                                            param_13 = clamp(_e530, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e532 = LinearToSrgb_u0028_vf3_u003b((&param_13));
                                                            srgb_1 = _e532;
                                                            let _e533 = srgb_1;
                                                            luma = dot(_e533, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e536 = (*s).metallic;
                                                            metal = (_e536 > 0.5f);
                                                            let _e538 = metal;
                                                            let _e540 = luma;
                                                            if (!(_e538) && (_e540 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e543 = metal;
                                                                let _e544 = !(_e543);
                                                                phi_3460_ = _e544;
                                                                if _e544 {
                                                                    let _e546 = srgb_1[0u];
                                                                    let _e548 = srgb_1[1u];
                                                                    let _e550 = srgb_1[2u];
                                                                    phi_3460_ = (max(_e546, max(_e548, _e550)) > 0.9411765f);
                                                                }
                                                                let _e555 = phi_3460_;
                                                                if _e555 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e556 = metal;
                                                                    let _e557 = luma;
                                                                    if (_e556 && (_e557 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e560 = luma;
                                                                        local_8 = vec3(_e560);
                                                                    }
                                                                    let _e562 = local_8;
                                                                    local_7 = _e562;
                                                                }
                                                                let _e563 = local_7;
                                                                local_6 = _e563;
                                                            }
                                                            let _e564 = local_6;
                                                            shown = _e564;
                                                        } else {
                                                            let _e565 = code;
                                                            if (_e565 == 16i) {
                                                                let _e568 = (*s).metallic;
                                                                m = _e568;
                                                                let _e569 = m;
                                                                let _e571 = m;
                                                                if ((_e569 > 0.05f) && (_e571 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e574 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e574 > 0.5f)));
                                                                }
                                                                let _e578 = local_9;
                                                                shown = _e578;
                                                            } else {
                                                                let _e579 = code;
                                                                if (_e579 == 17i) {
                                                                    let _e581 = normal_mapped;
                                                                    if !(_e581) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e583 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e583));
                                                                    }
                                                                    let _e586 = local_10;
                                                                    shown = _e586;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e587 = g_premultiply;
    if _e587 {
        let _e589 = (*s).alpha;
        local_11 = _e589;
    } else {
        local_11 = 1f;
    }
    let _e590 = local_11;
    weight_2 = _e590;
    let _e591 = shown;
    param_14 = _e591;
    let _e592 = SrgbToLinear_u0028_vf3_u003b((&param_14));
    let _e593 = weight_2;
    let _e594 = (_e592 * _e593);
    let _e596 = (*s).alpha;
    frag_color = vec4<f32>(_e594.x, _e594.y, _e594.z, _e596);
    let _e602 = (*s).roughness;
    param_15 = _e602;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_15));
    WriteWeightedBlended_u0028_();
    return true;
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e310 = (*alpha_3);
    let _e311 = (*alpha_3);
    a2_ = (_e310 * _e311);
    let _e313 = (*n_dot_l);
    let _e314 = (*n_dot_v);
    let _e315 = (*n_dot_v);
    let _e317 = a2_;
    let _e320 = a2_;
    lambda_v = (_e313 * sqrt((((_e314 * _e315) * (1f - _e317)) + _e320)));
    let _e324 = (*n_dot_v);
    let _e325 = (*n_dot_l);
    let _e326 = (*n_dot_l);
    let _e328 = a2_;
    let _e331 = a2_;
    lambda_l = (_e324 * sqrt((((_e325 * _e326) * (1f - _e328)) + _e331)));
    let _e335 = lambda_v;
    let _e336 = lambda_l;
    return (0.5f / max((_e335 + _e336), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_2: f32;

    let _e308 = (*n_dot_h);
    let _e309 = (*alpha_4);
    a = (_e308 * _e309);
    let _e311 = (*alpha_4);
    let _e312 = (*n_dot_h);
    let _e313 = (*n_dot_h);
    let _e316 = a;
    let _e317 = a;
    k_2 = (_e311 / max(((1f - (_e312 * _e313)) + (_e316 * _e317)), 0.0000001f));
    let _e322 = k_2;
    let _e323 = k_2;
    return ((_e322 * _e323) * 0.31830987f);
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle: f32;
    var local_12: vec3<f32>;

    let _e310 = (*a_1);
    let _e311 = (*b);
    axis = cross(_e310, _e311);
    let _e313 = axis;
    len = length(_e313);
    let _e315 = (*a_1);
    let _e316 = (*b);
    angle = acos(clamp(dot(_e315, _e316), -1f, 1f));
    let _e320 = len;
    if (_e320 > 0.000001f) {
        let _e322 = axis;
        let _e323 = angle;
        let _e324 = len;
        local_12 = (_e322 * (_e323 / (_e324 * 6.2831855f)));
    } else {
        local_12 = vec3<f32>(0f, 0f, 0f);
    }
    let _e328 = local_12;
    return _e328;
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e308 = (*x);
    let _e309 = (*y);
    inTable = ((vec2<f32>(_e308, _e309) * 0.984375f) + vec2(0.0078125f));
    let _e315 = inTable[0u];
    let _e317 = inTable[1u];
    let _e318 = (*table);
    return vec2<f32>(_e315, ((_e317 + _e318) * 0.5f));
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_2: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv_1: vec2<f32>;
    var inverse: vec4<f32>;
    var param_16: f32;
    var param_17: f32;
    var param_18: f32;
    var fit: vec4<f32>;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_13: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i: i32;
    var p: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: vec3<f32>;
    var param_25: vec3<f32>;
    var param_26: vec3<f32>;
    var param_27: vec3<f32>;
    var param_28: vec3<f32>;
    var param_29: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_14: f32;
    var sphere: f32;
    var param_30: f32;
    var param_31: f32;
    var param_32: f32;

    let _e342 = (*roughness_2);
    let _e344 = (*n_1);
    let _e345 = (*v);
    uv_1 = vec2<f32>(clamp(_e342, 0f, 1f), sqrt(clamp((1f - dot(_e344, _e345)), 0f, 1f)));
    let _e352 = uv_1[0u];
    param_16 = _e352;
    let _e354 = uv_1[1u];
    param_17 = _e354;
    param_18 = 0f;
    let _e355 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_16), (&param_17), (&param_18));
    let _e356 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e355, 0f);
    inverse = _e356;
    let _e358 = uv_1[0u];
    param_19 = _e358;
    let _e360 = uv_1[1u];
    param_20 = _e360;
    param_21 = 1f;
    let _e361 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21));
    let _e362 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e361, 0f);
    fit = _e362;
    let _e363 = (*v);
    let _e364 = (*n_1);
    let _e365 = (*v);
    let _e366 = (*n_1);
    along = (_e363 - (_e364 * dot(_e365, _e366)));
    let _e370 = along;
    alongLength = length(_e370);
    let _e372 = alongLength;
    if (_e372 > 0.00001f) {
        let _e374 = along;
        let _e375 = alongLength;
        local_13 = (_e374 / vec3(_e375));
    } else {
        let _e378 = (*n_1);
        let _e380 = (*n_1)[2u];
        local_13 = normalize(cross(_e378, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e380) < 0.999f)))));
    }
    let _e387 = local_13;
    t1_ = _e387;
    let _e388 = (*n_1);
    let _e389 = t1_;
    t2_ = cross(_e388, _e389);
    let _e392 = inverse[0u];
    let _e394 = inverse[1u];
    let _e395 = vec3<f32>(_e392, 0f, _e394);
    let _e397 = inverse[2u];
    let _e399 = inverse[3u];
    let _e400 = vec3<f32>(_e397, 0f, _e399);
    minv = mat3x3<f32>(vec3<f32>(_e395.x, _e395.y, _e395.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e400.x, _e400.y, _e400.z));
    i = 0i;
    loop {
        let _e414 = i;
        if (_e414 < 4i) {
            let _e416 = i;
            let _e418 = (*corners)[_e416];
            p = _e418;
            let _e419 = i;
            let _e420 = minv;
            let _e421 = p;
            let _e422 = t1_;
            let _e424 = p;
            let _e425 = t2_;
            let _e427 = p;
            let _e428 = (*n_1);
            l[_e419] = normalize((_e420 * vec3<f32>(dot(_e421, _e422), dot(_e424, _e425), dot(_e427, _e428))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e434 = i;
            i = (_e434 + 1i);
        }
    }
    let _e437 = l[0i];
    param_22 = _e437;
    let _e439 = l[1i];
    param_23 = _e439;
    let _e440 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_22), (&param_23));
    let _e442 = l[1i];
    param_24 = _e442;
    let _e444 = l[2i];
    param_25 = _e444;
    let _e445 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_24), (&param_25));
    let _e448 = l[2i];
    param_26 = _e448;
    let _e450 = l[3i];
    param_27 = _e450;
    let _e451 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_26), (&param_27));
    let _e454 = l[3i];
    param_28 = _e454;
    let _e456 = l[0i];
    param_29 = _e456;
    let _e457 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_28), (&param_29));
    f = -((((_e440 + _e445) + _e451) + _e457));
    let _e460 = f;
    len_1 = length(_e460);
    let _e462 = len_1;
    if (_e462 > 0.000000001f) {
        let _e465 = f[2u];
        let _e466 = len_1;
        local_14 = (_e465 / _e466);
    } else {
        local_14 = 0f;
    }
    let _e468 = local_14;
    z_1 = _e468;
    let _e469 = z_1;
    let _e472 = len_1;
    param_30 = ((_e469 * 0.5f) + 0.5f);
    param_31 = clamp(_e472, 0f, 1f);
    param_32 = 1f;
    let _e474 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_30), (&param_31), (&param_32));
    let _e475 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e474, 0f);
    sphere = _e475.w;
    let _e477 = len_1;
    let _e478 = sphere;
    let _e482 = fit[0u];
    let _e484 = fit[1u];
    return vec3<f32>(max((_e477 * _e478), 0f), _e482, _e484);
}

fn CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
    var ltc: vec3<f32>;
    var param_33: vec3<f32>;
    var param_34: vec3<f32>;
    var param_35: f32;
    var param_36: array<vec3<f32>, 4>;
    var lobe: f32;
    var alpha_5: f32;
    var n_dot_l_1: f32;
    var n_dot_h_1: f32;
    var d_1: f32;
    var param_37: f32;
    var param_38: f32;
    var vis: f32;
    var param_39: f32;
    var param_40: f32;
    var param_41: f32;
    var f_1: f32;

    let _e324 = (*light).integrated;
    if (_e324 > 0.5f) {
        let _e326 = g_coat_n;
        param_33 = _e326;
        let _e328 = (*s_1).v;
        param_34 = _e328;
        let _e329 = g_coat_roughness;
        param_35 = _e329;
        let _e330 = g_rect_corners;
        param_36 = _e330;
        let _e331 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_33), (&param_34), (&param_35), (&param_36));
        ltc = _e331;
        let _e333 = ltc[0u];
        let _e335 = ltc[1u];
        let _e338 = ltc[2u];
        let _e344 = frag_info.material[3u];
        let _e347 = (*light).n_dot_l;
        return (((_e333 * ((0.04f * _e335) + (0.96f * _e338))) * _e344) / max(_e347, 0.000001f));
    }
    let _e350 = g_coat_roughness;
    lobe = max(_e350, 0.045f);
    let _e352 = lobe;
    let _e353 = lobe;
    alpha_5 = (_e352 * _e353);
    let _e355 = g_coat_n;
    let _e357 = (*light).l;
    n_dot_l_1 = max(dot(_e355, _e357), 0f);
    let _e360 = g_coat_n;
    let _e362 = (*light).h;
    n_dot_h_1 = max(dot(_e360, _e362), 0f);
    let _e365 = n_dot_h_1;
    param_37 = _e365;
    let _e366 = alpha_5;
    param_38 = _e366;
    let _e367 = D_GGX_u0028_f1_u003b_f1_u003b((&param_37), (&param_38));
    d_1 = _e367;
    let _e368 = g_coat_n_dot_v;
    param_39 = _e368;
    let _e369 = n_dot_l_1;
    param_40 = _e369;
    let _e370 = alpha_5;
    param_41 = _e370;
    let _e371 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_39), (&param_40), (&param_41));
    vis = _e371;
    let _e373 = (*light).v_dot_h;
    f_1 = (0.04f + (0.96f * pow((1f - _e373), 5f)));
    let _e378 = d_1;
    let _e379 = vis;
    let _e381 = f_1;
    let _e385 = frag_info.material[3u];
    let _e387 = n_dot_l_1;
    let _e390 = (*light).n_dot_l;
    return (((((_e378 * _e379) * _e381) * _e385) * _e387) / max(_e390, 0.000001f));
}

fn V_Neubelt_u0028_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l_2: ptr<function, f32>) -> f32 {
    let _e306 = (*n_dot_l_2);
    let _e307 = (*n_dot_v_1);
    let _e309 = (*n_dot_l_2);
    let _e310 = (*n_dot_v_1);
    return (1f / (4f * ((_e306 + _e307) - (_e309 * _e310))));
}

fn D_Charlie_u0028_f1_u003b_f1_u003b(roughness_3: ptr<function, f32>, n_dot_h_2: ptr<function, f32>) -> f32 {
    var inv_alpha: f32;
    var sin2h: f32;

    let _e308 = (*roughness_3);
    let _e309 = (*roughness_3);
    inv_alpha = (1f / (_e308 * _e309));
    let _e312 = (*n_dot_h_2);
    let _e313 = (*n_dot_h_2);
    sin2h = max((1f - (_e312 * _e313)), 0.0078125f);
    let _e317 = inv_alpha;
    let _e319 = sin2h;
    let _e320 = inv_alpha;
    return (((2f + _e317) * pow(_e319, (_e320 * 0.5f))) / 6.2831855f);
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m_1: f32;
    var g: f32;

    let _e308 = (*mu);
    m_1 = (1f - _e308);
    let _e310 = m_1;
    let _e311 = m_1;
    let _e312 = m_1;
    let _e313 = m_1;
    g = (_e310 * (0.05710853f + (_e311 * (0.49188188f + (_e312 * (-0.33218145f + (_e313 * 0.071443f)))))));
    let _e321 = (*r);
    let _e322 = g;
    let _e325 = (*r);
    return ((1f + (_e321 * _e322)) / (1f + (0.2877934f * _e325)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e306 = (*rho);
    let _e307 = (*rho);
    let _e309 = (*average);
    let _e311 = (*rho);
    let _e312 = (*average);
    return (((_e306 * _e307) * _e309) / (vec3<f32>(1f, 1f, 1f) - (_e311 * (1f - _e312))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e305 = (*r_1);
    let _e308 = (*r_1);
    return ((1f + (0.07248821f * _e305)) / (1f + (0.2877934f * _e308)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s_2: f32;
    var s_over_t: f32;
    var local_15: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_42: f32;
    var multi: vec3<f32>;
    var param_43: vec3<f32>;
    var param_44: f32;
    var param_45: f32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;

    let _e323 = (*l_dot_v);
    let _e324 = (*mu_i);
    let _e325 = (*mu_o);
    s_2 = (_e323 - (_e324 * _e325));
    let _e328 = s_2;
    if (_e328 > 0f) {
        let _e330 = s_2;
        let _e331 = (*mu_i);
        let _e332 = (*mu_o);
        local_15 = (_e330 / max(_e331, _e332));
    } else {
        let _e335 = s_2;
        local_15 = _e335;
    }
    let _e336 = local_15;
    s_over_t = _e336;
    let _e337 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e337)));
    let _e341 = (*rho_1);
    let _e342 = af;
    let _e343 = (*r_2);
    let _e344 = s_over_t;
    single = (_e341 * (_e342 * (1f + (_e343 * _e344))));
    let _e349 = (*r_2);
    param_42 = _e349;
    let _e350 = FonAverage_u0028_f1_u003b((&param_42));
    average_1 = _e350;
    let _e351 = (*rho_1);
    param_43 = _e351;
    let _e352 = average_1;
    param_44 = _e352;
    let _e353 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_43), (&param_44));
    let _e354 = (*mu_o);
    param_45 = _e354;
    let _e355 = (*r_2);
    param_46 = _e355;
    let _e356 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_45), (&param_46));
    let _e359 = (*mu_i);
    param_47 = _e359;
    let _e360 = (*r_2);
    param_48 = _e360;
    let _e361 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_47), (&param_48));
    let _e365 = average_1;
    multi = (_e353 * ((max((1f - _e356), 0.0000001f) * max((1f - _e361), 0.0000001f)) / max((1f - _e365), 0.0000001f)));
    let _e370 = single;
    let _e371 = multi;
    return ((_e370 + _e371) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e306 = frag_info.ambient_sky[3u];
    return (_e306 > 0.5f);
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_49: f32;
    var param_50: f32;
    var param_51: f32;

    let _e310 = (*roughness_4);
    let _e312 = (*n_dot_v_2);
    param_49 = clamp(_e310, 0f, 1f);
    param_50 = sqrt(clamp((1f - _e312), 0f, 1f));
    param_51 = 1f;
    let _e316 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51));
    let _e317 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e316, 0f);
    dfg = _e317.xy;
    let _e320 = dfg[0u];
    let _e322 = dfg[1u];
    let _e325 = dfg[1u];
    return vec2<f32>((_e320 - _e322), _e325);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_3: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var ess: f32;

    let _e311 = (*s_3).roughness;
    param_52 = max(_e311, 0.045f);
    let _e314 = (*s_3).n_dot_v;
    param_53 = _e314;
    let _e315 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_52), (&param_53));
    ab = _e315;
    let _e317 = ab[0u];
    let _e319 = ab[1u];
    ess = max((_e317 + _e319), 0.0001f);
    let _e322 = (*f0_);
    let _e323 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e322 * ((1f / _e323) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e306 = frag_info.target_origin[2u];
    return (_e306 > 0.5f);
}

fn F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, f90_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f_2: f32;

    let _e308 = (*v_dot_h);
    f_2 = pow((1f - _e308), 5f);
    let _e311 = (*f0_1);
    let _e312 = (*f90_);
    let _e313 = (*f0_1);
    let _e315 = f_2;
    return (_e311 + ((_e312 - _e313) * _e315));
}

fn V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_l_3: ptr<function, f32>, n_dot_v_3: ptr<function, f32>, b_dot_v: ptr<function, f32>, t_dot_v: ptr<function, f32>, t_dot_l: ptr<function, f32>, b_dot_l: ptr<function, f32>, at: ptr<function, f32>, ab_1: ptr<function, f32>) -> f32 {
    var ggx_v: f32;
    var ggx_l: f32;

    let _e314 = (*n_dot_l_3);
    let _e315 = (*at);
    let _e316 = (*t_dot_v);
    let _e318 = (*ab_1);
    let _e319 = (*b_dot_v);
    let _e321 = (*n_dot_v_3);
    ggx_v = (_e314 * length(vec3<f32>((_e315 * _e316), (_e318 * _e319), _e321)));
    let _e325 = (*n_dot_v_3);
    let _e326 = (*at);
    let _e327 = (*t_dot_l);
    let _e329 = (*ab_1);
    let _e330 = (*b_dot_l);
    let _e332 = (*n_dot_l_3);
    ggx_l = (_e325 * length(vec3<f32>((_e326 * _e327), (_e329 * _e330), _e332)));
    let _e336 = ggx_v;
    let _e337 = ggx_l;
    return clamp((0.5f / max((_e336 + _e337), 0.00001f)), 0f, 1f);
}

fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3: ptr<function, f32>, t_dot_h: ptr<function, f32>, b_dot_h: ptr<function, f32>, at_1: ptr<function, f32>, ab_2: ptr<function, f32>) -> f32 {
    var a2_1: f32;
    var f_3: vec3<f32>;
    var w2_: f32;

    let _e312 = (*at_1);
    let _e313 = (*ab_2);
    a2_1 = (_e312 * _e313);
    let _e315 = (*ab_2);
    let _e316 = (*t_dot_h);
    let _e318 = (*at_1);
    let _e319 = (*b_dot_h);
    let _e321 = a2_1;
    let _e322 = (*n_dot_h_3);
    f_3 = vec3<f32>((_e315 * _e316), (_e318 * _e319), (_e321 * _e322));
    let _e325 = a2_1;
    let _e326 = f_3;
    let _e327 = f_3;
    w2_ = (_e325 / max(dot(_e326, _e327), 0.000000000001f));
    let _e331 = a2_1;
    let _e332 = w2_;
    let _e334 = w2_;
    return (((_e331 * _e332) * _e334) / 3.1415927f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_4: ptr<function, Surface>, light_1: ptr<function, LightSample>) -> vec3<f32> {
    var lobe_1: f32;
    var alpha_6: f32;
    var f0_2: vec3<f32>;
    var f90_1: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_2: f32;
    var param_54: f32;
    var param_55: f32;
    var vis_1: f32;
    var param_56: f32;
    var param_57: f32;
    var param_58: f32;
    var at_2: f32;
    var ab_3: f32;
    var param_59: f32;
    var param_60: f32;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;
    var param_64: f32;
    var param_65: f32;
    var param_66: f32;
    var param_67: f32;
    var param_68: f32;
    var param_69: f32;
    var param_70: f32;
    var param_71: f32;
    var f_4: vec3<f32>;
    var param_72: vec3<f32>;
    var param_73: vec3<f32>;
    var param_74: f32;
    var specular: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: Surface;
    var diffuse: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: f32;
    var param_79: f32;
    var param_80: f32;
    var param_81: f32;
    var sheen: vec3<f32>;
    var param_82: f32;
    var param_83: f32;
    var param_84: f32;
    var param_85: f32;
    var param_86: Surface;
    var param_87: LightSample;

    let _e354 = (*s_4).roughness;
    lobe_1 = max(_e354, 0.045f);
    let _e356 = lobe_1;
    let _e357 = lobe_1;
    alpha_6 = (_e356 * _e357);
    let _e359 = g_f0_dielectric;
    let _e361 = (*s_4).albedo;
    let _e363 = (*s_4).metallic;
    f0_2 = mix(_e359, _e361, vec3(_e363));
    let _e366 = g_f90_;
    let _e368 = (*s_4).metallic;
    f90_1 = vec3(mix(_e366, 1f, _e368));
    let _e372 = (*s_4).albedo;
    let _e374 = (*s_4).metallic;
    diffuseColor = (_e372 * (1f - _e374));
    let _e378 = (*light_1).n_dot_h;
    param_54 = _e378;
    let _e379 = alpha_6;
    param_55 = _e379;
    let _e380 = D_GGX_u0028_f1_u003b_f1_u003b((&param_54), (&param_55));
    d_2 = _e380;
    let _e382 = (*s_4).n_dot_v;
    param_56 = _e382;
    let _e384 = (*light_1).n_dot_l;
    param_57 = _e384;
    let _e385 = alpha_6;
    param_58 = _e385;
    let _e386 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
    vis_1 = _e386;
    let _e387 = g_aniso;
    if (_e387 > 0f) {
        let _e389 = alpha_6;
        let _e390 = g_aniso;
        let _e391 = g_aniso;
        at_2 = mix(_e389, 1f, (_e390 * _e391));
        let _e394 = alpha_6;
        ab_3 = max(_e394, 0.001f);
        let _e396 = g_aniso_t;
        let _e398 = (*light_1).h;
        let _e400 = g_aniso_b;
        let _e402 = (*light_1).h;
        let _e405 = (*light_1).n_dot_h;
        param_59 = _e405;
        param_60 = dot(_e396, _e398);
        param_61 = dot(_e400, _e402);
        let _e406 = at_2;
        param_62 = _e406;
        let _e407 = ab_3;
        param_63 = _e407;
        let _e408 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_59), (&param_60), (&param_61), (&param_62), (&param_63));
        d_2 = _e408;
        let _e409 = g_aniso_b;
        let _e411 = (*s_4).v;
        let _e413 = g_aniso_t;
        let _e415 = (*s_4).v;
        let _e417 = g_aniso_t;
        let _e419 = (*light_1).l;
        let _e421 = g_aniso_b;
        let _e423 = (*light_1).l;
        let _e426 = (*light_1).n_dot_l;
        param_64 = _e426;
        let _e428 = (*s_4).n_dot_v;
        param_65 = _e428;
        param_66 = dot(_e409, _e411);
        param_67 = dot(_e413, _e415);
        param_68 = dot(_e417, _e419);
        param_69 = dot(_e421, _e423);
        let _e429 = at_2;
        param_70 = _e429;
        let _e430 = ab_3;
        param_71 = _e430;
        let _e431 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_64), (&param_65), (&param_66), (&param_67), (&param_68), (&param_69), (&param_70), (&param_71));
        vis_1 = _e431;
    }
    let _e432 = f0_2;
    param_72 = _e432;
    let _e433 = f90_1;
    param_73 = _e433;
    let _e435 = (*light_1).v_dot_h;
    param_74 = _e435;
    let _e436 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_72), (&param_73), (&param_74));
    f_4 = _e436;
    let _e437 = f_4;
    let _e438 = g_irid_fresnel;
    let _e439 = g_iridescence;
    f_4 = mix(_e437, _e438, vec3(_e439));
    let _e442 = d_2;
    let _e443 = vis_1;
    let _e445 = f_4;
    let _e449 = frag_info.material[3u];
    specular = ((_e445 * (_e442 * _e443)) * _e449);
    let _e452 = (*light_1).integrated;
    if (_e452 > 0.5f) {
        let _e456 = (*light_1).ltc[0u];
        let _e457 = f0_2;
        let _e460 = (*light_1).ltc[1u];
        let _e462 = f90_1;
        let _e463 = f0_2;
        let _e467 = (*light_1).ltc[2u];
        let _e473 = frag_info.material[3u];
        let _e476 = (*light_1).n_dot_l;
        specular = (((((_e457 * _e460) + ((_e462 - _e463) * _e467)) * _e456) * _e473) / vec3(max(_e476, 0.000001f)));
    }
    let _e480 = EnergyCompensation_u0028_();
    if _e480 {
        let _e481 = f0_2;
        param_75 = _e481;
        let _e482 = (*s_4);
        param_76 = _e482;
        let _e483 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_75), (&param_76));
        let _e484 = specular;
        specular = (_e484 * _e483);
    }
    let _e486 = diffuseColor;
    let _e487 = f_4;
    diffuse = ((_e486 * (vec3<f32>(1f, 1f, 1f) - _e487)) / vec3(3.1415927f));
    let _e492 = EonDiffuse_u0028_();
    if _e492 {
        let _e494 = (*s_4).n;
        let _e496 = (*light_1).l;
        let _e500 = (*light_1).l;
        let _e502 = (*s_4).v;
        let _e504 = diffuseColor;
        param_77 = _e504;
        let _e506 = (*s_4).roughness;
        param_78 = _e506;
        param_79 = clamp(dot(_e494, _e496), 0.0001f, 1f);
        let _e508 = (*s_4).n_dot_v;
        param_80 = _e508;
        param_81 = dot(_e500, _e502);
        let _e509 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_77), (&param_78), (&param_79), (&param_80), (&param_81));
        let _e510 = f_4;
        diffuse = (_e509 * (vec3<f32>(1f, 1f, 1f) - _e510));
    }
    let _e513 = g_transmission;
    let _e515 = diffuse;
    diffuse = (_e515 * (1f - _e513));
    let _e517 = g_sheen;
    let _e518 = g_sheen_roughness;
    param_82 = _e518;
    let _e520 = (*light_1).n_dot_h;
    param_83 = _e520;
    let _e521 = D_Charlie_u0028_f1_u003b_f1_u003b((&param_82), (&param_83));
    let _e524 = (*s_4).n;
    let _e526 = (*light_1).l;
    let _e530 = (*s_4).n_dot_v;
    param_84 = _e530;
    param_85 = clamp(dot(_e524, _e526), 0f, 1f);
    let _e531 = V_Neubelt_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    sheen = ((_e517 * _e521) * _e531);
    let _e533 = diffuse;
    let _e534 = specular;
    let _e536 = g_sheen_scale;
    let _e538 = sheen;
    let _e540 = g_coat_through;
    let _e542 = g_coat;
    let _e543 = (*s_4);
    param_86 = _e543;
    let _e544 = (*light_1);
    param_87 = _e544;
    let _e545 = CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_86), (&param_87));
    return ((((((_e533 + _e534) * _e536) + _e538) * _e540) + vec3((_e542 * _e545))) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
    let _e305 = (*i_1);
    if (_e305 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e307 = (*i_1);
    if (_e307 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e309 = (*i_1);
    if (_e309 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e311 = (*i_1);
    if (_e311 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e313 = (*i_1);
    if (_e313 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e315 = (*i_1);
    if (_e315 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e317 = (*i_1);
    if (_e317 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_2: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p_1: vec2<f32>;
    var param_88: i32;

    let _e310 = (*i_2);
    param_88 = _e310;
    let _e311 = PointShadowDiskTap_u0028_i1_u003b((&param_88));
    p_1 = _e311;
    let _e313 = p_1[0u];
    let _e314 = (*ca);
    let _e317 = p_1[1u];
    let _e318 = (*sa);
    let _e322 = p_1[0u];
    let _e323 = (*sa);
    let _e326 = p_1[1u];
    let _e327 = (*ca);
    let _e331 = (*radius);
    return (vec2<f32>(((_e313 * _e314) - (_e317 * _e318)), ((_e322 * _e323) + (_e326 * _e327))) * _e331);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_16: vec2<f32>;
    var atlas: vec2<f32>;

    let _e313 = point_shadow.params[0u];
    inset = _e313;
    let _e314 = (*uv_2);
    let _e315 = (*offset);
    let _e317 = inset;
    let _e318 = inset;
    local_16 = clamp((_e314 + _e315), vec2(_e317), vec2((1f - _e318)));
    let _e323 = local_16;
    let _e324 = (*tile);
    atlas = ((_e323 + _e324) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e329 = point_shadow.params3_[0u];
    if (_e329 > 0.5f) {
        let _e332 = atlas[1u];
        atlas[1u] = (1f - _e332);
    }
    let _e335 = atlas;
    let _e336 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e335, 0f);
    let _e338 = atlas;
    let _e339 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e338, 0f);
    let _e342 = (*range);
    return (min(_e336.x, _e339.x) * _e342);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_89: vec2<f32>;
    var param_90: vec2<f32>;
    var param_91: vec2<f32>;
    var param_92: f32;

    let _e314 = (*uv_3);
    param_89 = _e314;
    let _e315 = (*offset_1);
    param_90 = _e315;
    let _e316 = (*tile_1);
    param_91 = _e316;
    let _e317 = (*range_1);
    param_92 = _e317;
    let _e318 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_89), (&param_90), (&param_91), (&param_92));
    stored = _e318;
    let _e319 = stored;
    let _e320 = (*range_1);
    if (_e319 >= (_e320 * 0.999f)) {
        return 1f;
    }
    let _e323 = (*receiver);
    let _e324 = stored;
    return select(1f, 0f, (_e323 > _e324));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_4: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_93: vec2<f32>;
    var param_94: vec2<f32>;
    var param_95: vec2<f32>;
    var param_96: f32;
    var sum: f32;
    var count: f32;
    var i_3: i32;
    var stored_1: f32;
    var param_97: i32;
    var param_98: f32;
    var param_99: f32;
    var param_100: f32;
    var param_101: vec2<f32>;
    var param_102: vec2<f32>;
    var param_103: vec2<f32>;
    var param_104: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e335 = point_shadow.params2_[1u];
    lightRadius = _e335;
    let _e338 = point_shadow.params2_[0u];
    minRadius = _e338;
    let _e341 = point_shadow.params2_[2u];
    maxRadius = _e341;
    let _e342 = lightRadius;
    if (_e342 <= 0f) {
        let _e344 = (*uv_4);
        param_93 = _e344;
        param_94 = vec2<f32>(0f, 0f);
        let _e345 = (*tile_2);
        param_95 = _e345;
        let _e346 = (*range_2);
        param_96 = _e346;
        let _e347 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_93), (&param_94), (&param_95), (&param_96));
        (*blockerOut) = _e347;
        let _e348 = minRadius;
        return _e348;
    }
    sum = 0f;
    count = 0f;
    i_3 = 0i;
    loop {
        let _e349 = i_3;
        if (_e349 < 8i) {
            let _e351 = i_3;
            param_97 = _e351;
            let _e352 = (*ca_1);
            param_98 = _e352;
            let _e353 = (*sa_1);
            param_99 = _e353;
            let _e354 = maxRadius;
            param_100 = _e354;
            let _e355 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_97), (&param_98), (&param_99), (&param_100));
            let _e356 = (*uv_4);
            param_101 = _e356;
            param_102 = _e355;
            let _e357 = (*tile_2);
            param_103 = _e357;
            let _e358 = (*range_2);
            param_104 = _e358;
            let _e359 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_101), (&param_102), (&param_103), (&param_104));
            stored_1 = _e359;
            let _e360 = stored_1;
            let _e361 = (*range_2);
            if (_e360 >= (_e361 * 0.999f)) {
                continue;
            }
            let _e364 = stored_1;
            let _e365 = (*receiver_1);
            if (_e364 >= _e365) {
                continue;
            }
            let _e367 = stored_1;
            let _e368 = sum;
            sum = (_e368 + _e367);
            let _e370 = count;
            count = (_e370 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e372 = i_3;
            i_3 = (_e372 + 1i);
        }
    }
    let _e374 = count;
    if (_e374 < 0.5f) {
        return -1f;
    }
    let _e376 = sum;
    let _e377 = count;
    blocker = max((_e376 / _e377), 0.0001f);
    let _e380 = blocker;
    (*blockerOut) = _e380;
    let _e381 = lightRadius;
    let _e382 = (*receiver_1);
    let _e383 = blocker;
    let _e387 = blocker;
    world = ((_e381 * max((_e382 - _e383), 0f)) / _e387);
    let _e389 = world;
    let _e390 = (*receiver_1);
    let _e392 = (*tanHalf);
    let _e395 = minRadius;
    let _e396 = maxRadius;
    return clamp((_e389 / ((2f * _e390) * _e392)), _e395, _e396);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_17: vec2<f32>;

    let _e306 = (*rows);
    if (_e306 > 0f) {
        let _e309 = gl_FragCoord_1[0u];
        let _e310 = (*rows);
        let _e312 = gl_FragCoord_1[1u];
        local_17 = vec2<f32>(_e309, (_e310 - _e312));
    } else {
        let _e315 = gl_FragCoord_1;
        local_17 = _e315.xy;
    }
    let _e317 = local_17;
    return _e317;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot_1: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_2: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_5: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_105: f32;
    var angle_1: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_106: vec2<f32>;
    var param_107: vec2<f32>;
    var param_108: f32;
    var param_109: f32;
    var param_110: f32;
    var param_111: f32;
    var param_112: f32;
    var param_113: f32;
    var local_18: vec3<f32>;
    var lit_1: f32;
    var param_114: vec2<f32>;
    var param_115: vec2<f32>;
    var param_116: vec2<f32>;
    var param_117: f32;
    var param_118: f32;
    var i_4: i32;
    var param_119: i32;
    var param_120: f32;
    var param_121: f32;
    var param_122: f32;
    var param_123: vec2<f32>;
    var param_124: vec2<f32>;
    var param_125: vec2<f32>;
    var param_126: f32;
    var param_127: f32;
    var phi_2789_: bool;
    var phi_2850_: bool;

    let _e358 = (*lightIndex);
    let _e362 = point_shadow.slots[_e358][0u];
    slot_1 = i32((_e362 + 0.5f));
    let _e365 = (*lightIndex);
    let _e369 = point_shadow.slots[_e365][0u];
    if (_e369 < 0f) {
        return 1f;
    }
    let _e373 = point_shadow.params[2u];
    strength = _e373;
    let _e374 = strength;
    if (_e374 <= 0f) {
        return 1f;
    }
    let _e376 = slot_1;
    let _e379 = point_shadow.lights[_e376];
    let _e381 = (*world_1);
    toLight = (_e379.xyz - _e381);
    let _e383 = toLight;
    toLightLength = max(length(_e383), 0.000001f);
    let _e386 = (*normal);
    let _e387 = toLight;
    let _e388 = toLightLength;
    nDotL = max(dot(_e386, (_e387 / vec3(_e388))), 0.15f);
    let _e393 = nDotL;
    let _e394 = nDotL;
    let _e399 = nDotL;
    let _e400 = nDotL;
    slope = min((sqrt(max((1f - (_e393 * _e394)), 0f)) / (_e399 * _e400)), 8f);
    let _e404 = toLightLength;
    let _e406 = (*lightIndex);
    let _e410 = point_shadow.slots[_e406][2u];
    let _e415 = point_shadow.params3_[1u];
    texel = (((2f * _e404) * max(_e410, 0.0001f)) * _e415);
    let _e417 = (*world_1);
    let _e418 = (*normal);
    let _e419 = texel;
    let _e423 = point_shadow.params[3u];
    let _e425 = slope;
    origin = (_e417 + (((_e418 * _e419) * _e423) * (1f + _e425)));
    let _e429 = origin;
    let _e430 = slot_1;
    let _e433 = point_shadow.lights[_e430];
    toFragment = (_e429 - _e433.xyz);
    let _e436 = toFragment;
    distance_ = length(_e436);
    let _e438 = slot_1;
    let _e442 = point_shadow.lights[_e438][3u];
    range_3 = max(_e442, 0.0001f);
    let _e444 = distance_;
    let _e445 = range_3;
    if (_e444 >= _e445) {
        return 1f;
    }
    face = 0i;
    let _e447 = (*lightIndex);
    let _e451 = point_shadow.slots[_e447][1u];
    if (_e451 < 0.5f) {
        let _e453 = toFragment;
        a_2 = abs(_e453);
        let _e456 = a_2[0u];
        let _e458 = a_2[1u];
        let _e459 = (_e456 >= _e458);
        phi_2789_ = _e459;
        if _e459 {
            let _e461 = a_2[0u];
            let _e463 = a_2[2u];
            phi_2789_ = (_e461 >= _e463);
        }
        let _e466 = phi_2789_;
        if _e466 {
            let _e468 = toFragment[0u];
            face = select(1i, 0i, (_e468 > 0f));
        } else {
            let _e472 = a_2[1u];
            let _e474 = a_2[2u];
            if (_e472 >= _e474) {
                let _e477 = toFragment[1u];
                face = select(3i, 2i, (_e477 > 0f));
            } else {
                let _e481 = toFragment[2u];
                face = select(5i, 4i, (_e481 > 0f));
            }
        }
    }
    let _e484 = slot_1;
    let _e486 = face;
    let _e490 = point_shadow.faces[((_e484 * 6i) + _e486)];
    let _e491 = origin;
    clip = (_e490 * vec4<f32>(_e491.x, _e491.y, _e491.z, 1f));
    let _e498 = clip[3u];
    if (_e498 <= 0f) {
        return 1f;
    }
    let _e500 = clip;
    let _e503 = clip[3u];
    ndc = (_e500.xy / vec2(_e503));
    let _e507 = ndc[0u];
    let _e509 = (abs(_e507) > 1f);
    phi_2850_ = _e509;
    if !(_e509) {
        let _e512 = ndc[1u];
        phi_2850_ = (abs(_e512) > 1f);
    }
    let _e516 = phi_2850_;
    if _e516 {
        return 1f;
    }
    let _e518 = ndc[0u];
    let _e522 = ndc[1u];
    uv_5 = vec2<f32>(((_e518 * 0.5f) + 0.5f), (0.5f - (_e522 * 0.5f)));
    let _e526 = face;
    let _e528 = slot_1;
    tile_3 = vec2<f32>(f32(_e526), f32(_e528));
    let _e531 = distance_;
    let _e534 = point_shadow.params[1u];
    receiver_2 = (_e531 - _e534);
    let _e538 = frag_info.target_origin[0u];
    param_105 = _e538;
    let _e539 = FragCoordFromTop_u0028_f1_u003b((&param_105));
    noise = fract((52.982918f * fract(dot(_e539, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e544 = noise;
    angle_1 = (_e544 * 6.2831855f);
    let _e546 = angle_1;
    ca_2 = cos(_e546);
    let _e548 = angle_1;
    sa_2 = sin(_e548);
    let _e550 = (*lightIndex);
    let _e554 = point_shadow.slots[_e550][2u];
    tanHalf_1 = max(_e554, 0.0001f);
    blocker_1 = -1f;
    let _e556 = uv_5;
    param_106 = _e556;
    let _e557 = tile_3;
    param_107 = _e557;
    let _e558 = range_3;
    param_108 = _e558;
    let _e559 = receiver_2;
    param_109 = _e559;
    let _e560 = ca_2;
    param_110 = _e560;
    let _e561 = sa_2;
    param_111 = _e561;
    let _e562 = tanHalf_1;
    param_112 = _e562;
    let _e563 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_106), (&param_107), (&param_108), (&param_109), (&param_110), (&param_111), (&param_112), (&param_113));
    let _e564 = param_113;
    blocker_1 = _e564;
    radius_1 = _e563;
    let _e567 = point_shadow.params2_[3u];
    if (_e567 > 0.5f) {
        g_debug_surface_on = true;
        let _e569 = radius_1;
        if (_e569 < 0f) {
            local_18 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e571 = radius_1;
            let _e574 = point_shadow.params2_[2u];
            let _e578 = blocker_1;
            let _e579 = range_3;
            local_18 = vec3<f32>(clamp((_e571 / max(_e574, 0.000001f)), 0f, 1f), clamp((_e578 / _e579), 0f, 1f), 0f);
        }
        let _e583 = local_18;
        g_debug_surface = _e583;
    }
    let _e584 = radius_1;
    if (_e584 < 0f) {
        return 1f;
    }
    let _e586 = uv_5;
    param_114 = _e586;
    param_115 = vec2<f32>(0f, 0f);
    let _e587 = tile_3;
    param_116 = _e587;
    let _e588 = range_3;
    param_117 = _e588;
    let _e589 = receiver_2;
    param_118 = _e589;
    let _e590 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_114), (&param_115), (&param_116), (&param_117), (&param_118));
    lit_1 = _e590;
    let _e591 = radius_1;
    if (_e591 > 0f) {
        i_4 = 0i;
        loop {
            let _e593 = i_4;
            if (_e593 < 8i) {
                let _e595 = i_4;
                param_119 = _e595;
                let _e596 = ca_2;
                param_120 = _e596;
                let _e597 = sa_2;
                param_121 = _e597;
                let _e598 = radius_1;
                param_122 = _e598;
                let _e599 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_119), (&param_120), (&param_121), (&param_122));
                let _e600 = uv_5;
                param_123 = _e600;
                param_124 = _e599;
                let _e601 = tile_3;
                param_125 = _e601;
                let _e602 = range_3;
                param_126 = _e602;
                let _e603 = receiver_2;
                param_127 = _e603;
                let _e604 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_123), (&param_124), (&param_125), (&param_126), (&param_127));
                let _e605 = lit_1;
                lit_1 = (_e605 + _e604);
                continue;
            } else {
                break;
            }
            continuing {
                let _e607 = i_4;
                i_4 = (_e607 + 1i);
            }
        }
        let _e609 = lit_1;
        lit_1 = (_e609 * 0.11111111f);
    }
    let _e611 = lit_1;
    let _e612 = strength;
    return mix(1f, _e611, clamp(_e612, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_5: ptr<function, i32>, n_2: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e309 = (*i_5);
    let _e312 = (*n_2);
    r_3 = sqrt(((f32(_e309) + 0.5f) / f32(_e312)));
    let _e316 = (*i_5);
    let _e319 = (*turn);
    theta = ((f32(_e316) * 2.3999631f) + _e319);
    let _e321 = r_3;
    let _e322 = theta;
    let _e324 = theta;
    return (vec2<f32>(cos(_e322), sin(_e324)) * _e321);
}

fn ShadowNoise_u0028_() -> f32 {
    var at_3: vec2<f32>;
    var param_128: f32;

    let _e308 = frag_info.target_origin[0u];
    param_128 = _e308;
    let _e309 = FragCoordFromTop_u0028_f1_u003b((&param_128));
    let _e312 = frag_info.target_origin[3u];
    at_3 = (_e309 + vec2((5.588238f * max(_e312, 0f))));
    let _e317 = at_3;
    return fract((52.982918f * fract(dot(_e317, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_19: f32;

    let _e307 = (*mode_1);
    if (_e307 > 0.5f) {
        let _e309 = (*stored_2);
        local_19 = (1f - _e309);
    } else {
        let _e311 = (*stored_2);
        local_19 = _e311;
    }
    let _e312 = local_19;
    return _e312;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_3: f32;
    var pMax: f32;
    var reduced: f32;

    let _e313 = (*moments)[1u];
    let _e315 = (*moments)[0u];
    let _e317 = (*moments)[0u];
    let _e320 = (*minVariance);
    variance = max((_e313 - (_e315 * _e317)), _e320);
    let _e322 = (*t);
    let _e324 = (*moments)[0u];
    d_3 = (_e322 - _e324);
    let _e326 = variance;
    let _e327 = variance;
    let _e328 = d_3;
    let _e329 = d_3;
    pMax = (_e326 / (_e327 + (_e328 * _e329)));
    let _e333 = pMax;
    let _e334 = (*bleed);
    let _e336 = (*bleed);
    reduced = clamp(((_e333 - _e334) / max((1f - _e336), 0.0001f)), 0f, 1f);
    let _e341 = (*t);
    let _e343 = (*moments)[0u];
    let _e345 = reduced;
    return select(_e345, 1f, (_e341 <= _e343));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_4: f32;

    let _e306 = (*depth);
    d_4 = ((2f * clamp(_e306, 0f, 1f)) - 1f);
    let _e310 = d_4;
    let _e313 = d_4;
    return vec2<f32>(exp((40f * _e310)), -(exp((-5f * _e313))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_129: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_130: vec2<f32>;
    var param_131: f32;
    var param_132: f32;
    var param_133: f32;
    var negative: f32;
    var param_134: vec2<f32>;
    var param_135: f32;
    var param_136: f32;
    var param_137: f32;

    let _e320 = (*depth_1);
    param_129 = _e320;
    let _e321 = EvsmWarp_u0028_f1_u003b((&param_129));
    warped = _e321;
    let _e322 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e322);
    let _e325 = scale[0u];
    let _e327 = scale[0u];
    let _e329 = (*moments_1);
    param_130 = _e329.xy;
    let _e332 = warped[0u];
    param_131 = _e332;
    param_132 = (_e325 * _e327);
    let _e333 = (*bleed_1);
    param_133 = _e333;
    let _e334 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_130), (&param_131), (&param_132), (&param_133));
    positive = _e334;
    let _e336 = scale[1u];
    let _e338 = scale[1u];
    let _e340 = (*moments_1);
    param_134 = _e340.zw;
    let _e343 = warped[1u];
    param_135 = _e343;
    param_136 = (_e336 * _e338);
    let _e344 = (*bleed_1);
    param_137 = _e344;
    let _e345 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_134), (&param_135), (&param_136), (&param_137));
    negative = _e345;
    let _e346 = positive;
    let _e347 = negative;
    return min(_e346, _e347);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e306 = (*depth_2);
    stored_3 = max((1f - _e306), 0.000061035156f);
    let _e309 = stored_3;
    return exp2((floor(log2(_e309)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_2: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_20: f32;
    var cascade: i32;
    var uv_6: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var local_22: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_23: f32;
    var local_24: f32;
    var storage_: f32;
    var param_138: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_139: vec4<f32>;
    var param_140: f32;
    var param_141: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_142: f32;
    var param_143: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_6: i32;
    var disc: vec2<f32>;
    var param_144: i32;
    var param_145: i32;
    var param_146: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_147: f32;
    var param_148: f32;
    var gap: f32;
    var radius_2: f32;
    var i_7: i32;
    var disc_1: vec2<f32>;
    var param_149: i32;
    var param_150: i32;
    var param_151: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_152: f32;
    var param_153: f32;
    var phi_4546_: bool;
    var phi_4557_: bool;
    var phi_4714_: bool;
    var phi_4721_: bool;
    var phi_4728_: bool;

    let _e385 = frag_info.shadow_params[3u];
    strength_1 = _e385;
    let _e386 = strength_1;
    if (_e386 <= 0f) {
        return 1f;
    }
    let _e388 = (*lightIndex_1);
    let _e391 = frag_info.frame_params[2u];
    if (_e388 != i32(floor((_e391 + 0.5f)))) {
        return 1f;
    }
    let _e398 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e398 + 0.5f));
    let _e401 = Orthographic_u0028_();
    if _e401 {
        let _e402 = ViewDepth_u0028_();
        local_20 = _e402;
    } else {
        let _e403 = v_world_position_1;
        let _e405 = frag_info.camera_position;
        local_20 = length((_e403 - _e405.xyz));
    }
    let _e409 = local_20;
    viewDistance = _e409;
    cascade = 0i;
    let _e410 = cascadeCount;
    let _e411 = (_e410 > 1i);
    phi_4546_ = _e411;
    if _e411 {
        let _e412 = viewDistance;
        let _e415 = frag_info.shadow_cascades[0u];
        phi_4546_ = (_e412 > _e415);
    }
    let _e418 = phi_4546_;
    if _e418 {
        cascade = 1i;
    }
    let _e419 = cascadeCount;
    let _e420 = (_e419 > 2i);
    phi_4557_ = _e420;
    if _e420 {
        let _e421 = viewDistance;
        let _e424 = frag_info.shadow_cascades[1u];
        phi_4557_ = (_e421 > _e424);
    }
    let _e427 = phi_4557_;
    if _e427 {
        cascade = 2i;
    }
    uv_6 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e428 = attempt;
        if (_e428 < 3i) {
            let _e430 = cascade;
            let _e431 = attempt;
            which = (_e430 + _e431);
            let _e433 = which;
            let _e434 = cascadeCount;
            if (_e433 >= _e434) {
                break;
            }
            let _e436 = which;
            if (_e436 == 0i) {
                let _e439 = frag_info.shadow_matrix;
                local_21 = _e439;
            } else {
                let _e440 = which;
                if (_e440 == 1i) {
                    let _e443 = frag_info.shadow_matrix_far;
                    local_22 = _e443;
                } else {
                    let _e445 = frag_info.shadow_matrix_farthest;
                    local_22 = _e445;
                }
                let _e446 = local_22;
                local_21 = _e446;
            }
            let _e447 = local_21;
            matrix = _e447;
            let _e450 = matrix[0][0u];
            let _e453 = matrix[1][0u];
            let _e456 = matrix[2][0u];
            axisX = vec3<f32>(_e450, _e453, _e456);
            let _e460 = matrix[0][1u];
            let _e463 = matrix[1][1u];
            let _e466 = matrix[2][1u];
            axisY = vec3<f32>(_e460, _e463, _e466);
            let _e468 = axisX;
            rowX = max(length(_e468), 0.000001f);
            let _e471 = axisY;
            rowY = max(length(_e471), 0.000001f);
            let _e476 = frag_info.shadow_cascades[3u];
            let _e478 = rowX;
            texelMetres = ((2f * _e476) / _e478);
            let _e482 = frag_info.shadow_cascades[3u];
            let _e485 = (*s_5).n;
            let _e486 = axisX;
            let _e489 = rowX;
            let _e490 = rowX;
            let _e494 = (*s_5).n;
            let _e495 = axisY;
            let _e498 = rowY;
            let _e499 = rowY;
            reach = ((3f * _e482) * ((abs(dot(_e485, _e486)) / (_e489 * _e490)) + (abs(dot(_e494, _e495)) / (_e498 * _e499))));
            let _e506 = frag_info.shadow_params[2u];
            let _e507 = texelMetres;
            flatOffset = min(_e506, _e507);
            let _e509 = v_world_position_1;
            let _e511 = (*s_5).n;
            let _e512 = flatOffset;
            let _e513 = reach;
            origin_1 = (_e509 + (_e511 * (_e512 + _e513)));
            let _e517 = matrix;
            let _e518 = origin_1;
            lightSpace = (_e517 * vec4<f32>(_e518.x, _e518.y, _e518.z, 1f));
            let _e525 = lightSpace[3u];
            if (_e525 <= 0f) {
                continue;
            }
            let _e527 = lightSpace;
            let _e530 = lightSpace[3u];
            candidate = (_e527.xyz / vec3(_e530));
            let _e534 = candidate[0u];
            let _e538 = candidate[1u];
            inTile = vec2<f32>(((_e534 * 0.5f) + 0.5f), (0.5f - (_e538 * 0.5f)));
            let _e543 = inTile[0u];
            let _e544 = (_e543 < 0f);
            phi_4714_ = _e544;
            if !(_e544) {
                let _e547 = inTile[0u];
                phi_4714_ = (_e547 > 1f);
            }
            let _e550 = phi_4714_;
            phi_4721_ = _e550;
            if !(_e550) {
                let _e553 = inTile[1u];
                phi_4721_ = (_e553 < 0f);
            }
            let _e556 = phi_4721_;
            phi_4728_ = _e556;
            if !(_e556) {
                let _e559 = inTile[1u];
                phi_4728_ = (_e559 > 1f);
            }
            let _e562 = phi_4728_;
            if _e562 {
                continue;
            }
            let _e564 = candidate[2u];
            if (_e564 > 1f) {
                let _e566 = which;
                let _e567 = cascadeCount;
                if (_e566 < (_e567 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e572 = inTile[0u];
            let _e573 = which;
            let _e576 = cascadeCount;
            let _e580 = inTile[1u];
            uv_6 = vec2<f32>(((_e572 + f32(_e573)) / f32(_e576)), _e580);
            let _e582 = candidate;
            projected = _e582;
            let _e583 = which;
            cascade = _e583;
            let _e584 = texelMetres;
            cascadeTexel = _e584;
            let _e587 = matrix[0][2u];
            let _e590 = matrix[1][2u];
            let _e593 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e587, _e590, _e593)), 0.000001f));
            let _e599 = (*s_5).n;
            let _e602 = matrix[0][2u];
            let _e605 = matrix[1][2u];
            let _e608 = matrix[2][2u];
            let _e612 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e599, vec3<f32>(_e602, _e605, _e608))) * _e612), 0.1f, 1f);
            let _e615 = texelMetres;
            let _e616 = cosSlope;
            let _e617 = cosSlope;
            let _e623 = cosSlope;
            let _e625 = cascadeDepth;
            receiverSlope = (((_e615 * sqrt(max((1f - (_e616 * _e617)), 0f))) / _e623) / _e625);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e627 = attempt;
            attempt = (_e627 + 1i);
        }
    }
    let _e629 = found;
    if !(_e629) {
        return 1f;
    }
    let _e631 = cascade;
    if (_e631 == 0i) {
        let _e635 = frag_info.shadow_bias[0u];
        local_23 = _e635;
    } else {
        let _e636 = cascade;
        if (_e636 == 1i) {
            let _e640 = frag_info.shadow_bias[1u];
            local_24 = _e640;
        } else {
            let _e643 = frag_info.shadow_bias[2u];
            local_24 = _e643;
        }
        let _e644 = local_24;
        local_23 = _e644;
    }
    let _e645 = local_23;
    bias = _e645;
    let _e648 = frag_info.shadow_params[1u];
    storage_ = _e648;
    let _e649 = storage_;
    let _e651 = storage_;
    if ((_e649 > 0.5f) && (_e651 < 1.5f)) {
        let _e654 = bias;
        let _e656 = projected[2u];
        param_138 = _e656;
        let _e657 = ShadowStoredStep_u0028_f1_u003b((&param_138));
        bias = max(_e654, _e657);
    }
    let _e661 = frag_info.shadow_params[0u];
    let _e664 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e661, _e664);
    let _e666 = cascade;
    let _e668 = cascadeCount;
    let _e672 = texel_1;
    tileLo = (vec2<f32>((f32(_e666) / f32(_e668)), 0f) + (_e672 * 0.5f));
    let _e675 = cascade;
    let _e678 = cascadeCount;
    let _e682 = texel_1;
    tileHi = (vec2<f32>((f32((_e675 + 1i)) / f32(_e678)), 1f) - (_e682 * 0.5f));
    let _e687 = frag_info.shadow_bias[3u];
    if (_e687 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e689 = y_1;
            if (_e689 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e691 = x_1;
                    if (_e691 <= 1i) {
                        let _e693 = uv_6;
                        let _e694 = x_1;
                        let _e696 = y_1;
                        let _e699 = texel_1;
                        let _e702 = tileLo;
                        let _e703 = tileHi;
                        let _e705 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e693 + (vec2<f32>(f32(_e694), f32(_e696)) * _e699)), _e702, _e703), 0f);
                        let _e706 = stored_4;
                        stored_4 = (_e706 + _e705);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e708 = x_1;
                        x_1 = (_e708 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e710 = y_1;
                y_1 = (_e710 + 1i);
            }
        }
        let _e712 = stored_4;
        stored_4 = (_e712 * 0.11111111f);
        let _e715 = stored_4[1u];
        let _e718 = stored_4[2u];
        let _e721 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e715), (1f - _e718), _e721), vec3(0f), vec3(4f));
        let _e726 = through;
        let _e727 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e726, vec3(clamp(_e727, 0f, 1f)));
    }
    let _e733 = frag_info.ambient_ground[3u];
    softness = _e733;
    lit_2 = 0f;
    let _e734 = softness;
    if (_e734 < 0f) {
        let _e736 = uv_6;
        let _e737 = tileLo;
        let _e738 = tileHi;
        let _e740 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e736, _e737, _e738), 0f);
        moments_2 = _e740;
        let _e742 = projected[2u];
        let _e743 = bias;
        let _e745 = softness;
        let _e749 = moments_2;
        param_139 = _e749;
        param_140 = (_e742 - _e743);
        param_141 = clamp((-(_e745) - 1f), 0f, 0.95f);
        let _e750 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_139), (&param_140), (&param_141));
        lit_2 = _e750;
    } else {
        let _e751 = softness;
        if (_e751 <= 0f) {
            y_2 = -1i;
            loop {
                let _e753 = y_2;
                if (_e753 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e755 = x_2;
                        if (_e755 <= 1i) {
                            let _e757 = uv_6;
                            let _e758 = x_2;
                            let _e760 = y_2;
                            let _e763 = texel_1;
                            let _e766 = tileLo;
                            let _e767 = tileHi;
                            let _e769 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e757 + (vec2<f32>(f32(_e758), f32(_e760)) * _e763)), _e766, _e767), 0f);
                            param_142 = _e769.x;
                            let _e771 = storage_;
                            param_143 = _e771;
                            let _e772 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_142), (&param_143));
                            occluder = _e772;
                            let _e774 = projected[2u];
                            let _e775 = bias;
                            let _e777 = occluder;
                            let _e780 = lit_2;
                            lit_2 = (_e780 + select(1f, 0f, ((_e774 - _e775) > _e777)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e782 = x_2;
                            x_2 = (_e782 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e784 = y_2;
                    y_2 = (_e784 + 1i);
                }
            }
            let _e786 = lit_2;
            lit_2 = (_e786 * 0.11111111f);
        } else {
            let _e788 = softness;
            spread = tan(min(_e788, 0.5f));
            let _e791 = ShadowNoise_u0028_();
            turn_1 = (_e791 * 6.2831855f);
            let _e793 = spread;
            let _e795 = projected[2u];
            let _e797 = cascadeDepth;
            let _e799 = cascadeTexel;
            searchRadius = clamp((((_e793 * _e795) * _e797) / _e799), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_6 = 0i;
            loop {
                let _e802 = i_6;
                if (_e802 < 16i) {
                    let _e804 = i_6;
                    param_144 = _e804;
                    param_145 = 16i;
                    let _e805 = turn_1;
                    param_146 = _e805;
                    let _e806 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_144), (&param_145), (&param_146));
                    disc = _e806;
                    let _e807 = bias;
                    let _e808 = disc;
                    let _e810 = searchRadius;
                    let _e814 = receiverSlope;
                    tapBias = (_e807 + (max(((length(_e808) * _e810) - 1.5f), 0f) * _e814));
                    let _e817 = uv_6;
                    let _e818 = disc;
                    let _e819 = texel_1;
                    let _e821 = searchRadius;
                    let _e824 = tileLo;
                    let _e825 = tileHi;
                    let _e827 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e817 + ((_e818 * _e819) * _e821)), _e824, _e825), 0f);
                    param_147 = _e827.x;
                    let _e829 = storage_;
                    param_148 = _e829;
                    let _e830 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_147), (&param_148));
                    occluder_1 = _e830;
                    let _e832 = projected[2u];
                    let _e833 = tapBias;
                    let _e835 = occluder_1;
                    if ((_e832 - _e833) > _e835) {
                        let _e837 = occluder_1;
                        let _e838 = blockerSum;
                        blockerSum = (_e838 + _e837);
                        let _e840 = blockerCount;
                        blockerCount = (_e840 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e842 = i_6;
                    i_6 = (_e842 + 1i);
                }
            }
            let _e844 = blockerCount;
            if (_e844 <= 0f) {
                return 1f;
            }
            let _e847 = projected[2u];
            let _e848 = blockerSum;
            let _e849 = blockerCount;
            let _e853 = cascadeDepth;
            gap = (max((_e847 - (_e848 / _e849)), 0f) * _e853);
            let _e855 = spread;
            let _e856 = gap;
            let _e858 = cascadeTexel;
            radius_2 = clamp(((_e855 * _e856) / _e858), 1f, 16f);
            i_7 = 0i;
            loop {
                let _e861 = i_7;
                if (_e861 < 16i) {
                    let _e863 = turn_1;
                    let _e865 = i_7;
                    param_149 = _e865;
                    param_150 = 16i;
                    param_151 = (_e863 + 1f);
                    let _e866 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_149), (&param_150), (&param_151));
                    disc_1 = _e866;
                    let _e867 = bias;
                    let _e868 = disc_1;
                    let _e870 = radius_2;
                    let _e874 = receiverSlope;
                    tapBias_1 = (_e867 + (max(((length(_e868) * _e870) - 1.5f), 0f) * _e874));
                    let _e877 = uv_6;
                    let _e878 = disc_1;
                    let _e879 = texel_1;
                    let _e881 = radius_2;
                    let _e884 = tileLo;
                    let _e885 = tileHi;
                    let _e887 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e877 + ((_e878 * _e879) * _e881)), _e884, _e885), 0f);
                    param_152 = _e887.x;
                    let _e889 = storage_;
                    param_153 = _e889;
                    let _e890 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_152), (&param_153));
                    occluder_2 = _e890;
                    let _e892 = projected[2u];
                    let _e893 = tapBias_1;
                    let _e895 = occluder_2;
                    let _e898 = lit_2;
                    lit_2 = (_e898 + select(1f, 0f, ((_e892 - _e893) > _e895)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e900 = i_7;
                    i_7 = (_e900 + 1i);
                }
            }
            let _e902 = lit_2;
            lit_2 = (_e902 * 0.0625f);
        }
    }
    let _e904 = lit_2;
    let _e905 = strength_1;
    return mix(1f, _e904, clamp(_e905, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_6: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_154: Surface;
    var param_155: LightSample;
    var param_156: i32;

    let _e310 = (*s_6);
    param_154 = _e310;
    let _e311 = (*light_3);
    param_155 = _e311;
    let _e312 = (*index);
    param_156 = _e312;
    let _e313 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_154), (&param_155), (&param_156));
    return _e313;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e305 = (*index_1);
    return (_e305 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e309 = (*distance_1);
    let _e310 = (*distance_1);
    attenuation = (1f / max((_e309 * _e310), 0.0001f));
    let _e314 = (*range_4);
    if (_e314 > 0f) {
        let _e316 = (*distance_1);
        let _e317 = (*range_4);
        ratio = (_e316 / _e317);
        let _e319 = ratio;
        let _e320 = ratio;
        let _e322 = ratio;
        let _e324 = ratio;
        window = clamp((1f - (((_e319 * _e320) * _e322) * _e324)), 0f, 1f);
        let _e328 = window;
        let _e329 = window;
        let _e331 = attenuation;
        attenuation = (_e331 * (_e328 * _e329));
    }
    let _e333 = attenuation;
    return _e333;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_25: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e321 = (*halfWidth);
    let _e322 = (*halfHeight);
    n_3 = cross(_e321, _e322);
    let _e324 = n_3;
    nLen = length(_e324);
    let _e326 = nLen;
    if (_e326 < 0.000000000001f) {
        let _e328 = (*centre);
        return _e328;
    }
    let _e329 = nLen;
    let _e330 = n_3;
    n_3 = (_e330 / vec3(_e329));
    let _e333 = (*centre);
    let _e334 = (*world_2);
    toPlane = (_e333 - _e334);
    let _e336 = (*mirror);
    let _e337 = n_3;
    denom = dot(_e336, _e337);
    let _e339 = denom;
    if (abs(_e339) < 0.00001f) {
        let _e342 = toPlane;
        let _e343 = n_3;
        let _e344 = toPlane;
        let _e345 = n_3;
        onPlane = (_e342 - (_e343 * dot(_e344, _e345)));
    } else {
        let _e349 = toPlane;
        let _e350 = n_3;
        let _e352 = denom;
        t_1 = (dot(_e349, _e350) / _e352);
        let _e354 = t_1;
        if (_e354 > 0f) {
            let _e356 = (*mirror);
            let _e357 = t_1;
            local_25 = (_e356 * _e357);
        } else {
            let _e359 = toPlane;
            let _e360 = n_3;
            let _e361 = toPlane;
            let _e362 = n_3;
            local_25 = (_e359 - (_e360 * dot(_e361, _e362)));
        }
        let _e366 = local_25;
        onPlane = _e366;
    }
    let _e367 = onPlane;
    let _e368 = toPlane;
    offset_2 = (_e367 - _e368);
    let _e370 = (*halfWidth);
    let _e371 = (*halfWidth);
    wLen2_ = max(dot(_e370, _e371), 0.000000000001f);
    let _e374 = (*halfHeight);
    let _e375 = (*halfHeight);
    hLen2_ = max(dot(_e374, _e375), 0.000000000001f);
    let _e378 = offset_2;
    let _e379 = (*halfWidth);
    let _e381 = wLen2_;
    u = clamp((dot(_e378, _e379) / _e381), -1f, 1f);
    let _e384 = offset_2;
    let _e385 = (*halfHeight);
    let _e387 = hLen2_;
    v_1 = clamp((dot(_e384, _e385) / _e387), -1f, 1f);
    let _e390 = (*centre);
    let _e391 = (*halfWidth);
    let _e392 = u;
    let _e395 = (*halfHeight);
    let _e396 = v_1;
    return ((_e390 + (_e391 * _e392)) + (_e395 * _e396));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_26: f32;

    let _e313 = (*a_3);
    let _e314 = (*a_3);
    ua = (_e313 / vec3(max(length(_e314), 0.000000000001f)));
    let _e319 = (*b_1);
    let _e320 = (*b_1);
    ub = (_e319 / vec3(max(length(_e320), 0.000000000001f)));
    let _e325 = ua;
    let _e326 = ub;
    angle_2 = acos(clamp(dot(_e325, _e326), -1f, 1f));
    let _e330 = ua;
    let _e331 = ub;
    axis_1 = cross(_e330, _e331);
    let _e333 = axis_1;
    len_2 = length(_e333);
    let _e335 = len_2;
    if (_e335 > 0.000001f) {
        let _e337 = angle_2;
        let _e338 = axis_1;
        let _e339 = (*n_4);
        let _e342 = len_2;
        local_26 = ((_e337 * dot(_e338, _e339)) / _e342);
    } else {
        local_26 = 0f;
    }
    let _e344 = local_26;
    return _e344;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_27: i32;
    var ha: f32;
    var hb: f32;
    var d_5: f32;
    var q: vec3<f32>;
    var local_28: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_29: f32;
    var param_157: vec3<f32>;
    var param_158: vec3<f32>;
    var param_159: vec3<f32>;
    var param_160: vec3<f32>;
    var param_161: vec3<f32>;
    var param_162: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e327 = i_8;
        if (_e327 < 4i) {
            let _e329 = i_8;
            let _e331 = (*corners_1)[_e329];
            a_4 = _e331;
            let _e332 = i_8;
            if (_e332 == 3i) {
                local_27 = 0i;
            } else {
                let _e334 = i_8;
                local_27 = (_e334 + 1i);
            }
            let _e336 = local_27;
            let _e338 = (*corners_1)[_e336];
            b_2 = _e338;
            let _e339 = a_4;
            let _e340 = (*n_5);
            ha = dot(_e339, _e340);
            let _e342 = b_2;
            let _e343 = (*n_5);
            hb = dot(_e342, _e343);
            let _e345 = ha;
            let _e346 = hb;
            d_5 = (_e345 - _e346);
            let _e348 = a_4;
            let _e349 = b_2;
            let _e350 = a_4;
            let _e352 = d_5;
            if (abs(_e352) > 0.000000000001f) {
                let _e355 = ha;
                let _e356 = d_5;
                local_28 = (_e355 / _e356);
            } else {
                local_28 = 0f;
            }
            let _e358 = local_28;
            q = (_e348 + ((_e349 - _e350) * _e358));
            let _e361 = ha;
            aAbove = (_e361 > 0f);
            let _e363 = hb;
            bAbove = (_e363 > 0f);
            let _e365 = aAbove;
            let _e366 = bAbove;
            if (_e365 || _e366) {
                let _e368 = aAbove;
                let _e369 = a_4;
                let _e370 = q;
                let _e373 = bAbove;
                let _e374 = b_2;
                let _e375 = q;
                param_157 = select(_e370, _e369, vec3(_e368));
                param_158 = select(_e375, _e374, vec3(_e373));
                let _e378 = (*n_5);
                param_159 = _e378;
                let _e379 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_157), (&param_158), (&param_159));
                local_29 = _e379;
            } else {
                local_29 = 0f;
            }
            let _e380 = local_29;
            let _e381 = total;
            total = (_e381 + _e380);
            let _e383 = aAbove;
            let _e384 = bAbove;
            let _e387 = q;
            let _e388 = exit;
            exit = select(_e388, _e387, vec3((_e383 && !(_e384))));
            let _e391 = aAbove;
            let _e393 = bAbove;
            let _e395 = q;
            let _e396 = entry;
            entry = select(_e396, _e395, vec3((!(_e391) && _e393)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e399 = i_8;
            i_8 = (_e399 + 1i);
        }
    }
    let _e401 = exit;
    param_160 = _e401;
    let _e402 = entry;
    param_161 = _e402;
    let _e403 = (*n_5);
    param_162 = _e403;
    let _e404 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_160), (&param_161), (&param_162));
    let _e405 = total;
    total = (_e405 + _e404);
    let _e407 = total;
    return max((-(_e407) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_2: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_30: f32;
    var local_31: f32;
    var local_32: f32;

    let _e310 = (*slot_2);
    let _e311 = (*slot_2);
    lane = (_e310 - ((_e311 / 4i) * 4i));
    let _e315 = lane;
    if (_e315 == 0i) {
        let _e318 = (*four)[0u];
        local_30 = _e318;
    } else {
        let _e319 = lane;
        if (_e319 == 1i) {
            let _e322 = (*four)[1u];
            local_31 = _e322;
        } else {
            let _e323 = lane;
            if (_e323 == 2i) {
                let _e326 = (*four)[2u];
                local_32 = _e326;
            } else {
                let _e328 = (*four)[3u];
                local_32 = _e328;
            }
            let _e329 = local_32;
            local_31 = _e329;
        }
        let _e330 = local_31;
        local_30 = _e330;
    }
    let _e331 = local_30;
    return _e331;
}

fn LightListScale_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_163: vec4<f32>;
    var param_164: i32;

    let _e307 = (*slot_3);
    let _e311 = light_list_info.scales[(_e307 / 4i)];
    param_163 = _e311;
    let _e312 = (*slot_3);
    param_164 = _e312;
    let _e313 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_163), (&param_164));
    return _e313;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e309 = light_list_info.slot_rows[0i];
    let _e310 = (*row);
    a_5 = abs((_e309 - vec4(_e310)));
    let _e316 = light_list_info.slot_rows[1i];
    let _e317 = (*row);
    b_3 = abs((_e316 - vec4(_e317)));
    let _e322 = a_5[0u];
    let _e324 = a_5[1u];
    let _e327 = a_5[2u];
    let _e329 = a_5[3u];
    let _e333 = b_3[0u];
    let _e335 = b_3[1u];
    let _e338 = b_3[2u];
    let _e340 = b_3[3u];
    return (min(min(min(_e322, _e324), min(_e327, _e329)), min(min(_e333, _e335), min(_e338, _e340))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var param_165: vec4<f32>;
    var param_166: i32;

    let _e307 = (*slot_4);
    let _e311 = light_list_info.indices[(_e307 / 4i)];
    param_165 = _e311;
    let _e312 = (*slot_4);
    param_166 = _e312;
    let _e313 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_165), (&param_166));
    return _e313;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e306 = (*texel_2);
    let _e310 = light_list_info.list[1u];
    let _e312 = (*row_1);
    let _e316 = light_list_info.list[2u];
    let _e319 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e306 + 0.5f) * _e310), ((_e312 + 0.5f) * _e316)), 0f);
    return _e319;
}

fn ClusterRow_u0028_i1_u003b(slot_5: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_167: f32;
    var param_168: f32;
    var param_169: vec4<f32>;
    var param_170: i32;

    let _e314 = g_cluster_offset;
    let _e315 = (*slot_5);
    entry_1 = (_e314 + f32(_e315));
    let _e318 = entry_1;
    row_2 = floor((_e318 / 16f));
    let _e321 = entry_1;
    let _e322 = row_2;
    within_1 = (_e321 - (_e322 * 16f));
    let _e325 = within_1;
    texel_3 = floor((_e325 / 4f));
    let _e330 = light_list_info.cluster_depth[3u];
    let _e331 = row_2;
    let _e333 = texel_3;
    param_167 = _e333;
    param_168 = (_e330 + _e331);
    let _e334 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_167), (&param_168));
    four_1 = _e334;
    let _e335 = within_1;
    let _e336 = texel_3;
    let _e341 = four_1;
    param_169 = _e341;
    param_170 = i32(((_e335 - (_e336 * 4f)) + 0.5f));
    let _e342 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_169), (&param_170));
    return _e342;
}

fn Clustered_u0028_() -> bool {
    let _e306 = light_list_info.cluster_grid[3u];
    return (_e306 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_7: ptr<function, Surface>) -> LightSample {
    var light_4: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_6: i32;
    var clustered: bool;
    var listRow: f32;
    var local_33: f32;
    var param_171: i32;
    var param_172: i32;
    var v_2: f32;
    var u_1: f32;
    var local_34: f32;
    var param_173: f32;
    var param_174: i32;
    var type_45: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_35: f32;
    var param_175: array<vec3<f32>, 4>;
    var param_176: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_36: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_177: vec3<f32>;
    var param_178: vec3<f32>;
    var param_179: vec3<f32>;
    var param_180: vec3<f32>;
    var param_181: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_37: vec3<f32>;
    var param_182: vec3<f32>;
    var param_183: vec3<f32>;
    var param_184: f32;
    var param_185: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_186: f32;
    var param_187: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_4.integrated = 0f;
    light_4.ltc = vec3<f32>(0f, 0f, 0f);
    let _e362 = (*index_2);
    if (_e362 < 8i) {
        let _e364 = (*index_2);
        let _e367 = frag_info.light_position[_e364];
        position = _e367;
        let _e368 = (*index_2);
        let _e371 = frag_info.light_color[_e368];
        color_1 = _e371;
        let _e372 = (*index_2);
        let _e375 = frag_info.light_direction[_e372];
        direction = _e375;
        let _e376 = (*index_2);
        let _e379 = frag_info.light_cone[_e376];
        cone = _e379;
    } else {
        let _e380 = (*index_2);
        slot_6 = (_e380 - 8i);
        let _e382 = Clustered_u0028_();
        clustered = _e382;
        let _e383 = clustered;
        if _e383 {
            let _e384 = slot_6;
            param_171 = _e384;
            let _e385 = ClusterRow_u0028_i1_u003b((&param_171));
            local_33 = _e385;
        } else {
            let _e386 = slot_6;
            param_172 = _e386;
            let _e387 = LightListRow_u0028_i1_u003b((&param_172));
            local_33 = _e387;
        }
        let _e388 = local_33;
        listRow = _e388;
        let _e389 = listRow;
        let _e393 = light_list_info.list[2u];
        v_2 = ((_e389 + 0.5f) * _e393);
        let _e397 = light_list_info.list[1u];
        u_1 = _e397;
        let _e398 = u_1;
        let _e400 = v_2;
        let _e402 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e398), _e400), 0f);
        position = _e402;
        let _e403 = u_1;
        let _e405 = v_2;
        let _e407 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e403), _e405), 0f);
        color_1 = _e407;
        let _e408 = u_1;
        let _e410 = v_2;
        let _e412 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e408), _e410), 0f);
        direction = _e412;
        let _e413 = u_1;
        let _e415 = v_2;
        let _e417 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e413), _e415), 0f);
        cone = _e417;
        let _e418 = clustered;
        if _e418 {
            let _e419 = listRow;
            param_173 = _e419;
            let _e420 = InSlots_u0028_f1_u003b((&param_173));
            local_34 = select(1f, 0f, _e420);
        } else {
            let _e422 = slot_6;
            param_174 = _e422;
            let _e423 = LightListScale_u0028_i1_u003b((&param_174));
            local_34 = _e423;
        }
        let _e424 = local_34;
        let _e426 = color_1[3u];
        color_1[3u] = (_e426 * _e424);
    }
    let _e430 = position[3u];
    type_45 = _e430;
    let _e431 = type_45;
    if (_e431 > 15.5f) {
        let _e434 = (*s_7).n;
        light_4.l = _e434;
        let _e437 = (*s_7).n;
        light_4.h = _e437;
        light_4.radiance = vec3<f32>(0f, 0f, 0f);
        light_4.n_dot_l = 0f;
        light_4.n_dot_h = 0f;
        light_4.v_dot_h = 0f;
        let _e443 = light_4;
        return _e443;
    }
    let _e444 = type_45;
    if (_e444 > 2.5f) {
        let _e446 = direction;
        halfWidth_1 = _e446.xyz;
        let _e448 = cone;
        halfHeight_1 = _e448.xyz;
        let _e450 = position;
        let _e452 = v_world_position_1;
        toCentre = (_e450.xyz - _e452);
        let _e454 = toCentre;
        let _e455 = halfWidth_1;
        let _e457 = halfHeight_1;
        corners_2[0i] = ((_e454 - _e455) - _e457);
        let _e460 = toCentre;
        let _e461 = halfWidth_1;
        let _e463 = halfHeight_1;
        corners_2[1i] = ((_e460 + _e461) - _e463);
        let _e466 = toCentre;
        let _e467 = halfWidth_1;
        let _e469 = halfHeight_1;
        corners_2[2i] = ((_e466 + _e467) + _e469);
        let _e472 = toCentre;
        let _e473 = halfWidth_1;
        let _e475 = halfHeight_1;
        corners_2[3i] = ((_e472 - _e473) + _e475);
        let _e478 = toCentre;
        let _e479 = halfWidth_1;
        let _e480 = halfHeight_1;
        behind = (dot(_e478, cross(_e479, _e480)) >= 0f);
        let _e484 = behind;
        if _e484 {
            local_35 = 0f;
        } else {
            let _e485 = corners_2;
            param_175 = _e485;
            let _e487 = (*s_7).n;
            param_176 = _e487;
            let _e488 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_175), (&param_176));
            local_35 = _e488;
        }
        let _e489 = local_35;
        formFactor = _e489;
        let _e490 = halfWidth_1;
        let _e491 = halfHeight_1;
        area = (length(cross(_e490, _e491)) * 4f);
        let _e495 = area;
        if (_e495 > 0.000000001f) {
            let _e497 = area;
            local_36 = (1f / _e497);
        } else {
            local_36 = 0f;
        }
        let _e499 = local_36;
        radiance = _e499;
        let _e500 = toCentre;
        distance_2 = length(_e500);
        let _e503 = direction[3u];
        if (_e503 > 0f) {
            let _e505 = distance_2;
            let _e507 = direction[3u];
            ratio_1 = (_e505 / _e507);
            let _e509 = ratio_1;
            let _e510 = ratio_1;
            let _e512 = ratio_1;
            let _e514 = ratio_1;
            window_1 = clamp((1f - (((_e509 * _e510) * _e512) * _e514)), 0f, 1f);
            let _e518 = window_1;
            let _e519 = window_1;
            let _e521 = radiance;
            radiance = (_e521 * (_e518 * _e519));
        }
        let _e524 = (*s_7).v;
        let _e527 = (*s_7).n;
        mirror_1 = reflect(-(_e524), _e527);
        let _e529 = position;
        param_177 = _e529.xyz;
        let _e531 = halfWidth_1;
        param_178 = _e531;
        let _e532 = halfHeight_1;
        param_179 = _e532;
        let _e533 = v_world_position_1;
        param_180 = _e533;
        let _e534 = mirror_1;
        param_181 = _e534;
        let _e535 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_177), (&param_178), (&param_179), (&param_180), (&param_181));
        representative = _e535;
        let _e536 = representative;
        let _e537 = v_world_position_1;
        toPoint = (_e536 - _e537);
        let _e539 = toPoint;
        pointDistance = length(_e539);
        let _e541 = pointDistance;
        if (_e541 > 0.000001f) {
            let _e543 = toPoint;
            let _e544 = pointDistance;
            local_37 = (_e543 / vec3(_e544));
        } else {
            let _e548 = (*s_7).n;
            local_37 = _e548;
        }
        let _e549 = local_37;
        light_4.l = _e549;
        let _e552 = light_4.l;
        let _e554 = (*s_7).v;
        light_4.h = normalize((_e552 + _e554));
        let _e558 = formFactor;
        light_4.n_dot_l = _e558;
        let _e561 = (*s_7).n;
        let _e563 = light_4.h;
        light_4.n_dot_h = max(dot(_e561, _e563), 0f);
        let _e568 = (*s_7).v;
        let _e570 = light_4.h;
        light_4.v_dot_h = max(dot(_e568, _e570), 0f);
        let _e574 = color_1;
        let _e577 = color_1[3u];
        let _e579 = radiance;
        light_4.radiance = ((_e574.xyz * _e577) * _e579);
        light_4.integrated = 1f;
        let _e584 = (*s_7).n;
        param_182 = _e584;
        let _e586 = (*s_7).v;
        param_183 = _e586;
        let _e588 = (*s_7).roughness;
        param_184 = _e588;
        let _e589 = corners_2;
        param_185 = _e589;
        let _e590 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_182), (&param_183), (&param_184), (&param_185));
        light_4.ltc = _e590;
        let _e592 = corners_2;
        g_rect_corners = _e592;
        let _e593 = light_4;
        return _e593;
    }
    let _e594 = direction;
    aim = normalize(_e594.xyz);
    attenuation_1 = 1f;
    let _e597 = type_45;
    if (_e597 < 0.5f) {
        let _e599 = aim;
        light_4.l = -(_e599);
    } else {
        let _e602 = position;
        let _e604 = v_world_position_1;
        toLight_1 = (_e602.xyz - _e604);
        let _e606 = toLight_1;
        distance_3 = length(_e606);
        let _e608 = distance_3;
        if (_e608 < 0.000001f) {
            let _e611 = (*s_7).n;
            light_4.l = _e611;
            let _e614 = (*s_7).n;
            light_4.h = _e614;
            light_4.radiance = vec3<f32>(0f, 0f, 0f);
            light_4.n_dot_l = 0f;
            light_4.n_dot_h = 0f;
            light_4.v_dot_h = 0f;
            let _e620 = light_4;
            return _e620;
        }
        let _e621 = toLight_1;
        let _e622 = distance_3;
        light_4.l = (_e621 / vec3(_e622));
        let _e626 = distance_3;
        param_186 = _e626;
        let _e628 = direction[3u];
        param_187 = _e628;
        let _e629 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_186), (&param_187));
        attenuation_1 = _e629;
        let _e630 = type_45;
        if (_e630 > 1.5f) {
            let _e632 = aim;
            let _e634 = light_4.l;
            cosAngle = dot(_e632, -(_e634));
            let _e637 = cosAngle;
            let _e639 = cone[1u];
            let _e642 = cone[0u];
            let _e644 = cone[1u];
            ramp = clamp(((_e637 - _e639) / (_e642 - _e644)), 0f, 1f);
            let _e648 = ramp;
            let _e649 = ramp;
            let _e651 = attenuation_1;
            attenuation_1 = (_e651 * (_e648 * _e649));
        }
    }
    let _e654 = light_4.l;
    let _e656 = (*s_7).v;
    light_4.h = normalize((_e654 + _e656));
    let _e661 = (*s_7).n;
    let _e663 = light_4.l;
    light_4.n_dot_l = max(dot(_e661, _e663), 0f);
    let _e668 = (*s_7).n;
    let _e670 = light_4.h;
    light_4.n_dot_h = max(dot(_e668, _e670), 0f);
    let _e675 = (*s_7).v;
    let _e677 = light_4.h;
    light_4.v_dot_h = max(dot(_e675, _e677), 0f);
    let _e681 = color_1;
    let _e684 = color_1[3u];
    let _e686 = attenuation_1;
    light_4.radiance = ((_e681.xyz * _e684) * _e686);
    let _e689 = light_4;
    return _e689;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_38: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_188: f32;
    var param_189: f32;

    let _e319 = light_list_info.cluster_view_projection;
    let _e320 = (*world_3);
    clip_1 = (_e319 * vec4<f32>(_e320.x, _e320.y, _e320.z, 1f));
    let _e326 = clip_1;
    let _e329 = clip_1[3u];
    ndc_1 = (_e326.xy / vec2(max(_e329, 0.000001f)));
    let _e334 = light_list_info.cluster_grid;
    grid = _e334.xyz;
    let _e338 = light_list_info.cluster_depth[0u];
    near_1 = _e338;
    let _e340 = ndc_1[0u];
    let _e344 = grid[0u];
    let _e348 = grid[0u];
    tx = clamp(floor((((_e340 * 0.5f) + 0.5f) * _e344)), 0f, (_e348 - 1f));
    let _e352 = ndc_1[1u];
    let _e356 = grid[1u];
    let _e360 = grid[1u];
    ty = clamp(floor((((_e352 * 0.5f) + 0.5f) * _e356)), 0f, (_e360 - 1f));
    let _e364 = clip_1[3u];
    let _e365 = near_1;
    if (_e364 <= _e365) {
        local_38 = 0f;
    } else {
        let _e368 = clip_1[3u];
        let _e369 = near_1;
        let _e374 = light_list_info.cluster_depth[1u];
        let _e378 = grid[2u];
        local_38 = clamp(floor((log((_e368 / _e369)) * _e374)), 0f, (_e378 - 1f));
    }
    let _e381 = local_38;
    tz = _e381;
    let _e382 = tx;
    let _e383 = ty;
    let _e385 = grid[0u];
    let _e388 = tz;
    let _e390 = grid[0u];
    let _e393 = grid[1u];
    cell_1 = ((_e382 + (_e383 * _e385)) + ((_e388 * _e390) * _e393));
    let _e396 = cell_1;
    row_3 = floor((_e396 / 4f));
    let _e399 = cell_1;
    let _e400 = row_3;
    let _e405 = light_list_info.cluster_depth[2u];
    let _e406 = row_3;
    param_188 = (_e399 - (_e400 * 4f));
    param_189 = (_e405 + _e406);
    let _e408 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_188), (&param_189));
    header = _e408;
    let _e410 = header[0u];
    g_cluster_offset = _e410;
    let _e412 = header[1u];
    g_cluster_count = _e412;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_190: vec3<f32>;

    let _e308 = light_list_info.list[0u];
    tail = _e308;
    let _e309 = Clustered_u0028_();
    if _e309 {
        let _e310 = v_world_position_1;
        param_190 = _e310;
        FindCluster_u0028_vf3_u003b((&param_190));
        let _e311 = g_cluster_count;
        tail = _e311;
    }
    let _e314 = frag_info.frame_params[1u];
    let _e318 = tail;
    return (clamp(i32((_e314 + 0.5f)), 0i, 8i) + clamp(i32((_e318 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_5: LightSample;
    var param_191: i32;
    var param_192: Surface;
    var visibility: f32;
    var param_193: i32;
    var local_39: f32;
    var param_194: Surface;
    var param_195: LightSample;
    var param_196: i32;
    var param_197: vec3<f32>;
    var param_198: vec3<f32>;
    var param_199: i32;
    var param_200: Surface;
    var param_201: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e322 = LightCount_u0028_();
    count_1 = _e322;
    i_9 = 0i;
    loop {
        let _e323 = i_9;
        if (_e323 < 32i) {
            let _e325 = i_9;
            let _e326 = count_1;
            if (_e325 >= _e326) {
                break;
            }
            let _e328 = i_9;
            param_191 = _e328;
            let _e329 = (*s_8);
            param_192 = _e329;
            let _e330 = 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((&param_191), (&param_192));
            light_5 = _e330;
            let _e332 = light_5.n_dot_l;
            if (_e332 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e334 = i_9;
            param_193 = _e334;
            let _e335 = LightHasShadow_u0028_i1_u003b((&param_193));
            if _e335 {
                let _e336 = (*s_8);
                param_194 = _e336;
                let _e337 = light_5;
                param_195 = _e337;
                let _e338 = i_9;
                param_196 = _e338;
                let _e339 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_194), (&param_195), (&param_196));
                let _e340 = v_world_position_1;
                param_197 = _e340;
                let _e342 = (*s_8).n;
                param_198 = _e342;
                let _e343 = i_9;
                param_199 = _e343;
                let _e344 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_197), (&param_198), (&param_199));
                local_39 = (_e339 * _e344);
            } else {
                local_39 = 1f;
            }
            let _e346 = local_39;
            visibility = _e346;
            let _e347 = visibility;
            if (_e347 <= 0f) {
                continue;
            }
            let _e349 = (*s_8);
            param_200 = _e349;
            let _e350 = light_5;
            param_201 = _e350;
            let _e351 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_200), (&param_201));
            let _e353 = light_5.radiance;
            let _e356 = light_5.n_dot_l;
            let _e358 = visibility;
            let _e360 = light_transmittance;
            let _e362 = total_1;
            total_1 = (_e362 + ((((_e351 * _e353) * _e356) * _e358) * _e360));
            continue;
        } else {
            break;
        }
        continuing {
            let _e364 = i_9;
            i_9 = (_e364 + 1i);
        }
    }
    let _e366 = total_1;
    return _e366;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e305 = v_lightmap_uv_1;
    let _e306 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e305);
    texel_4 = _e306;
    let _e307 = texel_4;
    let _e310 = texel_4[3u];
    return ((_e307.xyz * _e310) * 8f);
}

fn SceneColorLevel_u0028_vf2_u003b_i1_u003b(uv_7: ptr<function, vec2<f32>>, level: ptr<function, i32>) -> vec3<f32> {
    var rect: vec4<f32>;
    var inset_1: vec2<f32>;
    var at_4: vec2<f32>;

    let _e309 = (*level);
    let _e312 = layer_info.scene_levels[_e309];
    rect = _e312;
    let _e314 = layer_info.scene_color;
    inset_1 = (_e314.yz * 0.5f);
    let _e317 = rect;
    let _e319 = (*uv_7);
    let _e320 = rect;
    let _e323 = inset_1;
    let _e324 = rect;
    let _e326 = inset_1;
    let _e328 = inset_1;
    at_4 = (_e317.xy + clamp((_e319 * _e320.zw), _e323, max((_e324.zw - _e326), _e328)));
    let _e332 = at_4;
    let _e333 = textureSampleLevel(scene_color_texture_tex, scene_color_texture_smp, _e332, 0f);
    return _e333.xyz;
}

fn SceneColorAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod: ptr<function, f32>) -> vec3<f32> {
    var clip_2: vec4<f32>;
    var ndc_2: vec2<f32>;
    var view_1: vec2<f32>;
    var uv_8: vec2<f32>;
    var top: f32;
    var level_1: f32;
    var lower: f32;
    var near_2: vec3<f32>;
    var param_202: vec2<f32>;
    var param_203: i32;
    var far_1: vec3<f32>;
    var param_204: vec2<f32>;
    var param_205: i32;

    let _e320 = layer_info.scene_view_projection;
    let _e321 = (*world_4);
    clip_2 = (_e320 * vec4<f32>(_e321.x, _e321.y, _e321.z, 1f));
    let _e327 = clip_2;
    let _e330 = clip_2[3u];
    ndc_2 = (_e327.xy / vec2(max(_e330, 0.000001f)));
    let _e335 = ndc_2[0u];
    let _e339 = ndc_2[1u];
    view_1 = clamp(vec2<f32>(((_e335 * 0.5f) + 0.5f), (0.5f - (_e339 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
    let _e345 = layer_info.scene_viewport;
    let _e347 = view_1;
    let _e349 = layer_info.scene_viewport;
    uv_8 = (_e345.xy + (_e347 * _e349.zw));
    let _e355 = layer_info.scene_color[0u];
    top = (_e355 - 1f);
    let _e357 = (*lod);
    let _e358 = top;
    level_1 = clamp(_e357, 0f, _e358);
    let _e360 = level_1;
    lower = floor(_e360);
    let _e362 = lower;
    let _e364 = uv_8;
    param_202 = _e364;
    param_203 = i32(_e362);
    let _e365 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_202), (&param_203));
    near_2 = _e365;
    let _e366 = lower;
    let _e368 = top;
    let _e371 = uv_8;
    param_204 = _e371;
    param_205 = i32(min((_e366 + 1f), _e368));
    let _e372 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_204), (&param_205));
    far_1 = _e372;
    let _e373 = near_2;
    let _e374 = far_1;
    let _e375 = level_1;
    let _e376 = lower;
    return mix(_e373, _e374, vec3((_e375 - _e376)));
}

fn IorInfinite_u0028_() -> bool {
    let _e306 = layer_info.coat[2u];
    return (_e306 == 0f);
}

fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
    var local_40: f32;

    let _e306 = IorInfinite_u0028_();
    if _e306 {
        local_40 = 0f;
    } else {
        let _e307 = (*ior);
        let _e312 = layer_info.transmission[3u];
        local_40 = (((_e307 - 1f) * 0.025f) * _e312);
    }
    let _e314 = local_40;
    return _e314;
}

fn RefractionIor_u0028_() -> f32 {
    var local_41: f32;

    let _e305 = IorInfinite_u0028_();
    if _e305 {
        local_41 = 10000f;
    } else {
        let _e308 = layer_info.coat[2u];
        local_41 = max(_e308, 1f);
    }
    let _e310 = local_41;
    return _e310;
}

fn SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) -> vec3<f32> {
    var ior_1: f32;
    var spread_1: f32;
    var param_206: f32;
    var width: f32;
    var lod_1: f32;
    var thin: bool;
    var red: vec3<f32>;
    var local_42: vec3<f32>;
    var green: vec3<f32>;
    var local_43: vec3<f32>;
    var blue: vec3<f32>;
    var local_44: vec3<f32>;
    var param_207: vec3<f32>;
    var param_208: f32;
    var param_209: vec3<f32>;
    var param_210: f32;
    var param_211: vec3<f32>;
    var param_212: f32;

    let _e323 = RefractionIor_u0028_();
    ior_1 = _e323;
    let _e324 = ior_1;
    param_206 = _e324;
    let _e325 = DispersionSpread_u0028_f1_u003b((&param_206));
    spread_1 = _e325;
    let _e329 = layer_info.scene_levels[0i][2u];
    let _e332 = layer_info.scene_color[1u];
    width = (_e329 / max(_e332, 0.000000001f));
    let _e335 = width;
    let _e339 = (*s_9).roughness;
    let _e341 = ior_1;
    lod_1 = ((log2(max(_e335, 1f)) * _e339) * clamp(((_e341 * 2f) - 2f), 0f, 1f));
    let _e346 = g_thickness;
    thin = (_e346 <= 0f);
    let _e348 = thin;
    if _e348 {
        let _e350 = (*s_9).v;
        local_42 = -(_e350);
    } else {
        let _e353 = (*s_9).v;
        let _e356 = (*s_9).n;
        let _e357 = ior_1;
        let _e358 = spread_1;
        local_42 = refract(-(_e353), _e356, (1f / max((_e357 - _e358), 1f)));
    }
    let _e363 = local_42;
    red = _e363;
    let _e364 = thin;
    if _e364 {
        let _e366 = (*s_9).v;
        local_43 = -(_e366);
    } else {
        let _e369 = (*s_9).v;
        let _e372 = (*s_9).n;
        let _e373 = ior_1;
        local_43 = refract(-(_e369), _e372, (1f / _e373));
    }
    let _e376 = local_43;
    green = _e376;
    let _e377 = thin;
    if _e377 {
        let _e379 = (*s_9).v;
        local_44 = -(_e379);
    } else {
        let _e382 = (*s_9).v;
        let _e385 = (*s_9).n;
        let _e386 = ior_1;
        let _e387 = spread_1;
        local_44 = refract(-(_e382), _e385, (1f / (_e386 + _e387)));
    }
    let _e391 = local_44;
    blue = _e391;
    let _e392 = v_world_position_1;
    let _e393 = red;
    let _e394 = g_thickness;
    param_207 = (_e392 + (_e393 * _e394));
    let _e397 = lod_1;
    param_208 = _e397;
    let _e398 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_207), (&param_208));
    let _e400 = v_world_position_1;
    let _e401 = green;
    let _e402 = g_thickness;
    param_209 = (_e400 + (_e401 * _e402));
    let _e405 = lod_1;
    param_210 = _e405;
    let _e406 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_209), (&param_210));
    let _e408 = v_world_position_1;
    let _e409 = blue;
    let _e410 = g_thickness;
    param_211 = (_e408 + (_e409 * _e410));
    let _e413 = lod_1;
    param_212 = _e413;
    let _e414 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_211), (&param_212));
    return vec3<f32>(_e398.x, _e406.y, _e414.z);
}

fn TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b(s_10: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
    var ior_2: f32;
    var spread_2: f32;
    var param_213: f32;
    var lod_2: f32;
    var thin_1: bool;
    var red_1: vec3<f32>;
    var local_45: vec3<f32>;
    var green_1: vec3<f32>;
    var local_46: vec3<f32>;
    var blue_1: vec3<f32>;
    var local_47: vec3<f32>;

    let _e317 = RefractionIor_u0028_();
    ior_2 = _e317;
    let _e318 = ior_2;
    param_213 = _e318;
    let _e319 = DispersionSpread_u0028_f1_u003b((&param_213));
    spread_2 = _e319;
    let _e321 = (*s_10).roughness;
    let _e322 = ior_2;
    let _e327 = (*levels);
    lod_2 = ((_e321 * clamp(((_e322 * 2f) - 2f), 0f, 1f)) * _e327);
    let _e329 = g_thickness;
    thin_1 = (_e329 <= 0f);
    let _e331 = thin_1;
    if _e331 {
        let _e333 = (*s_10).v;
        local_45 = -(_e333);
    } else {
        let _e336 = (*s_10).v;
        let _e339 = (*s_10).n;
        let _e340 = ior_2;
        let _e341 = spread_2;
        local_45 = refract(-(_e336), _e339, (1f / max((_e340 - _e341), 1f)));
    }
    let _e346 = local_45;
    red_1 = _e346;
    let _e347 = thin_1;
    if _e347 {
        let _e349 = (*s_10).v;
        local_46 = -(_e349);
    } else {
        let _e352 = (*s_10).v;
        let _e355 = (*s_10).n;
        let _e356 = ior_2;
        local_46 = refract(-(_e352), _e355, (1f / _e356));
    }
    let _e359 = local_46;
    green_1 = _e359;
    let _e360 = thin_1;
    if _e360 {
        let _e362 = (*s_10).v;
        local_47 = -(_e362);
    } else {
        let _e365 = (*s_10).v;
        let _e368 = (*s_10).n;
        let _e369 = ior_2;
        let _e370 = spread_2;
        local_47 = refract(-(_e365), _e368, (1f / (_e369 + _e370)));
    }
    let _e374 = local_47;
    blue_1 = _e374;
    let _e375 = red_1;
    let _e376 = lod_2;
    let _e377 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e375, _e376);
    let _e379 = green_1;
    let _e380 = lod_2;
    let _e381 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e379, _e380);
    let _e383 = blue_1;
    let _e384 = lod_2;
    let _e385 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e383, _e384);
    return vec3<f32>(_e377.x, _e381.y, _e385.z);
}

fn SceneColorBound_u0028_() -> bool {
    let _e306 = layer_info.scene_color[0u];
    return (_e306 > 0f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_48: f32;

    let _e307 = frag_info.material2_[2u];
    local_48 = floor((_e307 * 0.5f));
    let _e310 = local_48;
    return _e310;
}

fn IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) -> f32 {
    var target_: f32;
    var local_49: f32;
    var local_50: f32;

    let _e308 = OcclusionTarget_u0028_();
    target_ = _e308;
    let _e309 = target_;
    let _e311 = target_;
    if ((_e309 > 0.5f) && (_e311 < 1.5f)) {
        local_49 = 1f;
    } else {
        let _e315 = (*s_11).occlusion;
        local_49 = _e315;
    }
    let _e316 = local_49;
    local_50 = _e316;
    let _e317 = local_50;
    return _e317;
}

fn DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) -> f32 {
    var local_51: f32;
    var local_52: f32;

    let _e307 = OcclusionTarget_u0028_();
    if (_e307 > 1.5f) {
        local_51 = 1f;
    } else {
        let _e310 = (*s_12).occlusion;
        local_51 = _e310;
    }
    let _e311 = local_51;
    local_52 = _e311;
    let _e312 = local_52;
    return _e312;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_214: f32;
    var param_215: f32;
    var param_216: f32;
    var param_217: vec3<f32>;
    var param_218: f32;

    let _e313 = (*mu_1);
    param_214 = _e313;
    let _e314 = (*r_4);
    param_215 = _e314;
    let _e315 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_214), (&param_215));
    e_1 = _e315;
    let _e316 = (*rho_2);
    let _e317 = e_1;
    let _e319 = (*r_4);
    param_216 = _e319;
    let _e320 = FonAverage_u0028_f1_u003b((&param_216));
    let _e321 = (*rho_2);
    param_217 = _e321;
    param_218 = _e320;
    let _e322 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_217), (&param_218));
    let _e323 = e_1;
    return ((_e316 * _e317) + (_e322 * (1f - _e323)));
}

fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shift: ptr<function, vec3<f32>>) -> vec3<f32> {
    var phase: f32;
    var val: vec3<f32>;
    var pos: vec3<f32>;
    var variance_1: vec3<f32>;
    var xyz: vec3<f32>;

    let _e311 = (*opd);
    phase = ((6.2831855f * _e311) * 0.000000001f);
    val = vec3<f32>(0.00000000000054856f, 0.00000000000044201f, 0.00000000000052481f);
    pos = vec3<f32>(1681000f, 1795300f, 2208400f);
    variance_1 = vec3<f32>(4327800000f, 9304600000f, 6612100000f);
    let _e314 = val;
    let _e315 = variance_1;
    let _e319 = pos;
    let _e320 = phase;
    let _e322 = (*shift);
    let _e326 = phase;
    let _e327 = phase;
    let _e330 = variance_1;
    xyz = (((_e314 * sqrt((_e315 * 6.2831855f))) * cos(((_e319 * _e320) + _e322))) * exp((_e330 * -((_e326 * _e327)))));
    let _e334 = phase;
    let _e337 = (*shift)[0u];
    let _e341 = phase;
    let _e343 = phase;
    let _e348 = xyz[0u];
    xyz[0u] = (_e348 + ((0.00000001644083f * cos(((2239900f * _e334) + _e337))) * exp(((-4528200000f * _e341) * _e343))));
    let _e351 = xyz;
    xyz = (_e351 / vec3(0.00000010685f));
    let _e354 = xyz;
    return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e354);
}

fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<function, f32>, cos1_: ptr<function, f32>, thickness: ptr<function, f32>, base: ptr<function, vec3<f32>>) -> vec3<f32> {
    var eta2_: f32;
    var sin2Sq: f32;
    var cos2Sq: f32;
    var cos2_: f32;
    var r0_: f32;
    var r12_: f32;
    var t121_: f32;
    var phi12_: f32;
    var phi21_: f32;
    var sqrtBase: vec3<f32>;
    var baseIor: vec3<f32>;
    var r1_: vec3<f32>;
    var r23_: vec3<f32>;
    var phi23_: vec3<f32>;
    var opd_1: f32;
    var phi: vec3<f32>;
    var r123_: vec3<f32>;
    var rootR123_: vec3<f32>;
    var rs: vec3<f32>;
    var total_2: vec3<f32>;
    var cm: vec3<f32>;
    var m_2: i32;
    var param_219: f32;
    var param_220: vec3<f32>;
    var local_53: vec3<f32>;

    let _e333 = (*film);
    let _e334 = (*thickness);
    eta2_ = mix(1f, _e333, smoothstep(0f, 0.03f, _e334));
    let _e337 = (*cos1_);
    let _e338 = (*cos1_);
    let _e341 = eta2_;
    let _e342 = eta2_;
    sin2Sq = ((1f - (_e337 * _e338)) / (_e341 * _e342));
    let _e345 = sin2Sq;
    cos2Sq = (1f - _e345);
    let _e347 = cos2Sq;
    cos2_ = sqrt(max(_e347, 0f));
    let _e350 = eta2_;
    let _e352 = eta2_;
    r0_ = ((_e350 - 1f) / (_e352 + 1f));
    let _e355 = r0_;
    let _e356 = r0_;
    let _e358 = r0_;
    let _e359 = r0_;
    let _e362 = (*cos1_);
    r12_ = ((_e355 * _e356) + ((1f - (_e358 * _e359)) * pow((1f - _e362), 5f)));
    let _e367 = r12_;
    t121_ = (1f - _e367);
    let _e369 = eta2_;
    phi12_ = select(0f, 3.1415927f, (_e369 < 1f));
    let _e372 = phi12_;
    phi21_ = (3.1415927f - _e372);
    let _e374 = (*base);
    sqrtBase = sqrt(clamp(_e374, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
    let _e377 = sqrtBase;
    let _e379 = sqrtBase;
    baseIor = ((vec3<f32>(1f, 1f, 1f) + _e377) / (vec3<f32>(1f, 1f, 1f) - _e379));
    let _e382 = baseIor;
    let _e383 = eta2_;
    let _e386 = baseIor;
    let _e387 = eta2_;
    r1_ = ((_e382 - vec3(_e383)) / (_e386 + vec3(_e387)));
    let _e391 = r1_;
    let _e392 = r1_;
    r1_ = (_e392 * _e391);
    let _e394 = r1_;
    let _e395 = r1_;
    let _e397 = cos2_;
    r23_ = (_e394 + ((vec3<f32>(1f, 1f, 1f) - _e395) * pow((1f - _e397), 5f)));
    let _e403 = baseIor[0u];
    let _e404 = eta2_;
    let _e408 = baseIor[1u];
    let _e409 = eta2_;
    let _e413 = baseIor[2u];
    let _e414 = eta2_;
    phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e403 < _e404)), select(0f, 3.1415927f, (_e408 < _e409)), select(0f, 3.1415927f, (_e413 < _e414)));
    let _e418 = eta2_;
    let _e420 = (*thickness);
    let _e422 = cos2_;
    opd_1 = (((2f * _e418) * _e420) * _e422);
    let _e424 = phi21_;
    let _e426 = phi23_;
    phi = (vec3(_e424) + _e426);
    let _e428 = r12_;
    let _e429 = r23_;
    r123_ = clamp((_e429 * _e428), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
    let _e432 = r123_;
    rootR123_ = sqrt(_e432);
    let _e434 = t121_;
    let _e435 = t121_;
    let _e437 = r23_;
    let _e439 = r123_;
    rs = ((_e437 * (_e434 * _e435)) / (vec3<f32>(1f, 1f, 1f) - _e439));
    let _e442 = r12_;
    let _e444 = rs;
    total_2 = (vec3(_e442) + _e444);
    let _e446 = rs;
    let _e447 = t121_;
    cm = (_e446 - vec3(_e447));
    m_2 = 1i;
    loop {
        let _e450 = m_2;
        if (_e450 <= 2i) {
            let _e452 = rootR123_;
            let _e453 = cm;
            cm = (_e453 * _e452);
            let _e455 = cm;
            let _e457 = m_2;
            let _e459 = opd_1;
            let _e461 = m_2;
            let _e463 = phi;
            param_219 = (f32(_e457) * _e459);
            param_220 = (_e463 * f32(_e461));
            let _e465 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((&param_219), (&param_220));
            let _e467 = total_2;
            total_2 = (_e467 + ((_e455 * 2f) * _e465));
            continue;
        } else {
            break;
        }
        continuing {
            let _e469 = m_2;
            m_2 = (_e469 + 1i);
        }
    }
    let _e471 = cos2Sq;
    if (_e471 < 0f) {
        local_53 = vec3<f32>(1f, 1f, 1f);
    } else {
        let _e473 = total_2;
        local_53 = max(_e473, vec3<f32>(0f, 0f, 0f));
    }
    let _e475 = local_53;
    return _e475;
}

fn ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var f0_3: vec3<f32>;
    var param_221: f32;
    var param_222: f32;
    var param_223: f32;
    var param_224: vec3<f32>;

    let _e310 = g_f0_dielectric;
    let _e312 = (*s_13).albedo;
    let _e314 = (*s_13).metallic;
    f0_3 = mix(_e310, _e312, vec3(clamp(_e314, 0f, 1f)));
    let _e320 = layer_info.iridescence[1u];
    param_221 = _e320;
    let _e322 = (*s_13).n_dot_v;
    param_222 = _e322;
    let _e325 = layer_info.iridescence[2u];
    param_223 = _e325;
    let _e326 = f0_3;
    param_224 = _e326;
    let _e327 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((&param_221), (&param_222), (&param_223), (&param_224));
    g_irid_fresnel = _e327;
    return;
}

fn ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_14: ptr<function, Surface>) {
    var param_225: f32;
    var param_226: f32;
    var param_227: f32;
    var t_2: vec3<f32>;
    var usable: bool;
    var local_54: vec3<f32>;
    var b_4: vec3<f32>;
    var turn_2: vec2<f32>;
    var along_1: vec3<f32>;
    var local_55: f32;
    var local_56: vec3<f32>;
    var phi_5520_: bool;

    let _e317 = (*s_14).n_dot_v;
    let _e321 = g_sheen_roughness;
    param_225 = _e321;
    param_226 = sqrt(clamp((1f - _e317), 0f, 1f));
    param_227 = 1f;
    let _e322 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_225), (&param_226), (&param_227));
    let _e323 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e322, 0f);
    g_sheen_albedo = _e323.z;
    let _e326 = g_sheen[0u];
    let _e328 = g_sheen[1u];
    let _e331 = g_sheen[2u];
    let _e333 = g_sheen_albedo;
    g_sheen_scale = (1f - (max(max(_e326, _e328), _e331) * _e333));
    let _e336 = v_tangent_1;
    let _e339 = (*s_14).n;
    let _e341 = (*s_14).n;
    let _e342 = v_tangent_1;
    t_2 = (_e336.xyz - (_e339 * dot(_e341, _e342.xyz)));
    let _e347 = t_2;
    let _e348 = t_2;
    usable = (dot(_e347, _e348) > 0.000000000001f);
    let _e351 = usable;
    if _e351 {
        let _e352 = t_2;
        local_54 = normalize(_e352);
    } else {
        local_54 = vec3<f32>(1f, 0f, 0f);
    }
    let _e354 = local_54;
    t_2 = _e354;
    let _e356 = (*s_14).n;
    let _e357 = t_2;
    let _e360 = v_tangent_1[3u];
    b_4 = (cross(_e356, _e357) * _e360);
    let _e362 = gl_FrontFacing_1;
    if !(_e362) {
        let _e364 = t_2;
        t_2 = -(_e364);
    }
    let _e367 = layer_info.anisotropy;
    turn_2 = _e367.yz;
    let _e369 = t_2;
    let _e371 = turn_2[0u];
    let _e373 = b_4;
    let _e375 = turn_2[1u];
    along_1 = ((_e369 * _e371) + (_e373 * _e375));
    let _e378 = usable;
    phi_5520_ = _e378;
    if _e378 {
        let _e379 = along_1;
        let _e380 = along_1;
        phi_5520_ = (dot(_e379, _e380) > 0.000000000001f);
    }
    let _e384 = phi_5520_;
    if _e384 {
        let _e387 = layer_info.anisotropy[0u];
        local_55 = clamp(_e387, 0f, 1f);
    } else {
        local_55 = 0f;
    }
    let _e389 = local_55;
    g_aniso = _e389;
    let _e390 = g_aniso;
    if (_e390 > 0f) {
        let _e392 = along_1;
        local_56 = normalize(_e392);
    } else {
        let _e394 = t_2;
        local_56 = _e394;
    }
    let _e395 = local_56;
    g_aniso_t = _e395;
    let _e397 = (*s_14).n;
    let _e398 = g_aniso_t;
    g_aniso_b = cross(_e397, _e398);
    return;
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e306 = frag_info.target_origin[1u];
    return _e306;
}

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_15: ptr<function, Surface>) {
    var orm: vec3<f32>;
    var param_228: i32;

    param_228 = 1i;
    let _e307 = MapUv_u0028_i1_u003b((&param_228));
    let _e308 = MaterialLodBias_u0028_();
    let _e309 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e307, _e308);
    orm = _e309.xyz;
    let _e312 = (*s_15).metallic;
    let _e314 = orm[2u];
    (*s_15).metallic = clamp((_e312 * _e314), 0f, 1f);
    let _e319 = (*s_15).roughness;
    let _e321 = orm[1u];
    (*s_15).roughness = clamp((_e319 * _e321), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_16: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_229: i32;
    var param_230: vec3<f32>;

    param_229 = 4i;
    let _e308 = MapUv_u0028_i1_u003b((&param_229));
    let _e309 = MaterialLodBias_u0028_();
    let _e310 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e308, _e309);
    param_230 = _e310.xyz;
    let _e312 = SrgbToLinear_u0028_vf3_u003b((&param_230));
    emissive = _e312;
    let _e313 = emissive;
    let _e315 = frag_info.emissive;
    let _e320 = frag_info.material2_[3u];
    (*s_16).emissive = ((_e313 * _e315.xyz) * _e320);
    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_17: ptr<function, Surface>) {
    var occlusion: f32;
    var param_231: i32;
    var strength_2: f32;

    param_231 = 3i;
    let _e308 = MapUv_u0028_i1_u003b((&param_231));
    let _e309 = MaterialLodBias_u0028_();
    let _e310 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e308, _e309);
    occlusion = _e310.x;
    let _e314 = frag_info.material2_[2u];
    let _e315 = OcclusionTarget_u0028_();
    strength_2 = (_e314 - (2f * _e315));
    let _e318 = occlusion;
    let _e319 = strength_2;
    (*s_17).occlusion = mix(1f, _e318, clamp(_e319, 0f, 1f));
    return;
}

fn MapMatrix_u0028_i1_u003b(slot_7: ptr<function, i32>) -> vec4<f32> {
    var u_2: vec4<f32>;
    var v_3: vec4<f32>;

    let _e307 = (*slot_7);
    let _e311 = layer_info.uv_transform[(_e307 * 2i)];
    u_2 = _e311;
    let _e312 = (*slot_7);
    let _e317 = layer_info.uv_transform[((_e312 * 2i) + 1i)];
    v_3 = _e317;
    let _e319 = u_2[0u];
    let _e321 = u_2[1u];
    let _e323 = v_3[0u];
    let _e325 = v_3[1u];
    return vec4<f32>(_e319, _e321, _e323, _e325);
}

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_18: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var param_232: i32;
    var t_3: vec3<f32>;
    var b_5: vec3<f32>;
    var m_3: vec4<f32>;
    var param_233: i32;
    var det: f32;
    var flip: f32;
    var front: vec3<f32>;
    var local_57: vec3<f32>;
    var turned: vec3<f32>;
    var turns: bool;
    var local_58: vec3<f32>;
    var local_59: vec3<f32>;
    var sampled: vec3<f32>;
    var phi_4194_: bool;
    var phi_4201_: bool;
    var phi_4208_: bool;
    var phi_4215_: bool;

    param_232 = 2i;
    let _e320 = MapUv_u0028_i1_u003b((&param_232));
    let _e321 = MaterialLodBias_u0028_();
    let _e322 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e320, _e321);
    sampledTexel = _e322;
    let _e323 = v_tangent_1;
    t_3 = _e323.xyz;
    let _e325 = t_3;
    let _e327 = (*s_18).n;
    let _e329 = (*s_18).n;
    let _e330 = t_3;
    t_3 = (_e325 - (_e327 * dot(_e329, _e330)));
    let _e334 = t_3;
    let _e335 = t_3;
    if (dot(_e334, _e335) < 0.000000000001f) {
        return;
    }
    let _e338 = t_3;
    t_3 = normalize(_e338);
    let _e341 = (*s_18).n;
    let _e342 = t_3;
    let _e345 = v_tangent_1[3u];
    b_5 = (cross(_e341, _e342) * _e345);
    param_233 = 2i;
    let _e347 = MapMatrix_u0028_i1_u003b((&param_233));
    m_3 = _e347;
    let _e349 = m_3[0u];
    let _e351 = m_3[3u];
    let _e354 = m_3[1u];
    let _e356 = m_3[2u];
    det = ((_e349 * _e351) - (_e354 * _e356));
    let _e359 = det;
    flip = select(1f, -1f, (_e359 < 0f));
    let _e362 = gl_FrontFacing_1;
    if _e362 {
        let _e363 = b_5;
        local_57 = _e363;
    } else {
        let _e364 = b_5;
        local_57 = -(_e364);
    }
    let _e366 = local_57;
    front = _e366;
    let _e367 = t_3;
    let _e369 = m_3[3u];
    let _e371 = front;
    let _e373 = m_3[2u];
    let _e376 = flip;
    turned = (((_e367 * _e369) + (_e371 * _e373)) * _e376);
    let _e379 = m_3[1u];
    let _e380 = (_e379 != 0f);
    phi_4194_ = _e380;
    if !(_e380) {
        let _e383 = m_3[2u];
        phi_4194_ = (_e383 != 0f);
    }
    let _e386 = phi_4194_;
    phi_4201_ = _e386;
    if !(_e386) {
        let _e389 = m_3[0u];
        phi_4201_ = (_e389 < 0f);
    }
    let _e392 = phi_4201_;
    phi_4208_ = _e392;
    if !(_e392) {
        let _e395 = m_3[3u];
        phi_4208_ = (_e395 < 0f);
    }
    let _e398 = phi_4208_;
    phi_4215_ = _e398;
    if _e398 {
        let _e399 = turned;
        let _e400 = turned;
        phi_4215_ = (dot(_e399, _e400) > 0.000000000001f);
    }
    let _e404 = phi_4215_;
    turns = _e404;
    let _e405 = turns;
    if _e405 {
        let _e406 = turned;
        local_58 = normalize(_e406);
    } else {
        let _e408 = t_3;
        local_58 = _e408;
    }
    let _e409 = local_58;
    t_3 = _e409;
    let _e410 = turns;
    if _e410 {
        let _e412 = (*s_18).n;
        let _e413 = t_3;
        let _e416 = v_tangent_1[3u];
        let _e418 = flip;
        local_59 = ((cross(_e412, _e413) * _e416) * _e418);
    } else {
        let _e420 = b_5;
        local_59 = _e420;
    }
    let _e421 = local_59;
    b_5 = _e421;
    let _e422 = gl_FrontFacing_1;
    if !(_e422) {
        let _e424 = t_3;
        t_3 = -(_e424);
    }
    let _e426 = sampledTexel;
    sampled = ((_e426.xyz * 2f) - vec3(1f));
    let _e433 = frag_info.emissive[3u];
    if (_e433 > 0.5f) {
        let _e435 = sampled;
        let _e437 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e435.xy, _e437.xy)), 0f));
    }
    let _e446 = frag_info.material2_[1u];
    let _e447 = sampled;
    let _e449 = (_e447.xy * _e446);
    sampled[0u] = _e449.x;
    sampled[1u] = _e449.y;
    let _e454 = t_3;
    let _e456 = sampled[0u];
    let _e458 = b_5;
    let _e460 = sampled[1u];
    let _e464 = (*s_18).n;
    let _e466 = sampled[2u];
    (*s_18).n = normalize((((_e454 * _e456) + (_e458 * _e460)) + (_e464 * _e466)));
    let _e472 = (*s_18).n;
    let _e474 = (*s_18).v;
    (*s_18).n_dot_v = max(dot(_e472, _e474), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e305 = (*texel_5);
    let _e309 = irradiance_info.atlas;
    let _e312 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e305 + vec2(0.5f)) * _e309.xy), 0f);
    return _e312;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_9: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_5: vec2<f32>;
    var low: vec2<f32>;
    var f_5: vec2<f32>;
    var a_6: vec4<f32>;
    var param_234: vec2<f32>;
    var b_6: vec4<f32>;
    var param_235: vec2<f32>;
    var c_1: vec4<f32>;
    var param_236: vec2<f32>;
    var d_6: vec4<f32>;
    var param_237: vec2<f32>;

    let _e318 = (*uv_9);
    let _e319 = (*interior);
    at_5 = ((vec2(1f) + (_e318 * _e319)) - vec2(0.5f));
    let _e325 = at_5;
    low = floor(_e325);
    let _e327 = at_5;
    let _e328 = low;
    f_5 = (_e327 - _e328);
    let _e330 = (*corner);
    let _e331 = low;
    param_234 = (_e330 + _e331);
    let _e333 = AtlasTexel_u0028_vf2_u003b((&param_234));
    a_6 = _e333;
    let _e334 = (*corner);
    let _e335 = low;
    param_235 = ((_e334 + _e335) + vec2<f32>(1f, 0f));
    let _e338 = AtlasTexel_u0028_vf2_u003b((&param_235));
    b_6 = _e338;
    let _e339 = (*corner);
    let _e340 = low;
    param_236 = ((_e339 + _e340) + vec2<f32>(0f, 1f));
    let _e343 = AtlasTexel_u0028_vf2_u003b((&param_236));
    c_1 = _e343;
    let _e344 = (*corner);
    let _e345 = low;
    param_237 = ((_e344 + _e345) + vec2<f32>(1f, 1f));
    let _e348 = AtlasTexel_u0028_vf2_u003b((&param_237));
    d_6 = _e348;
    let _e349 = a_6;
    let _e350 = b_6;
    let _e352 = f_5[0u];
    let _e355 = c_1;
    let _e356 = d_6;
    let _e358 = f_5[0u];
    let _e362 = f_5[1u];
    return mix(mix(_e349, _e350, vec4(_e352)), mix(_e355, _e356, vec4(_e358)), vec4(_e362));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e309 = (*direction_1)[0u];
    let _e312 = (*direction_1)[1u];
    let _e316 = (*direction_1)[2u];
    sum_1 = ((abs(_e309) + abs(_e312)) + abs(_e316));
    let _e319 = sum_1;
    if (_e319 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e321 = (*direction_1);
    let _e322 = sum_1;
    n_6 = (_e321 / vec3(_e322));
    let _e325 = n_6;
    xy = _e325.xy;
    let _e328 = n_6[2u];
    if (_e328 < 0f) {
        let _e331 = n_6[1u];
        let _e335 = n_6[0u];
        let _e340 = n_6[0u];
        let _e344 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e331)) * select(-1f, 1f, (_e335 >= 0f))), ((1f - abs(_e340)) * select(-1f, 1f, (_e344 >= 0f))));
    }
    let _e349 = xy;
    return ((_e349 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_2: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base_1: vec3<f32>;
    var f_6: vec3<f32>;
    var total_3: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_238: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_239: vec3<f32>;
    var param_240: vec2<f32>;
    var param_241: f32;
    var param_242: vec2<f32>;
    var chebyshev: f32;
    var variance_2: f32;
    var difference: f32;
    var param_243: vec3<f32>;
    var param_244: vec2<f32>;
    var param_245: f32;
    var param_246: vec2<f32>;
    var local_60: vec3<f32>;

    let _e351 = irradiance_info.origin;
    origin_2 = _e351.xyz;
    let _e354 = irradiance_info.spacing;
    spacing = _e354.xyz;
    let _e357 = irradiance_info.counts;
    counts = _e357.xyz;
    let _e361 = irradiance_info.tiles[0u];
    irradianceTile = _e361;
    let _e364 = irradiance_info.tiles[1u];
    depthTile = _e364;
    let _e367 = irradiance_info.tiles[2u];
    columns = _e367;
    let _e370 = irradiance_info.tiles[3u];
    momentsTop = _e370;
    let _e371 = (*normal_1);
    unit = normalize(_e371);
    let _e373 = (*world_5);
    let _e374 = unit;
    let _e377 = irradiance_info.spacing[3u];
    let _e380 = (*view_2);
    let _e383 = irradiance_info.counts[3u];
    biased = ((_e373 + (_e374 * _e377)) + (_e380 * _e383));
    let _e386 = biased;
    let _e387 = origin_2;
    let _e389 = spacing;
    grid_1 = ((_e386 - _e387) / _e389);
    let _e391 = grid_1;
    let _e393 = counts;
    base_1 = clamp(floor(_e391), vec3<f32>(0f, 0f, 0f), (_e393 - vec3(2f)));
    let _e397 = grid_1;
    let _e398 = base_1;
    f_6 = clamp((_e397 - _e398), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_3 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e401 = corner_1;
        if (_e401 < 8i) {
            let _e403 = corner_1;
            let _e406 = corner_1;
            let _e411 = corner_1;
            offset_3 = vec3<f32>(f32((_e403 & 1i)), f32(((_e406 >> bitcast<u32>(1i)) & 1i)), f32(((_e411 >> bitcast<u32>(2i)) & 1i)));
            let _e417 = base_1;
            let _e418 = offset_3;
            cell_2 = (_e417 + _e418);
            let _e421 = cell_2[2u];
            let _e423 = counts[1u];
            let _e426 = cell_2[1u];
            let _e429 = counts[0u];
            let _e432 = cell_2[0u];
            probe = ((((_e421 * _e423) + _e426) * _e429) + _e432);
            let _e434 = probe;
            let _e435 = columns;
            let _e440 = probe;
            let _e441 = columns;
            tile_4 = vec2<f32>((_e434 - (floor((_e434 / _e435)) * _e435)), floor((_e440 / _e441)));
            let _e445 = tile_4;
            let _e446 = irradianceTile;
            irradianceCorner = (_e445 * (_e446 + 2f));
            let _e450 = tile_4[0u];
            let _e451 = depthTile;
            let _e454 = momentsTop;
            let _e456 = tile_4[1u];
            let _e457 = depthTile;
            momentCorner = vec2<f32>((_e450 * (_e451 + 2f)), (_e454 + (_e456 * (_e457 + 2f))));
            let _e462 = irradianceCorner;
            param_238 = (_e462 + vec2(1f));
            let _e465 = AtlasTexel_u0028_vf2_u003b((&param_238));
            if (_e465.w < 0.5f) {
                continue;
            }
            let _e468 = f_6;
            let _e470 = f_6;
            let _e471 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e468), _e470, _e471);
            let _e474 = trilinear[0u];
            let _e476 = trilinear[1u];
            let _e479 = trilinear[2u];
            weight_3 = max(((_e474 * _e476) * _e479), 0.001f);
            let _e482 = origin_2;
            let _e483 = spacing;
            let _e484 = cell_2;
            probePosition = (_e482 + (_e483 * _e484));
            let _e487 = probePosition;
            let _e488 = biased;
            toProbe = (_e487 - _e488);
            let _e490 = toProbe;
            distance_4 = length(_e490);
            let _e492 = distance_4;
            if (_e492 > 0.000001f) {
                let _e494 = toProbe;
                let _e495 = distance_4;
                direction_2 = (_e494 / vec3(_e495));
                let _e498 = unit;
                let _e499 = probePosition;
                let _e500 = (*world_5);
                facing = ((dot(_e498, normalize((_e499 - _e500))) * 0.5f) + 0.5f);
                let _e506 = facing;
                let _e507 = facing;
                probeWeight = ((_e506 * _e507) + 0.2f);
                let _e510 = direction_2;
                param_239 = -(_e510);
                let _e512 = ProbeOctahedral_u0028_vf3_u003b((&param_239));
                let _e513 = momentCorner;
                param_240 = _e513;
                let _e514 = depthTile;
                param_241 = _e514;
                param_242 = _e512;
                let _e515 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_240), (&param_241), (&param_242));
                moments_3 = _e515.xy;
                chebyshev = 1f;
                let _e517 = distance_4;
                let _e519 = moments_3[0u];
                if (_e517 > _e519) {
                    let _e522 = moments_3[1u];
                    let _e524 = moments_3[0u];
                    let _e526 = moments_3[0u];
                    variance_2 = max((_e522 - (_e524 * _e526)), 0.000001f);
                    let _e530 = distance_4;
                    let _e532 = moments_3[0u];
                    difference = (_e530 - _e532);
                    let _e534 = variance_2;
                    let _e535 = variance_2;
                    let _e536 = difference;
                    let _e537 = difference;
                    chebyshev = (_e534 / (_e535 + (_e536 * _e537)));
                    let _e541 = chebyshev;
                    let _e542 = chebyshev;
                    let _e544 = chebyshev;
                    chebyshev = ((_e541 * _e542) * _e544);
                }
                let _e546 = probeWeight;
                let _e547 = chebyshev;
                probeWeight = max((_e546 * max(_e547, 0.05f)), 0.000001f);
                let _e551 = probeWeight;
                if (_e551 < 0.2f) {
                    let _e553 = probeWeight;
                    let _e554 = probeWeight;
                    let _e557 = probeWeight;
                    probeWeight = (_e557 * ((_e553 * _e554) * 25f));
                }
                let _e559 = probeWeight;
                let _e560 = weight_3;
                weight_3 = (_e560 * _e559);
            }
            let _e562 = unit;
            param_243 = _e562;
            let _e563 = ProbeOctahedral_u0028_vf3_u003b((&param_243));
            let _e564 = irradianceCorner;
            param_244 = _e564;
            let _e565 = irradianceTile;
            param_245 = _e565;
            param_246 = _e563;
            let _e566 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_244), (&param_245), (&param_246));
            let _e568 = weight_3;
            let _e570 = total_3;
            total_3 = (_e570 + (_e566.xyz * _e568));
            let _e572 = weight_3;
            let _e573 = weights;
            weights = (_e573 + _e572);
            continue;
        } else {
            break;
        }
        continuing {
            let _e575 = corner_1;
            corner_1 = (_e575 + 1i);
        }
    }
    let _e577 = weights;
    if (_e577 > 0f) {
        let _e579 = total_3;
        let _e580 = weights;
        local_60 = (_e579 / vec3(_e580));
    } else {
        local_60 = vec3<f32>(0f, 0f, 0f);
    }
    let _e583 = local_60;
    return _e583;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e306 = irradiance_info.origin[3u];
    return (_e306 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_19: ptr<function, Surface>) {
    var param_247: vec3<f32>;
    var param_248: vec3<f32>;
    var param_249: vec3<f32>;
    var param_250: Surface;
    var param_251: Surface;
    var param_252: Surface;

    let _e311 = IrradianceEnabled_u0028_();
    if _e311 {
        let _e312 = v_world_position_1;
        param_247 = _e312;
        let _e314 = (*s_19).n;
        param_248 = _e314;
        let _e316 = (*s_19).v;
        param_249 = _e316;
        let _e317 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_247), (&param_248), (&param_249));
        let _e320 = frag_info.material[2u];
        (*s_19).ambient = (_e317 * _e320);
    }
    let _e323 = (*s_19);
    param_250 = _e323;
    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((&param_250));
    let _e324 = param_250;
    (*s_19) = _e324;
    let _e325 = (*s_19);
    param_251 = _e325;
    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((&param_251));
    let _e326 = param_251;
    (*s_19) = _e326;
    let _e327 = (*s_19);
    param_252 = _e327;
    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((&param_252));
    let _e328 = param_252;
    (*s_19) = _e328;
    return;
}

fn ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_20: ptr<function, Surface>) {
    var coatTexel: vec4<f32>;
    var sheenTexel: vec4<f32>;
    var param_253: vec3<f32>;
    var ior_3: f32;
    var r_5: f32;
    var local_61: f32;
    var bent: vec3<f32>;
    var distance_5: f32;
    var local_62: vec3<f32>;
    var fc: f32;

    let _e315 = v_texcoord_1;
    let _e316 = MaterialLodBias_u0028_();
    let _e317 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e315, _e316);
    coatTexel = _e317;
    let _e318 = v_texcoord_1;
    let _e319 = MaterialLodBias_u0028_();
    let _e320 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e318, _e319);
    sheenTexel = _e320;
    let _e322 = layer_info.sheen;
    let _e324 = sheenTexel;
    param_253 = _e324.xyz;
    let _e326 = SrgbToLinear_u0028_vf3_u003b((&param_253));
    g_sheen = (_e322.xyz * _e326);
    let _e330 = layer_info.sheen[3u];
    let _e332 = sheenTexel[3u];
    g_sheen_roughness = clamp((_e330 * _e332), 0.07f, 1f);
    let _e337 = layer_info.coat[2u];
    ior_3 = max(_e337, 1f);
    let _e339 = IorInfinite_u0028_();
    if _e339 {
        local_61 = 1f;
    } else {
        let _e340 = ior_3;
        let _e342 = ior_3;
        local_61 = ((_e340 - 1f) / (_e342 + 1f));
    }
    let _e345 = local_61;
    r_5 = _e345;
    let _e346 = r_5;
    let _e347 = r_5;
    let _e351 = layer_info.specular;
    let _e357 = layer_info.specular[3u];
    g_f0_dielectric = (min((vec3((_e346 * _e347)) * _e351.xyz), vec3<f32>(1f, 1f, 1f)) * _e357);
    let _e361 = layer_info.specular[3u];
    g_f90_ = _e361;
    let _e364 = layer_info.coat[0u];
    let _e366 = coatTexel[0u];
    g_coat = clamp((_e364 * _e366), 0f, 1f);
    let _e371 = layer_info.coat[1u];
    let _e373 = coatTexel[1u];
    g_coat_roughness = clamp((_e371 * _e373), 0.02f, 1f);
    let _e378 = layer_info.transmission[0u];
    let _e380 = coatTexel[2u];
    g_transmission = clamp((_e378 * _e380), 0f, 1f);
    let _e385 = layer_info.transmission[1u];
    let _e387 = coatTexel[3u];
    g_thickness = max((_e385 * _e387), 0f);
    let _e392 = layer_info.attenuation[3u];
    let _e394 = g_thickness;
    if ((_e392 > 0.5f) && (_e394 > 0f)) {
        let _e398 = (*s_20).v;
        let _e401 = (*s_20).n;
        let _e402 = RefractionIor_u0028_();
        bent = refract(-(_e398), _e401, (1f / _e402));
        let _e405 = g_thickness;
        let _e407 = (*s_20).n;
        let _e408 = bent;
        let _e413 = g_thickness;
        g_thickness = max((_e405 * max(-(dot(_e407, _e408)), 0f)), (0.0001f * _e413));
    }
    let _e418 = layer_info.transmission[2u];
    distance_5 = _e418;
    let _e419 = distance_5;
    if (_e419 > 0f) {
        let _e422 = layer_info.attenuation;
        let _e425 = g_thickness;
        let _e426 = distance_5;
        local_62 = pow(max(_e422.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e425 / _e426)));
    } else {
        local_62 = vec3<f32>(1f, 1f, 1f);
    }
    let _e430 = local_62;
    g_transmittance = _e430;
    let _e433 = layer_info.iridescence[0u];
    g_iridescence = clamp(_e433, 0f, 1f);
    let _e436 = (*s_20).n;
    g_coat_n = _e436;
    let _e438 = (*s_20).n;
    let _e440 = (*s_20).v;
    g_coat_n_dot_v = max(dot(_e438, _e440), 0.0001f);
    let _e443 = g_coat_n_dot_v;
    fc = (0.04f + (0.96f * pow((1f - _e443), 5f)));
    let _e448 = g_coat;
    let _e449 = fc;
    g_coat_through = (1f - (_e448 * _e449));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_63: vec3<f32>;

    let _e305 = Orthographic_u0028_();
    if _e305 {
        let _e307 = fog_info.forward;
        local_63 = -(_e307.xyz);
    } else {
        let _e311 = fog_info.eye;
        let _e313 = v_world_position_1;
        local_63 = normalize((_e311.xyz - _e313));
    }
    let _e316 = local_63;
    return _e316;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin_3: vec3<f32>;
    var cell_3: vec3<f32>;
    var p3_: vec3<f32>;

    let _e310 = (*cutoff);
    key_2 = (-2f - _e310);
    let _e312 = key_2;
    let _e315 = key_2;
    let _e317 = floor((_e315 / 128f));
    let _e322 = key_2;
    origin_3 = vec3<f32>(floor((_e312 / 16384f)), (_e317 - (floor((_e317 / 128f)) * 128f)), (_e322 - (floor((_e322 / 128f)) * 128f)));
    let _e328 = (*scenePosition);
    let _e331 = origin_3;
    let _e332 = (floor((_e328 * 16f)) + _e331);
    let _e333 = vec3(128f);
    cell_3 = (_e332 - (floor((_e332 / _e333)) * _e333));
    let _e338 = cell_3;
    p3_ = fract((_e338 * 0.1031f));
    let _e341 = p3_;
    let _e342 = p3_;
    let _e347 = p3_;
    p3_ = (_e347 + vec3(dot(_e341, (_e342.zyx + vec3(31.32f)))));
    let _e351 = p3_[0u];
    let _e353 = p3_[1u];
    let _e356 = p3_[2u];
    return fract(((_e351 + _e353) * _e356));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var param_254: i32;
    var s_21: Surface;
    var param_255: vec3<f32>;
    var param_256: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_257: vec3<f32>;
    var param_258: f32;

    param_254 = 0i;
    let _e313 = MapUv_u0028_i1_u003b((&param_254));
    let _e314 = MaterialLodBias_u0028_();
    let _e315 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e313, _e314);
    texel_6 = _e315;
    let _e316 = texel_6;
    param_255 = _e316.xyz;
    let _e318 = SrgbToLinear_u0028_vf3_u003b((&param_255));
    let _e320 = frag_info.base_color;
    param_256 = _e320.xyz;
    let _e322 = SrgbToLinear_u0028_vf3_u003b((&param_256));
    let _e324 = v_color_1;
    s_21.albedo = ((_e318 * _e322) * _e324.xyz);
    let _e329 = texel_6[3u];
    let _e332 = frag_info.base_color[3u];
    let _e335 = v_color_1[3u];
    s_21.alpha = ((_e329 * _e332) * _e335);
    let _e339 = s_21.albedo;
    g_albedo = _e339;
    let _e342 = frag_info.material2_[0u];
    cutoff_1 = _e342;
    let _e343 = cutoff_1;
    if (_e343 > 1f) {
        let _e345 = cutoff_1;
        edge = (_e345 - 1f);
        let _e348 = s_21.alpha;
        let _e349 = edge;
        let _e352 = s_21.alpha;
        let _e353 = fwidth(_e352);
        s_21.alpha = clamp((((_e348 - _e349) / max(_e353, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e359 = cutoff_1;
        if (_e359 >= 0f) {
            let _e362 = s_21.alpha;
            let _e363 = cutoff_1;
            if (_e362 < _e363) {
                discard;
            }
            s_21.alpha = 1f;
        } else {
            let _e366 = cutoff_1;
            if (_e366 < -1.5f) {
                let _e369 = s_21.alpha;
                let _e370 = v_world_position_1;
                param_257 = _e370;
                let _e371 = cutoff_1;
                param_258 = _e371;
                let _e372 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_257), (&param_258));
                if (_e369 < _e372) {
                    discard;
                }
            }
        }
    }
    let _e374 = cutoff_1;
    let _e376 = cutoff_1;
    g_premultiply = ((_e374 < 0f) && (_e376 > -0.75f));
    let _e379 = v_normal_1;
    s_21.n = normalize(_e379);
    let _e382 = gl_FrontFacing_1;
    if !(_e382) {
        let _e385 = s_21.n;
        s_21.n = -(_e385);
    }
    let _e388 = TowardsEye_u0028_();
    s_21.v = _e388;
    let _e391 = s_21.n;
    let _e393 = s_21.v;
    s_21.n_dot_v = max(dot(_e391, _e393), 0.0001f);
    let _e399 = frag_info.material[0u];
    s_21.metallic = clamp(_e399, 0f, 1f);
    let _e404 = frag_info.material[1u];
    s_21.roughness = clamp(_e404, 0.02f, 1f);
    let _e408 = frag_info.ambient_ground;
    let _e411 = frag_info.ambient_sky;
    let _e415 = s_21.n[1u];
    let _e422 = frag_info.material[2u];
    s_21.ambient = (mix(_e408.xyz, _e411.xyz, vec3(((_e415 * 0.5f) + 0.5f))) * _e422);
    let _e427 = frag_info.frame_params[0u];
    s_21.exposure = max(_e427, 0f);
    s_21.occlusion = 1f;
    s_21.emissive = vec3<f32>(0f, 0f, 0f);
    let _e432 = s_21;
    return _e432;
}

fn main_1() {
    var s_22: Surface;
    var param_259: Surface;
    var param_260: Surface;
    var param_261: Surface;
    var param_262: Surface;
    var param_263: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_264: vec3<f32>;
    var param_265: f32;
    var param_266: f32;
    var directOcclusion: f32;
    var param_267: Surface;
    var indirectOcclusion: f32;
    var param_268: Surface;
    var ambient: vec3<f32>;
    var levels_1: f32;
    var coatAmbient: vec3<f32>;
    var sheenIncoming: vec3<f32>;
    var f0_4: vec3<f32>;
    var f90_2: f32;
    var bent_1: vec3<f32>;
    var across: vec3<f32>;
    var anisoN: vec3<f32>;
    var bend: f32;
    var bend4_: f32;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_4: vec2<f32>;
    var param_269: f32;
    var param_270: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var reflects: vec3<f32>;
    var through_1: vec3<f32>;
    var local_64: vec3<f32>;
    var param_271: Surface;
    var param_272: f32;
    var coatPrefiltered: vec3<f32>;
    var coatAb: vec2<f32>;
    var param_273: f32;
    var param_274: f32;
    var sceneAb: vec2<f32>;
    var param_275: f32;
    var param_276: f32;
    var sceneReflects: vec3<f32>;
    var passes: vec3<f32>;
    var param_277: Surface;
    var sheenAmbient: vec3<f32>;
    var lit_3: vec3<f32>;
    var param_278: Surface;
    var param_279: Surface;
    var param_280: vec3<f32>;
    var param_281: vec3<f32>;
    var param_282: f32;
    var param_283: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    g_f0_dielectric = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_f90_ = 1f;
    g_coat = 0f;
    g_coat_roughness = 0.02f;
    g_coat_n = vec3<f32>(0f, 0f, 1f);
    g_coat_n_dot_v = 1f;
    g_coat_through = 1f;
    g_sheen = vec3<f32>(0f, 0f, 0f);
    g_sheen_roughness = 0.07f;
    g_sheen_albedo = 0f;
    g_sheen_scale = 1f;
    g_aniso = 0f;
    g_aniso_t = vec3<f32>(1f, 0f, 0f);
    g_aniso_b = vec3<f32>(0f, 1f, 0f);
    g_transmission = 0f;
    g_thickness = 0f;
    g_transmittance = vec3<f32>(1f, 1f, 1f);
    g_iridescence = 0f;
    g_irid_fresnel = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_pane = false;
    let _e364 = ReadSurface_u0028_();
    s_22 = _e364;
    let _e365 = s_22;
    param_259 = _e365;
    ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_259));
    let _e366 = s_22;
    param_260 = _e366;
    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((&param_260));
    let _e367 = param_260;
    s_22 = _e367;
    let _e368 = s_22;
    param_261 = _e368;
    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((&param_261));
    let _e369 = param_261;
    s_22 = _e369;
    let _e370 = s_22;
    param_262 = _e370;
    ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_262));
    let _e371 = s_22;
    param_263 = _e371;
    ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_263));
    let _e373 = s_22.metallic;
    metallic = clamp(_e373, 0f, 1f);
    let _e376 = s_22.albedo;
    let _e377 = metallic;
    diffuseColor_1 = (_e376 * (1f - _e377));
    let _e380 = EonDiffuse_u0028_();
    if _e380 {
        let _e381 = diffuseColor_1;
        param_264 = _e381;
        let _e383 = s_22.roughness;
        param_265 = _e383;
        let _e385 = s_22.n_dot_v;
        param_266 = _e385;
        let _e386 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_264), (&param_265), (&param_266));
        diffuseColor_1 = _e386;
    }
    let _e387 = s_22;
    param_267 = _e387;
    let _e388 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_267));
    directOcclusion = _e388;
    let _e389 = s_22;
    param_268 = _e389;
    let _e390 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_268));
    indirectOcclusion = _e390;
    let _e391 = diffuseColor_1;
    let _e393 = s_22.ambient;
    let _e395 = indirectOcclusion;
    ambient = ((_e391 * _e393) * _e395);
    let _e397 = g_premultiply;
    let _e398 = g_transmission;
    let _e401 = g_thickness;
    g_pane = ((_e397 && (_e398 > 0f)) && (_e401 <= 0f));
    let _e404 = SceneColorBound_u0028_();
    let _e405 = g_pane;
    let _e407 = g_transmittance;
    let _e410 = g_transmission;
    let _e413 = ambient;
    ambient = (_e413 * mix(vec3<f32>(1f, 1f, 1f), select(_e407, vec3<f32>(0f, 0f, 0f), vec3((_e404 || _e405))), vec3(_e410)));
    let _e417 = frag_info.frame_params[3u];
    levels_1 = _e417;
    coatAmbient = vec3<f32>(0f, 0f, 0f);
    let _e419 = s_22.ambient;
    sheenIncoming = _e419;
    let _e420 = levels_1;
    if (_e420 > 0f) {
        let _e422 = g_f0_dielectric;
        let _e424 = s_22.albedo;
        let _e425 = metallic;
        f0_4 = mix(_e422, _e424, vec3(_e425));
        let _e428 = g_f90_;
        let _e429 = metallic;
        f90_2 = mix(_e428, 1f, _e429);
        let _e432 = s_22.n;
        bent_1 = _e432;
        let _e433 = g_aniso;
        if (_e433 > 0f) {
            let _e435 = g_aniso_t;
            let _e437 = s_22.v;
            across = cross(_e435, _e437);
            let _e439 = across;
            let _e440 = g_aniso_t;
            anisoN = cross(_e439, _e440);
            let _e442 = g_aniso;
            let _e444 = s_22.roughness;
            bend = (1f - (_e442 * (1f - _e444)));
            let _e448 = bend;
            let _e449 = bend;
            let _e451 = bend;
            let _e453 = bend;
            bend4_ = (((_e448 * _e449) * _e451) * _e453);
            let _e455 = anisoN;
            let _e457 = s_22.n;
            let _e458 = bend4_;
            bent_1 = normalize(mix(_e455, _e457, vec3(_e458)));
        }
        let _e463 = s_22.v;
        let _e465 = bent_1;
        reflected = reflect(-(_e463), _e465);
        let _e468 = s_22.n;
        let _e469 = levels_1;
        let _e470 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e468, _e469);
        irradiance = _e470.xyz;
        let _e472 = reflected;
        let _e474 = s_22.roughness;
        let _e475 = levels_1;
        let _e477 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e472, (_e474 * _e475));
        prefiltered = _e477.xyz;
        let _e480 = s_22.roughness;
        param_269 = _e480;
        let _e482 = s_22.n_dot_v;
        param_270 = _e482;
        let _e483 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_269), (&param_270));
        ab_4 = _e483;
        let _e484 = f0_4;
        let _e485 = g_irid_fresnel;
        let _e486 = g_iridescence;
        let _e490 = ab_4[0u];
        let _e492 = f90_2;
        let _e494 = ab_4[1u];
        single_1 = ((mix(_e484, _e485, vec3(_e486)) * _e490) + vec3((_e492 * _e494)));
        let _e498 = prefiltered;
        let _e499 = single_1;
        specular_1 = (_e498 * _e499);
        let _e501 = EnergyCompensation_u0028_();
        if _e501 {
            let _e503 = ab_4[0u];
            let _e505 = ab_4[1u];
            missed = (1f - (_e503 + _e505));
            let _e508 = f0_4;
            let _e509 = f0_4;
            average_2 = (_e508 + ((vec3<f32>(1f, 1f, 1f) - _e509) / vec3(21f)));
            let _e514 = single_1;
            let _e515 = average_2;
            let _e517 = missed;
            let _e518 = average_2;
            multiple = ((_e514 * _e515) / (vec3<f32>(1f, 1f, 1f) - (_e518 * _e517)));
            let _e522 = multiple;
            let _e523 = missed;
            let _e525 = irradiance;
            let _e527 = specular_1;
            specular_1 = (_e527 + ((_e522 * _e523) * _e525));
        }
        let _e529 = diffuseColor_1;
        let _e530 = irradiance;
        let _e532 = specular_1;
        let _e536 = frag_info.material[2u];
        let _e538 = indirectOcclusion;
        ambient = ((((_e529 * _e530) + _e532) * _e536) * _e538);
        let _e540 = g_f0_dielectric;
        let _e541 = g_irid_fresnel;
        let _e542 = g_iridescence;
        let _e546 = ab_4[0u];
        let _e548 = g_f90_;
        let _e550 = ab_4[1u];
        reflects = ((mix(_e540, _e541, vec3(_e542)) * _e546) + vec3((_e548 * _e550)));
        let _e554 = SceneColorBound_u0028_();
        let _e555 = g_pane;
        if (_e554 || _e555) {
            local_64 = vec3<f32>(0f, 0f, 0f);
        } else {
            let _e557 = s_22;
            param_271 = _e557;
            let _e558 = levels_1;
            param_272 = _e558;
            let _e559 = TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b((&param_271), (&param_272));
            let _e560 = g_transmittance;
            let _e562 = reflects;
            local_64 = ((_e559 * _e560) * (vec3<f32>(1f, 1f, 1f) - min(_e562, vec3<f32>(1f, 1f, 1f))));
        }
        let _e566 = local_64;
        through_1 = _e566;
        let _e567 = diffuseColor_1;
        let _e568 = through_1;
        let _e569 = irradiance;
        let _e572 = g_transmission;
        let _e576 = frag_info.material[2u];
        let _e578 = indirectOcclusion;
        let _e580 = ambient;
        ambient = (_e580 + ((((_e567 * (_e568 - _e569)) * _e572) * _e576) * _e578));
        let _e583 = s_22.v;
        let _e585 = g_coat_n;
        let _e587 = g_coat_roughness;
        let _e588 = levels_1;
        let _e590 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e583), _e585), (_e587 * _e588));
        coatPrefiltered = _e590.xyz;
        let _e592 = g_coat_roughness;
        param_273 = _e592;
        let _e593 = g_coat_n_dot_v;
        param_274 = _e593;
        let _e594 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_273), (&param_274));
        coatAb = _e594;
        let _e595 = coatPrefiltered;
        let _e597 = coatAb[0u];
        let _e600 = coatAb[1u];
        let _e603 = g_coat;
        let _e607 = frag_info.material[2u];
        let _e609 = indirectOcclusion;
        coatAmbient = ((((_e595 * ((0.04f * _e597) + _e600)) * _e603) * _e607) * _e609);
        let _e612 = s_22.n;
        let _e613 = g_sheen_roughness;
        let _e614 = levels_1;
        let _e616 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e612, (_e613 * _e614));
        let _e620 = frag_info.material[2u];
        sheenIncoming = (_e616.xyz * _e620);
    }
    let _e623 = s_22.roughness;
    param_275 = _e623;
    let _e625 = s_22.n_dot_v;
    param_276 = _e625;
    let _e626 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_275), (&param_276));
    sceneAb = _e626;
    let _e627 = g_f0_dielectric;
    let _e628 = g_irid_fresnel;
    let _e629 = g_iridescence;
    let _e633 = sceneAb[0u];
    let _e635 = g_f90_;
    let _e637 = sceneAb[1u];
    sceneReflects = ((mix(_e627, _e628, vec3(_e629)) * _e633) + vec3((_e635 * _e637)));
    let _e641 = diffuseColor_1;
    let _e642 = g_transmittance;
    let _e644 = sceneReflects;
    let _e648 = g_transmission;
    passes = (((_e641 * _e642) * (vec3<f32>(1f, 1f, 1f) - min(_e644, vec3<f32>(1f, 1f, 1f)))) * _e648);
    let _e650 = g_pane;
    if _e650 {
        let _e652 = passes[0u];
        let _e654 = passes[1u];
        let _e657 = passes[2u];
        g_pass_through = clamp((((_e652 + _e654) + _e657) / 3f), 0f, 1f);
    } else {
        let _e661 = SceneColorBound_u0028_();
        if _e661 {
            let _e662 = s_22;
            param_277 = _e662;
            let _e663 = SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_277));
            let _e664 = passes;
            let _e666 = ambient;
            ambient = (_e666 + (_e663 * _e664));
        }
    }
    let _e668 = diffuseColor_1;
    let _e669 = SampleLightmap_u0028_();
    let _e671 = indirectOcclusion;
    let _e673 = ambient;
    ambient = (_e673 + ((_e668 * _e669) * _e671));
    let _e675 = g_sheen;
    let _e676 = g_sheen_albedo;
    let _e678 = sheenIncoming;
    let _e680 = indirectOcclusion;
    sheenAmbient = (((_e675 * _e676) * _e678) * _e680);
    let _e682 = s_22;
    param_278 = _e682;
    let _e683 = 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((&param_278));
    let _e684 = directOcclusion;
    let _e686 = ambient;
    let _e687 = g_sheen_scale;
    let _e689 = sheenAmbient;
    let _e692 = s_22.emissive;
    let _e694 = g_coat_through;
    let _e697 = coatAmbient;
    lit_3 = (((_e683 * _e684) + ((((_e686 * _e687) + _e689) + _e692) * _e694)) + _e697);
    let _e699 = s_22;
    param_279 = _e699;
    let _e700 = lit_3;
    param_280 = _e700;
    let _e701 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_279), (&param_280));
    if _e701 {
        return;
    }
    let _e702 = lit_3;
    param_281 = _e702;
    let _e704 = s_22.alpha;
    param_282 = _e704;
    let _e706 = s_22.roughness;
    param_283 = _e706;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_281), (&param_282), (&param_283));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(5) v_texcoord: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_texcoord_1 = v_texcoord;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LayerInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 464,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'specular',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'coat', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'sheen',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'anisotropy',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'transmission',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'attenuation',
              offsetInBytes: 80,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'iridescence',
              offsetInBytes: 96,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'uv_transform',
              offsetInBytes: 112,
              sizeInBytes: 160,
            ),
            WebGpuBlockMember(
              name: 'scene_color',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_viewport',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_levels',
              offsetInBytes: 304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scene_view_projection',
              offsetInBytes: 400,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 4,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 5,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'coat_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 16,
          samplerBinding: 17,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 18,
          samplerBinding: 19,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 20,
          samplerBinding: 21,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 22,
          samplerBinding: 23,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 24,
          samplerBinding: 25,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 26,
          samplerBinding: 27,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 28,
          samplerBinding: 29,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 30,
          samplerBinding: 31,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_color_texture',
          group: 1,
          textureBinding: 32,
          samplerBinding: 33,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 34,
          samplerBinding: 35,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'sheen_texture',
          group: 1,
          textureBinding: 36,
          samplerBinding: 37,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ToonDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e217 = v_world_position_1;
    let _e219 = fog_info.eye;
    let _e223 = fog_info.forward;
    return dot((_e217 - _e219.xyz), _e223.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e222 = ViewDepth_u0028_();
    z = abs(_e222);
    let _e224 = z;
    near = (_e224 / 5f);
    let _e226 = z;
    far = (_e226 / 200f);
    let _e228 = far;
    let _e229 = far;
    let _e231 = far;
    far3_ = ((_e228 * _e229) * _e231);
    let _e233 = (*alpha);
    let _e234 = near;
    let _e235 = near;
    let _e238 = far3_;
    let _e239 = far3_;
    return (_e233 * clamp((10f / ((0.00001f + (_e234 * _e235)) + (_e238 * _e239))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e226 = fog_info.forward[3u];
    mode = _e226;
    let _e227 = mode;
    if (_e227 > 0.5f) {
        let _e230 = frag_color[3u];
        alpha_1 = _e230;
        let _e231 = alpha_1;
        param = _e231;
        let _e232 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e232;
        let _e233 = frag_color;
        let _e235 = weight;
        let _e236 = (_e233.xyz * _e235);
        let _e237 = alpha_1;
        let _e238 = weight;
        accumulate = vec4<f32>(_e236.x, _e236.y, _e236.z, (_e237 * _e238));
        let _e244 = mode;
        let _e246 = mode;
        revealage = ((_e244 > 1.5f) && (_e246 < 2.5f));
        let _e249 = revealage;
        if _e249 {
            let _e250 = alpha_1;
            local = vec4(_e250);
        } else {
            let _e252 = accumulate;
            local = _e252;
        }
        let _e253 = local;
        frag_color = _e253;
        let _e254 = mode;
        if (_e254 > 2.5f) {
            let _e256 = alpha_1;
            frag_surface = vec4(_e256);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e220 = (*n)[0u];
    let _e223 = (*n)[1u];
    let _e227 = (*n)[2u];
    let _e230 = (*n);
    (*n) = (_e230 / vec3(((abs(_e220) + abs(_e223)) + abs(_e227))));
    let _e233 = (*n);
    e = _e233.xy;
    let _e236 = (*n)[2u];
    if (_e236 < 0f) {
        let _e238 = (*n);
        let _e244 = (*n)[0u];
        let _e248 = (*n)[1u];
        e = ((vec2(1f) - abs(_e238.yx)) * vec2<f32>(select(-1f, 1f, (_e244 >= 0f)), select(-1f, 1f, (_e248 >= 0f))));
    }
    let _e253 = e;
    return ((_e253 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e218 = (*linear);
    let _e220 = (*linear);
    let _e224 = (*linear);
    return mix((_e218 * 12.92f), ((pow(_e220, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e224));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e221 = g_albedo;
    param_1 = clamp(_e221, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e223 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e223.x, _e223.y, _e223.z, 1f);
    let _e228 = g_debug_surface_on;
    if _e228 {
        let _e229 = g_debug_surface;
        let _e230 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e229.x, _e229.y, _e229.z, _e230);
        return;
    }
    let _e235 = v_normal_1;
    geometric = normalize(_e235);
    let _e237 = gl_FrontFacing_1;
    if !(_e237) {
        let _e239 = geometric;
        geometric = -(_e239);
    }
    let _e241 = geometric;
    param_2 = _e241;
    let _e242 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e243 = (*roughness);
    let _e245 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e242.x, _e242.y, clamp(_e243, 0f, 1f), _e245);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e219 = fog_info.projection[0u];
    return (_e219 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e218 = Orthographic_u0028_();
    if _e218 {
        let _e219 = ViewDepth_u0028_();
        local_1 = max(_e219, 0f);
    } else {
        let _e221 = v_world_position_1;
        let _e223 = fog_info.eye;
        local_1 = distance(_e221, _e223.xyz);
    }
    let _e226 = local_1;
    return _e226;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e225 = fog_info.fog[3u];
    density = _e225;
    let _e226 = density;
    if (_e226 <= 0f) {
        let _e228 = (*color);
        return _e228;
    }
    let _e229 = EyeDistance_u0028_();
    d = _e229;
    let _e232 = fog_info.eye[3u];
    falloff = _e232;
    let _e233 = falloff;
    if (_e233 > 0f) {
        let _e235 = falloff;
        let _e237 = v_world_position_1[1u];
        let _e240 = fog_info.eye[1u];
        k = (_e235 * (_e237 - _e240));
        let _e243 = k;
        if (abs(_e243) > 0.001f) {
            let _e246 = k;
            let _e250 = k;
            local_2 = ((1f - exp(-(_e246))) / _e250);
        } else {
            let _e252 = k;
            local_2 = (1f - (0.5f * _e252));
        }
        let _e255 = local_2;
        let _e256 = density;
        density = (_e256 * _e255);
    }
    let _e259 = fog_info.fog;
    let _e261 = (*color);
    let _e262 = density;
    let _e264 = d;
    return mix(_e259.xyz, _e261, vec3(clamp(exp((-(_e262) * _e264)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e223 = g_premultiply;
    let _e224 = (*alpha_2);
    weight_1 = select(1f, _e224, _e223);
    let _e226 = (*linearColor);
    param_3 = _e226;
    let _e227 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e228 = weight_1;
    let _e229 = (_e227 * _e228);
    let _e230 = (*alpha_2);
    let _e231 = g_pass_through;
    frag_color = vec4<f32>(_e229.x, _e229.y, _e229.z, (_e230 * (1f - _e231)));
    let _e238 = (*roughness_1);
    param_4 = _e238;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e218 = (*srgb);
    let _e221 = (*srgb);
    let _e226 = (*srgb);
    return mix((_e218 / vec3(12.92f)), pow(((_e221 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e226));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e220 = (*key);
    hue = fract(((_e220 * 0.618034f) + 0.13f));
    let _e224 = hue;
    k_1 = clamp((abs(((fract((vec3(_e224) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e237 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e237, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2648_: bool;

    let _e218 = (*c);
    let _e219 = (*c);
    let _e221 = any((_e218 != _e219));
    phi_2648_ = _e221;
    if !(_e221) {
        let _e223 = (*c);
        phi_2648_ = any((abs(_e223) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e228 = phi_2648_;
    return _e228;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2738_: bool;
    var phi_3006_: bool;

    let _e260 = gl_FragCoord_1[0u];
    let _e263 = frag_info.debug_view[1u];
    if (_e260 < _e263) {
        let _e267 = frag_info.debug_view[2u];
        local_3 = _e267;
    } else {
        let _e270 = frag_info.debug_view[0u];
        local_3 = _e270;
    }
    let _e271 = local_3;
    view = _e271;
    let _e272 = view;
    if (_e272 < 0.5f) {
        return false;
    }
    let _e274 = view;
    code = i32((_e274 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e277 = v_normal_1;
    geometric_n = normalize(_e277);
    let _e279 = v_tangent_1;
    let _e281 = geometric_n;
    let _e282 = geometric_n;
    let _e283 = v_tangent_1;
    tangent = (_e279.xyz - (_e281 * dot(_e282, _e283.xyz)));
    let _e288 = tangent;
    let _e289 = tangent;
    let _e291 = (dot(_e288, _e289) > 0.000000000001f);
    phi_2738_ = _e291;
    if _e291 {
        let _e293 = v_tangent_1[3u];
        phi_2738_ = (abs((abs(_e293) - 1f)) < 0.01f);
    }
    let _e299 = phi_2738_;
    tangent_usable = _e299;
    let _e302 = frag_info.debug_view[3u];
    identity = _e302;
    let _e303 = identity;
    identity_object = floor((_e303 / 8192f));
    let _e306 = identity;
    let _e307 = identity_object;
    identity_rest = (_e306 - (_e307 * 8192f));
    let _e310 = identity_rest;
    identity_material = floor((_e310 / 2f));
    let _e313 = identity_rest;
    let _e314 = identity_material;
    normal_mapped = ((_e313 - (_e314 * 2f)) > 0.5f);
    let _e318 = code;
    if (_e318 == 1i) {
        let _e321 = (*s).albedo;
        param_5 = clamp(_e321, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e323 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e323;
    } else {
        let _e324 = code;
        if (_e324 == 2i) {
            let _e327 = (*s).n;
            shown = ((_e327 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e330 = code;
            if (_e330 == 3i) {
                let _e333 = (*s).roughness;
                shown = vec3(clamp(_e333, 0f, 1f));
            } else {
                let _e336 = code;
                if (_e336 == 4i) {
                    let _e339 = (*s).metallic;
                    shown = vec3(clamp(_e339, 0f, 1f));
                } else {
                    let _e342 = code;
                    if (_e342 == 5i) {
                        let _e345 = (*s).occlusion;
                        shown = vec3(clamp(_e345, 0f, 1f));
                    } else {
                        let _e348 = code;
                        if (_e348 == 6i) {
                            let _e351 = (*s).emissive;
                            param_6 = clamp(_e351, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e353 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e353;
                        } else {
                            let _e354 = code;
                            if (_e354 == 7i) {
                                let _e356 = v_texcoord_1;
                                let _e357 = fract(_e356);
                                shown = vec3<f32>(_e357.x, _e357.y, 0f);
                            } else {
                                let _e361 = code;
                                if (_e361 == 8i) {
                                    let _e363 = (*lit);
                                    param_7 = clamp(_e363, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e365 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e365, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e367 = (*lit);
                                    param_8 = _e367;
                                    let _e368 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e368 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e369 = grey;
                                        local_4 = vec3((_e369 * 0.5f));
                                    }
                                    let _e372 = local_4;
                                    shown = _e372;
                                } else {
                                    let _e373 = code;
                                    if (_e373 == 9i) {
                                        let _e375 = tangent_usable;
                                        if _e375 {
                                            let _e376 = tangent;
                                            local_5 = ((normalize(_e376) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e380 = local_5;
                                        shown = _e380;
                                    } else {
                                        let _e381 = code;
                                        if (_e381 == 10i) {
                                            let _e383 = v_texcoord_1;
                                            uv = _e383;
                                            let _e384 = uv;
                                            cell = floor((_e384 * 8f));
                                            let _e388 = cell[0u];
                                            let _e390 = cell[1u];
                                            odd = (fract(((_e388 + _e390) * 0.5f)) * 2f);
                                            let _e395 = uv;
                                            within = fract(_e395);
                                            let _e397 = odd;
                                            let _e401 = within[0u];
                                            let _e405 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e397)) * vec3<f32>((0.55f + (0.45f * _e401)), (0.55f + (0.45f * _e405)), 0.85f));
                                        } else {
                                            let _e410 = code;
                                            if (_e410 == 11i) {
                                                let _e412 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e412));
                                            } else {
                                                let _e415 = code;
                                                if (_e415 == 12i) {
                                                    let _e417 = v_color_1;
                                                    param_9 = clamp(_e417.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e420 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e420;
                                                } else {
                                                    let _e421 = code;
                                                    let _e423 = code;
                                                    if ((_e421 == 13i) || (_e423 == 14i)) {
                                                        let _e426 = code;
                                                        let _e428 = identity_object;
                                                        let _e429 = identity_material;
                                                        key_1 = select(_e429, _e428, (_e426 == 13i));
                                                        let _e431 = key_1;
                                                        param_10 = _e431;
                                                        let _e432 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e434 = (*s).n_dot_v;
                                                        shown = (_e432 * (0.55f + (0.45f * _e434)));
                                                    } else {
                                                        let _e438 = code;
                                                        if (_e438 == 15i) {
                                                            let _e441 = (*s).albedo;
                                                            param_11 = clamp(_e441, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e443 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e443;
                                                            let _e444 = srgb_1;
                                                            luma = dot(_e444, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e447 = (*s).metallic;
                                                            metal = (_e447 > 0.5f);
                                                            let _e449 = metal;
                                                            let _e451 = luma;
                                                            if (!(_e449) && (_e451 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e454 = metal;
                                                                let _e455 = !(_e454);
                                                                phi_3006_ = _e455;
                                                                if _e455 {
                                                                    let _e457 = srgb_1[0u];
                                                                    let _e459 = srgb_1[1u];
                                                                    let _e461 = srgb_1[2u];
                                                                    phi_3006_ = (max(_e457, max(_e459, _e461)) > 0.9411765f);
                                                                }
                                                                let _e466 = phi_3006_;
                                                                if _e466 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e467 = metal;
                                                                    let _e468 = luma;
                                                                    if (_e467 && (_e468 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e471 = luma;
                                                                        local_8 = vec3(_e471);
                                                                    }
                                                                    let _e473 = local_8;
                                                                    local_7 = _e473;
                                                                }
                                                                let _e474 = local_7;
                                                                local_6 = _e474;
                                                            }
                                                            let _e475 = local_6;
                                                            shown = _e475;
                                                        } else {
                                                            let _e476 = code;
                                                            if (_e476 == 16i) {
                                                                let _e479 = (*s).metallic;
                                                                m = _e479;
                                                                let _e480 = m;
                                                                let _e482 = m;
                                                                if ((_e480 > 0.05f) && (_e482 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e485 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e485 > 0.5f)));
                                                                }
                                                                let _e489 = local_9;
                                                                shown = _e489;
                                                            } else {
                                                                let _e490 = code;
                                                                if (_e490 == 17i) {
                                                                    let _e492 = normal_mapped;
                                                                    if !(_e492) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e494 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e494));
                                                                    }
                                                                    let _e497 = local_10;
                                                                    shown = _e497;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e498 = g_premultiply;
    if _e498 {
        let _e500 = (*s).alpha;
        local_11 = _e500;
    } else {
        local_11 = 1f;
    }
    let _e501 = local_11;
    weight_2 = _e501;
    let _e502 = shown;
    param_12 = _e502;
    let _e503 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e504 = weight_2;
    let _e505 = (_e503 * _e504);
    let _e507 = (*s).alpha;
    frag_color = vec4<f32>(_e505.x, _e505.y, _e505.z, _e507);
    let _e513 = (*s).roughness;
    param_13 = _e513;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_12: f32;

    let _e220 = frag_info.material2_[2u];
    local_12 = floor((_e220 * 0.5f));
    let _e223 = local_12;
    return _e223;
}

fn DirectOcclusion_u0028_struct_u002d_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_1: ptr<function, Surface>) -> f32 {
    var local_13: f32;
    var local_14: f32;

    let _e220 = OcclusionTarget_u0028_();
    if (_e220 > 1.5f) {
        local_13 = 1f;
    } else {
        let _e223 = (*s_1).occlusion;
        local_13 = _e223;
    }
    let _e224 = local_13;
    local_14 = _e224;
    let _e225 = local_14;
    return _e225;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var bands: f32;
    var quantized: f32;
    var fraction: f32;
    var ramp: f32;

    let _e224 = (*s_2).roughness;
    bands = mix(5f, 2f, _e224);
    let _e227 = (*light).n_dot_l;
    let _e228 = bands;
    let _e231 = bands;
    quantized = (floor((_e227 * _e228)) / _e231);
    let _e234 = (*light).n_dot_l;
    let _e235 = bands;
    fraction = fract((_e234 * _e235));
    let _e238 = fraction;
    let _e240 = bands;
    let _e242 = quantized;
    quantized = (_e242 + (smoothstep(0.85f, 1f, _e238) / _e240));
    let _e244 = quantized;
    let _e246 = (*light).n_dot_l;
    ramp = (_e244 / max(_e246, 0.001f));
    let _e250 = (*s_2).albedo;
    let _e251 = ramp;
    return (_e250 * _e251);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e218 = (*i);
    if (_e218 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e220 = (*i);
    if (_e220 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e222 = (*i);
    if (_e222 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e224 = (*i);
    if (_e224 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e226 = (*i);
    if (_e226 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e228 = (*i);
    if (_e228 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e230 = (*i);
    if (_e230 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e223 = (*i_1);
    param_14 = _e223;
    let _e224 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e224;
    let _e226 = p[0u];
    let _e227 = (*ca);
    let _e230 = p[1u];
    let _e231 = (*sa);
    let _e235 = p[0u];
    let _e236 = (*sa);
    let _e239 = p[1u];
    let _e240 = (*ca);
    let _e244 = (*radius);
    return (vec2<f32>(((_e226 * _e227) - (_e230 * _e231)), ((_e235 * _e236) + (_e239 * _e240))) * _e244);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_15: vec2<f32>;
    var atlas: vec2<f32>;

    let _e226 = point_shadow.params[0u];
    inset = _e226;
    let _e227 = (*uv_1);
    let _e228 = (*offset);
    let _e230 = inset;
    let _e231 = inset;
    local_15 = clamp((_e227 + _e228), vec2(_e230), vec2((1f - _e231)));
    let _e236 = local_15;
    let _e237 = (*tile);
    atlas = ((_e236 + _e237) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e242 = point_shadow.params3_[0u];
    if (_e242 > 0.5f) {
        let _e245 = atlas[1u];
        atlas[1u] = (1f - _e245);
    }
    let _e248 = atlas;
    let _e249 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e248, 0f);
    let _e251 = atlas;
    let _e252 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e251, 0f);
    let _e255 = (*range);
    return (min(_e249.x, _e252.x) * _e255);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e227 = (*uv_2);
    param_15 = _e227;
    let _e228 = (*offset_1);
    param_16 = _e228;
    let _e229 = (*tile_1);
    param_17 = _e229;
    let _e230 = (*range_1);
    param_18 = _e230;
    let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e231;
    let _e232 = stored;
    let _e233 = (*range_1);
    if (_e232 >= (_e233 * 0.999f)) {
        return 1f;
    }
    let _e236 = (*receiver);
    let _e237 = stored;
    return select(1f, 0f, (_e236 > _e237));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e248 = point_shadow.params2_[1u];
    lightRadius = _e248;
    let _e251 = point_shadow.params2_[0u];
    minRadius = _e251;
    let _e254 = point_shadow.params2_[2u];
    maxRadius = _e254;
    let _e255 = lightRadius;
    if (_e255 <= 0f) {
        let _e257 = (*uv_3);
        param_19 = _e257;
        param_20 = vec2<f32>(0f, 0f);
        let _e258 = (*tile_2);
        param_21 = _e258;
        let _e259 = (*range_2);
        param_22 = _e259;
        let _e260 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e260;
        let _e261 = minRadius;
        return _e261;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e262 = i_2;
        if (_e262 < 8i) {
            let _e264 = i_2;
            param_23 = _e264;
            let _e265 = (*ca_1);
            param_24 = _e265;
            let _e266 = (*sa_1);
            param_25 = _e266;
            let _e267 = maxRadius;
            param_26 = _e267;
            let _e268 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e269 = (*uv_3);
            param_27 = _e269;
            param_28 = _e268;
            let _e270 = (*tile_2);
            param_29 = _e270;
            let _e271 = (*range_2);
            param_30 = _e271;
            let _e272 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e272;
            let _e273 = stored_1;
            let _e274 = (*range_2);
            if (_e273 >= (_e274 * 0.999f)) {
                continue;
            }
            let _e277 = stored_1;
            let _e278 = (*receiver_1);
            if (_e277 >= _e278) {
                continue;
            }
            let _e280 = stored_1;
            let _e281 = sum;
            sum = (_e281 + _e280);
            let _e283 = count;
            count = (_e283 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e285 = i_2;
            i_2 = (_e285 + 1i);
        }
    }
    let _e287 = count;
    if (_e287 < 0.5f) {
        return -1f;
    }
    let _e289 = sum;
    let _e290 = count;
    blocker = max((_e289 / _e290), 0.0001f);
    let _e293 = blocker;
    (*blockerOut) = _e293;
    let _e294 = lightRadius;
    let _e295 = (*receiver_1);
    let _e296 = blocker;
    let _e300 = blocker;
    world = ((_e294 * max((_e295 - _e296), 0f)) / _e300);
    let _e302 = world;
    let _e303 = (*receiver_1);
    let _e305 = (*tanHalf);
    let _e308 = minRadius;
    let _e309 = maxRadius;
    return clamp((_e302 / ((2f * _e303) * _e305)), _e308, _e309);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_16: vec2<f32>;

    let _e219 = (*rows);
    if (_e219 > 0f) {
        let _e222 = gl_FragCoord_1[0u];
        let _e223 = (*rows);
        let _e225 = gl_FragCoord_1[1u];
        local_16 = vec2<f32>(_e222, (_e223 - _e225));
    } else {
        let _e228 = gl_FragCoord_1;
        local_16 = _e228.xy;
    }
    let _e230 = local_16;
    return _e230;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_17: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2335_: bool;
    var phi_2396_: bool;

    let _e271 = (*lightIndex);
    let _e275 = point_shadow.slots[_e271][0u];
    slot = i32((_e275 + 0.5f));
    let _e278 = (*lightIndex);
    let _e282 = point_shadow.slots[_e278][0u];
    if (_e282 < 0f) {
        return 1f;
    }
    let _e286 = point_shadow.params[2u];
    strength = _e286;
    let _e287 = strength;
    if (_e287 <= 0f) {
        return 1f;
    }
    let _e289 = slot;
    let _e292 = point_shadow.lights[_e289];
    let _e294 = (*world_1);
    toLight = (_e292.xyz - _e294);
    let _e296 = toLight;
    toLightLength = max(length(_e296), 0.000001f);
    let _e299 = (*normal);
    let _e300 = toLight;
    let _e301 = toLightLength;
    nDotL = max(dot(_e299, (_e300 / vec3(_e301))), 0.15f);
    let _e306 = nDotL;
    let _e307 = nDotL;
    let _e312 = nDotL;
    let _e313 = nDotL;
    slope = min((sqrt(max((1f - (_e306 * _e307)), 0f)) / (_e312 * _e313)), 8f);
    let _e317 = toLightLength;
    let _e319 = (*lightIndex);
    let _e323 = point_shadow.slots[_e319][2u];
    let _e328 = point_shadow.params3_[1u];
    texel = (((2f * _e317) * max(_e323, 0.0001f)) * _e328);
    let _e330 = (*world_1);
    let _e331 = (*normal);
    let _e332 = texel;
    let _e336 = point_shadow.params[3u];
    let _e338 = slope;
    origin = (_e330 + (((_e331 * _e332) * _e336) * (1f + _e338)));
    let _e342 = origin;
    let _e343 = slot;
    let _e346 = point_shadow.lights[_e343];
    toFragment = (_e342 - _e346.xyz);
    let _e349 = toFragment;
    distance_ = length(_e349);
    let _e351 = slot;
    let _e355 = point_shadow.lights[_e351][3u];
    range_3 = max(_e355, 0.0001f);
    let _e357 = distance_;
    let _e358 = range_3;
    if (_e357 >= _e358) {
        return 1f;
    }
    face = 0i;
    let _e360 = (*lightIndex);
    let _e364 = point_shadow.slots[_e360][1u];
    if (_e364 < 0.5f) {
        let _e366 = toFragment;
        a = abs(_e366);
        let _e369 = a[0u];
        let _e371 = a[1u];
        let _e372 = (_e369 >= _e371);
        phi_2335_ = _e372;
        if _e372 {
            let _e374 = a[0u];
            let _e376 = a[2u];
            phi_2335_ = (_e374 >= _e376);
        }
        let _e379 = phi_2335_;
        if _e379 {
            let _e381 = toFragment[0u];
            face = select(1i, 0i, (_e381 > 0f));
        } else {
            let _e385 = a[1u];
            let _e387 = a[2u];
            if (_e385 >= _e387) {
                let _e390 = toFragment[1u];
                face = select(3i, 2i, (_e390 > 0f));
            } else {
                let _e394 = toFragment[2u];
                face = select(5i, 4i, (_e394 > 0f));
            }
        }
    }
    let _e397 = slot;
    let _e399 = face;
    let _e403 = point_shadow.faces[((_e397 * 6i) + _e399)];
    let _e404 = origin;
    clip = (_e403 * vec4<f32>(_e404.x, _e404.y, _e404.z, 1f));
    let _e411 = clip[3u];
    if (_e411 <= 0f) {
        return 1f;
    }
    let _e413 = clip;
    let _e416 = clip[3u];
    ndc = (_e413.xy / vec2(_e416));
    let _e420 = ndc[0u];
    let _e422 = (abs(_e420) > 1f);
    phi_2396_ = _e422;
    if !(_e422) {
        let _e425 = ndc[1u];
        phi_2396_ = (abs(_e425) > 1f);
    }
    let _e429 = phi_2396_;
    if _e429 {
        return 1f;
    }
    let _e431 = ndc[0u];
    let _e435 = ndc[1u];
    uv_4 = vec2<f32>(((_e431 * 0.5f) + 0.5f), (0.5f - (_e435 * 0.5f)));
    let _e439 = face;
    let _e441 = slot;
    tile_3 = vec2<f32>(f32(_e439), f32(_e441));
    let _e444 = distance_;
    let _e447 = point_shadow.params[1u];
    receiver_2 = (_e444 - _e447);
    let _e451 = frag_info.target_origin[0u];
    param_31 = _e451;
    let _e452 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e452, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e457 = noise;
    angle = (_e457 * 6.2831855f);
    let _e459 = angle;
    ca_2 = cos(_e459);
    let _e461 = angle;
    sa_2 = sin(_e461);
    let _e463 = (*lightIndex);
    let _e467 = point_shadow.slots[_e463][2u];
    tanHalf_1 = max(_e467, 0.0001f);
    blocker_1 = -1f;
    let _e469 = uv_4;
    param_32 = _e469;
    let _e470 = tile_3;
    param_33 = _e470;
    let _e471 = range_3;
    param_34 = _e471;
    let _e472 = receiver_2;
    param_35 = _e472;
    let _e473 = ca_2;
    param_36 = _e473;
    let _e474 = sa_2;
    param_37 = _e474;
    let _e475 = tanHalf_1;
    param_38 = _e475;
    let _e476 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e477 = param_39;
    blocker_1 = _e477;
    radius_1 = _e476;
    let _e480 = point_shadow.params2_[3u];
    if (_e480 > 0.5f) {
        g_debug_surface_on = true;
        let _e482 = radius_1;
        if (_e482 < 0f) {
            local_17 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e484 = radius_1;
            let _e487 = point_shadow.params2_[2u];
            let _e491 = blocker_1;
            let _e492 = range_3;
            local_17 = vec3<f32>(clamp((_e484 / max(_e487, 0.000001f)), 0f, 1f), clamp((_e491 / _e492), 0f, 1f), 0f);
        }
        let _e496 = local_17;
        g_debug_surface = _e496;
    }
    let _e497 = radius_1;
    if (_e497 < 0f) {
        return 1f;
    }
    let _e499 = uv_4;
    param_40 = _e499;
    param_41 = vec2<f32>(0f, 0f);
    let _e500 = tile_3;
    param_42 = _e500;
    let _e501 = range_3;
    param_43 = _e501;
    let _e502 = receiver_2;
    param_44 = _e502;
    let _e503 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e503;
    let _e504 = radius_1;
    if (_e504 > 0f) {
        i_3 = 0i;
        loop {
            let _e506 = i_3;
            if (_e506 < 8i) {
                let _e508 = i_3;
                param_45 = _e508;
                let _e509 = ca_2;
                param_46 = _e509;
                let _e510 = sa_2;
                param_47 = _e510;
                let _e511 = radius_1;
                param_48 = _e511;
                let _e512 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e513 = uv_4;
                param_49 = _e513;
                param_50 = _e512;
                let _e514 = tile_3;
                param_51 = _e514;
                let _e515 = range_3;
                param_52 = _e515;
                let _e516 = receiver_2;
                param_53 = _e516;
                let _e517 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e518 = lit_1;
                lit_1 = (_e518 + _e517);
                continue;
            } else {
                break;
            }
            continuing {
                let _e520 = i_3;
                i_3 = (_e520 + 1i);
            }
        }
        let _e522 = lit_1;
        lit_1 = (_e522 * 0.11111111f);
    }
    let _e524 = lit_1;
    let _e525 = strength;
    return mix(1f, _e524, clamp(_e525, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e222 = (*i_4);
    let _e225 = (*n_1);
    r = sqrt(((f32(_e222) + 0.5f) / f32(_e225)));
    let _e229 = (*i_4);
    let _e232 = (*turn);
    theta = ((f32(_e229) * 2.3999631f) + _e232);
    let _e234 = r;
    let _e235 = theta;
    let _e237 = theta;
    return (vec2<f32>(cos(_e235), sin(_e237)) * _e234);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e221 = frag_info.target_origin[0u];
    param_54 = _e221;
    let _e222 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e225 = frag_info.target_origin[3u];
    at = (_e222 + vec2((5.588238f * max(_e225, 0f))));
    let _e230 = at;
    return fract((52.982918f * fract(dot(_e230, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_18: f32;

    let _e220 = (*mode_1);
    if (_e220 > 0.5f) {
        let _e222 = (*stored_2);
        local_18 = (1f - _e222);
    } else {
        let _e224 = (*stored_2);
        local_18 = _e224;
    }
    let _e225 = local_18;
    return _e225;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e226 = (*moments)[1u];
    let _e228 = (*moments)[0u];
    let _e230 = (*moments)[0u];
    let _e233 = (*minVariance);
    variance = max((_e226 - (_e228 * _e230)), _e233);
    let _e235 = (*t);
    let _e237 = (*moments)[0u];
    d_1 = (_e235 - _e237);
    let _e239 = variance;
    let _e240 = variance;
    let _e241 = d_1;
    let _e242 = d_1;
    pMax = (_e239 / (_e240 + (_e241 * _e242)));
    let _e246 = pMax;
    let _e247 = (*bleed);
    let _e249 = (*bleed);
    reduced = clamp(((_e246 - _e247) / max((1f - _e249), 0.0001f)), 0f, 1f);
    let _e254 = (*t);
    let _e256 = (*moments)[0u];
    let _e258 = reduced;
    return select(_e258, 1f, (_e254 <= _e256));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e219 = (*depth);
    d_2 = ((2f * clamp(_e219, 0f, 1f)) - 1f);
    let _e223 = d_2;
    let _e226 = d_2;
    return vec2<f32>(exp((40f * _e223)), -(exp((-5f * _e226))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e233 = (*depth_1);
    param_55 = _e233;
    let _e234 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e234;
    let _e235 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e235);
    let _e238 = scale[0u];
    let _e240 = scale[0u];
    let _e242 = (*moments_1);
    param_56 = _e242.xy;
    let _e245 = warped[0u];
    param_57 = _e245;
    param_58 = (_e238 * _e240);
    let _e246 = (*bleed_1);
    param_59 = _e246;
    let _e247 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e247;
    let _e249 = scale[1u];
    let _e251 = scale[1u];
    let _e253 = (*moments_1);
    param_60 = _e253.zw;
    let _e256 = warped[1u];
    param_61 = _e256;
    param_62 = (_e249 * _e251);
    let _e257 = (*bleed_1);
    param_63 = _e257;
    let _e258 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e258;
    let _e259 = positive;
    let _e260 = negative;
    return min(_e259, _e260);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e219 = (*depth_2);
    stored_3 = max((1f - _e219), 0.000061035156f);
    let _e222 = stored_3;
    return exp2((floor(log2(_e222)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_19: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_20: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_22: f32;
    var local_23: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3989_: bool;
    var phi_4000_: bool;
    var phi_4157_: bool;
    var phi_4164_: bool;
    var phi_4171_: bool;

    let _e298 = frag_info.shadow_params[3u];
    strength_1 = _e298;
    let _e299 = strength_1;
    if (_e299 <= 0f) {
        return 1f;
    }
    let _e301 = (*lightIndex_1);
    let _e304 = frag_info.frame_params[2u];
    if (_e301 != i32(floor((_e304 + 0.5f)))) {
        return 1f;
    }
    let _e311 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e311 + 0.5f));
    let _e314 = Orthographic_u0028_();
    if _e314 {
        let _e315 = ViewDepth_u0028_();
        local_19 = _e315;
    } else {
        let _e316 = v_world_position_1;
        let _e318 = frag_info.camera_position;
        local_19 = length((_e316 - _e318.xyz));
    }
    let _e322 = local_19;
    viewDistance = _e322;
    cascade = 0i;
    let _e323 = cascadeCount;
    let _e324 = (_e323 > 1i);
    phi_3989_ = _e324;
    if _e324 {
        let _e325 = viewDistance;
        let _e328 = frag_info.shadow_cascades[0u];
        phi_3989_ = (_e325 > _e328);
    }
    let _e331 = phi_3989_;
    if _e331 {
        cascade = 1i;
    }
    let _e332 = cascadeCount;
    let _e333 = (_e332 > 2i);
    phi_4000_ = _e333;
    if _e333 {
        let _e334 = viewDistance;
        let _e337 = frag_info.shadow_cascades[1u];
        phi_4000_ = (_e334 > _e337);
    }
    let _e340 = phi_4000_;
    if _e340 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e341 = attempt;
        if (_e341 < 3i) {
            let _e343 = cascade;
            let _e344 = attempt;
            which = (_e343 + _e344);
            let _e346 = which;
            let _e347 = cascadeCount;
            if (_e346 >= _e347) {
                break;
            }
            let _e349 = which;
            if (_e349 == 0i) {
                let _e352 = frag_info.shadow_matrix;
                local_20 = _e352;
            } else {
                let _e353 = which;
                if (_e353 == 1i) {
                    let _e356 = frag_info.shadow_matrix_far;
                    local_21 = _e356;
                } else {
                    let _e358 = frag_info.shadow_matrix_farthest;
                    local_21 = _e358;
                }
                let _e359 = local_21;
                local_20 = _e359;
            }
            let _e360 = local_20;
            matrix = _e360;
            let _e363 = matrix[0][0u];
            let _e366 = matrix[1][0u];
            let _e369 = matrix[2][0u];
            axisX = vec3<f32>(_e363, _e366, _e369);
            let _e373 = matrix[0][1u];
            let _e376 = matrix[1][1u];
            let _e379 = matrix[2][1u];
            axisY = vec3<f32>(_e373, _e376, _e379);
            let _e381 = axisX;
            rowX = max(length(_e381), 0.000001f);
            let _e384 = axisY;
            rowY = max(length(_e384), 0.000001f);
            let _e389 = frag_info.shadow_cascades[3u];
            let _e391 = rowX;
            texelMetres = ((2f * _e389) / _e391);
            let _e395 = frag_info.shadow_cascades[3u];
            let _e398 = (*s_3).n;
            let _e399 = axisX;
            let _e402 = rowX;
            let _e403 = rowX;
            let _e407 = (*s_3).n;
            let _e408 = axisY;
            let _e411 = rowY;
            let _e412 = rowY;
            reach = ((3f * _e395) * ((abs(dot(_e398, _e399)) / (_e402 * _e403)) + (abs(dot(_e407, _e408)) / (_e411 * _e412))));
            let _e419 = frag_info.shadow_params[2u];
            let _e420 = texelMetres;
            flatOffset = min(_e419, _e420);
            let _e422 = v_world_position_1;
            let _e424 = (*s_3).n;
            let _e425 = flatOffset;
            let _e426 = reach;
            origin_1 = (_e422 + (_e424 * (_e425 + _e426)));
            let _e430 = matrix;
            let _e431 = origin_1;
            lightSpace = (_e430 * vec4<f32>(_e431.x, _e431.y, _e431.z, 1f));
            let _e438 = lightSpace[3u];
            if (_e438 <= 0f) {
                continue;
            }
            let _e440 = lightSpace;
            let _e443 = lightSpace[3u];
            candidate = (_e440.xyz / vec3(_e443));
            let _e447 = candidate[0u];
            let _e451 = candidate[1u];
            inTile = vec2<f32>(((_e447 * 0.5f) + 0.5f), (0.5f - (_e451 * 0.5f)));
            let _e456 = inTile[0u];
            let _e457 = (_e456 < 0f);
            phi_4157_ = _e457;
            if !(_e457) {
                let _e460 = inTile[0u];
                phi_4157_ = (_e460 > 1f);
            }
            let _e463 = phi_4157_;
            phi_4164_ = _e463;
            if !(_e463) {
                let _e466 = inTile[1u];
                phi_4164_ = (_e466 < 0f);
            }
            let _e469 = phi_4164_;
            phi_4171_ = _e469;
            if !(_e469) {
                let _e472 = inTile[1u];
                phi_4171_ = (_e472 > 1f);
            }
            let _e475 = phi_4171_;
            if _e475 {
                continue;
            }
            let _e477 = candidate[2u];
            if (_e477 > 1f) {
                let _e479 = which;
                let _e480 = cascadeCount;
                if (_e479 < (_e480 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e485 = inTile[0u];
            let _e486 = which;
            let _e489 = cascadeCount;
            let _e493 = inTile[1u];
            uv_5 = vec2<f32>(((_e485 + f32(_e486)) / f32(_e489)), _e493);
            let _e495 = candidate;
            projected = _e495;
            let _e496 = which;
            cascade = _e496;
            let _e497 = texelMetres;
            cascadeTexel = _e497;
            let _e500 = matrix[0][2u];
            let _e503 = matrix[1][2u];
            let _e506 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e500, _e503, _e506)), 0.000001f));
            let _e512 = (*s_3).n;
            let _e515 = matrix[0][2u];
            let _e518 = matrix[1][2u];
            let _e521 = matrix[2][2u];
            let _e525 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e512, vec3<f32>(_e515, _e518, _e521))) * _e525), 0.1f, 1f);
            let _e528 = texelMetres;
            let _e529 = cosSlope;
            let _e530 = cosSlope;
            let _e536 = cosSlope;
            let _e538 = cascadeDepth;
            receiverSlope = (((_e528 * sqrt(max((1f - (_e529 * _e530)), 0f))) / _e536) / _e538);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e540 = attempt;
            attempt = (_e540 + 1i);
        }
    }
    let _e542 = found;
    if !(_e542) {
        return 1f;
    }
    let _e544 = cascade;
    if (_e544 == 0i) {
        let _e548 = frag_info.shadow_bias[0u];
        local_22 = _e548;
    } else {
        let _e549 = cascade;
        if (_e549 == 1i) {
            let _e553 = frag_info.shadow_bias[1u];
            local_23 = _e553;
        } else {
            let _e556 = frag_info.shadow_bias[2u];
            local_23 = _e556;
        }
        let _e557 = local_23;
        local_22 = _e557;
    }
    let _e558 = local_22;
    bias = _e558;
    let _e561 = frag_info.shadow_params[1u];
    storage_ = _e561;
    let _e562 = storage_;
    let _e564 = storage_;
    if ((_e562 > 0.5f) && (_e564 < 1.5f)) {
        let _e567 = bias;
        let _e569 = projected[2u];
        param_64 = _e569;
        let _e570 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e567, _e570);
    }
    let _e574 = frag_info.shadow_params[0u];
    let _e577 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e574, _e577);
    let _e579 = cascade;
    let _e581 = cascadeCount;
    let _e585 = texel_1;
    tileLo = (vec2<f32>((f32(_e579) / f32(_e581)), 0f) + (_e585 * 0.5f));
    let _e588 = cascade;
    let _e591 = cascadeCount;
    let _e595 = texel_1;
    tileHi = (vec2<f32>((f32((_e588 + 1i)) / f32(_e591)), 1f) - (_e595 * 0.5f));
    let _e600 = frag_info.shadow_bias[3u];
    if (_e600 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e602 = y;
            if (_e602 <= 1i) {
                x = -1i;
                loop {
                    let _e604 = x;
                    if (_e604 <= 1i) {
                        let _e606 = uv_5;
                        let _e607 = x;
                        let _e609 = y;
                        let _e612 = texel_1;
                        let _e615 = tileLo;
                        let _e616 = tileHi;
                        let _e618 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e606 + (vec2<f32>(f32(_e607), f32(_e609)) * _e612)), _e615, _e616), 0f);
                        let _e619 = stored_4;
                        stored_4 = (_e619 + _e618);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e621 = x;
                        x = (_e621 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e623 = y;
                y = (_e623 + 1i);
            }
        }
        let _e625 = stored_4;
        stored_4 = (_e625 * 0.11111111f);
        let _e628 = stored_4[1u];
        let _e631 = stored_4[2u];
        let _e634 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e628), (1f - _e631), _e634), vec3(0f), vec3(4f));
        let _e639 = through;
        let _e640 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e639, vec3(clamp(_e640, 0f, 1f)));
    }
    let _e646 = frag_info.ambient_ground[3u];
    softness = _e646;
    lit_2 = 0f;
    let _e647 = softness;
    if (_e647 < 0f) {
        let _e649 = uv_5;
        let _e650 = tileLo;
        let _e651 = tileHi;
        let _e653 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e649, _e650, _e651), 0f);
        moments_2 = _e653;
        let _e655 = projected[2u];
        let _e656 = bias;
        let _e658 = softness;
        let _e662 = moments_2;
        param_65 = _e662;
        param_66 = (_e655 - _e656);
        param_67 = clamp((-(_e658) - 1f), 0f, 0.95f);
        let _e663 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e663;
    } else {
        let _e664 = softness;
        if (_e664 <= 0f) {
            y_1 = -1i;
            loop {
                let _e666 = y_1;
                if (_e666 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e668 = x_1;
                        if (_e668 <= 1i) {
                            let _e670 = uv_5;
                            let _e671 = x_1;
                            let _e673 = y_1;
                            let _e676 = texel_1;
                            let _e679 = tileLo;
                            let _e680 = tileHi;
                            let _e682 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e670 + (vec2<f32>(f32(_e671), f32(_e673)) * _e676)), _e679, _e680), 0f);
                            param_68 = _e682.x;
                            let _e684 = storage_;
                            param_69 = _e684;
                            let _e685 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e685;
                            let _e687 = projected[2u];
                            let _e688 = bias;
                            let _e690 = occluder;
                            let _e693 = lit_2;
                            lit_2 = (_e693 + select(1f, 0f, ((_e687 - _e688) > _e690)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e695 = x_1;
                            x_1 = (_e695 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e697 = y_1;
                    y_1 = (_e697 + 1i);
                }
            }
            let _e699 = lit_2;
            lit_2 = (_e699 * 0.11111111f);
        } else {
            let _e701 = softness;
            spread = tan(min(_e701, 0.5f));
            let _e704 = ShadowNoise_u0028_();
            turn_1 = (_e704 * 6.2831855f);
            let _e706 = spread;
            let _e708 = projected[2u];
            let _e710 = cascadeDepth;
            let _e712 = cascadeTexel;
            searchRadius = clamp((((_e706 * _e708) * _e710) / _e712), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e715 = i_5;
                if (_e715 < 16i) {
                    let _e717 = i_5;
                    param_70 = _e717;
                    param_71 = 16i;
                    let _e718 = turn_1;
                    param_72 = _e718;
                    let _e719 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e719;
                    let _e720 = bias;
                    let _e721 = disc;
                    let _e723 = searchRadius;
                    let _e727 = receiverSlope;
                    tapBias = (_e720 + (max(((length(_e721) * _e723) - 1.5f), 0f) * _e727));
                    let _e730 = uv_5;
                    let _e731 = disc;
                    let _e732 = texel_1;
                    let _e734 = searchRadius;
                    let _e737 = tileLo;
                    let _e738 = tileHi;
                    let _e740 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e730 + ((_e731 * _e732) * _e734)), _e737, _e738), 0f);
                    param_73 = _e740.x;
                    let _e742 = storage_;
                    param_74 = _e742;
                    let _e743 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e743;
                    let _e745 = projected[2u];
                    let _e746 = tapBias;
                    let _e748 = occluder_1;
                    if ((_e745 - _e746) > _e748) {
                        let _e750 = occluder_1;
                        let _e751 = blockerSum;
                        blockerSum = (_e751 + _e750);
                        let _e753 = blockerCount;
                        blockerCount = (_e753 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e755 = i_5;
                    i_5 = (_e755 + 1i);
                }
            }
            let _e757 = blockerCount;
            if (_e757 <= 0f) {
                return 1f;
            }
            let _e760 = projected[2u];
            let _e761 = blockerSum;
            let _e762 = blockerCount;
            let _e766 = cascadeDepth;
            gap = (max((_e760 - (_e761 / _e762)), 0f) * _e766);
            let _e768 = spread;
            let _e769 = gap;
            let _e771 = cascadeTexel;
            radius_2 = clamp(((_e768 * _e769) / _e771), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e774 = i_6;
                if (_e774 < 16i) {
                    let _e776 = turn_1;
                    let _e778 = i_6;
                    param_75 = _e778;
                    param_76 = 16i;
                    param_77 = (_e776 + 1f);
                    let _e779 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e779;
                    let _e780 = bias;
                    let _e781 = disc_1;
                    let _e783 = radius_2;
                    let _e787 = receiverSlope;
                    tapBias_1 = (_e780 + (max(((length(_e781) * _e783) - 1.5f), 0f) * _e787));
                    let _e790 = uv_5;
                    let _e791 = disc_1;
                    let _e792 = texel_1;
                    let _e794 = radius_2;
                    let _e797 = tileLo;
                    let _e798 = tileHi;
                    let _e800 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e790 + ((_e791 * _e792) * _e794)), _e797, _e798), 0f);
                    param_78 = _e800.x;
                    let _e802 = storage_;
                    param_79 = _e802;
                    let _e803 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e803;
                    let _e805 = projected[2u];
                    let _e806 = tapBias_1;
                    let _e808 = occluder_2;
                    let _e811 = lit_2;
                    lit_2 = (_e811 + select(1f, 0f, ((_e805 - _e806) > _e808)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e813 = i_6;
                    i_6 = (_e813 + 1i);
                }
            }
            let _e815 = lit_2;
            lit_2 = (_e815 * 0.0625f);
        }
    }
    let _e817 = lit_2;
    let _e818 = strength_1;
    return mix(1f, _e817, clamp(_e818, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e223 = (*s_4);
    param_80 = _e223;
    let _e224 = (*light_2);
    param_81 = _e224;
    let _e225 = (*index);
    param_82 = _e225;
    let _e226 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e226;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e218 = (*index_1);
    return (_e218 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e222 = (*distance_1);
    let _e223 = (*distance_1);
    attenuation = (1f / max((_e222 * _e223), 0.0001f));
    let _e227 = (*range_4);
    if (_e227 > 0f) {
        let _e229 = (*distance_1);
        let _e230 = (*range_4);
        ratio = (_e229 / _e230);
        let _e232 = ratio;
        let _e233 = ratio;
        let _e235 = ratio;
        let _e237 = ratio;
        window = clamp((1f - (((_e232 * _e233) * _e235) * _e237)), 0f, 1f);
        let _e241 = window;
        let _e242 = window;
        let _e244 = attenuation;
        attenuation = (_e244 * (_e241 * _e242));
    }
    let _e246 = attenuation;
    return _e246;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_24: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e234 = (*halfWidth);
    let _e235 = (*halfHeight);
    n_2 = cross(_e234, _e235);
    let _e237 = n_2;
    nLen = length(_e237);
    let _e239 = nLen;
    if (_e239 < 0.000000000001f) {
        let _e241 = (*centre);
        return _e241;
    }
    let _e242 = nLen;
    let _e243 = n_2;
    n_2 = (_e243 / vec3(_e242));
    let _e246 = (*centre);
    let _e247 = (*world_2);
    toPlane = (_e246 - _e247);
    let _e249 = (*mirror);
    let _e250 = n_2;
    denom = dot(_e249, _e250);
    let _e252 = denom;
    if (abs(_e252) < 0.00001f) {
        let _e255 = toPlane;
        let _e256 = n_2;
        let _e257 = toPlane;
        let _e258 = n_2;
        onPlane = (_e255 - (_e256 * dot(_e257, _e258)));
    } else {
        let _e262 = toPlane;
        let _e263 = n_2;
        let _e265 = denom;
        t_1 = (dot(_e262, _e263) / _e265);
        let _e267 = t_1;
        if (_e267 > 0f) {
            let _e269 = (*mirror);
            let _e270 = t_1;
            local_24 = (_e269 * _e270);
        } else {
            let _e272 = toPlane;
            let _e273 = n_2;
            let _e274 = toPlane;
            let _e275 = n_2;
            local_24 = (_e272 - (_e273 * dot(_e274, _e275)));
        }
        let _e279 = local_24;
        onPlane = _e279;
    }
    let _e280 = onPlane;
    let _e281 = toPlane;
    offset_2 = (_e280 - _e281);
    let _e283 = (*halfWidth);
    let _e284 = (*halfWidth);
    wLen2_ = max(dot(_e283, _e284), 0.000000000001f);
    let _e287 = (*halfHeight);
    let _e288 = (*halfHeight);
    hLen2_ = max(dot(_e287, _e288), 0.000000000001f);
    let _e291 = offset_2;
    let _e292 = (*halfWidth);
    let _e294 = wLen2_;
    u = clamp((dot(_e291, _e292) / _e294), -1f, 1f);
    let _e297 = offset_2;
    let _e298 = (*halfHeight);
    let _e300 = hLen2_;
    v = clamp((dot(_e297, _e298) / _e300), -1f, 1f);
    let _e303 = (*centre);
    let _e304 = (*halfWidth);
    let _e305 = u;
    let _e308 = (*halfHeight);
    let _e309 = v;
    return ((_e303 + (_e304 * _e305)) + (_e308 * _e309));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_25: f32;

    let _e226 = (*a_1);
    let _e227 = (*a_1);
    ua = (_e226 / vec3(max(length(_e227), 0.000000000001f)));
    let _e232 = (*b);
    let _e233 = (*b);
    ub = (_e232 / vec3(max(length(_e233), 0.000000000001f)));
    let _e238 = ua;
    let _e239 = ub;
    angle_1 = acos(clamp(dot(_e238, _e239), -1f, 1f));
    let _e243 = ua;
    let _e244 = ub;
    axis = cross(_e243, _e244);
    let _e246 = axis;
    len = length(_e246);
    let _e248 = len;
    if (_e248 > 0.000001f) {
        let _e250 = angle_1;
        let _e251 = axis;
        let _e252 = (*n_3);
        let _e255 = len;
        local_25 = ((_e250 * dot(_e251, _e252)) / _e255);
    } else {
        local_25 = 0f;
    }
    let _e257 = local_25;
    return _e257;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_26: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_27: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_28: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e240 = i_7;
        if (_e240 < 4i) {
            let _e242 = i_7;
            let _e244 = (*corners)[_e242];
            a_2 = _e244;
            let _e245 = i_7;
            if (_e245 == 3i) {
                local_26 = 0i;
            } else {
                let _e247 = i_7;
                local_26 = (_e247 + 1i);
            }
            let _e249 = local_26;
            let _e251 = (*corners)[_e249];
            b_1 = _e251;
            let _e252 = a_2;
            let _e253 = (*n_4);
            ha = dot(_e252, _e253);
            let _e255 = b_1;
            let _e256 = (*n_4);
            hb = dot(_e255, _e256);
            let _e258 = ha;
            let _e259 = hb;
            d_3 = (_e258 - _e259);
            let _e261 = a_2;
            let _e262 = b_1;
            let _e263 = a_2;
            let _e265 = d_3;
            if (abs(_e265) > 0.000000000001f) {
                let _e268 = ha;
                let _e269 = d_3;
                local_27 = (_e268 / _e269);
            } else {
                local_27 = 0f;
            }
            let _e271 = local_27;
            q = (_e261 + ((_e262 - _e263) * _e271));
            let _e274 = ha;
            aAbove = (_e274 > 0f);
            let _e276 = hb;
            bAbove = (_e276 > 0f);
            let _e278 = aAbove;
            let _e279 = bAbove;
            if (_e278 || _e279) {
                let _e281 = aAbove;
                let _e282 = a_2;
                let _e283 = q;
                let _e286 = bAbove;
                let _e287 = b_1;
                let _e288 = q;
                param_83 = select(_e283, _e282, vec3(_e281));
                param_84 = select(_e288, _e287, vec3(_e286));
                let _e291 = (*n_4);
                param_85 = _e291;
                let _e292 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_28 = _e292;
            } else {
                local_28 = 0f;
            }
            let _e293 = local_28;
            let _e294 = total;
            total = (_e294 + _e293);
            let _e296 = aAbove;
            let _e297 = bAbove;
            let _e300 = q;
            let _e301 = exit;
            exit = select(_e301, _e300, vec3((_e296 && !(_e297))));
            let _e304 = aAbove;
            let _e306 = bAbove;
            let _e308 = q;
            let _e309 = entry;
            entry = select(_e309, _e308, vec3((!(_e304) && _e306)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e312 = i_7;
            i_7 = (_e312 + 1i);
        }
    }
    let _e314 = exit;
    param_86 = _e314;
    let _e315 = entry;
    param_87 = _e315;
    let _e316 = (*n_4);
    param_88 = _e316;
    let _e317 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e318 = total;
    total = (_e318 + _e317);
    let _e320 = total;
    return max((-(_e320) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_29: f32;
    var local_30: f32;
    var local_31: f32;

    let _e223 = (*slot_1);
    let _e224 = (*slot_1);
    lane = (_e223 - ((_e224 / 4i) * 4i));
    let _e228 = lane;
    if (_e228 == 0i) {
        let _e231 = (*four)[0u];
        local_29 = _e231;
    } else {
        let _e232 = lane;
        if (_e232 == 1i) {
            let _e235 = (*four)[1u];
            local_30 = _e235;
        } else {
            let _e236 = lane;
            if (_e236 == 2i) {
                let _e239 = (*four)[2u];
                local_31 = _e239;
            } else {
                let _e241 = (*four)[3u];
                local_31 = _e241;
            }
            let _e242 = local_31;
            local_30 = _e242;
        }
        let _e243 = local_30;
        local_29 = _e243;
    }
    let _e244 = local_29;
    return _e244;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e220 = (*slot_2);
    let _e224 = light_list_info.scales[(_e220 / 4i)];
    param_89 = _e224;
    let _e225 = (*slot_2);
    param_90 = _e225;
    let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e226;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e222 = light_list_info.slot_rows[0i];
    let _e223 = (*row);
    a_3 = abs((_e222 - vec4(_e223)));
    let _e229 = light_list_info.slot_rows[1i];
    let _e230 = (*row);
    b_2 = abs((_e229 - vec4(_e230)));
    let _e235 = a_3[0u];
    let _e237 = a_3[1u];
    let _e240 = a_3[2u];
    let _e242 = a_3[3u];
    let _e246 = b_2[0u];
    let _e248 = b_2[1u];
    let _e251 = b_2[2u];
    let _e253 = b_2[3u];
    return (min(min(min(_e235, _e237), min(_e240, _e242)), min(min(_e246, _e248), min(_e251, _e253))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e220 = (*slot_3);
    let _e224 = light_list_info.indices[(_e220 / 4i)];
    param_91 = _e224;
    let _e225 = (*slot_3);
    param_92 = _e225;
    let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e226;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e219 = (*texel_2);
    let _e223 = light_list_info.list[1u];
    let _e225 = (*row_1);
    let _e229 = light_list_info.list[2u];
    let _e232 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e219 + 0.5f) * _e223), ((_e225 + 0.5f) * _e229)), 0f);
    return _e232;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e227 = g_cluster_offset;
    let _e228 = (*slot_4);
    entry_1 = (_e227 + f32(_e228));
    let _e231 = entry_1;
    row_2 = floor((_e231 / 16f));
    let _e234 = entry_1;
    let _e235 = row_2;
    within_1 = (_e234 - (_e235 * 16f));
    let _e238 = within_1;
    texel_3 = floor((_e238 / 4f));
    let _e243 = light_list_info.cluster_depth[3u];
    let _e244 = row_2;
    let _e246 = texel_3;
    param_93 = _e246;
    param_94 = (_e243 + _e244);
    let _e247 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e247;
    let _e248 = within_1;
    let _e249 = texel_3;
    let _e254 = four_1;
    param_95 = _e254;
    param_96 = i32(((_e248 - (_e249 * 4f)) + 0.5f));
    let _e255 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e255;
}

fn Clustered_u0028_() -> bool {
    let _e219 = light_list_info.cluster_grid[3u];
    return (_e219 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_32: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_33: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_34: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_35: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_36: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp_1: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e271 = (*index_2);
    if (_e271 < 8i) {
        let _e273 = (*index_2);
        let _e276 = frag_info.light_position[_e273];
        position = _e276;
        let _e277 = (*index_2);
        let _e280 = frag_info.light_color[_e277];
        color_1 = _e280;
        let _e281 = (*index_2);
        let _e284 = frag_info.light_direction[_e281];
        direction = _e284;
        let _e285 = (*index_2);
        let _e288 = frag_info.light_cone[_e285];
        cone = _e288;
    } else {
        let _e289 = (*index_2);
        slot_5 = (_e289 - 8i);
        let _e291 = Clustered_u0028_();
        clustered = _e291;
        let _e292 = clustered;
        if _e292 {
            let _e293 = slot_5;
            param_97 = _e293;
            let _e294 = ClusterRow_u0028_i1_u003b((&param_97));
            local_32 = _e294;
        } else {
            let _e295 = slot_5;
            param_98 = _e295;
            let _e296 = LightListRow_u0028_i1_u003b((&param_98));
            local_32 = _e296;
        }
        let _e297 = local_32;
        listRow = _e297;
        let _e298 = listRow;
        let _e302 = light_list_info.list[2u];
        v_1 = ((_e298 + 0.5f) * _e302);
        let _e306 = light_list_info.list[1u];
        u_1 = _e306;
        let _e307 = u_1;
        let _e309 = v_1;
        let _e311 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e307), _e309), 0f);
        position = _e311;
        let _e312 = u_1;
        let _e314 = v_1;
        let _e316 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e312), _e314), 0f);
        color_1 = _e316;
        let _e317 = u_1;
        let _e319 = v_1;
        let _e321 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e317), _e319), 0f);
        direction = _e321;
        let _e322 = u_1;
        let _e324 = v_1;
        let _e326 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e322), _e324), 0f);
        cone = _e326;
        let _e327 = clustered;
        if _e327 {
            let _e328 = listRow;
            param_99 = _e328;
            let _e329 = InSlots_u0028_f1_u003b((&param_99));
            local_33 = select(1f, 0f, _e329);
        } else {
            let _e331 = slot_5;
            param_100 = _e331;
            let _e332 = LightListScale_u0028_i1_u003b((&param_100));
            local_33 = _e332;
        }
        let _e333 = local_33;
        let _e335 = color_1[3u];
        color_1[3u] = (_e335 * _e333);
    }
    let _e339 = position[3u];
    type_39 = _e339;
    let _e340 = type_39;
    if (_e340 > 15.5f) {
        let _e343 = (*s_5).n;
        light_3.l = _e343;
        let _e346 = (*s_5).n;
        light_3.h = _e346;
        light_3.radiance = vec3<f32>(0f, 0f, 0f);
        light_3.n_dot_l = 0f;
        light_3.n_dot_h = 0f;
        light_3.v_dot_h = 0f;
        let _e352 = light_3;
        return _e352;
    }
    let _e353 = type_39;
    if (_e353 > 2.5f) {
        let _e355 = direction;
        halfWidth_1 = _e355.xyz;
        let _e357 = cone;
        halfHeight_1 = _e357.xyz;
        let _e359 = position;
        let _e361 = v_world_position_1;
        toCentre = (_e359.xyz - _e361);
        let _e363 = toCentre;
        let _e364 = halfWidth_1;
        let _e366 = halfHeight_1;
        corners_1[0i] = ((_e363 - _e364) - _e366);
        let _e369 = toCentre;
        let _e370 = halfWidth_1;
        let _e372 = halfHeight_1;
        corners_1[1i] = ((_e369 + _e370) - _e372);
        let _e375 = toCentre;
        let _e376 = halfWidth_1;
        let _e378 = halfHeight_1;
        corners_1[2i] = ((_e375 + _e376) + _e378);
        let _e381 = toCentre;
        let _e382 = halfWidth_1;
        let _e384 = halfHeight_1;
        corners_1[3i] = ((_e381 - _e382) + _e384);
        let _e387 = toCentre;
        let _e388 = halfWidth_1;
        let _e389 = halfHeight_1;
        behind = (dot(_e387, cross(_e388, _e389)) >= 0f);
        let _e393 = behind;
        if _e393 {
            local_34 = 0f;
        } else {
            let _e394 = corners_1;
            param_101 = _e394;
            let _e396 = (*s_5).n;
            param_102 = _e396;
            let _e397 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_34 = _e397;
        }
        let _e398 = local_34;
        formFactor = _e398;
        let _e399 = halfWidth_1;
        let _e400 = halfHeight_1;
        area = (length(cross(_e399, _e400)) * 4f);
        let _e404 = area;
        if (_e404 > 0.000000001f) {
            let _e406 = area;
            local_35 = (1f / _e406);
        } else {
            local_35 = 0f;
        }
        let _e408 = local_35;
        radiance = _e408;
        let _e409 = toCentre;
        distance_2 = length(_e409);
        let _e412 = direction[3u];
        if (_e412 > 0f) {
            let _e414 = distance_2;
            let _e416 = direction[3u];
            ratio_1 = (_e414 / _e416);
            let _e418 = ratio_1;
            let _e419 = ratio_1;
            let _e421 = ratio_1;
            let _e423 = ratio_1;
            window_1 = clamp((1f - (((_e418 * _e419) * _e421) * _e423)), 0f, 1f);
            let _e427 = window_1;
            let _e428 = window_1;
            let _e430 = radiance;
            radiance = (_e430 * (_e427 * _e428));
        }
        let _e433 = (*s_5).v;
        let _e436 = (*s_5).n;
        mirror_1 = reflect(-(_e433), _e436);
        let _e438 = position;
        param_103 = _e438.xyz;
        let _e440 = halfWidth_1;
        param_104 = _e440;
        let _e441 = halfHeight_1;
        param_105 = _e441;
        let _e442 = v_world_position_1;
        param_106 = _e442;
        let _e443 = mirror_1;
        param_107 = _e443;
        let _e444 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e444;
        let _e445 = representative;
        let _e446 = v_world_position_1;
        toPoint = (_e445 - _e446);
        let _e448 = toPoint;
        pointDistance = length(_e448);
        let _e450 = pointDistance;
        if (_e450 > 0.000001f) {
            let _e452 = toPoint;
            let _e453 = pointDistance;
            local_36 = (_e452 / vec3(_e453));
        } else {
            let _e457 = (*s_5).n;
            local_36 = _e457;
        }
        let _e458 = local_36;
        light_3.l = _e458;
        let _e461 = light_3.l;
        let _e463 = (*s_5).v;
        light_3.h = normalize((_e461 + _e463));
        let _e467 = formFactor;
        light_3.n_dot_l = _e467;
        let _e470 = (*s_5).n;
        let _e472 = light_3.h;
        light_3.n_dot_h = max(dot(_e470, _e472), 0f);
        let _e477 = (*s_5).v;
        let _e479 = light_3.h;
        light_3.v_dot_h = max(dot(_e477, _e479), 0f);
        let _e483 = color_1;
        let _e486 = color_1[3u];
        let _e488 = radiance;
        light_3.radiance = ((_e483.xyz * _e486) * _e488);
        let _e491 = light_3;
        return _e491;
    }
    let _e492 = direction;
    aim = normalize(_e492.xyz);
    attenuation_1 = 1f;
    let _e495 = type_39;
    if (_e495 < 0.5f) {
        let _e497 = aim;
        light_3.l = -(_e497);
    } else {
        let _e500 = position;
        let _e502 = v_world_position_1;
        toLight_1 = (_e500.xyz - _e502);
        let _e504 = toLight_1;
        distance_3 = length(_e504);
        let _e506 = distance_3;
        if (_e506 < 0.000001f) {
            let _e509 = (*s_5).n;
            light_3.l = _e509;
            let _e512 = (*s_5).n;
            light_3.h = _e512;
            light_3.radiance = vec3<f32>(0f, 0f, 0f);
            light_3.n_dot_l = 0f;
            light_3.n_dot_h = 0f;
            light_3.v_dot_h = 0f;
            let _e518 = light_3;
            return _e518;
        }
        let _e519 = toLight_1;
        let _e520 = distance_3;
        light_3.l = (_e519 / vec3(_e520));
        let _e524 = distance_3;
        param_108 = _e524;
        let _e526 = direction[3u];
        param_109 = _e526;
        let _e527 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e527;
        let _e528 = type_39;
        if (_e528 > 1.5f) {
            let _e530 = aim;
            let _e532 = light_3.l;
            cosAngle = dot(_e530, -(_e532));
            let _e535 = cosAngle;
            let _e537 = cone[1u];
            let _e540 = cone[0u];
            let _e542 = cone[1u];
            ramp_1 = clamp(((_e535 - _e537) / (_e540 - _e542)), 0f, 1f);
            let _e546 = ramp_1;
            let _e547 = ramp_1;
            let _e549 = attenuation_1;
            attenuation_1 = (_e549 * (_e546 * _e547));
        }
    }
    let _e552 = light_3.l;
    let _e554 = (*s_5).v;
    light_3.h = normalize((_e552 + _e554));
    let _e559 = (*s_5).n;
    let _e561 = light_3.l;
    light_3.n_dot_l = max(dot(_e559, _e561), 0f);
    let _e566 = (*s_5).n;
    let _e568 = light_3.h;
    light_3.n_dot_h = max(dot(_e566, _e568), 0f);
    let _e573 = (*s_5).v;
    let _e575 = light_3.h;
    light_3.v_dot_h = max(dot(_e573, _e575), 0f);
    let _e579 = color_1;
    let _e582 = color_1[3u];
    let _e584 = attenuation_1;
    light_3.radiance = ((_e579.xyz * _e582) * _e584);
    let _e587 = light_3;
    return _e587;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_37: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e232 = light_list_info.cluster_view_projection;
    let _e233 = (*world_3);
    clip_1 = (_e232 * vec4<f32>(_e233.x, _e233.y, _e233.z, 1f));
    let _e239 = clip_1;
    let _e242 = clip_1[3u];
    ndc_1 = (_e239.xy / vec2(max(_e242, 0.000001f)));
    let _e247 = light_list_info.cluster_grid;
    grid = _e247.xyz;
    let _e251 = light_list_info.cluster_depth[0u];
    near_1 = _e251;
    let _e253 = ndc_1[0u];
    let _e257 = grid[0u];
    let _e261 = grid[0u];
    tx = clamp(floor((((_e253 * 0.5f) + 0.5f) * _e257)), 0f, (_e261 - 1f));
    let _e265 = ndc_1[1u];
    let _e269 = grid[1u];
    let _e273 = grid[1u];
    ty = clamp(floor((((_e265 * 0.5f) + 0.5f) * _e269)), 0f, (_e273 - 1f));
    let _e277 = clip_1[3u];
    let _e278 = near_1;
    if (_e277 <= _e278) {
        local_37 = 0f;
    } else {
        let _e281 = clip_1[3u];
        let _e282 = near_1;
        let _e287 = light_list_info.cluster_depth[1u];
        let _e291 = grid[2u];
        local_37 = clamp(floor((log((_e281 / _e282)) * _e287)), 0f, (_e291 - 1f));
    }
    let _e294 = local_37;
    tz = _e294;
    let _e295 = tx;
    let _e296 = ty;
    let _e298 = grid[0u];
    let _e301 = tz;
    let _e303 = grid[0u];
    let _e306 = grid[1u];
    cell_1 = ((_e295 + (_e296 * _e298)) + ((_e301 * _e303) * _e306));
    let _e309 = cell_1;
    row_3 = floor((_e309 / 4f));
    let _e312 = cell_1;
    let _e313 = row_3;
    let _e318 = light_list_info.cluster_depth[2u];
    let _e319 = row_3;
    param_110 = (_e312 - (_e313 * 4f));
    param_111 = (_e318 + _e319);
    let _e321 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e321;
    let _e323 = header[0u];
    g_cluster_offset = _e323;
    let _e325 = header[1u];
    g_cluster_count = _e325;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e221 = light_list_info.list[0u];
    tail = _e221;
    let _e222 = Clustered_u0028_();
    if _e222 {
        let _e223 = v_world_position_1;
        param_112 = _e223;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e224 = g_cluster_count;
        tail = _e224;
    }
    let _e227 = frag_info.frame_params[1u];
    let _e231 = tail;
    return (clamp(i32((_e227 + 0.5f)), 0i, 8i) + clamp(i32((_e231 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_38: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e235 = LightCount_u0028_();
    count_1 = _e235;
    i_8 = 0i;
    loop {
        let _e236 = i_8;
        if (_e236 < 32i) {
            let _e238 = i_8;
            let _e239 = count_1;
            if (_e238 >= _e239) {
                break;
            }
            let _e241 = i_8;
            param_113 = _e241;
            let _e242 = (*s_6);
            param_114 = _e242;
            let _e243 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_113), (&param_114));
            light_4 = _e243;
            let _e245 = light_4.n_dot_l;
            if (_e245 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e247 = i_8;
            param_115 = _e247;
            let _e248 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e248 {
                let _e249 = (*s_6);
                param_116 = _e249;
                let _e250 = light_4;
                param_117 = _e250;
                let _e251 = i_8;
                param_118 = _e251;
                let _e252 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e253 = v_world_position_1;
                param_119 = _e253;
                let _e255 = (*s_6).n;
                param_120 = _e255;
                let _e256 = i_8;
                param_121 = _e256;
                let _e257 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_38 = (_e252 * _e257);
            } else {
                local_38 = 1f;
            }
            let _e259 = local_38;
            visibility = _e259;
            let _e260 = visibility;
            if (_e260 <= 0f) {
                continue;
            }
            let _e262 = (*s_6);
            param_122 = _e262;
            let _e263 = light_4;
            param_123 = _e263;
            let _e264 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e266 = light_4.radiance;
            let _e269 = light_4.n_dot_l;
            let _e271 = visibility;
            let _e273 = light_transmittance;
            let _e275 = total_1;
            total_1 = (_e275 + ((((_e264 * _e266) * _e269) * _e271) * _e273));
            continue;
        } else {
            break;
        }
        continuing {
            let _e277 = i_8;
            i_8 = (_e277 + 1i);
        }
    }
    let _e279 = total_1;
    return _e279;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_39: f32;
    var local_40: f32;

    let _e221 = OcclusionTarget_u0028_();
    target_ = _e221;
    let _e222 = target_;
    let _e224 = target_;
    if ((_e222 > 0.5f) && (_e224 < 1.5f)) {
        local_39 = 1f;
    } else {
        let _e228 = (*s_7).occlusion;
        local_39 = _e228;
    }
    let _e229 = local_39;
    local_40 = _e229;
    let _e230 = local_40;
    return _e230;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e218 = v_lightmap_uv_1;
    let _e219 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e218);
    texel_4 = _e219;
    let _e220 = texel_4;
    let _e223 = texel_4[3u];
    return ((_e220.xyz * _e223) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e219 = frag_info.target_origin[1u];
    return _e219;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e219 = v_texcoord_1;
    let _e220 = MaterialLodBias_u0028_();
    let _e221 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e219, _e220);
    orm = _e221.xyz;
    let _e224 = (*s_8).metallic;
    let _e226 = orm[2u];
    (*s_8).metallic = clamp((_e224 * _e226), 0f, 1f);
    let _e231 = (*s_8).roughness;
    let _e233 = orm[1u];
    (*s_8).roughness = clamp((_e231 * _e233), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_124: vec3<f32>;

    let _e220 = v_texcoord_1;
    let _e221 = MaterialLodBias_u0028_();
    let _e222 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e220, _e221);
    param_124 = _e222.xyz;
    let _e224 = SrgbToLinear_u0028_vf3_u003b((&param_124));
    emissive = _e224;
    let _e225 = emissive;
    let _e227 = frag_info.emissive;
    let _e232 = frag_info.material2_[3u];
    (*s_9).emissive = ((_e225 * _e227.xyz) * _e232);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e220 = v_texcoord_1;
    let _e221 = MaterialLodBias_u0028_();
    let _e222 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e220, _e221);
    occlusion = _e222.x;
    let _e226 = frag_info.material2_[2u];
    let _e227 = OcclusionTarget_u0028_();
    strength_2 = (_e226 - (2f * _e227));
    let _e230 = occlusion;
    let _e231 = strength_2;
    (*s_10).occlusion = mix(1f, _e230, clamp(_e231, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e222 = v_texcoord_1;
    let _e223 = MaterialLodBias_u0028_();
    let _e224 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e222, _e223);
    sampledTexel = _e224;
    let _e225 = v_tangent_1;
    t_2 = _e225.xyz;
    let _e227 = t_2;
    let _e229 = (*s_11).n;
    let _e231 = (*s_11).n;
    let _e232 = t_2;
    t_2 = (_e227 - (_e229 * dot(_e231, _e232)));
    let _e236 = t_2;
    let _e237 = t_2;
    if (dot(_e236, _e237) < 0.000000000001f) {
        return;
    }
    let _e240 = t_2;
    t_2 = normalize(_e240);
    let _e243 = (*s_11).n;
    let _e244 = t_2;
    let _e247 = v_tangent_1[3u];
    b_3 = (cross(_e243, _e244) * _e247);
    let _e249 = gl_FrontFacing_1;
    if !(_e249) {
        let _e251 = t_2;
        t_2 = -(_e251);
    }
    let _e253 = sampledTexel;
    sampled = ((_e253.xyz * 2f) - vec3(1f));
    let _e260 = frag_info.emissive[3u];
    if (_e260 > 0.5f) {
        let _e262 = sampled;
        let _e264 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e262.xy, _e264.xy)), 0f));
    }
    let _e273 = frag_info.material2_[1u];
    let _e274 = sampled;
    let _e276 = (_e274.xy * _e273);
    sampled[0u] = _e276.x;
    sampled[1u] = _e276.y;
    let _e281 = t_2;
    let _e283 = sampled[0u];
    let _e285 = b_3;
    let _e287 = sampled[1u];
    let _e291 = (*s_11).n;
    let _e293 = sampled[2u];
    (*s_11).n = normalize((((_e281 * _e283) + (_e285 * _e287)) + (_e291 * _e293)));
    let _e299 = (*s_11).n;
    let _e301 = (*s_11).v;
    (*s_11).n_dot_v = max(dot(_e299, _e301), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e218 = (*texel_5);
    let _e222 = irradiance_info.atlas;
    let _e225 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e218 + vec2(0.5f)) * _e222.xy), 0f);
    return _e225;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_125: vec2<f32>;
    var b_4: vec4<f32>;
    var param_126: vec2<f32>;
    var c_1: vec4<f32>;
    var param_127: vec2<f32>;
    var d_4: vec4<f32>;
    var param_128: vec2<f32>;

    let _e231 = (*uv_6);
    let _e232 = (*interior);
    at_1 = ((vec2(1f) + (_e231 * _e232)) - vec2(0.5f));
    let _e238 = at_1;
    low = floor(_e238);
    let _e240 = at_1;
    let _e241 = low;
    f = (_e240 - _e241);
    let _e243 = (*corner);
    let _e244 = low;
    param_125 = (_e243 + _e244);
    let _e246 = AtlasTexel_u0028_vf2_u003b((&param_125));
    a_4 = _e246;
    let _e247 = (*corner);
    let _e248 = low;
    param_126 = ((_e247 + _e248) + vec2<f32>(1f, 0f));
    let _e251 = AtlasTexel_u0028_vf2_u003b((&param_126));
    b_4 = _e251;
    let _e252 = (*corner);
    let _e253 = low;
    param_127 = ((_e252 + _e253) + vec2<f32>(0f, 1f));
    let _e256 = AtlasTexel_u0028_vf2_u003b((&param_127));
    c_1 = _e256;
    let _e257 = (*corner);
    let _e258 = low;
    param_128 = ((_e257 + _e258) + vec2<f32>(1f, 1f));
    let _e261 = AtlasTexel_u0028_vf2_u003b((&param_128));
    d_4 = _e261;
    let _e262 = a_4;
    let _e263 = b_4;
    let _e265 = f[0u];
    let _e268 = c_1;
    let _e269 = d_4;
    let _e271 = f[0u];
    let _e275 = f[1u];
    return mix(mix(_e262, _e263, vec4(_e265)), mix(_e268, _e269, vec4(_e271)), vec4(_e275));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e222 = (*direction_1)[0u];
    let _e225 = (*direction_1)[1u];
    let _e229 = (*direction_1)[2u];
    sum_1 = ((abs(_e222) + abs(_e225)) + abs(_e229));
    let _e232 = sum_1;
    if (_e232 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e234 = (*direction_1);
    let _e235 = sum_1;
    n_5 = (_e234 / vec3(_e235));
    let _e238 = n_5;
    xy = _e238.xy;
    let _e241 = n_5[2u];
    if (_e241 < 0f) {
        let _e244 = n_5[1u];
        let _e248 = n_5[0u];
        let _e253 = n_5[0u];
        let _e257 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e244)) * select(-1f, 1f, (_e248 >= 0f))), ((1f - abs(_e253)) * select(-1f, 1f, (_e257 >= 0f))));
    }
    let _e262 = xy;
    return ((_e262 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_129: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_130: vec3<f32>;
    var param_131: vec2<f32>;
    var param_132: f32;
    var param_133: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_134: vec3<f32>;
    var param_135: vec2<f32>;
    var param_136: f32;
    var param_137: vec2<f32>;
    var local_41: vec3<f32>;

    let _e264 = irradiance_info.origin;
    origin_2 = _e264.xyz;
    let _e267 = irradiance_info.spacing;
    spacing = _e267.xyz;
    let _e270 = irradiance_info.counts;
    counts = _e270.xyz;
    let _e274 = irradiance_info.tiles[0u];
    irradianceTile = _e274;
    let _e277 = irradiance_info.tiles[1u];
    depthTile = _e277;
    let _e280 = irradiance_info.tiles[2u];
    columns = _e280;
    let _e283 = irradiance_info.tiles[3u];
    momentsTop = _e283;
    let _e284 = (*normal_1);
    unit = normalize(_e284);
    let _e286 = (*world_4);
    let _e287 = unit;
    let _e290 = irradiance_info.spacing[3u];
    let _e293 = (*view_1);
    let _e296 = irradiance_info.counts[3u];
    biased = ((_e286 + (_e287 * _e290)) + (_e293 * _e296));
    let _e299 = biased;
    let _e300 = origin_2;
    let _e302 = spacing;
    grid_1 = ((_e299 - _e300) / _e302);
    let _e304 = grid_1;
    let _e306 = counts;
    base = clamp(floor(_e304), vec3<f32>(0f, 0f, 0f), (_e306 - vec3(2f)));
    let _e310 = grid_1;
    let _e311 = base;
    f_1 = clamp((_e310 - _e311), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e314 = corner_1;
        if (_e314 < 8i) {
            let _e316 = corner_1;
            let _e319 = corner_1;
            let _e324 = corner_1;
            offset_3 = vec3<f32>(f32((_e316 & 1i)), f32(((_e319 >> bitcast<u32>(1i)) & 1i)), f32(((_e324 >> bitcast<u32>(2i)) & 1i)));
            let _e330 = base;
            let _e331 = offset_3;
            cell_2 = (_e330 + _e331);
            let _e334 = cell_2[2u];
            let _e336 = counts[1u];
            let _e339 = cell_2[1u];
            let _e342 = counts[0u];
            let _e345 = cell_2[0u];
            probe = ((((_e334 * _e336) + _e339) * _e342) + _e345);
            let _e347 = probe;
            let _e348 = columns;
            let _e353 = probe;
            let _e354 = columns;
            tile_4 = vec2<f32>((_e347 - (floor((_e347 / _e348)) * _e348)), floor((_e353 / _e354)));
            let _e358 = tile_4;
            let _e359 = irradianceTile;
            irradianceCorner = (_e358 * (_e359 + 2f));
            let _e363 = tile_4[0u];
            let _e364 = depthTile;
            let _e367 = momentsTop;
            let _e369 = tile_4[1u];
            let _e370 = depthTile;
            momentCorner = vec2<f32>((_e363 * (_e364 + 2f)), (_e367 + (_e369 * (_e370 + 2f))));
            let _e375 = irradianceCorner;
            param_129 = (_e375 + vec2(1f));
            let _e378 = AtlasTexel_u0028_vf2_u003b((&param_129));
            if (_e378.w < 0.5f) {
                continue;
            }
            let _e381 = f_1;
            let _e383 = f_1;
            let _e384 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e381), _e383, _e384);
            let _e387 = trilinear[0u];
            let _e389 = trilinear[1u];
            let _e392 = trilinear[2u];
            weight_3 = max(((_e387 * _e389) * _e392), 0.001f);
            let _e395 = origin_2;
            let _e396 = spacing;
            let _e397 = cell_2;
            probePosition = (_e395 + (_e396 * _e397));
            let _e400 = probePosition;
            let _e401 = biased;
            toProbe = (_e400 - _e401);
            let _e403 = toProbe;
            distance_4 = length(_e403);
            let _e405 = distance_4;
            if (_e405 > 0.000001f) {
                let _e407 = toProbe;
                let _e408 = distance_4;
                direction_2 = (_e407 / vec3(_e408));
                let _e411 = unit;
                let _e412 = probePosition;
                let _e413 = (*world_4);
                facing = ((dot(_e411, normalize((_e412 - _e413))) * 0.5f) + 0.5f);
                let _e419 = facing;
                let _e420 = facing;
                probeWeight = ((_e419 * _e420) + 0.2f);
                let _e423 = direction_2;
                param_130 = -(_e423);
                let _e425 = ProbeOctahedral_u0028_vf3_u003b((&param_130));
                let _e426 = momentCorner;
                param_131 = _e426;
                let _e427 = depthTile;
                param_132 = _e427;
                param_133 = _e425;
                let _e428 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_131), (&param_132), (&param_133));
                moments_3 = _e428.xy;
                chebyshev = 1f;
                let _e430 = distance_4;
                let _e432 = moments_3[0u];
                if (_e430 > _e432) {
                    let _e435 = moments_3[1u];
                    let _e437 = moments_3[0u];
                    let _e439 = moments_3[0u];
                    variance_1 = max((_e435 - (_e437 * _e439)), 0.000001f);
                    let _e443 = distance_4;
                    let _e445 = moments_3[0u];
                    difference = (_e443 - _e445);
                    let _e447 = variance_1;
                    let _e448 = variance_1;
                    let _e449 = difference;
                    let _e450 = difference;
                    chebyshev = (_e447 / (_e448 + (_e449 * _e450)));
                    let _e454 = chebyshev;
                    let _e455 = chebyshev;
                    let _e457 = chebyshev;
                    chebyshev = ((_e454 * _e455) * _e457);
                }
                let _e459 = probeWeight;
                let _e460 = chebyshev;
                probeWeight = max((_e459 * max(_e460, 0.05f)), 0.000001f);
                let _e464 = probeWeight;
                if (_e464 < 0.2f) {
                    let _e466 = probeWeight;
                    let _e467 = probeWeight;
                    let _e470 = probeWeight;
                    probeWeight = (_e470 * ((_e466 * _e467) * 25f));
                }
                let _e472 = probeWeight;
                let _e473 = weight_3;
                weight_3 = (_e473 * _e472);
            }
            let _e475 = unit;
            param_134 = _e475;
            let _e476 = ProbeOctahedral_u0028_vf3_u003b((&param_134));
            let _e477 = irradianceCorner;
            param_135 = _e477;
            let _e478 = irradianceTile;
            param_136 = _e478;
            param_137 = _e476;
            let _e479 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_135), (&param_136), (&param_137));
            let _e481 = weight_3;
            let _e483 = total_2;
            total_2 = (_e483 + (_e479.xyz * _e481));
            let _e485 = weight_3;
            let _e486 = weights;
            weights = (_e486 + _e485);
            continue;
        } else {
            break;
        }
        continuing {
            let _e488 = corner_1;
            corner_1 = (_e488 + 1i);
        }
    }
    let _e490 = weights;
    if (_e490 > 0f) {
        let _e492 = total_2;
        let _e493 = weights;
        local_41 = (_e492 / vec3(_e493));
    } else {
        local_41 = vec3<f32>(0f, 0f, 0f);
    }
    let _e496 = local_41;
    return _e496;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e219 = irradiance_info.origin[3u];
    return (_e219 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: Surface;

    let _e224 = IrradianceEnabled_u0028_();
    if _e224 {
        let _e225 = v_world_position_1;
        param_138 = _e225;
        let _e227 = (*s_12).n;
        param_139 = _e227;
        let _e229 = (*s_12).v;
        param_140 = _e229;
        let _e230 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_138), (&param_139), (&param_140));
        let _e233 = frag_info.material[2u];
        (*s_12).ambient = (_e230 * _e233);
    }
    let _e236 = (*s_12);
    param_141 = _e236;
    ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    let _e237 = param_141;
    (*s_12) = _e237;
    let _e238 = (*s_12);
    param_142 = _e238;
    ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_142));
    let _e239 = param_142;
    (*s_12) = _e239;
    let _e240 = (*s_12);
    param_143 = _e240;
    ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_143));
    let _e241 = param_143;
    (*s_12) = _e241;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_42: vec3<f32>;

    let _e218 = Orthographic_u0028_();
    if _e218 {
        let _e220 = fog_info.forward;
        local_42 = -(_e220.xyz);
    } else {
        let _e224 = fog_info.eye;
        let _e226 = v_world_position_1;
        local_42 = normalize((_e224.xyz - _e226));
    }
    let _e229 = local_42;
    return _e229;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin_3: vec3<f32>;
    var cell_3: vec3<f32>;
    var p3_: vec3<f32>;

    let _e223 = (*cutoff);
    key_2 = (-2f - _e223);
    let _e225 = key_2;
    let _e228 = key_2;
    let _e230 = floor((_e228 / 128f));
    let _e235 = key_2;
    origin_3 = vec3<f32>(floor((_e225 / 16384f)), (_e230 - (floor((_e230 / 128f)) * 128f)), (_e235 - (floor((_e235 / 128f)) * 128f)));
    let _e241 = (*scenePosition);
    let _e244 = origin_3;
    let _e245 = (floor((_e241 * 16f)) + _e244);
    let _e246 = vec3(128f);
    cell_3 = (_e245 - (floor((_e245 / _e246)) * _e246));
    let _e251 = cell_3;
    p3_ = fract((_e251 * 0.1031f));
    let _e254 = p3_;
    let _e255 = p3_;
    let _e260 = p3_;
    p3_ = (_e260 + vec3(dot(_e254, (_e255.zyx + vec3(31.32f)))));
    let _e264 = p3_[0u];
    let _e266 = p3_[1u];
    let _e269 = p3_[2u];
    return fract(((_e264 + _e266) * _e269));
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_13: Surface;
    var param_144: vec3<f32>;
    var param_145: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_146: vec3<f32>;
    var param_147: f32;

    let _e225 = v_texcoord_1;
    let _e226 = MaterialLodBias_u0028_();
    let _e227 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e225, _e226);
    texel_6 = _e227;
    let _e228 = texel_6;
    param_144 = _e228.xyz;
    let _e230 = SrgbToLinear_u0028_vf3_u003b((&param_144));
    let _e232 = frag_info.base_color;
    param_145 = _e232.xyz;
    let _e234 = SrgbToLinear_u0028_vf3_u003b((&param_145));
    let _e236 = v_color_1;
    s_13.albedo = ((_e230 * _e234) * _e236.xyz);
    let _e241 = texel_6[3u];
    let _e244 = frag_info.base_color[3u];
    let _e247 = v_color_1[3u];
    s_13.alpha = ((_e241 * _e244) * _e247);
    let _e251 = s_13.albedo;
    g_albedo = _e251;
    let _e254 = frag_info.material2_[0u];
    cutoff_1 = _e254;
    let _e255 = cutoff_1;
    if (_e255 > 1f) {
        let _e257 = cutoff_1;
        edge = (_e257 - 1f);
        let _e260 = s_13.alpha;
        let _e261 = edge;
        let _e264 = s_13.alpha;
        let _e265 = fwidth(_e264);
        s_13.alpha = clamp((((_e260 - _e261) / max(_e265, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e271 = cutoff_1;
        if (_e271 >= 0f) {
            let _e274 = s_13.alpha;
            let _e275 = cutoff_1;
            if (_e274 < _e275) {
                discard;
            }
            s_13.alpha = 1f;
        } else {
            let _e278 = cutoff_1;
            if (_e278 < -1.5f) {
                let _e281 = s_13.alpha;
                let _e282 = v_world_position_1;
                param_146 = _e282;
                let _e283 = cutoff_1;
                param_147 = _e283;
                let _e284 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_146), (&param_147));
                if (_e281 < _e284) {
                    discard;
                }
            }
        }
    }
    let _e286 = cutoff_1;
    let _e288 = cutoff_1;
    g_premultiply = ((_e286 < 0f) && (_e288 > -0.75f));
    let _e291 = v_normal_1;
    s_13.n = normalize(_e291);
    let _e294 = gl_FrontFacing_1;
    if !(_e294) {
        let _e297 = s_13.n;
        s_13.n = -(_e297);
    }
    let _e300 = TowardsEye_u0028_();
    s_13.v = _e300;
    let _e303 = s_13.n;
    let _e305 = s_13.v;
    s_13.n_dot_v = max(dot(_e303, _e305), 0.0001f);
    let _e311 = frag_info.material[0u];
    s_13.metallic = clamp(_e311, 0f, 1f);
    let _e316 = frag_info.material[1u];
    s_13.roughness = clamp(_e316, 0.02f, 1f);
    let _e320 = frag_info.ambient_ground;
    let _e323 = frag_info.ambient_sky;
    let _e327 = s_13.n[1u];
    let _e334 = frag_info.material[2u];
    s_13.ambient = (mix(_e320.xyz, _e323.xyz, vec3(((_e327 * 0.5f) + 0.5f))) * _e334);
    let _e339 = frag_info.frame_params[0u];
    s_13.exposure = max(_e339, 0f);
    s_13.occlusion = 1f;
    s_13.emissive = vec3<f32>(0f, 0f, 0f);
    let _e344 = s_13;
    return _e344;
}

fn main_1() {
    var s_14: Surface;
    var param_148: Surface;
    var param_149: Surface;
    var rim: f32;
    var ambient: vec3<f32>;
    var param_150: Surface;
    var lit_3: vec3<f32>;
    var param_151: Surface;
    var param_152: Surface;
    var param_153: Surface;
    var param_154: vec3<f32>;
    var param_155: vec3<f32>;
    var param_156: f32;
    var param_157: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e231 = ReadSurface_u0028_();
    s_14 = _e231;
    let _e232 = s_14;
    param_148 = _e232;
    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((&param_148));
    let _e233 = param_148;
    s_14 = _e233;
    let _e234 = s_14;
    param_149 = _e234;
    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((&param_149));
    let _e235 = param_149;
    s_14 = _e235;
    let _e237 = s_14.n_dot_v;
    let _e242 = frag_info.material[3u];
    rim = (pow((1f - _e237), 3f) * _e242);
    let _e245 = s_14.albedo;
    let _e247 = s_14.ambient;
    let _e248 = SampleLightmap_u0028_();
    let _e251 = s_14;
    param_150 = _e251;
    let _e252 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_150));
    ambient = ((_e245 * (_e247 + _e248)) * _e252);
    let _e254 = s_14;
    param_151 = _e254;
    let _e255 = 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((&param_151));
    let _e256 = s_14;
    param_152 = _e256;
    let _e257 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_152));
    let _e259 = ambient;
    let _e261 = rim;
    let _e266 = s_14.emissive;
    lit_3 = ((((_e255 * _e257) + _e259) + vec3((_e261 * 0.35f))) + _e266);
    let _e268 = s_14;
    param_153 = _e268;
    let _e269 = lit_3;
    param_154 = _e269;
    let _e270 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_153), (&param_154));
    if _e270 {
        return;
    }
    let _e271 = lit_3;
    param_155 = _e271;
    let _e273 = s_14.alpha;
    param_156 = _e273;
    let _e275 = s_14.roughness;
    param_157 = _e275;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_155), (&param_156), (&param_157));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'UnlitOpaqueDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e124 = v_world_position_1;
    let _e126 = fog_info.eye;
    let _e130 = fog_info.forward;
    return dot((_e124 - _e126.xyz), _e130.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e129 = ViewDepth_u0028_();
    z = abs(_e129);
    let _e131 = z;
    near = (_e131 / 5f);
    let _e133 = z;
    far = (_e133 / 200f);
    let _e135 = far;
    let _e136 = far;
    let _e138 = far;
    far3_ = ((_e135 * _e136) * _e138);
    let _e140 = (*alpha);
    let _e141 = near;
    let _e142 = near;
    let _e145 = far3_;
    let _e146 = far3_;
    return (_e140 * clamp((10f / ((0.00001f + (_e141 * _e142)) + (_e145 * _e146))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e133 = fog_info.forward[3u];
    mode = _e133;
    let _e134 = mode;
    if (_e134 > 0.5f) {
        let _e137 = frag_color[3u];
        alpha_1 = _e137;
        let _e138 = alpha_1;
        param = _e138;
        let _e139 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e139;
        let _e140 = frag_color;
        let _e142 = weight;
        let _e143 = (_e140.xyz * _e142);
        let _e144 = alpha_1;
        let _e145 = weight;
        accumulate = vec4<f32>(_e143.x, _e143.y, _e143.z, (_e144 * _e145));
        let _e151 = mode;
        let _e153 = mode;
        revealage = ((_e151 > 1.5f) && (_e153 < 2.5f));
        let _e156 = revealage;
        if _e156 {
            let _e157 = alpha_1;
            local = vec4(_e157);
        } else {
            let _e159 = accumulate;
            local = _e159;
        }
        let _e160 = local;
        frag_color = _e160;
        let _e161 = mode;
        if (_e161 > 2.5f) {
            let _e163 = alpha_1;
            frag_surface = vec4(_e163);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e127 = (*n)[0u];
    let _e130 = (*n)[1u];
    let _e134 = (*n)[2u];
    let _e137 = (*n);
    (*n) = (_e137 / vec3(((abs(_e127) + abs(_e130)) + abs(_e134))));
    let _e140 = (*n);
    e = _e140.xy;
    let _e143 = (*n)[2u];
    if (_e143 < 0f) {
        let _e145 = (*n);
        let _e151 = (*n)[0u];
        let _e155 = (*n)[1u];
        e = ((vec2(1f) - abs(_e145.yx)) * vec2<f32>(select(-1f, 1f, (_e151 >= 0f)), select(-1f, 1f, (_e155 >= 0f))));
    }
    let _e160 = e;
    return ((_e160 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e125 = (*linear);
    let _e127 = (*linear);
    let _e131 = (*linear);
    return mix((_e125 * 12.92f), ((pow(_e127, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e131));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e128 = g_albedo;
    param_1 = clamp(_e128, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e130 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e130.x, _e130.y, _e130.z, 1f);
    let _e135 = g_debug_surface_on;
    if _e135 {
        let _e136 = g_debug_surface;
        let _e137 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e136.x, _e136.y, _e136.z, _e137);
        return;
    }
    let _e142 = v_normal_1;
    geometric = normalize(_e142);
    let _e144 = gl_FrontFacing_1;
    if !(_e144) {
        let _e146 = geometric;
        geometric = -(_e146);
    }
    let _e148 = geometric;
    param_2 = _e148;
    let _e149 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e150 = (*roughness);
    let _e152 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e149.x, _e149.y, clamp(_e150, 0f, 1f), _e152);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e126 = fog_info.projection[0u];
    return (_e126 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e125 = Orthographic_u0028_();
    if _e125 {
        let _e126 = ViewDepth_u0028_();
        local_1 = max(_e126, 0f);
    } else {
        let _e128 = v_world_position_1;
        let _e130 = fog_info.eye;
        local_1 = distance(_e128, _e130.xyz);
    }
    let _e133 = local_1;
    return _e133;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e132 = fog_info.fog[3u];
    density = _e132;
    let _e133 = density;
    if (_e133 <= 0f) {
        let _e135 = (*color);
        return _e135;
    }
    let _e136 = EyeDistance_u0028_();
    d = _e136;
    let _e139 = fog_info.eye[3u];
    falloff = _e139;
    let _e140 = falloff;
    if (_e140 > 0f) {
        let _e142 = falloff;
        let _e144 = v_world_position_1[1u];
        let _e147 = fog_info.eye[1u];
        k = (_e142 * (_e144 - _e147));
        let _e150 = k;
        if (abs(_e150) > 0.001f) {
            let _e153 = k;
            let _e157 = k;
            local_2 = ((1f - exp(-(_e153))) / _e157);
        } else {
            let _e159 = k;
            local_2 = (1f - (0.5f * _e159));
        }
        let _e162 = local_2;
        let _e163 = density;
        density = (_e163 * _e162);
    }
    let _e166 = fog_info.fog;
    let _e168 = (*color);
    let _e169 = density;
    let _e171 = d;
    return mix(_e166.xyz, _e168, vec3(clamp(exp((-(_e169) * _e171)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e130 = g_premultiply;
    let _e131 = (*alpha_2);
    weight_1 = select(1f, _e131, _e130);
    let _e133 = (*linearColor);
    param_3 = _e133;
    let _e134 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e135 = weight_1;
    let _e136 = (_e134 * _e135);
    let _e137 = (*alpha_2);
    let _e138 = g_pass_through;
    frag_color = vec4<f32>(_e136.x, _e136.y, _e136.z, (_e137 * (1f - _e138)));
    let _e145 = (*roughness_1);
    param_4 = _e145;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b(linearColor_1: ptr<function, vec3<f32>>, alpha_3: ptr<function, f32>) {
    var param_5: vec3<f32>;
    var param_6: f32;
    var param_7: f32;

    let _e129 = (*linearColor_1);
    param_5 = _e129;
    let _e130 = (*alpha_3);
    param_6 = _e130;
    param_7 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e125 = (*srgb);
    let _e128 = (*srgb);
    let _e133 = (*srgb);
    return mix((_e125 / vec3(12.92f)), pow(((_e128 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e133));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e127 = (*key);
    hue = fract(((_e127 * 0.618034f) + 0.13f));
    let _e131 = hue;
    k_1 = clamp((abs(((fract((vec3(_e131) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e144 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e144, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_629_: bool;

    let _e125 = (*c);
    let _e126 = (*c);
    let _e128 = any((_e125 != _e126));
    phi_629_ = _e128;
    if !(_e128) {
        let _e130 = (*c);
        phi_629_ = any((abs(_e130) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e135 = phi_629_;
    return _e135;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_8: vec3<f32>;
    var param_9: vec3<f32>;
    var grey: f32;
    var param_10: vec3<f32>;
    var param_11: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_12: vec3<f32>;
    var key_1: f32;
    var param_13: f32;
    var srgb_1: vec3<f32>;
    var param_14: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_15: vec3<f32>;
    var param_16: f32;
    var phi_722_: bool;
    var phi_993_: bool;

    let _e167 = gl_FragCoord_1[0u];
    let _e170 = frag_info.debug_view[1u];
    if (_e167 < _e170) {
        let _e174 = frag_info.debug_view[2u];
        local_3 = _e174;
    } else {
        let _e177 = frag_info.debug_view[0u];
        local_3 = _e177;
    }
    let _e178 = local_3;
    view = _e178;
    let _e179 = view;
    if (_e179 < 0.5f) {
        return false;
    }
    let _e181 = view;
    code = i32((_e181 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e184 = v_normal_1;
    geometric_n = normalize(_e184);
    let _e186 = v_tangent_1;
    let _e188 = geometric_n;
    let _e189 = geometric_n;
    let _e190 = v_tangent_1;
    tangent = (_e186.xyz - (_e188 * dot(_e189, _e190.xyz)));
    let _e195 = tangent;
    let _e196 = tangent;
    let _e198 = (dot(_e195, _e196) > 0.000000000001f);
    phi_722_ = _e198;
    if _e198 {
        let _e200 = v_tangent_1[3u];
        phi_722_ = (abs((abs(_e200) - 1f)) < 0.01f);
    }
    let _e206 = phi_722_;
    tangent_usable = _e206;
    let _e209 = frag_info.debug_view[3u];
    identity = _e209;
    let _e210 = identity;
    identity_object = floor((_e210 / 8192f));
    let _e213 = identity;
    let _e214 = identity_object;
    identity_rest = (_e213 - (_e214 * 8192f));
    let _e217 = identity_rest;
    identity_material = floor((_e217 / 2f));
    let _e220 = identity_rest;
    let _e221 = identity_material;
    normal_mapped = ((_e220 - (_e221 * 2f)) > 0.5f);
    let _e225 = code;
    if (_e225 == 1i) {
        let _e228 = (*s).albedo;
        param_8 = clamp(_e228, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e230 = LinearToSrgb_u0028_vf3_u003b((&param_8));
        shown = _e230;
    } else {
        let _e231 = code;
        if (_e231 == 2i) {
            let _e234 = (*s).n;
            shown = ((_e234 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e237 = code;
            if (_e237 == 3i) {
                let _e240 = (*s).roughness;
                shown = vec3(clamp(_e240, 0f, 1f));
            } else {
                let _e243 = code;
                if (_e243 == 4i) {
                    let _e246 = (*s).metallic;
                    shown = vec3(clamp(_e246, 0f, 1f));
                } else {
                    let _e249 = code;
                    if (_e249 == 5i) {
                        let _e252 = (*s).occlusion;
                        shown = vec3(clamp(_e252, 0f, 1f));
                    } else {
                        let _e255 = code;
                        if (_e255 == 6i) {
                            let _e258 = (*s).emissive;
                            param_9 = clamp(_e258, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e260 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                            shown = _e260;
                        } else {
                            let _e261 = code;
                            if (_e261 == 7i) {
                                let _e263 = v_texcoord_1;
                                let _e264 = fract(_e263);
                                shown = vec3<f32>(_e264.x, _e264.y, 0f);
                            } else {
                                let _e268 = code;
                                if (_e268 == 8i) {
                                    let _e270 = (*lit);
                                    param_10 = clamp(_e270, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e272 = LinearToSrgb_u0028_vf3_u003b((&param_10));
                                    grey = dot(_e272, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e274 = (*lit);
                                    param_11 = _e274;
                                    let _e275 = NonFinite_u0028_vf3_u003b((&param_11));
                                    if _e275 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e276 = grey;
                                        local_4 = vec3((_e276 * 0.5f));
                                    }
                                    let _e279 = local_4;
                                    shown = _e279;
                                } else {
                                    let _e280 = code;
                                    if (_e280 == 9i) {
                                        let _e282 = tangent_usable;
                                        if _e282 {
                                            let _e283 = tangent;
                                            local_5 = ((normalize(_e283) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e287 = local_5;
                                        shown = _e287;
                                    } else {
                                        let _e288 = code;
                                        if (_e288 == 10i) {
                                            let _e290 = v_texcoord_1;
                                            uv = _e290;
                                            let _e291 = uv;
                                            cell = floor((_e291 * 8f));
                                            let _e295 = cell[0u];
                                            let _e297 = cell[1u];
                                            odd = (fract(((_e295 + _e297) * 0.5f)) * 2f);
                                            let _e302 = uv;
                                            within = fract(_e302);
                                            let _e304 = odd;
                                            let _e308 = within[0u];
                                            let _e312 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e304)) * vec3<f32>((0.55f + (0.45f * _e308)), (0.55f + (0.45f * _e312)), 0.85f));
                                        } else {
                                            let _e317 = code;
                                            if (_e317 == 11i) {
                                                let _e319 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e319));
                                            } else {
                                                let _e322 = code;
                                                if (_e322 == 12i) {
                                                    let _e324 = v_color_1;
                                                    param_12 = clamp(_e324.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e327 = LinearToSrgb_u0028_vf3_u003b((&param_12));
                                                    shown = _e327;
                                                } else {
                                                    let _e328 = code;
                                                    let _e330 = code;
                                                    if ((_e328 == 13i) || (_e330 == 14i)) {
                                                        let _e333 = code;
                                                        let _e335 = identity_object;
                                                        let _e336 = identity_material;
                                                        key_1 = select(_e336, _e335, (_e333 == 13i));
                                                        let _e338 = key_1;
                                                        param_13 = _e338;
                                                        let _e339 = DebugIdentityColour_u0028_f1_u003b((&param_13));
                                                        let _e341 = (*s).n_dot_v;
                                                        shown = (_e339 * (0.55f + (0.45f * _e341)));
                                                    } else {
                                                        let _e345 = code;
                                                        if (_e345 == 15i) {
                                                            let _e348 = (*s).albedo;
                                                            param_14 = clamp(_e348, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e350 = LinearToSrgb_u0028_vf3_u003b((&param_14));
                                                            srgb_1 = _e350;
                                                            let _e351 = srgb_1;
                                                            luma = dot(_e351, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e354 = (*s).metallic;
                                                            metal = (_e354 > 0.5f);
                                                            let _e356 = metal;
                                                            let _e358 = luma;
                                                            if (!(_e356) && (_e358 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e361 = metal;
                                                                let _e362 = !(_e361);
                                                                phi_993_ = _e362;
                                                                if _e362 {
                                                                    let _e364 = srgb_1[0u];
                                                                    let _e366 = srgb_1[1u];
                                                                    let _e368 = srgb_1[2u];
                                                                    phi_993_ = (max(_e364, max(_e366, _e368)) > 0.9411765f);
                                                                }
                                                                let _e373 = phi_993_;
                                                                if _e373 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e374 = metal;
                                                                    let _e375 = luma;
                                                                    if (_e374 && (_e375 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e378 = luma;
                                                                        local_8 = vec3(_e378);
                                                                    }
                                                                    let _e380 = local_8;
                                                                    local_7 = _e380;
                                                                }
                                                                let _e381 = local_7;
                                                                local_6 = _e381;
                                                            }
                                                            let _e382 = local_6;
                                                            shown = _e382;
                                                        } else {
                                                            let _e383 = code;
                                                            if (_e383 == 16i) {
                                                                let _e386 = (*s).metallic;
                                                                m = _e386;
                                                                let _e387 = m;
                                                                let _e389 = m;
                                                                if ((_e387 > 0.05f) && (_e389 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e392 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e392 > 0.5f)));
                                                                }
                                                                let _e396 = local_9;
                                                                shown = _e396;
                                                            } else {
                                                                let _e397 = code;
                                                                if (_e397 == 17i) {
                                                                    let _e399 = normal_mapped;
                                                                    if !(_e399) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e401 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e401));
                                                                    }
                                                                    let _e404 = local_10;
                                                                    shown = _e404;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e405 = g_premultiply;
    if _e405 {
        let _e407 = (*s).alpha;
        local_11 = _e407;
    } else {
        local_11 = 1f;
    }
    let _e408 = local_11;
    weight_2 = _e408;
    let _e409 = shown;
    param_15 = _e409;
    let _e410 = SrgbToLinear_u0028_vf3_u003b((&param_15));
    let _e411 = weight_2;
    let _e412 = (_e410 * _e411);
    let _e414 = (*s).alpha;
    frag_color = vec4<f32>(_e412.x, _e412.y, _e412.z, _e414);
    let _e420 = (*s).roughness;
    param_16 = _e420;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_16));
    WriteWeightedBlended_u0028_();
    return true;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_12: vec3<f32>;

    let _e125 = Orthographic_u0028_();
    if _e125 {
        let _e127 = fog_info.forward;
        local_12 = -(_e127.xyz);
    } else {
        let _e131 = fog_info.eye;
        let _e133 = v_world_position_1;
        local_12 = normalize((_e131.xyz - _e133));
    }
    let _e136 = local_12;
    return _e136;
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e126 = frag_info.target_origin[1u];
    return _e126;
}

fn ReadSurface_u0028_() -> Surface {
    var texel: vec4<f32>;
    var s_1: Surface;
    var param_17: vec3<f32>;
    var param_18: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e130 = v_texcoord_1;
    let _e131 = MaterialLodBias_u0028_();
    let _e132 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e130, _e131);
    texel = _e132;
    let _e133 = texel;
    param_17 = _e133.xyz;
    let _e135 = SrgbToLinear_u0028_vf3_u003b((&param_17));
    let _e137 = frag_info.base_color;
    param_18 = _e137.xyz;
    let _e139 = SrgbToLinear_u0028_vf3_u003b((&param_18));
    let _e141 = v_color_1;
    s_1.albedo = ((_e135 * _e139) * _e141.xyz);
    let _e146 = texel[3u];
    let _e149 = frag_info.base_color[3u];
    let _e152 = v_color_1[3u];
    s_1.alpha = ((_e146 * _e149) * _e152);
    let _e156 = s_1.albedo;
    g_albedo = _e156;
    let _e159 = frag_info.material2_[0u];
    cutoff = _e159;
    let _e160 = cutoff;
    if (_e160 > 1f) {
        let _e162 = cutoff;
        edge = (_e162 - 1f);
        let _e165 = s_1.alpha;
        let _e166 = edge;
        let _e169 = s_1.alpha;
        let _e170 = fwidth(_e169);
        s_1.alpha = clamp((((_e165 - _e166) / max(_e170, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e176 = cutoff;
        if (_e176 >= 0f) {
            s_1.alpha = 1f;
        }
    }
    let _e179 = cutoff;
    let _e181 = cutoff;
    g_premultiply = ((_e179 < 0f) && (_e181 > -0.75f));
    let _e184 = v_normal_1;
    s_1.n = normalize(_e184);
    let _e187 = gl_FrontFacing_1;
    if !(_e187) {
        let _e190 = s_1.n;
        s_1.n = -(_e190);
    }
    let _e193 = TowardsEye_u0028_();
    s_1.v = _e193;
    let _e196 = s_1.n;
    let _e198 = s_1.v;
    s_1.n_dot_v = max(dot(_e196, _e198), 0.0001f);
    let _e204 = frag_info.material[0u];
    s_1.metallic = clamp(_e204, 0f, 1f);
    let _e209 = frag_info.material[1u];
    s_1.roughness = clamp(_e209, 0.02f, 1f);
    let _e213 = frag_info.ambient_ground;
    let _e216 = frag_info.ambient_sky;
    let _e220 = s_1.n[1u];
    let _e227 = frag_info.material[2u];
    s_1.ambient = (mix(_e213.xyz, _e216.xyz, vec3(((_e220 * 0.5f) + 0.5f))) * _e227);
    let _e232 = frag_info.frame_params[0u];
    s_1.exposure = max(_e232, 0f);
    s_1.occlusion = 1f;
    s_1.emissive = vec3<f32>(0f, 0f, 0f);
    let _e237 = s_1;
    return _e237;
}

fn main_1() {
    var s_2: Surface;
    var param_19: Surface;
    var param_20: vec3<f32>;
    var param_21: vec3<f32>;
    var param_22: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e129 = ReadSurface_u0028_();
    s_2 = _e129;
    g_albedo = vec3<f32>(0f, 0f, 0f);
    let _e130 = s_2;
    param_19 = _e130;
    let _e132 = s_2.albedo;
    param_20 = _e132;
    let _e133 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_19), (&param_20));
    if _e133 {
        return;
    }
    let _e135 = s_2.albedo;
    param_21 = _e135;
    let _e137 = s_2.alpha;
    param_22 = _e137;
    WriteSurface_u0028_vf3_u003b_f1_u003b((&param_21), (&param_22));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    gl_FragCoord_1 = gl_FragCoord;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LambertOpaqueDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(21)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_texture_smp: sampler;
@group(1) @binding(19)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(17)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(15)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var normal_texture_smp: sampler;
@group(1) @binding(23)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e209 = v_world_position_1;
    let _e211 = fog_info.eye;
    let _e215 = fog_info.forward;
    return dot((_e209 - _e211.xyz), _e215.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e214 = ViewDepth_u0028_();
    z = abs(_e214);
    let _e216 = z;
    near = (_e216 / 5f);
    let _e218 = z;
    far = (_e218 / 200f);
    let _e220 = far;
    let _e221 = far;
    let _e223 = far;
    far3_ = ((_e220 * _e221) * _e223);
    let _e225 = (*alpha);
    let _e226 = near;
    let _e227 = near;
    let _e230 = far3_;
    let _e231 = far3_;
    return (_e225 * clamp((10f / ((0.00001f + (_e226 * _e227)) + (_e230 * _e231))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e218 = fog_info.forward[3u];
    mode = _e218;
    let _e219 = mode;
    if (_e219 > 0.5f) {
        let _e222 = frag_color[3u];
        alpha_1 = _e222;
        let _e223 = alpha_1;
        param = _e223;
        let _e224 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e224;
        let _e225 = frag_color;
        let _e227 = weight;
        let _e228 = (_e225.xyz * _e227);
        let _e229 = alpha_1;
        let _e230 = weight;
        accumulate = vec4<f32>(_e228.x, _e228.y, _e228.z, (_e229 * _e230));
        let _e236 = mode;
        let _e238 = mode;
        revealage = ((_e236 > 1.5f) && (_e238 < 2.5f));
        let _e241 = revealage;
        if _e241 {
            let _e242 = alpha_1;
            local = vec4(_e242);
        } else {
            let _e244 = accumulate;
            local = _e244;
        }
        let _e245 = local;
        frag_color = _e245;
        let _e246 = mode;
        if (_e246 > 2.5f) {
            let _e248 = alpha_1;
            frag_surface = vec4(_e248);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e212 = (*n)[0u];
    let _e215 = (*n)[1u];
    let _e219 = (*n)[2u];
    let _e222 = (*n);
    (*n) = (_e222 / vec3(((abs(_e212) + abs(_e215)) + abs(_e219))));
    let _e225 = (*n);
    e = _e225.xy;
    let _e228 = (*n)[2u];
    if (_e228 < 0f) {
        let _e230 = (*n);
        let _e236 = (*n)[0u];
        let _e240 = (*n)[1u];
        e = ((vec2(1f) - abs(_e230.yx)) * vec2<f32>(select(-1f, 1f, (_e236 >= 0f)), select(-1f, 1f, (_e240 >= 0f))));
    }
    let _e245 = e;
    return ((_e245 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e210 = (*linear);
    let _e212 = (*linear);
    let _e216 = (*linear);
    return mix((_e210 * 12.92f), ((pow(_e212, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e216));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e213 = g_albedo;
    param_1 = clamp(_e213, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e215 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e215.x, _e215.y, _e215.z, 1f);
    let _e220 = g_debug_surface_on;
    if _e220 {
        let _e221 = g_debug_surface;
        let _e222 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e221.x, _e221.y, _e221.z, _e222);
        return;
    }
    let _e227 = v_normal_1;
    geometric = normalize(_e227);
    let _e229 = gl_FrontFacing_1;
    if !(_e229) {
        let _e231 = geometric;
        geometric = -(_e231);
    }
    let _e233 = geometric;
    param_2 = _e233;
    let _e234 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e235 = (*roughness);
    let _e237 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e234.x, _e234.y, clamp(_e235, 0f, 1f), _e237);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e211 = fog_info.projection[0u];
    return (_e211 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e210 = Orthographic_u0028_();
    if _e210 {
        let _e211 = ViewDepth_u0028_();
        local_1 = max(_e211, 0f);
    } else {
        let _e213 = v_world_position_1;
        let _e215 = fog_info.eye;
        local_1 = distance(_e213, _e215.xyz);
    }
    let _e218 = local_1;
    return _e218;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e217 = fog_info.fog[3u];
    density = _e217;
    let _e218 = density;
    if (_e218 <= 0f) {
        let _e220 = (*color);
        return _e220;
    }
    let _e221 = EyeDistance_u0028_();
    d = _e221;
    let _e224 = fog_info.eye[3u];
    falloff = _e224;
    let _e225 = falloff;
    if (_e225 > 0f) {
        let _e227 = falloff;
        let _e229 = v_world_position_1[1u];
        let _e232 = fog_info.eye[1u];
        k = (_e227 * (_e229 - _e232));
        let _e235 = k;
        if (abs(_e235) > 0.001f) {
            let _e238 = k;
            let _e242 = k;
            local_2 = ((1f - exp(-(_e238))) / _e242);
        } else {
            let _e244 = k;
            local_2 = (1f - (0.5f * _e244));
        }
        let _e247 = local_2;
        let _e248 = density;
        density = (_e248 * _e247);
    }
    let _e251 = fog_info.fog;
    let _e253 = (*color);
    let _e254 = density;
    let _e256 = d;
    return mix(_e251.xyz, _e253, vec3(clamp(exp((-(_e254) * _e256)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e215 = g_premultiply;
    let _e216 = (*alpha_2);
    weight_1 = select(1f, _e216, _e215);
    let _e218 = (*linearColor);
    param_3 = _e218;
    let _e219 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e220 = weight_1;
    let _e221 = (_e219 * _e220);
    let _e222 = (*alpha_2);
    let _e223 = g_pass_through;
    frag_color = vec4<f32>(_e221.x, _e221.y, _e221.z, (_e222 * (1f - _e223)));
    let _e230 = (*roughness_1);
    param_4 = _e230;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e210 = (*srgb);
    let _e213 = (*srgb);
    let _e218 = (*srgb);
    return mix((_e210 / vec3(12.92f)), pow(((_e213 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e218));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e212 = (*key);
    hue = fract(((_e212 * 0.618034f) + 0.13f));
    let _e216 = hue;
    k_1 = clamp((abs(((fract((vec3(_e216) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e229 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e229, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2565_: bool;

    let _e210 = (*c);
    let _e211 = (*c);
    let _e213 = any((_e210 != _e211));
    phi_2565_ = _e213;
    if !(_e213) {
        let _e215 = (*c);
        phi_2565_ = any((abs(_e215) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e220 = phi_2565_;
    return _e220;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2655_: bool;
    var phi_2923_: bool;

    let _e252 = gl_FragCoord_1[0u];
    let _e255 = frag_info.debug_view[1u];
    if (_e252 < _e255) {
        let _e259 = frag_info.debug_view[2u];
        local_3 = _e259;
    } else {
        let _e262 = frag_info.debug_view[0u];
        local_3 = _e262;
    }
    let _e263 = local_3;
    view = _e263;
    let _e264 = view;
    if (_e264 < 0.5f) {
        return false;
    }
    let _e266 = view;
    code = i32((_e266 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e269 = v_normal_1;
    geometric_n = normalize(_e269);
    let _e271 = v_tangent_1;
    let _e273 = geometric_n;
    let _e274 = geometric_n;
    let _e275 = v_tangent_1;
    tangent = (_e271.xyz - (_e273 * dot(_e274, _e275.xyz)));
    let _e280 = tangent;
    let _e281 = tangent;
    let _e283 = (dot(_e280, _e281) > 0.000000000001f);
    phi_2655_ = _e283;
    if _e283 {
        let _e285 = v_tangent_1[3u];
        phi_2655_ = (abs((abs(_e285) - 1f)) < 0.01f);
    }
    let _e291 = phi_2655_;
    tangent_usable = _e291;
    let _e294 = frag_info.debug_view[3u];
    identity = _e294;
    let _e295 = identity;
    identity_object = floor((_e295 / 8192f));
    let _e298 = identity;
    let _e299 = identity_object;
    identity_rest = (_e298 - (_e299 * 8192f));
    let _e302 = identity_rest;
    identity_material = floor((_e302 / 2f));
    let _e305 = identity_rest;
    let _e306 = identity_material;
    normal_mapped = ((_e305 - (_e306 * 2f)) > 0.5f);
    let _e310 = code;
    if (_e310 == 1i) {
        let _e313 = (*s).albedo;
        param_5 = clamp(_e313, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e315 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e315;
    } else {
        let _e316 = code;
        if (_e316 == 2i) {
            let _e319 = (*s).n;
            shown = ((_e319 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e322 = code;
            if (_e322 == 3i) {
                let _e325 = (*s).roughness;
                shown = vec3(clamp(_e325, 0f, 1f));
            } else {
                let _e328 = code;
                if (_e328 == 4i) {
                    let _e331 = (*s).metallic;
                    shown = vec3(clamp(_e331, 0f, 1f));
                } else {
                    let _e334 = code;
                    if (_e334 == 5i) {
                        let _e337 = (*s).occlusion;
                        shown = vec3(clamp(_e337, 0f, 1f));
                    } else {
                        let _e340 = code;
                        if (_e340 == 6i) {
                            let _e343 = (*s).emissive;
                            param_6 = clamp(_e343, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e345 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e345;
                        } else {
                            let _e346 = code;
                            if (_e346 == 7i) {
                                let _e348 = v_texcoord_1;
                                let _e349 = fract(_e348);
                                shown = vec3<f32>(_e349.x, _e349.y, 0f);
                            } else {
                                let _e353 = code;
                                if (_e353 == 8i) {
                                    let _e355 = (*lit);
                                    param_7 = clamp(_e355, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e357 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e357, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e359 = (*lit);
                                    param_8 = _e359;
                                    let _e360 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e360 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e361 = grey;
                                        local_4 = vec3((_e361 * 0.5f));
                                    }
                                    let _e364 = local_4;
                                    shown = _e364;
                                } else {
                                    let _e365 = code;
                                    if (_e365 == 9i) {
                                        let _e367 = tangent_usable;
                                        if _e367 {
                                            let _e368 = tangent;
                                            local_5 = ((normalize(_e368) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e372 = local_5;
                                        shown = _e372;
                                    } else {
                                        let _e373 = code;
                                        if (_e373 == 10i) {
                                            let _e375 = v_texcoord_1;
                                            uv = _e375;
                                            let _e376 = uv;
                                            cell = floor((_e376 * 8f));
                                            let _e380 = cell[0u];
                                            let _e382 = cell[1u];
                                            odd = (fract(((_e380 + _e382) * 0.5f)) * 2f);
                                            let _e387 = uv;
                                            within = fract(_e387);
                                            let _e389 = odd;
                                            let _e393 = within[0u];
                                            let _e397 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e389)) * vec3<f32>((0.55f + (0.45f * _e393)), (0.55f + (0.45f * _e397)), 0.85f));
                                        } else {
                                            let _e402 = code;
                                            if (_e402 == 11i) {
                                                let _e404 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e404));
                                            } else {
                                                let _e407 = code;
                                                if (_e407 == 12i) {
                                                    let _e409 = v_color_1;
                                                    param_9 = clamp(_e409.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e412 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e412;
                                                } else {
                                                    let _e413 = code;
                                                    let _e415 = code;
                                                    if ((_e413 == 13i) || (_e415 == 14i)) {
                                                        let _e418 = code;
                                                        let _e420 = identity_object;
                                                        let _e421 = identity_material;
                                                        key_1 = select(_e421, _e420, (_e418 == 13i));
                                                        let _e423 = key_1;
                                                        param_10 = _e423;
                                                        let _e424 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e426 = (*s).n_dot_v;
                                                        shown = (_e424 * (0.55f + (0.45f * _e426)));
                                                    } else {
                                                        let _e430 = code;
                                                        if (_e430 == 15i) {
                                                            let _e433 = (*s).albedo;
                                                            param_11 = clamp(_e433, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e435 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e435;
                                                            let _e436 = srgb_1;
                                                            luma = dot(_e436, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e439 = (*s).metallic;
                                                            metal = (_e439 > 0.5f);
                                                            let _e441 = metal;
                                                            let _e443 = luma;
                                                            if (!(_e441) && (_e443 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e446 = metal;
                                                                let _e447 = !(_e446);
                                                                phi_2923_ = _e447;
                                                                if _e447 {
                                                                    let _e449 = srgb_1[0u];
                                                                    let _e451 = srgb_1[1u];
                                                                    let _e453 = srgb_1[2u];
                                                                    phi_2923_ = (max(_e449, max(_e451, _e453)) > 0.9411765f);
                                                                }
                                                                let _e458 = phi_2923_;
                                                                if _e458 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e459 = metal;
                                                                    let _e460 = luma;
                                                                    if (_e459 && (_e460 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e463 = luma;
                                                                        local_8 = vec3(_e463);
                                                                    }
                                                                    let _e465 = local_8;
                                                                    local_7 = _e465;
                                                                }
                                                                let _e466 = local_7;
                                                                local_6 = _e466;
                                                            }
                                                            let _e467 = local_6;
                                                            shown = _e467;
                                                        } else {
                                                            let _e468 = code;
                                                            if (_e468 == 16i) {
                                                                let _e471 = (*s).metallic;
                                                                m = _e471;
                                                                let _e472 = m;
                                                                let _e474 = m;
                                                                if ((_e472 > 0.05f) && (_e474 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e477 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e477 > 0.5f)));
                                                                }
                                                                let _e481 = local_9;
                                                                shown = _e481;
                                                            } else {
                                                                let _e482 = code;
                                                                if (_e482 == 17i) {
                                                                    let _e484 = normal_mapped;
                                                                    if !(_e484) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e486 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e486));
                                                                    }
                                                                    let _e489 = local_10;
                                                                    shown = _e489;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e490 = g_premultiply;
    if _e490 {
        let _e492 = (*s).alpha;
        local_11 = _e492;
    } else {
        local_11 = 1f;
    }
    let _e493 = local_11;
    weight_2 = _e493;
    let _e494 = shown;
    param_12 = _e494;
    let _e495 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e496 = weight_2;
    let _e497 = (_e495 * _e496);
    let _e499 = (*s).alpha;
    frag_color = vec4<f32>(_e497.x, _e497.y, _e497.z, _e499);
    let _e505 = (*s).roughness;
    param_13 = _e505;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_12: f32;

    let _e212 = frag_info.material2_[2u];
    local_12 = floor((_e212 * 0.5f));
    let _e215 = local_12;
    return _e215;
}

fn DirectOcclusion_u0028_struct_u002d_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_1: ptr<function, Surface>) -> f32 {
    var local_13: f32;
    var local_14: f32;

    let _e212 = OcclusionTarget_u0028_();
    if (_e212 > 1.5f) {
        local_13 = 1f;
    } else {
        let _e215 = (*s_1).occlusion;
        local_13 = _e215;
    }
    let _e216 = local_13;
    local_14 = _e216;
    let _e217 = local_14;
    return _e217;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    let _e212 = (*s_2).albedo;
    return _e212;
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e210 = (*i);
    if (_e210 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e212 = (*i);
    if (_e212 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e214 = (*i);
    if (_e214 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e216 = (*i);
    if (_e216 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e218 = (*i);
    if (_e218 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e220 = (*i);
    if (_e220 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e222 = (*i);
    if (_e222 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e215 = (*i_1);
    param_14 = _e215;
    let _e216 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e216;
    let _e218 = p[0u];
    let _e219 = (*ca);
    let _e222 = p[1u];
    let _e223 = (*sa);
    let _e227 = p[0u];
    let _e228 = (*sa);
    let _e231 = p[1u];
    let _e232 = (*ca);
    let _e236 = (*radius);
    return (vec2<f32>(((_e218 * _e219) - (_e222 * _e223)), ((_e227 * _e228) + (_e231 * _e232))) * _e236);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_15: vec2<f32>;
    var atlas: vec2<f32>;

    let _e218 = point_shadow.params[0u];
    inset = _e218;
    let _e219 = (*uv_1);
    let _e220 = (*offset);
    let _e222 = inset;
    let _e223 = inset;
    local_15 = clamp((_e219 + _e220), vec2(_e222), vec2((1f - _e223)));
    let _e228 = local_15;
    let _e229 = (*tile);
    atlas = ((_e228 + _e229) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e234 = point_shadow.params3_[0u];
    if (_e234 > 0.5f) {
        let _e237 = atlas[1u];
        atlas[1u] = (1f - _e237);
    }
    let _e240 = atlas;
    let _e241 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e240, 0f);
    let _e243 = atlas;
    let _e244 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e243, 0f);
    let _e247 = (*range);
    return (min(_e241.x, _e244.x) * _e247);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e219 = (*uv_2);
    param_15 = _e219;
    let _e220 = (*offset_1);
    param_16 = _e220;
    let _e221 = (*tile_1);
    param_17 = _e221;
    let _e222 = (*range_1);
    param_18 = _e222;
    let _e223 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e223;
    let _e224 = stored;
    let _e225 = (*range_1);
    if (_e224 >= (_e225 * 0.999f)) {
        return 1f;
    }
    let _e228 = (*receiver);
    let _e229 = stored;
    return select(1f, 0f, (_e228 > _e229));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e240 = point_shadow.params2_[1u];
    lightRadius = _e240;
    let _e243 = point_shadow.params2_[0u];
    minRadius = _e243;
    let _e246 = point_shadow.params2_[2u];
    maxRadius = _e246;
    let _e247 = lightRadius;
    if (_e247 <= 0f) {
        let _e249 = (*uv_3);
        param_19 = _e249;
        param_20 = vec2<f32>(0f, 0f);
        let _e250 = (*tile_2);
        param_21 = _e250;
        let _e251 = (*range_2);
        param_22 = _e251;
        let _e252 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e252;
        let _e253 = minRadius;
        return _e253;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e254 = i_2;
        if (_e254 < 8i) {
            let _e256 = i_2;
            param_23 = _e256;
            let _e257 = (*ca_1);
            param_24 = _e257;
            let _e258 = (*sa_1);
            param_25 = _e258;
            let _e259 = maxRadius;
            param_26 = _e259;
            let _e260 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e261 = (*uv_3);
            param_27 = _e261;
            param_28 = _e260;
            let _e262 = (*tile_2);
            param_29 = _e262;
            let _e263 = (*range_2);
            param_30 = _e263;
            let _e264 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e264;
            let _e265 = stored_1;
            let _e266 = (*range_2);
            if (_e265 >= (_e266 * 0.999f)) {
                continue;
            }
            let _e269 = stored_1;
            let _e270 = (*receiver_1);
            if (_e269 >= _e270) {
                continue;
            }
            let _e272 = stored_1;
            let _e273 = sum;
            sum = (_e273 + _e272);
            let _e275 = count;
            count = (_e275 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e277 = i_2;
            i_2 = (_e277 + 1i);
        }
    }
    let _e279 = count;
    if (_e279 < 0.5f) {
        return -1f;
    }
    let _e281 = sum;
    let _e282 = count;
    blocker = max((_e281 / _e282), 0.0001f);
    let _e285 = blocker;
    (*blockerOut) = _e285;
    let _e286 = lightRadius;
    let _e287 = (*receiver_1);
    let _e288 = blocker;
    let _e292 = blocker;
    world = ((_e286 * max((_e287 - _e288), 0f)) / _e292);
    let _e294 = world;
    let _e295 = (*receiver_1);
    let _e297 = (*tanHalf);
    let _e300 = minRadius;
    let _e301 = maxRadius;
    return clamp((_e294 / ((2f * _e295) * _e297)), _e300, _e301);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_16: vec2<f32>;

    let _e211 = (*rows);
    if (_e211 > 0f) {
        let _e214 = gl_FragCoord_1[0u];
        let _e215 = (*rows);
        let _e217 = gl_FragCoord_1[1u];
        local_16 = vec2<f32>(_e214, (_e215 - _e217));
    } else {
        let _e220 = gl_FragCoord_1;
        local_16 = _e220.xy;
    }
    let _e222 = local_16;
    return _e222;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_17: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2252_: bool;
    var phi_2313_: bool;

    let _e263 = (*lightIndex);
    let _e267 = point_shadow.slots[_e263][0u];
    slot = i32((_e267 + 0.5f));
    let _e270 = (*lightIndex);
    let _e274 = point_shadow.slots[_e270][0u];
    if (_e274 < 0f) {
        return 1f;
    }
    let _e278 = point_shadow.params[2u];
    strength = _e278;
    let _e279 = strength;
    if (_e279 <= 0f) {
        return 1f;
    }
    let _e281 = slot;
    let _e284 = point_shadow.lights[_e281];
    let _e286 = (*world_1);
    toLight = (_e284.xyz - _e286);
    let _e288 = toLight;
    toLightLength = max(length(_e288), 0.000001f);
    let _e291 = (*normal);
    let _e292 = toLight;
    let _e293 = toLightLength;
    nDotL = max(dot(_e291, (_e292 / vec3(_e293))), 0.15f);
    let _e298 = nDotL;
    let _e299 = nDotL;
    let _e304 = nDotL;
    let _e305 = nDotL;
    slope = min((sqrt(max((1f - (_e298 * _e299)), 0f)) / (_e304 * _e305)), 8f);
    let _e309 = toLightLength;
    let _e311 = (*lightIndex);
    let _e315 = point_shadow.slots[_e311][2u];
    let _e320 = point_shadow.params3_[1u];
    texel = (((2f * _e309) * max(_e315, 0.0001f)) * _e320);
    let _e322 = (*world_1);
    let _e323 = (*normal);
    let _e324 = texel;
    let _e328 = point_shadow.params[3u];
    let _e330 = slope;
    origin = (_e322 + (((_e323 * _e324) * _e328) * (1f + _e330)));
    let _e334 = origin;
    let _e335 = slot;
    let _e338 = point_shadow.lights[_e335];
    toFragment = (_e334 - _e338.xyz);
    let _e341 = toFragment;
    distance_ = length(_e341);
    let _e343 = slot;
    let _e347 = point_shadow.lights[_e343][3u];
    range_3 = max(_e347, 0.0001f);
    let _e349 = distance_;
    let _e350 = range_3;
    if (_e349 >= _e350) {
        return 1f;
    }
    face = 0i;
    let _e352 = (*lightIndex);
    let _e356 = point_shadow.slots[_e352][1u];
    if (_e356 < 0.5f) {
        let _e358 = toFragment;
        a = abs(_e358);
        let _e361 = a[0u];
        let _e363 = a[1u];
        let _e364 = (_e361 >= _e363);
        phi_2252_ = _e364;
        if _e364 {
            let _e366 = a[0u];
            let _e368 = a[2u];
            phi_2252_ = (_e366 >= _e368);
        }
        let _e371 = phi_2252_;
        if _e371 {
            let _e373 = toFragment[0u];
            face = select(1i, 0i, (_e373 > 0f));
        } else {
            let _e377 = a[1u];
            let _e379 = a[2u];
            if (_e377 >= _e379) {
                let _e382 = toFragment[1u];
                face = select(3i, 2i, (_e382 > 0f));
            } else {
                let _e386 = toFragment[2u];
                face = select(5i, 4i, (_e386 > 0f));
            }
        }
    }
    let _e389 = slot;
    let _e391 = face;
    let _e395 = point_shadow.faces[((_e389 * 6i) + _e391)];
    let _e396 = origin;
    clip = (_e395 * vec4<f32>(_e396.x, _e396.y, _e396.z, 1f));
    let _e403 = clip[3u];
    if (_e403 <= 0f) {
        return 1f;
    }
    let _e405 = clip;
    let _e408 = clip[3u];
    ndc = (_e405.xy / vec2(_e408));
    let _e412 = ndc[0u];
    let _e414 = (abs(_e412) > 1f);
    phi_2313_ = _e414;
    if !(_e414) {
        let _e417 = ndc[1u];
        phi_2313_ = (abs(_e417) > 1f);
    }
    let _e421 = phi_2313_;
    if _e421 {
        return 1f;
    }
    let _e423 = ndc[0u];
    let _e427 = ndc[1u];
    uv_4 = vec2<f32>(((_e423 * 0.5f) + 0.5f), (0.5f - (_e427 * 0.5f)));
    let _e431 = face;
    let _e433 = slot;
    tile_3 = vec2<f32>(f32(_e431), f32(_e433));
    let _e436 = distance_;
    let _e439 = point_shadow.params[1u];
    receiver_2 = (_e436 - _e439);
    let _e443 = frag_info.target_origin[0u];
    param_31 = _e443;
    let _e444 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e444, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e449 = noise;
    angle = (_e449 * 6.2831855f);
    let _e451 = angle;
    ca_2 = cos(_e451);
    let _e453 = angle;
    sa_2 = sin(_e453);
    let _e455 = (*lightIndex);
    let _e459 = point_shadow.slots[_e455][2u];
    tanHalf_1 = max(_e459, 0.0001f);
    blocker_1 = -1f;
    let _e461 = uv_4;
    param_32 = _e461;
    let _e462 = tile_3;
    param_33 = _e462;
    let _e463 = range_3;
    param_34 = _e463;
    let _e464 = receiver_2;
    param_35 = _e464;
    let _e465 = ca_2;
    param_36 = _e465;
    let _e466 = sa_2;
    param_37 = _e466;
    let _e467 = tanHalf_1;
    param_38 = _e467;
    let _e468 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e469 = param_39;
    blocker_1 = _e469;
    radius_1 = _e468;
    let _e472 = point_shadow.params2_[3u];
    if (_e472 > 0.5f) {
        g_debug_surface_on = true;
        let _e474 = radius_1;
        if (_e474 < 0f) {
            local_17 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e476 = radius_1;
            let _e479 = point_shadow.params2_[2u];
            let _e483 = blocker_1;
            let _e484 = range_3;
            local_17 = vec3<f32>(clamp((_e476 / max(_e479, 0.000001f)), 0f, 1f), clamp((_e483 / _e484), 0f, 1f), 0f);
        }
        let _e488 = local_17;
        g_debug_surface = _e488;
    }
    let _e489 = radius_1;
    if (_e489 < 0f) {
        return 1f;
    }
    let _e491 = uv_4;
    param_40 = _e491;
    param_41 = vec2<f32>(0f, 0f);
    let _e492 = tile_3;
    param_42 = _e492;
    let _e493 = range_3;
    param_43 = _e493;
    let _e494 = receiver_2;
    param_44 = _e494;
    let _e495 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e495;
    let _e496 = radius_1;
    if (_e496 > 0f) {
        i_3 = 0i;
        loop {
            let _e498 = i_3;
            if (_e498 < 8i) {
                let _e500 = i_3;
                param_45 = _e500;
                let _e501 = ca_2;
                param_46 = _e501;
                let _e502 = sa_2;
                param_47 = _e502;
                let _e503 = radius_1;
                param_48 = _e503;
                let _e504 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e505 = uv_4;
                param_49 = _e505;
                param_50 = _e504;
                let _e506 = tile_3;
                param_51 = _e506;
                let _e507 = range_3;
                param_52 = _e507;
                let _e508 = receiver_2;
                param_53 = _e508;
                let _e509 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e510 = lit_1;
                lit_1 = (_e510 + _e509);
                continue;
            } else {
                break;
            }
            continuing {
                let _e512 = i_3;
                i_3 = (_e512 + 1i);
            }
        }
        let _e514 = lit_1;
        lit_1 = (_e514 * 0.11111111f);
    }
    let _e516 = lit_1;
    let _e517 = strength;
    return mix(1f, _e516, clamp(_e517, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e214 = (*i_4);
    let _e217 = (*n_1);
    r = sqrt(((f32(_e214) + 0.5f) / f32(_e217)));
    let _e221 = (*i_4);
    let _e224 = (*turn);
    theta = ((f32(_e221) * 2.3999631f) + _e224);
    let _e226 = r;
    let _e227 = theta;
    let _e229 = theta;
    return (vec2<f32>(cos(_e227), sin(_e229)) * _e226);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e213 = frag_info.target_origin[0u];
    param_54 = _e213;
    let _e214 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e217 = frag_info.target_origin[3u];
    at = (_e214 + vec2((5.588238f * max(_e217, 0f))));
    let _e222 = at;
    return fract((52.982918f * fract(dot(_e222, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_18: f32;

    let _e212 = (*mode_1);
    if (_e212 > 0.5f) {
        let _e214 = (*stored_2);
        local_18 = (1f - _e214);
    } else {
        let _e216 = (*stored_2);
        local_18 = _e216;
    }
    let _e217 = local_18;
    return _e217;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e218 = (*moments)[1u];
    let _e220 = (*moments)[0u];
    let _e222 = (*moments)[0u];
    let _e225 = (*minVariance);
    variance = max((_e218 - (_e220 * _e222)), _e225);
    let _e227 = (*t);
    let _e229 = (*moments)[0u];
    d_1 = (_e227 - _e229);
    let _e231 = variance;
    let _e232 = variance;
    let _e233 = d_1;
    let _e234 = d_1;
    pMax = (_e231 / (_e232 + (_e233 * _e234)));
    let _e238 = pMax;
    let _e239 = (*bleed);
    let _e241 = (*bleed);
    reduced = clamp(((_e238 - _e239) / max((1f - _e241), 0.0001f)), 0f, 1f);
    let _e246 = (*t);
    let _e248 = (*moments)[0u];
    let _e250 = reduced;
    return select(_e250, 1f, (_e246 <= _e248));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e211 = (*depth);
    d_2 = ((2f * clamp(_e211, 0f, 1f)) - 1f);
    let _e215 = d_2;
    let _e218 = d_2;
    return vec2<f32>(exp((40f * _e215)), -(exp((-5f * _e218))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e225 = (*depth_1);
    param_55 = _e225;
    let _e226 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e226;
    let _e227 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e227);
    let _e230 = scale[0u];
    let _e232 = scale[0u];
    let _e234 = (*moments_1);
    param_56 = _e234.xy;
    let _e237 = warped[0u];
    param_57 = _e237;
    param_58 = (_e230 * _e232);
    let _e238 = (*bleed_1);
    param_59 = _e238;
    let _e239 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e239;
    let _e241 = scale[1u];
    let _e243 = scale[1u];
    let _e245 = (*moments_1);
    param_60 = _e245.zw;
    let _e248 = warped[1u];
    param_61 = _e248;
    param_62 = (_e241 * _e243);
    let _e249 = (*bleed_1);
    param_63 = _e249;
    let _e250 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e250;
    let _e251 = positive;
    let _e252 = negative;
    return min(_e251, _e252);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e211 = (*depth_2);
    stored_3 = max((1f - _e211), 0.000061035156f);
    let _e214 = stored_3;
    return exp2((floor(log2(_e214)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_19: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_20: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_22: f32;
    var local_23: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3882_: bool;
    var phi_3893_: bool;
    var phi_4050_: bool;
    var phi_4057_: bool;
    var phi_4064_: bool;

    let _e290 = frag_info.shadow_params[3u];
    strength_1 = _e290;
    let _e291 = strength_1;
    if (_e291 <= 0f) {
        return 1f;
    }
    let _e293 = (*lightIndex_1);
    let _e296 = frag_info.frame_params[2u];
    if (_e293 != i32(floor((_e296 + 0.5f)))) {
        return 1f;
    }
    let _e303 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e303 + 0.5f));
    let _e306 = Orthographic_u0028_();
    if _e306 {
        let _e307 = ViewDepth_u0028_();
        local_19 = _e307;
    } else {
        let _e308 = v_world_position_1;
        let _e310 = frag_info.camera_position;
        local_19 = length((_e308 - _e310.xyz));
    }
    let _e314 = local_19;
    viewDistance = _e314;
    cascade = 0i;
    let _e315 = cascadeCount;
    let _e316 = (_e315 > 1i);
    phi_3882_ = _e316;
    if _e316 {
        let _e317 = viewDistance;
        let _e320 = frag_info.shadow_cascades[0u];
        phi_3882_ = (_e317 > _e320);
    }
    let _e323 = phi_3882_;
    if _e323 {
        cascade = 1i;
    }
    let _e324 = cascadeCount;
    let _e325 = (_e324 > 2i);
    phi_3893_ = _e325;
    if _e325 {
        let _e326 = viewDistance;
        let _e329 = frag_info.shadow_cascades[1u];
        phi_3893_ = (_e326 > _e329);
    }
    let _e332 = phi_3893_;
    if _e332 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e333 = attempt;
        if (_e333 < 3i) {
            let _e335 = cascade;
            let _e336 = attempt;
            which = (_e335 + _e336);
            let _e338 = which;
            let _e339 = cascadeCount;
            if (_e338 >= _e339) {
                break;
            }
            let _e341 = which;
            if (_e341 == 0i) {
                let _e344 = frag_info.shadow_matrix;
                local_20 = _e344;
            } else {
                let _e345 = which;
                if (_e345 == 1i) {
                    let _e348 = frag_info.shadow_matrix_far;
                    local_21 = _e348;
                } else {
                    let _e350 = frag_info.shadow_matrix_farthest;
                    local_21 = _e350;
                }
                let _e351 = local_21;
                local_20 = _e351;
            }
            let _e352 = local_20;
            matrix = _e352;
            let _e355 = matrix[0][0u];
            let _e358 = matrix[1][0u];
            let _e361 = matrix[2][0u];
            axisX = vec3<f32>(_e355, _e358, _e361);
            let _e365 = matrix[0][1u];
            let _e368 = matrix[1][1u];
            let _e371 = matrix[2][1u];
            axisY = vec3<f32>(_e365, _e368, _e371);
            let _e373 = axisX;
            rowX = max(length(_e373), 0.000001f);
            let _e376 = axisY;
            rowY = max(length(_e376), 0.000001f);
            let _e381 = frag_info.shadow_cascades[3u];
            let _e383 = rowX;
            texelMetres = ((2f * _e381) / _e383);
            let _e387 = frag_info.shadow_cascades[3u];
            let _e390 = (*s_3).n;
            let _e391 = axisX;
            let _e394 = rowX;
            let _e395 = rowX;
            let _e399 = (*s_3).n;
            let _e400 = axisY;
            let _e403 = rowY;
            let _e404 = rowY;
            reach = ((3f * _e387) * ((abs(dot(_e390, _e391)) / (_e394 * _e395)) + (abs(dot(_e399, _e400)) / (_e403 * _e404))));
            let _e411 = frag_info.shadow_params[2u];
            let _e412 = texelMetres;
            flatOffset = min(_e411, _e412);
            let _e414 = v_world_position_1;
            let _e416 = (*s_3).n;
            let _e417 = flatOffset;
            let _e418 = reach;
            origin_1 = (_e414 + (_e416 * (_e417 + _e418)));
            let _e422 = matrix;
            let _e423 = origin_1;
            lightSpace = (_e422 * vec4<f32>(_e423.x, _e423.y, _e423.z, 1f));
            let _e430 = lightSpace[3u];
            if (_e430 <= 0f) {
                continue;
            }
            let _e432 = lightSpace;
            let _e435 = lightSpace[3u];
            candidate = (_e432.xyz / vec3(_e435));
            let _e439 = candidate[0u];
            let _e443 = candidate[1u];
            inTile = vec2<f32>(((_e439 * 0.5f) + 0.5f), (0.5f - (_e443 * 0.5f)));
            let _e448 = inTile[0u];
            let _e449 = (_e448 < 0f);
            phi_4050_ = _e449;
            if !(_e449) {
                let _e452 = inTile[0u];
                phi_4050_ = (_e452 > 1f);
            }
            let _e455 = phi_4050_;
            phi_4057_ = _e455;
            if !(_e455) {
                let _e458 = inTile[1u];
                phi_4057_ = (_e458 < 0f);
            }
            let _e461 = phi_4057_;
            phi_4064_ = _e461;
            if !(_e461) {
                let _e464 = inTile[1u];
                phi_4064_ = (_e464 > 1f);
            }
            let _e467 = phi_4064_;
            if _e467 {
                continue;
            }
            let _e469 = candidate[2u];
            if (_e469 > 1f) {
                let _e471 = which;
                let _e472 = cascadeCount;
                if (_e471 < (_e472 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e477 = inTile[0u];
            let _e478 = which;
            let _e481 = cascadeCount;
            let _e485 = inTile[1u];
            uv_5 = vec2<f32>(((_e477 + f32(_e478)) / f32(_e481)), _e485);
            let _e487 = candidate;
            projected = _e487;
            let _e488 = which;
            cascade = _e488;
            let _e489 = texelMetres;
            cascadeTexel = _e489;
            let _e492 = matrix[0][2u];
            let _e495 = matrix[1][2u];
            let _e498 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e492, _e495, _e498)), 0.000001f));
            let _e504 = (*s_3).n;
            let _e507 = matrix[0][2u];
            let _e510 = matrix[1][2u];
            let _e513 = matrix[2][2u];
            let _e517 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e504, vec3<f32>(_e507, _e510, _e513))) * _e517), 0.1f, 1f);
            let _e520 = texelMetres;
            let _e521 = cosSlope;
            let _e522 = cosSlope;
            let _e528 = cosSlope;
            let _e530 = cascadeDepth;
            receiverSlope = (((_e520 * sqrt(max((1f - (_e521 * _e522)), 0f))) / _e528) / _e530);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e532 = attempt;
            attempt = (_e532 + 1i);
        }
    }
    let _e534 = found;
    if !(_e534) {
        return 1f;
    }
    let _e536 = cascade;
    if (_e536 == 0i) {
        let _e540 = frag_info.shadow_bias[0u];
        local_22 = _e540;
    } else {
        let _e541 = cascade;
        if (_e541 == 1i) {
            let _e545 = frag_info.shadow_bias[1u];
            local_23 = _e545;
        } else {
            let _e548 = frag_info.shadow_bias[2u];
            local_23 = _e548;
        }
        let _e549 = local_23;
        local_22 = _e549;
    }
    let _e550 = local_22;
    bias = _e550;
    let _e553 = frag_info.shadow_params[1u];
    storage_ = _e553;
    let _e554 = storage_;
    let _e556 = storage_;
    if ((_e554 > 0.5f) && (_e556 < 1.5f)) {
        let _e559 = bias;
        let _e561 = projected[2u];
        param_64 = _e561;
        let _e562 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e559, _e562);
    }
    let _e566 = frag_info.shadow_params[0u];
    let _e569 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e566, _e569);
    let _e571 = cascade;
    let _e573 = cascadeCount;
    let _e577 = texel_1;
    tileLo = (vec2<f32>((f32(_e571) / f32(_e573)), 0f) + (_e577 * 0.5f));
    let _e580 = cascade;
    let _e583 = cascadeCount;
    let _e587 = texel_1;
    tileHi = (vec2<f32>((f32((_e580 + 1i)) / f32(_e583)), 1f) - (_e587 * 0.5f));
    let _e592 = frag_info.shadow_bias[3u];
    if (_e592 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e594 = y;
            if (_e594 <= 1i) {
                x = -1i;
                loop {
                    let _e596 = x;
                    if (_e596 <= 1i) {
                        let _e598 = uv_5;
                        let _e599 = x;
                        let _e601 = y;
                        let _e604 = texel_1;
                        let _e607 = tileLo;
                        let _e608 = tileHi;
                        let _e610 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e598 + (vec2<f32>(f32(_e599), f32(_e601)) * _e604)), _e607, _e608), 0f);
                        let _e611 = stored_4;
                        stored_4 = (_e611 + _e610);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e613 = x;
                        x = (_e613 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e615 = y;
                y = (_e615 + 1i);
            }
        }
        let _e617 = stored_4;
        stored_4 = (_e617 * 0.11111111f);
        let _e620 = stored_4[1u];
        let _e623 = stored_4[2u];
        let _e626 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e620), (1f - _e623), _e626), vec3(0f), vec3(4f));
        let _e631 = through;
        let _e632 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e631, vec3(clamp(_e632, 0f, 1f)));
    }
    let _e638 = frag_info.ambient_ground[3u];
    softness = _e638;
    lit_2 = 0f;
    let _e639 = softness;
    if (_e639 < 0f) {
        let _e641 = uv_5;
        let _e642 = tileLo;
        let _e643 = tileHi;
        let _e645 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e641, _e642, _e643), 0f);
        moments_2 = _e645;
        let _e647 = projected[2u];
        let _e648 = bias;
        let _e650 = softness;
        let _e654 = moments_2;
        param_65 = _e654;
        param_66 = (_e647 - _e648);
        param_67 = clamp((-(_e650) - 1f), 0f, 0.95f);
        let _e655 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e655;
    } else {
        let _e656 = softness;
        if (_e656 <= 0f) {
            y_1 = -1i;
            loop {
                let _e658 = y_1;
                if (_e658 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e660 = x_1;
                        if (_e660 <= 1i) {
                            let _e662 = uv_5;
                            let _e663 = x_1;
                            let _e665 = y_1;
                            let _e668 = texel_1;
                            let _e671 = tileLo;
                            let _e672 = tileHi;
                            let _e674 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e662 + (vec2<f32>(f32(_e663), f32(_e665)) * _e668)), _e671, _e672), 0f);
                            param_68 = _e674.x;
                            let _e676 = storage_;
                            param_69 = _e676;
                            let _e677 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e677;
                            let _e679 = projected[2u];
                            let _e680 = bias;
                            let _e682 = occluder;
                            let _e685 = lit_2;
                            lit_2 = (_e685 + select(1f, 0f, ((_e679 - _e680) > _e682)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e687 = x_1;
                            x_1 = (_e687 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e689 = y_1;
                    y_1 = (_e689 + 1i);
                }
            }
            let _e691 = lit_2;
            lit_2 = (_e691 * 0.11111111f);
        } else {
            let _e693 = softness;
            spread = tan(min(_e693, 0.5f));
            let _e696 = ShadowNoise_u0028_();
            turn_1 = (_e696 * 6.2831855f);
            let _e698 = spread;
            let _e700 = projected[2u];
            let _e702 = cascadeDepth;
            let _e704 = cascadeTexel;
            searchRadius = clamp((((_e698 * _e700) * _e702) / _e704), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e707 = i_5;
                if (_e707 < 16i) {
                    let _e709 = i_5;
                    param_70 = _e709;
                    param_71 = 16i;
                    let _e710 = turn_1;
                    param_72 = _e710;
                    let _e711 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e711;
                    let _e712 = bias;
                    let _e713 = disc;
                    let _e715 = searchRadius;
                    let _e719 = receiverSlope;
                    tapBias = (_e712 + (max(((length(_e713) * _e715) - 1.5f), 0f) * _e719));
                    let _e722 = uv_5;
                    let _e723 = disc;
                    let _e724 = texel_1;
                    let _e726 = searchRadius;
                    let _e729 = tileLo;
                    let _e730 = tileHi;
                    let _e732 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e722 + ((_e723 * _e724) * _e726)), _e729, _e730), 0f);
                    param_73 = _e732.x;
                    let _e734 = storage_;
                    param_74 = _e734;
                    let _e735 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e735;
                    let _e737 = projected[2u];
                    let _e738 = tapBias;
                    let _e740 = occluder_1;
                    if ((_e737 - _e738) > _e740) {
                        let _e742 = occluder_1;
                        let _e743 = blockerSum;
                        blockerSum = (_e743 + _e742);
                        let _e745 = blockerCount;
                        blockerCount = (_e745 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e747 = i_5;
                    i_5 = (_e747 + 1i);
                }
            }
            let _e749 = blockerCount;
            if (_e749 <= 0f) {
                return 1f;
            }
            let _e752 = projected[2u];
            let _e753 = blockerSum;
            let _e754 = blockerCount;
            let _e758 = cascadeDepth;
            gap = (max((_e752 - (_e753 / _e754)), 0f) * _e758);
            let _e760 = spread;
            let _e761 = gap;
            let _e763 = cascadeTexel;
            radius_2 = clamp(((_e760 * _e761) / _e763), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e766 = i_6;
                if (_e766 < 16i) {
                    let _e768 = turn_1;
                    let _e770 = i_6;
                    param_75 = _e770;
                    param_76 = 16i;
                    param_77 = (_e768 + 1f);
                    let _e771 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e771;
                    let _e772 = bias;
                    let _e773 = disc_1;
                    let _e775 = radius_2;
                    let _e779 = receiverSlope;
                    tapBias_1 = (_e772 + (max(((length(_e773) * _e775) - 1.5f), 0f) * _e779));
                    let _e782 = uv_5;
                    let _e783 = disc_1;
                    let _e784 = texel_1;
                    let _e786 = radius_2;
                    let _e789 = tileLo;
                    let _e790 = tileHi;
                    let _e792 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e782 + ((_e783 * _e784) * _e786)), _e789, _e790), 0f);
                    param_78 = _e792.x;
                    let _e794 = storage_;
                    param_79 = _e794;
                    let _e795 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e795;
                    let _e797 = projected[2u];
                    let _e798 = tapBias_1;
                    let _e800 = occluder_2;
                    let _e803 = lit_2;
                    lit_2 = (_e803 + select(1f, 0f, ((_e797 - _e798) > _e800)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e805 = i_6;
                    i_6 = (_e805 + 1i);
                }
            }
            let _e807 = lit_2;
            lit_2 = (_e807 * 0.0625f);
        }
    }
    let _e809 = lit_2;
    let _e810 = strength_1;
    return mix(1f, _e809, clamp(_e810, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e215 = (*s_4);
    param_80 = _e215;
    let _e216 = (*light_2);
    param_81 = _e216;
    let _e217 = (*index);
    param_82 = _e217;
    let _e218 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e218;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e210 = (*index_1);
    return (_e210 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e214 = (*distance_1);
    let _e215 = (*distance_1);
    attenuation = (1f / max((_e214 * _e215), 0.0001f));
    let _e219 = (*range_4);
    if (_e219 > 0f) {
        let _e221 = (*distance_1);
        let _e222 = (*range_4);
        ratio = (_e221 / _e222);
        let _e224 = ratio;
        let _e225 = ratio;
        let _e227 = ratio;
        let _e229 = ratio;
        window = clamp((1f - (((_e224 * _e225) * _e227) * _e229)), 0f, 1f);
        let _e233 = window;
        let _e234 = window;
        let _e236 = attenuation;
        attenuation = (_e236 * (_e233 * _e234));
    }
    let _e238 = attenuation;
    return _e238;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_24: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e226 = (*halfWidth);
    let _e227 = (*halfHeight);
    n_2 = cross(_e226, _e227);
    let _e229 = n_2;
    nLen = length(_e229);
    let _e231 = nLen;
    if (_e231 < 0.000000000001f) {
        let _e233 = (*centre);
        return _e233;
    }
    let _e234 = nLen;
    let _e235 = n_2;
    n_2 = (_e235 / vec3(_e234));
    let _e238 = (*centre);
    let _e239 = (*world_2);
    toPlane = (_e238 - _e239);
    let _e241 = (*mirror);
    let _e242 = n_2;
    denom = dot(_e241, _e242);
    let _e244 = denom;
    if (abs(_e244) < 0.00001f) {
        let _e247 = toPlane;
        let _e248 = n_2;
        let _e249 = toPlane;
        let _e250 = n_2;
        onPlane = (_e247 - (_e248 * dot(_e249, _e250)));
    } else {
        let _e254 = toPlane;
        let _e255 = n_2;
        let _e257 = denom;
        t_1 = (dot(_e254, _e255) / _e257);
        let _e259 = t_1;
        if (_e259 > 0f) {
            let _e261 = (*mirror);
            let _e262 = t_1;
            local_24 = (_e261 * _e262);
        } else {
            let _e264 = toPlane;
            let _e265 = n_2;
            let _e266 = toPlane;
            let _e267 = n_2;
            local_24 = (_e264 - (_e265 * dot(_e266, _e267)));
        }
        let _e271 = local_24;
        onPlane = _e271;
    }
    let _e272 = onPlane;
    let _e273 = toPlane;
    offset_2 = (_e272 - _e273);
    let _e275 = (*halfWidth);
    let _e276 = (*halfWidth);
    wLen2_ = max(dot(_e275, _e276), 0.000000000001f);
    let _e279 = (*halfHeight);
    let _e280 = (*halfHeight);
    hLen2_ = max(dot(_e279, _e280), 0.000000000001f);
    let _e283 = offset_2;
    let _e284 = (*halfWidth);
    let _e286 = wLen2_;
    u = clamp((dot(_e283, _e284) / _e286), -1f, 1f);
    let _e289 = offset_2;
    let _e290 = (*halfHeight);
    let _e292 = hLen2_;
    v = clamp((dot(_e289, _e290) / _e292), -1f, 1f);
    let _e295 = (*centre);
    let _e296 = (*halfWidth);
    let _e297 = u;
    let _e300 = (*halfHeight);
    let _e301 = v;
    return ((_e295 + (_e296 * _e297)) + (_e300 * _e301));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_25: f32;

    let _e218 = (*a_1);
    let _e219 = (*a_1);
    ua = (_e218 / vec3(max(length(_e219), 0.000000000001f)));
    let _e224 = (*b);
    let _e225 = (*b);
    ub = (_e224 / vec3(max(length(_e225), 0.000000000001f)));
    let _e230 = ua;
    let _e231 = ub;
    angle_1 = acos(clamp(dot(_e230, _e231), -1f, 1f));
    let _e235 = ua;
    let _e236 = ub;
    axis = cross(_e235, _e236);
    let _e238 = axis;
    len = length(_e238);
    let _e240 = len;
    if (_e240 > 0.000001f) {
        let _e242 = angle_1;
        let _e243 = axis;
        let _e244 = (*n_3);
        let _e247 = len;
        local_25 = ((_e242 * dot(_e243, _e244)) / _e247);
    } else {
        local_25 = 0f;
    }
    let _e249 = local_25;
    return _e249;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_26: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_27: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_28: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e232 = i_7;
        if (_e232 < 4i) {
            let _e234 = i_7;
            let _e236 = (*corners)[_e234];
            a_2 = _e236;
            let _e237 = i_7;
            if (_e237 == 3i) {
                local_26 = 0i;
            } else {
                let _e239 = i_7;
                local_26 = (_e239 + 1i);
            }
            let _e241 = local_26;
            let _e243 = (*corners)[_e241];
            b_1 = _e243;
            let _e244 = a_2;
            let _e245 = (*n_4);
            ha = dot(_e244, _e245);
            let _e247 = b_1;
            let _e248 = (*n_4);
            hb = dot(_e247, _e248);
            let _e250 = ha;
            let _e251 = hb;
            d_3 = (_e250 - _e251);
            let _e253 = a_2;
            let _e254 = b_1;
            let _e255 = a_2;
            let _e257 = d_3;
            if (abs(_e257) > 0.000000000001f) {
                let _e260 = ha;
                let _e261 = d_3;
                local_27 = (_e260 / _e261);
            } else {
                local_27 = 0f;
            }
            let _e263 = local_27;
            q = (_e253 + ((_e254 - _e255) * _e263));
            let _e266 = ha;
            aAbove = (_e266 > 0f);
            let _e268 = hb;
            bAbove = (_e268 > 0f);
            let _e270 = aAbove;
            let _e271 = bAbove;
            if (_e270 || _e271) {
                let _e273 = aAbove;
                let _e274 = a_2;
                let _e275 = q;
                let _e278 = bAbove;
                let _e279 = b_1;
                let _e280 = q;
                param_83 = select(_e275, _e274, vec3(_e273));
                param_84 = select(_e280, _e279, vec3(_e278));
                let _e283 = (*n_4);
                param_85 = _e283;
                let _e284 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_28 = _e284;
            } else {
                local_28 = 0f;
            }
            let _e285 = local_28;
            let _e286 = total;
            total = (_e286 + _e285);
            let _e288 = aAbove;
            let _e289 = bAbove;
            let _e292 = q;
            let _e293 = exit;
            exit = select(_e293, _e292, vec3((_e288 && !(_e289))));
            let _e296 = aAbove;
            let _e298 = bAbove;
            let _e300 = q;
            let _e301 = entry;
            entry = select(_e301, _e300, vec3((!(_e296) && _e298)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e304 = i_7;
            i_7 = (_e304 + 1i);
        }
    }
    let _e306 = exit;
    param_86 = _e306;
    let _e307 = entry;
    param_87 = _e307;
    let _e308 = (*n_4);
    param_88 = _e308;
    let _e309 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e310 = total;
    total = (_e310 + _e309);
    let _e312 = total;
    return max((-(_e312) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_29: f32;
    var local_30: f32;
    var local_31: f32;

    let _e215 = (*slot_1);
    let _e216 = (*slot_1);
    lane = (_e215 - ((_e216 / 4i) * 4i));
    let _e220 = lane;
    if (_e220 == 0i) {
        let _e223 = (*four)[0u];
        local_29 = _e223;
    } else {
        let _e224 = lane;
        if (_e224 == 1i) {
            let _e227 = (*four)[1u];
            local_30 = _e227;
        } else {
            let _e228 = lane;
            if (_e228 == 2i) {
                let _e231 = (*four)[2u];
                local_31 = _e231;
            } else {
                let _e233 = (*four)[3u];
                local_31 = _e233;
            }
            let _e234 = local_31;
            local_30 = _e234;
        }
        let _e235 = local_30;
        local_29 = _e235;
    }
    let _e236 = local_29;
    return _e236;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e212 = (*slot_2);
    let _e216 = light_list_info.scales[(_e212 / 4i)];
    param_89 = _e216;
    let _e217 = (*slot_2);
    param_90 = _e217;
    let _e218 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e218;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e214 = light_list_info.slot_rows[0i];
    let _e215 = (*row);
    a_3 = abs((_e214 - vec4(_e215)));
    let _e221 = light_list_info.slot_rows[1i];
    let _e222 = (*row);
    b_2 = abs((_e221 - vec4(_e222)));
    let _e227 = a_3[0u];
    let _e229 = a_3[1u];
    let _e232 = a_3[2u];
    let _e234 = a_3[3u];
    let _e238 = b_2[0u];
    let _e240 = b_2[1u];
    let _e243 = b_2[2u];
    let _e245 = b_2[3u];
    return (min(min(min(_e227, _e229), min(_e232, _e234)), min(min(_e238, _e240), min(_e243, _e245))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e212 = (*slot_3);
    let _e216 = light_list_info.indices[(_e212 / 4i)];
    param_91 = _e216;
    let _e217 = (*slot_3);
    param_92 = _e217;
    let _e218 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e218;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e211 = (*texel_2);
    let _e215 = light_list_info.list[1u];
    let _e217 = (*row_1);
    let _e221 = light_list_info.list[2u];
    let _e224 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e211 + 0.5f) * _e215), ((_e217 + 0.5f) * _e221)), 0f);
    return _e224;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e219 = g_cluster_offset;
    let _e220 = (*slot_4);
    entry_1 = (_e219 + f32(_e220));
    let _e223 = entry_1;
    row_2 = floor((_e223 / 16f));
    let _e226 = entry_1;
    let _e227 = row_2;
    within_1 = (_e226 - (_e227 * 16f));
    let _e230 = within_1;
    texel_3 = floor((_e230 / 4f));
    let _e235 = light_list_info.cluster_depth[3u];
    let _e236 = row_2;
    let _e238 = texel_3;
    param_93 = _e238;
    param_94 = (_e235 + _e236);
    let _e239 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e239;
    let _e240 = within_1;
    let _e241 = texel_3;
    let _e246 = four_1;
    param_95 = _e246;
    param_96 = i32(((_e240 - (_e241 * 4f)) + 0.5f));
    let _e247 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e247;
}

fn Clustered_u0028_() -> bool {
    let _e211 = light_list_info.cluster_grid[3u];
    return (_e211 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_32: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_33: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_34: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_35: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_36: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e263 = (*index_2);
    if (_e263 < 8i) {
        let _e265 = (*index_2);
        let _e268 = frag_info.light_position[_e265];
        position = _e268;
        let _e269 = (*index_2);
        let _e272 = frag_info.light_color[_e269];
        color_1 = _e272;
        let _e273 = (*index_2);
        let _e276 = frag_info.light_direction[_e273];
        direction = _e276;
        let _e277 = (*index_2);
        let _e280 = frag_info.light_cone[_e277];
        cone = _e280;
    } else {
        let _e281 = (*index_2);
        slot_5 = (_e281 - 8i);
        let _e283 = Clustered_u0028_();
        clustered = _e283;
        let _e284 = clustered;
        if _e284 {
            let _e285 = slot_5;
            param_97 = _e285;
            let _e286 = ClusterRow_u0028_i1_u003b((&param_97));
            local_32 = _e286;
        } else {
            let _e287 = slot_5;
            param_98 = _e287;
            let _e288 = LightListRow_u0028_i1_u003b((&param_98));
            local_32 = _e288;
        }
        let _e289 = local_32;
        listRow = _e289;
        let _e290 = listRow;
        let _e294 = light_list_info.list[2u];
        v_1 = ((_e290 + 0.5f) * _e294);
        let _e298 = light_list_info.list[1u];
        u_1 = _e298;
        let _e299 = u_1;
        let _e301 = v_1;
        let _e303 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e299), _e301), 0f);
        position = _e303;
        let _e304 = u_1;
        let _e306 = v_1;
        let _e308 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e304), _e306), 0f);
        color_1 = _e308;
        let _e309 = u_1;
        let _e311 = v_1;
        let _e313 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e309), _e311), 0f);
        direction = _e313;
        let _e314 = u_1;
        let _e316 = v_1;
        let _e318 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e314), _e316), 0f);
        cone = _e318;
        let _e319 = clustered;
        if _e319 {
            let _e320 = listRow;
            param_99 = _e320;
            let _e321 = InSlots_u0028_f1_u003b((&param_99));
            local_33 = select(1f, 0f, _e321);
        } else {
            let _e323 = slot_5;
            param_100 = _e323;
            let _e324 = LightListScale_u0028_i1_u003b((&param_100));
            local_33 = _e324;
        }
        let _e325 = local_33;
        let _e327 = color_1[3u];
        color_1[3u] = (_e327 * _e325);
    }
    let _e331 = position[3u];
    type_39 = _e331;
    let _e332 = type_39;
    if (_e332 > 15.5f) {
        let _e335 = (*s_5).n;
        light_3.l = _e335;
        let _e338 = (*s_5).n;
        light_3.h = _e338;
        light_3.radiance = vec3<f32>(0f, 0f, 0f);
        light_3.n_dot_l = 0f;
        light_3.n_dot_h = 0f;
        light_3.v_dot_h = 0f;
        let _e344 = light_3;
        return _e344;
    }
    let _e345 = type_39;
    if (_e345 > 2.5f) {
        let _e347 = direction;
        halfWidth_1 = _e347.xyz;
        let _e349 = cone;
        halfHeight_1 = _e349.xyz;
        let _e351 = position;
        let _e353 = v_world_position_1;
        toCentre = (_e351.xyz - _e353);
        let _e355 = toCentre;
        let _e356 = halfWidth_1;
        let _e358 = halfHeight_1;
        corners_1[0i] = ((_e355 - _e356) - _e358);
        let _e361 = toCentre;
        let _e362 = halfWidth_1;
        let _e364 = halfHeight_1;
        corners_1[1i] = ((_e361 + _e362) - _e364);
        let _e367 = toCentre;
        let _e368 = halfWidth_1;
        let _e370 = halfHeight_1;
        corners_1[2i] = ((_e367 + _e368) + _e370);
        let _e373 = toCentre;
        let _e374 = halfWidth_1;
        let _e376 = halfHeight_1;
        corners_1[3i] = ((_e373 - _e374) + _e376);
        let _e379 = toCentre;
        let _e380 = halfWidth_1;
        let _e381 = halfHeight_1;
        behind = (dot(_e379, cross(_e380, _e381)) >= 0f);
        let _e385 = behind;
        if _e385 {
            local_34 = 0f;
        } else {
            let _e386 = corners_1;
            param_101 = _e386;
            let _e388 = (*s_5).n;
            param_102 = _e388;
            let _e389 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_34 = _e389;
        }
        let _e390 = local_34;
        formFactor = _e390;
        let _e391 = halfWidth_1;
        let _e392 = halfHeight_1;
        area = (length(cross(_e391, _e392)) * 4f);
        let _e396 = area;
        if (_e396 > 0.000000001f) {
            let _e398 = area;
            local_35 = (1f / _e398);
        } else {
            local_35 = 0f;
        }
        let _e400 = local_35;
        radiance = _e400;
        let _e401 = toCentre;
        distance_2 = length(_e401);
        let _e404 = direction[3u];
        if (_e404 > 0f) {
            let _e406 = distance_2;
            let _e408 = direction[3u];
            ratio_1 = (_e406 / _e408);
            let _e410 = ratio_1;
            let _e411 = ratio_1;
            let _e413 = ratio_1;
            let _e415 = ratio_1;
            window_1 = clamp((1f - (((_e410 * _e411) * _e413) * _e415)), 0f, 1f);
            let _e419 = window_1;
            let _e420 = window_1;
            let _e422 = radiance;
            radiance = (_e422 * (_e419 * _e420));
        }
        let _e425 = (*s_5).v;
        let _e428 = (*s_5).n;
        mirror_1 = reflect(-(_e425), _e428);
        let _e430 = position;
        param_103 = _e430.xyz;
        let _e432 = halfWidth_1;
        param_104 = _e432;
        let _e433 = halfHeight_1;
        param_105 = _e433;
        let _e434 = v_world_position_1;
        param_106 = _e434;
        let _e435 = mirror_1;
        param_107 = _e435;
        let _e436 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e436;
        let _e437 = representative;
        let _e438 = v_world_position_1;
        toPoint = (_e437 - _e438);
        let _e440 = toPoint;
        pointDistance = length(_e440);
        let _e442 = pointDistance;
        if (_e442 > 0.000001f) {
            let _e444 = toPoint;
            let _e445 = pointDistance;
            local_36 = (_e444 / vec3(_e445));
        } else {
            let _e449 = (*s_5).n;
            local_36 = _e449;
        }
        let _e450 = local_36;
        light_3.l = _e450;
        let _e453 = light_3.l;
        let _e455 = (*s_5).v;
        light_3.h = normalize((_e453 + _e455));
        let _e459 = formFactor;
        light_3.n_dot_l = _e459;
        let _e462 = (*s_5).n;
        let _e464 = light_3.h;
        light_3.n_dot_h = max(dot(_e462, _e464), 0f);
        let _e469 = (*s_5).v;
        let _e471 = light_3.h;
        light_3.v_dot_h = max(dot(_e469, _e471), 0f);
        let _e475 = color_1;
        let _e478 = color_1[3u];
        let _e480 = radiance;
        light_3.radiance = ((_e475.xyz * _e478) * _e480);
        let _e483 = light_3;
        return _e483;
    }
    let _e484 = direction;
    aim = normalize(_e484.xyz);
    attenuation_1 = 1f;
    let _e487 = type_39;
    if (_e487 < 0.5f) {
        let _e489 = aim;
        light_3.l = -(_e489);
    } else {
        let _e492 = position;
        let _e494 = v_world_position_1;
        toLight_1 = (_e492.xyz - _e494);
        let _e496 = toLight_1;
        distance_3 = length(_e496);
        let _e498 = distance_3;
        if (_e498 < 0.000001f) {
            let _e501 = (*s_5).n;
            light_3.l = _e501;
            let _e504 = (*s_5).n;
            light_3.h = _e504;
            light_3.radiance = vec3<f32>(0f, 0f, 0f);
            light_3.n_dot_l = 0f;
            light_3.n_dot_h = 0f;
            light_3.v_dot_h = 0f;
            let _e510 = light_3;
            return _e510;
        }
        let _e511 = toLight_1;
        let _e512 = distance_3;
        light_3.l = (_e511 / vec3(_e512));
        let _e516 = distance_3;
        param_108 = _e516;
        let _e518 = direction[3u];
        param_109 = _e518;
        let _e519 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e519;
        let _e520 = type_39;
        if (_e520 > 1.5f) {
            let _e522 = aim;
            let _e524 = light_3.l;
            cosAngle = dot(_e522, -(_e524));
            let _e527 = cosAngle;
            let _e529 = cone[1u];
            let _e532 = cone[0u];
            let _e534 = cone[1u];
            ramp = clamp(((_e527 - _e529) / (_e532 - _e534)), 0f, 1f);
            let _e538 = ramp;
            let _e539 = ramp;
            let _e541 = attenuation_1;
            attenuation_1 = (_e541 * (_e538 * _e539));
        }
    }
    let _e544 = light_3.l;
    let _e546 = (*s_5).v;
    light_3.h = normalize((_e544 + _e546));
    let _e551 = (*s_5).n;
    let _e553 = light_3.l;
    light_3.n_dot_l = max(dot(_e551, _e553), 0f);
    let _e558 = (*s_5).n;
    let _e560 = light_3.h;
    light_3.n_dot_h = max(dot(_e558, _e560), 0f);
    let _e565 = (*s_5).v;
    let _e567 = light_3.h;
    light_3.v_dot_h = max(dot(_e565, _e567), 0f);
    let _e571 = color_1;
    let _e574 = color_1[3u];
    let _e576 = attenuation_1;
    light_3.radiance = ((_e571.xyz * _e574) * _e576);
    let _e579 = light_3;
    return _e579;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_37: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e224 = light_list_info.cluster_view_projection;
    let _e225 = (*world_3);
    clip_1 = (_e224 * vec4<f32>(_e225.x, _e225.y, _e225.z, 1f));
    let _e231 = clip_1;
    let _e234 = clip_1[3u];
    ndc_1 = (_e231.xy / vec2(max(_e234, 0.000001f)));
    let _e239 = light_list_info.cluster_grid;
    grid = _e239.xyz;
    let _e243 = light_list_info.cluster_depth[0u];
    near_1 = _e243;
    let _e245 = ndc_1[0u];
    let _e249 = grid[0u];
    let _e253 = grid[0u];
    tx = clamp(floor((((_e245 * 0.5f) + 0.5f) * _e249)), 0f, (_e253 - 1f));
    let _e257 = ndc_1[1u];
    let _e261 = grid[1u];
    let _e265 = grid[1u];
    ty = clamp(floor((((_e257 * 0.5f) + 0.5f) * _e261)), 0f, (_e265 - 1f));
    let _e269 = clip_1[3u];
    let _e270 = near_1;
    if (_e269 <= _e270) {
        local_37 = 0f;
    } else {
        let _e273 = clip_1[3u];
        let _e274 = near_1;
        let _e279 = light_list_info.cluster_depth[1u];
        let _e283 = grid[2u];
        local_37 = clamp(floor((log((_e273 / _e274)) * _e279)), 0f, (_e283 - 1f));
    }
    let _e286 = local_37;
    tz = _e286;
    let _e287 = tx;
    let _e288 = ty;
    let _e290 = grid[0u];
    let _e293 = tz;
    let _e295 = grid[0u];
    let _e298 = grid[1u];
    cell_1 = ((_e287 + (_e288 * _e290)) + ((_e293 * _e295) * _e298));
    let _e301 = cell_1;
    row_3 = floor((_e301 / 4f));
    let _e304 = cell_1;
    let _e305 = row_3;
    let _e310 = light_list_info.cluster_depth[2u];
    let _e311 = row_3;
    param_110 = (_e304 - (_e305 * 4f));
    param_111 = (_e310 + _e311);
    let _e313 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e313;
    let _e315 = header[0u];
    g_cluster_offset = _e315;
    let _e317 = header[1u];
    g_cluster_count = _e317;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e213 = light_list_info.list[0u];
    tail = _e213;
    let _e214 = Clustered_u0028_();
    if _e214 {
        let _e215 = v_world_position_1;
        param_112 = _e215;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e216 = g_cluster_count;
        tail = _e216;
    }
    let _e219 = frag_info.frame_params[1u];
    let _e223 = tail;
    return (clamp(i32((_e219 + 0.5f)), 0i, 8i) + clamp(i32((_e223 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_38: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e227 = LightCount_u0028_();
    count_1 = _e227;
    i_8 = 0i;
    loop {
        let _e228 = i_8;
        if (_e228 < 32i) {
            let _e230 = i_8;
            let _e231 = count_1;
            if (_e230 >= _e231) {
                break;
            }
            let _e233 = i_8;
            param_113 = _e233;
            let _e234 = (*s_6);
            param_114 = _e234;
            let _e235 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_113), (&param_114));
            light_4 = _e235;
            let _e237 = light_4.n_dot_l;
            if (_e237 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e239 = i_8;
            param_115 = _e239;
            let _e240 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e240 {
                let _e241 = (*s_6);
                param_116 = _e241;
                let _e242 = light_4;
                param_117 = _e242;
                let _e243 = i_8;
                param_118 = _e243;
                let _e244 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e245 = v_world_position_1;
                param_119 = _e245;
                let _e247 = (*s_6).n;
                param_120 = _e247;
                let _e248 = i_8;
                param_121 = _e248;
                let _e249 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_38 = (_e244 * _e249);
            } else {
                local_38 = 1f;
            }
            let _e251 = local_38;
            visibility = _e251;
            let _e252 = visibility;
            if (_e252 <= 0f) {
                continue;
            }
            let _e254 = (*s_6);
            param_122 = _e254;
            let _e255 = light_4;
            param_123 = _e255;
            let _e256 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e258 = light_4.radiance;
            let _e261 = light_4.n_dot_l;
            let _e263 = visibility;
            let _e265 = light_transmittance;
            let _e267 = total_1;
            total_1 = (_e267 + ((((_e256 * _e258) * _e261) * _e263) * _e265));
            continue;
        } else {
            break;
        }
        continuing {
            let _e269 = i_8;
            i_8 = (_e269 + 1i);
        }
    }
    let _e271 = total_1;
    return _e271;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_39: f32;
    var local_40: f32;

    let _e213 = OcclusionTarget_u0028_();
    target_ = _e213;
    let _e214 = target_;
    let _e216 = target_;
    if ((_e214 > 0.5f) && (_e216 < 1.5f)) {
        local_39 = 1f;
    } else {
        let _e220 = (*s_7).occlusion;
        local_39 = _e220;
    }
    let _e221 = local_39;
    local_40 = _e221;
    let _e222 = local_40;
    return _e222;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e210 = v_lightmap_uv_1;
    let _e211 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e210);
    texel_4 = _e211;
    let _e212 = texel_4;
    let _e215 = texel_4[3u];
    return ((_e212.xyz * _e215) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e211 = frag_info.target_origin[1u];
    return _e211;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_124: vec3<f32>;

    let _e212 = v_texcoord_1;
    let _e213 = MaterialLodBias_u0028_();
    let _e214 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e212, _e213);
    param_124 = _e214.xyz;
    let _e216 = SrgbToLinear_u0028_vf3_u003b((&param_124));
    emissive = _e216;
    let _e217 = emissive;
    let _e219 = frag_info.emissive;
    let _e224 = frag_info.material2_[3u];
    (*s_8).emissive = ((_e217 * _e219.xyz) * _e224);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e212 = v_texcoord_1;
    let _e213 = MaterialLodBias_u0028_();
    let _e214 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e212, _e213);
    occlusion = _e214.x;
    let _e218 = frag_info.material2_[2u];
    let _e219 = OcclusionTarget_u0028_();
    strength_2 = (_e218 - (2f * _e219));
    let _e222 = occlusion;
    let _e223 = strength_2;
    (*s_9).occlusion = mix(1f, _e222, clamp(_e223, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e214 = v_texcoord_1;
    let _e215 = MaterialLodBias_u0028_();
    let _e216 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e214, _e215);
    sampledTexel = _e216;
    let _e217 = v_tangent_1;
    t_2 = _e217.xyz;
    let _e219 = t_2;
    let _e221 = (*s_10).n;
    let _e223 = (*s_10).n;
    let _e224 = t_2;
    t_2 = (_e219 - (_e221 * dot(_e223, _e224)));
    let _e228 = t_2;
    let _e229 = t_2;
    if (dot(_e228, _e229) < 0.000000000001f) {
        return;
    }
    let _e232 = t_2;
    t_2 = normalize(_e232);
    let _e235 = (*s_10).n;
    let _e236 = t_2;
    let _e239 = v_tangent_1[3u];
    b_3 = (cross(_e235, _e236) * _e239);
    let _e241 = gl_FrontFacing_1;
    if !(_e241) {
        let _e243 = t_2;
        t_2 = -(_e243);
    }
    let _e245 = sampledTexel;
    sampled = ((_e245.xyz * 2f) - vec3(1f));
    let _e252 = frag_info.emissive[3u];
    if (_e252 > 0.5f) {
        let _e254 = sampled;
        let _e256 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e254.xy, _e256.xy)), 0f));
    }
    let _e265 = frag_info.material2_[1u];
    let _e266 = sampled;
    let _e268 = (_e266.xy * _e265);
    sampled[0u] = _e268.x;
    sampled[1u] = _e268.y;
    let _e273 = t_2;
    let _e275 = sampled[0u];
    let _e277 = b_3;
    let _e279 = sampled[1u];
    let _e283 = (*s_10).n;
    let _e285 = sampled[2u];
    (*s_10).n = normalize((((_e273 * _e275) + (_e277 * _e279)) + (_e283 * _e285)));
    let _e291 = (*s_10).n;
    let _e293 = (*s_10).v;
    (*s_10).n_dot_v = max(dot(_e291, _e293), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e210 = (*texel_5);
    let _e214 = irradiance_info.atlas;
    let _e217 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e210 + vec2(0.5f)) * _e214.xy), 0f);
    return _e217;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_125: vec2<f32>;
    var b_4: vec4<f32>;
    var param_126: vec2<f32>;
    var c_1: vec4<f32>;
    var param_127: vec2<f32>;
    var d_4: vec4<f32>;
    var param_128: vec2<f32>;

    let _e223 = (*uv_6);
    let _e224 = (*interior);
    at_1 = ((vec2(1f) + (_e223 * _e224)) - vec2(0.5f));
    let _e230 = at_1;
    low = floor(_e230);
    let _e232 = at_1;
    let _e233 = low;
    f = (_e232 - _e233);
    let _e235 = (*corner);
    let _e236 = low;
    param_125 = (_e235 + _e236);
    let _e238 = AtlasTexel_u0028_vf2_u003b((&param_125));
    a_4 = _e238;
    let _e239 = (*corner);
    let _e240 = low;
    param_126 = ((_e239 + _e240) + vec2<f32>(1f, 0f));
    let _e243 = AtlasTexel_u0028_vf2_u003b((&param_126));
    b_4 = _e243;
    let _e244 = (*corner);
    let _e245 = low;
    param_127 = ((_e244 + _e245) + vec2<f32>(0f, 1f));
    let _e248 = AtlasTexel_u0028_vf2_u003b((&param_127));
    c_1 = _e248;
    let _e249 = (*corner);
    let _e250 = low;
    param_128 = ((_e249 + _e250) + vec2<f32>(1f, 1f));
    let _e253 = AtlasTexel_u0028_vf2_u003b((&param_128));
    d_4 = _e253;
    let _e254 = a_4;
    let _e255 = b_4;
    let _e257 = f[0u];
    let _e260 = c_1;
    let _e261 = d_4;
    let _e263 = f[0u];
    let _e267 = f[1u];
    return mix(mix(_e254, _e255, vec4(_e257)), mix(_e260, _e261, vec4(_e263)), vec4(_e267));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e214 = (*direction_1)[0u];
    let _e217 = (*direction_1)[1u];
    let _e221 = (*direction_1)[2u];
    sum_1 = ((abs(_e214) + abs(_e217)) + abs(_e221));
    let _e224 = sum_1;
    if (_e224 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e226 = (*direction_1);
    let _e227 = sum_1;
    n_5 = (_e226 / vec3(_e227));
    let _e230 = n_5;
    xy = _e230.xy;
    let _e233 = n_5[2u];
    if (_e233 < 0f) {
        let _e236 = n_5[1u];
        let _e240 = n_5[0u];
        let _e245 = n_5[0u];
        let _e249 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e236)) * select(-1f, 1f, (_e240 >= 0f))), ((1f - abs(_e245)) * select(-1f, 1f, (_e249 >= 0f))));
    }
    let _e254 = xy;
    return ((_e254 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_129: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_130: vec3<f32>;
    var param_131: vec2<f32>;
    var param_132: f32;
    var param_133: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_134: vec3<f32>;
    var param_135: vec2<f32>;
    var param_136: f32;
    var param_137: vec2<f32>;
    var local_41: vec3<f32>;

    let _e256 = irradiance_info.origin;
    origin_2 = _e256.xyz;
    let _e259 = irradiance_info.spacing;
    spacing = _e259.xyz;
    let _e262 = irradiance_info.counts;
    counts = _e262.xyz;
    let _e266 = irradiance_info.tiles[0u];
    irradianceTile = _e266;
    let _e269 = irradiance_info.tiles[1u];
    depthTile = _e269;
    let _e272 = irradiance_info.tiles[2u];
    columns = _e272;
    let _e275 = irradiance_info.tiles[3u];
    momentsTop = _e275;
    let _e276 = (*normal_1);
    unit = normalize(_e276);
    let _e278 = (*world_4);
    let _e279 = unit;
    let _e282 = irradiance_info.spacing[3u];
    let _e285 = (*view_1);
    let _e288 = irradiance_info.counts[3u];
    biased = ((_e278 + (_e279 * _e282)) + (_e285 * _e288));
    let _e291 = biased;
    let _e292 = origin_2;
    let _e294 = spacing;
    grid_1 = ((_e291 - _e292) / _e294);
    let _e296 = grid_1;
    let _e298 = counts;
    base = clamp(floor(_e296), vec3<f32>(0f, 0f, 0f), (_e298 - vec3(2f)));
    let _e302 = grid_1;
    let _e303 = base;
    f_1 = clamp((_e302 - _e303), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e306 = corner_1;
        if (_e306 < 8i) {
            let _e308 = corner_1;
            let _e311 = corner_1;
            let _e316 = corner_1;
            offset_3 = vec3<f32>(f32((_e308 & 1i)), f32(((_e311 >> bitcast<u32>(1i)) & 1i)), f32(((_e316 >> bitcast<u32>(2i)) & 1i)));
            let _e322 = base;
            let _e323 = offset_3;
            cell_2 = (_e322 + _e323);
            let _e326 = cell_2[2u];
            let _e328 = counts[1u];
            let _e331 = cell_2[1u];
            let _e334 = counts[0u];
            let _e337 = cell_2[0u];
            probe = ((((_e326 * _e328) + _e331) * _e334) + _e337);
            let _e339 = probe;
            let _e340 = columns;
            let _e345 = probe;
            let _e346 = columns;
            tile_4 = vec2<f32>((_e339 - (floor((_e339 / _e340)) * _e340)), floor((_e345 / _e346)));
            let _e350 = tile_4;
            let _e351 = irradianceTile;
            irradianceCorner = (_e350 * (_e351 + 2f));
            let _e355 = tile_4[0u];
            let _e356 = depthTile;
            let _e359 = momentsTop;
            let _e361 = tile_4[1u];
            let _e362 = depthTile;
            momentCorner = vec2<f32>((_e355 * (_e356 + 2f)), (_e359 + (_e361 * (_e362 + 2f))));
            let _e367 = irradianceCorner;
            param_129 = (_e367 + vec2(1f));
            let _e370 = AtlasTexel_u0028_vf2_u003b((&param_129));
            if (_e370.w < 0.5f) {
                continue;
            }
            let _e373 = f_1;
            let _e375 = f_1;
            let _e376 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e373), _e375, _e376);
            let _e379 = trilinear[0u];
            let _e381 = trilinear[1u];
            let _e384 = trilinear[2u];
            weight_3 = max(((_e379 * _e381) * _e384), 0.001f);
            let _e387 = origin_2;
            let _e388 = spacing;
            let _e389 = cell_2;
            probePosition = (_e387 + (_e388 * _e389));
            let _e392 = probePosition;
            let _e393 = biased;
            toProbe = (_e392 - _e393);
            let _e395 = toProbe;
            distance_4 = length(_e395);
            let _e397 = distance_4;
            if (_e397 > 0.000001f) {
                let _e399 = toProbe;
                let _e400 = distance_4;
                direction_2 = (_e399 / vec3(_e400));
                let _e403 = unit;
                let _e404 = probePosition;
                let _e405 = (*world_4);
                facing = ((dot(_e403, normalize((_e404 - _e405))) * 0.5f) + 0.5f);
                let _e411 = facing;
                let _e412 = facing;
                probeWeight = ((_e411 * _e412) + 0.2f);
                let _e415 = direction_2;
                param_130 = -(_e415);
                let _e417 = ProbeOctahedral_u0028_vf3_u003b((&param_130));
                let _e418 = momentCorner;
                param_131 = _e418;
                let _e419 = depthTile;
                param_132 = _e419;
                param_133 = _e417;
                let _e420 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_131), (&param_132), (&param_133));
                moments_3 = _e420.xy;
                chebyshev = 1f;
                let _e422 = distance_4;
                let _e424 = moments_3[0u];
                if (_e422 > _e424) {
                    let _e427 = moments_3[1u];
                    let _e429 = moments_3[0u];
                    let _e431 = moments_3[0u];
                    variance_1 = max((_e427 - (_e429 * _e431)), 0.000001f);
                    let _e435 = distance_4;
                    let _e437 = moments_3[0u];
                    difference = (_e435 - _e437);
                    let _e439 = variance_1;
                    let _e440 = variance_1;
                    let _e441 = difference;
                    let _e442 = difference;
                    chebyshev = (_e439 / (_e440 + (_e441 * _e442)));
                    let _e446 = chebyshev;
                    let _e447 = chebyshev;
                    let _e449 = chebyshev;
                    chebyshev = ((_e446 * _e447) * _e449);
                }
                let _e451 = probeWeight;
                let _e452 = chebyshev;
                probeWeight = max((_e451 * max(_e452, 0.05f)), 0.000001f);
                let _e456 = probeWeight;
                if (_e456 < 0.2f) {
                    let _e458 = probeWeight;
                    let _e459 = probeWeight;
                    let _e462 = probeWeight;
                    probeWeight = (_e462 * ((_e458 * _e459) * 25f));
                }
                let _e464 = probeWeight;
                let _e465 = weight_3;
                weight_3 = (_e465 * _e464);
            }
            let _e467 = unit;
            param_134 = _e467;
            let _e468 = ProbeOctahedral_u0028_vf3_u003b((&param_134));
            let _e469 = irradianceCorner;
            param_135 = _e469;
            let _e470 = irradianceTile;
            param_136 = _e470;
            param_137 = _e468;
            let _e471 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_135), (&param_136), (&param_137));
            let _e473 = weight_3;
            let _e475 = total_2;
            total_2 = (_e475 + (_e471.xyz * _e473));
            let _e477 = weight_3;
            let _e478 = weights;
            weights = (_e478 + _e477);
            continue;
        } else {
            break;
        }
        continuing {
            let _e480 = corner_1;
            corner_1 = (_e480 + 1i);
        }
    }
    let _e482 = weights;
    if (_e482 > 0f) {
        let _e484 = total_2;
        let _e485 = weights;
        local_41 = (_e484 / vec3(_e485));
    } else {
        local_41 = vec3<f32>(0f, 0f, 0f);
    }
    let _e488 = local_41;
    return _e488;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e211 = irradiance_info.origin[3u];
    return (_e211 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: Surface;

    let _e216 = IrradianceEnabled_u0028_();
    if _e216 {
        let _e217 = v_world_position_1;
        param_138 = _e217;
        let _e219 = (*s_11).n;
        param_139 = _e219;
        let _e221 = (*s_11).v;
        param_140 = _e221;
        let _e222 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_138), (&param_139), (&param_140));
        let _e225 = frag_info.material[2u];
        (*s_11).ambient = (_e222 * _e225);
    }
    let _e228 = (*s_11);
    param_141 = _e228;
    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((&param_141));
    let _e229 = param_141;
    (*s_11) = _e229;
    let _e230 = (*s_11);
    param_142 = _e230;
    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((&param_142));
    let _e231 = param_142;
    (*s_11) = _e231;
    let _e232 = (*s_11);
    param_143 = _e232;
    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((&param_143));
    let _e233 = param_143;
    (*s_11) = _e233;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_42: vec3<f32>;

    let _e210 = Orthographic_u0028_();
    if _e210 {
        let _e212 = fog_info.forward;
        local_42 = -(_e212.xyz);
    } else {
        let _e216 = fog_info.eye;
        let _e218 = v_world_position_1;
        local_42 = normalize((_e216.xyz - _e218));
    }
    let _e221 = local_42;
    return _e221;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_12: Surface;
    var param_144: vec3<f32>;
    var param_145: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e215 = v_texcoord_1;
    let _e216 = MaterialLodBias_u0028_();
    let _e217 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e215, _e216);
    texel_6 = _e217;
    let _e218 = texel_6;
    param_144 = _e218.xyz;
    let _e220 = SrgbToLinear_u0028_vf3_u003b((&param_144));
    let _e222 = frag_info.base_color;
    param_145 = _e222.xyz;
    let _e224 = SrgbToLinear_u0028_vf3_u003b((&param_145));
    let _e226 = v_color_1;
    s_12.albedo = ((_e220 * _e224) * _e226.xyz);
    let _e231 = texel_6[3u];
    let _e234 = frag_info.base_color[3u];
    let _e237 = v_color_1[3u];
    s_12.alpha = ((_e231 * _e234) * _e237);
    let _e241 = s_12.albedo;
    g_albedo = _e241;
    let _e244 = frag_info.material2_[0u];
    cutoff = _e244;
    let _e245 = cutoff;
    if (_e245 > 1f) {
        let _e247 = cutoff;
        edge = (_e247 - 1f);
        let _e250 = s_12.alpha;
        let _e251 = edge;
        let _e254 = s_12.alpha;
        let _e255 = fwidth(_e254);
        s_12.alpha = clamp((((_e250 - _e251) / max(_e255, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e261 = cutoff;
        if (_e261 >= 0f) {
            s_12.alpha = 1f;
        }
    }
    let _e264 = cutoff;
    let _e266 = cutoff;
    g_premultiply = ((_e264 < 0f) && (_e266 > -0.75f));
    let _e269 = v_normal_1;
    s_12.n = normalize(_e269);
    let _e272 = gl_FrontFacing_1;
    if !(_e272) {
        let _e275 = s_12.n;
        s_12.n = -(_e275);
    }
    let _e278 = TowardsEye_u0028_();
    s_12.v = _e278;
    let _e281 = s_12.n;
    let _e283 = s_12.v;
    s_12.n_dot_v = max(dot(_e281, _e283), 0.0001f);
    let _e289 = frag_info.material[0u];
    s_12.metallic = clamp(_e289, 0f, 1f);
    let _e294 = frag_info.material[1u];
    s_12.roughness = clamp(_e294, 0.02f, 1f);
    let _e298 = frag_info.ambient_ground;
    let _e301 = frag_info.ambient_sky;
    let _e305 = s_12.n[1u];
    let _e312 = frag_info.material[2u];
    s_12.ambient = (mix(_e298.xyz, _e301.xyz, vec3(((_e305 * 0.5f) + 0.5f))) * _e312);
    let _e317 = frag_info.frame_params[0u];
    s_12.exposure = max(_e317, 0f);
    s_12.occlusion = 1f;
    s_12.emissive = vec3<f32>(0f, 0f, 0f);
    let _e322 = s_12;
    return _e322;
}

fn main_1() {
    var s_13: Surface;
    var param_146: Surface;
    var ambient: vec3<f32>;
    var param_147: Surface;
    var lit_3: vec3<f32>;
    var param_148: Surface;
    var param_149: Surface;
    var param_150: Surface;
    var param_151: vec3<f32>;
    var param_152: vec3<f32>;
    var param_153: f32;
    var param_154: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e221 = ReadSurface_u0028_();
    s_13 = _e221;
    let _e222 = s_13;
    param_146 = _e222;
    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((&param_146));
    let _e223 = param_146;
    s_13 = _e223;
    let _e225 = s_13.albedo;
    let _e227 = s_13.ambient;
    let _e228 = SampleLightmap_u0028_();
    let _e231 = s_13;
    param_147 = _e231;
    let _e232 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_147));
    ambient = ((_e225 * (_e227 + _e228)) * _e232);
    let _e234 = s_13;
    param_148 = _e234;
    let _e235 = 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((&param_148));
    let _e236 = s_13;
    param_149 = _e236;
    let _e237 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_149));
    let _e239 = ambient;
    let _e242 = s_13.emissive;
    lit_3 = (((_e235 * _e237) + _e239) + _e242);
    let _e244 = s_13;
    param_150 = _e244;
    let _e245 = lit_3;
    param_151 = _e245;
    let _e246 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_150), (&param_151));
    if _e246 {
        return;
    }
    let _e247 = lit_3;
    param_152 = _e247;
    let _e249 = s_13.alpha;
    param_153 = _e249;
    let _e251 = s_13.roughness;
    param_154 = _e251;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_152), (&param_153), (&param_154));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'BlinnPhongOpaqueDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e212 = v_world_position_1;
    let _e214 = fog_info.eye;
    let _e218 = fog_info.forward;
    return dot((_e212 - _e214.xyz), _e218.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e217 = ViewDepth_u0028_();
    z = abs(_e217);
    let _e219 = z;
    near = (_e219 / 5f);
    let _e221 = z;
    far = (_e221 / 200f);
    let _e223 = far;
    let _e224 = far;
    let _e226 = far;
    far3_ = ((_e223 * _e224) * _e226);
    let _e228 = (*alpha);
    let _e229 = near;
    let _e230 = near;
    let _e233 = far3_;
    let _e234 = far3_;
    return (_e228 * clamp((10f / ((0.00001f + (_e229 * _e230)) + (_e233 * _e234))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e221 = fog_info.forward[3u];
    mode = _e221;
    let _e222 = mode;
    if (_e222 > 0.5f) {
        let _e225 = frag_color[3u];
        alpha_1 = _e225;
        let _e226 = alpha_1;
        param = _e226;
        let _e227 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e227;
        let _e228 = frag_color;
        let _e230 = weight;
        let _e231 = (_e228.xyz * _e230);
        let _e232 = alpha_1;
        let _e233 = weight;
        accumulate = vec4<f32>(_e231.x, _e231.y, _e231.z, (_e232 * _e233));
        let _e239 = mode;
        let _e241 = mode;
        revealage = ((_e239 > 1.5f) && (_e241 < 2.5f));
        let _e244 = revealage;
        if _e244 {
            let _e245 = alpha_1;
            local = vec4(_e245);
        } else {
            let _e247 = accumulate;
            local = _e247;
        }
        let _e248 = local;
        frag_color = _e248;
        let _e249 = mode;
        if (_e249 > 2.5f) {
            let _e251 = alpha_1;
            frag_surface = vec4(_e251);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e215 = (*n)[0u];
    let _e218 = (*n)[1u];
    let _e222 = (*n)[2u];
    let _e225 = (*n);
    (*n) = (_e225 / vec3(((abs(_e215) + abs(_e218)) + abs(_e222))));
    let _e228 = (*n);
    e = _e228.xy;
    let _e231 = (*n)[2u];
    if (_e231 < 0f) {
        let _e233 = (*n);
        let _e239 = (*n)[0u];
        let _e243 = (*n)[1u];
        e = ((vec2(1f) - abs(_e233.yx)) * vec2<f32>(select(-1f, 1f, (_e239 >= 0f)), select(-1f, 1f, (_e243 >= 0f))));
    }
    let _e248 = e;
    return ((_e248 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e213 = (*linear);
    let _e215 = (*linear);
    let _e219 = (*linear);
    return mix((_e213 * 12.92f), ((pow(_e215, 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), _e219));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e216 = g_albedo;
    param_1 = clamp(_e216, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e218 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e218.x, _e218.y, _e218.z, 1f);
    let _e223 = g_debug_surface_on;
    if _e223 {
        let _e224 = g_debug_surface;
        let _e225 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e224.x, _e224.y, _e224.z, _e225);
        return;
    }
    let _e230 = v_normal_1;
    geometric = normalize(_e230);
    let _e232 = gl_FrontFacing_1;
    if !(_e232) {
        let _e234 = geometric;
        geometric = -(_e234);
    }
    let _e236 = geometric;
    param_2 = _e236;
    let _e237 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e238 = (*roughness);
    let _e240 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e237.x, _e237.y, clamp(_e238, 0f, 1f), _e240);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e214 = fog_info.projection[0u];
    return (_e214 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e213 = Orthographic_u0028_();
    if _e213 {
        let _e214 = ViewDepth_u0028_();
        local_1 = max(_e214, 0f);
    } else {
        let _e216 = v_world_position_1;
        let _e218 = fog_info.eye;
        local_1 = distance(_e216, _e218.xyz);
    }
    let _e221 = local_1;
    return _e221;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e220 = fog_info.fog[3u];
    density = _e220;
    let _e221 = density;
    if (_e221 <= 0f) {
        let _e223 = (*color);
        return _e223;
    }
    let _e224 = EyeDistance_u0028_();
    d = _e224;
    let _e227 = fog_info.eye[3u];
    falloff = _e227;
    let _e228 = falloff;
    if (_e228 > 0f) {
        let _e230 = falloff;
        let _e232 = v_world_position_1[1u];
        let _e235 = fog_info.eye[1u];
        k = (_e230 * (_e232 - _e235));
        let _e238 = k;
        if (abs(_e238) > 0.001f) {
            let _e241 = k;
            let _e245 = k;
            local_2 = ((1f - exp(-(_e241))) / _e245);
        } else {
            let _e247 = k;
            local_2 = (1f - (0.5f * _e247));
        }
        let _e250 = local_2;
        let _e251 = density;
        density = (_e251 * _e250);
    }
    let _e254 = fog_info.fog;
    let _e256 = (*color);
    let _e257 = density;
    let _e259 = d;
    return mix(_e254.xyz, _e256, vec3(clamp(exp((-(_e257) * _e259)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e218 = g_premultiply;
    let _e219 = (*alpha_2);
    weight_1 = select(1f, _e219, _e218);
    let _e221 = (*linearColor);
    param_3 = _e221;
    let _e222 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e223 = weight_1;
    let _e224 = (_e222 * _e223);
    let _e225 = (*alpha_2);
    let _e226 = g_pass_through;
    frag_color = vec4<f32>(_e224.x, _e224.y, _e224.z, (_e225 * (1f - _e226)));
    let _e233 = (*roughness_1);
    param_4 = _e233;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e213 = (*srgb);
    let _e216 = (*srgb);
    let _e221 = (*srgb);
    return mix((_e213 / vec3(12.92f)), pow(((_e216 + 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), _e221));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e215 = (*key);
    hue = fract(((_e215 * 0.618034f) + 0.13f));
    let _e219 = hue;
    k_1 = clamp((abs(((fract((vec3(_e219) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e232 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e232, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2568_: bool;

    let _e213 = (*c);
    let _e214 = (*c);
    let _e216 = any((_e213 != _e214));
    phi_2568_ = _e216;
    if !(_e216) {
        let _e218 = (*c);
        phi_2568_ = any((abs(_e218) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e223 = phi_2568_;
    return _e223;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2658_: bool;
    var phi_2926_: bool;

    let _e255 = gl_FragCoord_1[0u];
    let _e258 = frag_info.debug_view[1u];
    if (_e255 < _e258) {
        let _e262 = frag_info.debug_view[2u];
        local_3 = _e262;
    } else {
        let _e265 = frag_info.debug_view[0u];
        local_3 = _e265;
    }
    let _e266 = local_3;
    view = _e266;
    let _e267 = view;
    if (_e267 < 0.5f) {
        return false;
    }
    let _e269 = view;
    code = i32((_e269 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e272 = v_normal_1;
    geometric_n = normalize(_e272);
    let _e274 = v_tangent_1;
    let _e276 = geometric_n;
    let _e277 = geometric_n;
    let _e278 = v_tangent_1;
    tangent = (_e274.xyz - (_e276 * dot(_e277, _e278.xyz)));
    let _e283 = tangent;
    let _e284 = tangent;
    let _e286 = (dot(_e283, _e284) > 0.000000000001f);
    phi_2658_ = _e286;
    if _e286 {
        let _e288 = v_tangent_1[3u];
        phi_2658_ = (abs((abs(_e288) - 1f)) < 0.01f);
    }
    let _e294 = phi_2658_;
    tangent_usable = _e294;
    let _e297 = frag_info.debug_view[3u];
    identity = _e297;
    let _e298 = identity;
    identity_object = floor((_e298 / 8192f));
    let _e301 = identity;
    let _e302 = identity_object;
    identity_rest = (_e301 - (_e302 * 8192f));
    let _e305 = identity_rest;
    identity_material = floor((_e305 / 2f));
    let _e308 = identity_rest;
    let _e309 = identity_material;
    normal_mapped = ((_e308 - (_e309 * 2f)) > 0.5f);
    let _e313 = code;
    if (_e313 == 1i) {
        let _e316 = (*s).albedo;
        param_5 = clamp(_e316, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e318 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e318;
    } else {
        let _e319 = code;
        if (_e319 == 2i) {
            let _e322 = (*s).n;
            shown = ((_e322 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e325 = code;
            if (_e325 == 3i) {
                let _e328 = (*s).roughness;
                shown = vec3(clamp(_e328, 0f, 1f));
            } else {
                let _e331 = code;
                if (_e331 == 4i) {
                    let _e334 = (*s).metallic;
                    shown = vec3(clamp(_e334, 0f, 1f));
                } else {
                    let _e337 = code;
                    if (_e337 == 5i) {
                        let _e340 = (*s).occlusion;
                        shown = vec3(clamp(_e340, 0f, 1f));
                    } else {
                        let _e343 = code;
                        if (_e343 == 6i) {
                            let _e346 = (*s).emissive;
                            param_6 = clamp(_e346, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e348 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e348;
                        } else {
                            let _e349 = code;
                            if (_e349 == 7i) {
                                let _e351 = v_texcoord_1;
                                let _e352 = fract(_e351);
                                shown = vec3<f32>(_e352.x, _e352.y, 0f);
                            } else {
                                let _e356 = code;
                                if (_e356 == 8i) {
                                    let _e358 = (*lit);
                                    param_7 = clamp(_e358, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e360 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e360, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e362 = (*lit);
                                    param_8 = _e362;
                                    let _e363 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e363 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e364 = grey;
                                        local_4 = vec3((_e364 * 0.5f));
                                    }
                                    let _e367 = local_4;
                                    shown = _e367;
                                } else {
                                    let _e368 = code;
                                    if (_e368 == 9i) {
                                        let _e370 = tangent_usable;
                                        if _e370 {
                                            let _e371 = tangent;
                                            local_5 = ((normalize(_e371) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e375 = local_5;
                                        shown = _e375;
                                    } else {
                                        let _e376 = code;
                                        if (_e376 == 10i) {
                                            let _e378 = v_texcoord_1;
                                            uv = _e378;
                                            let _e379 = uv;
                                            cell = floor((_e379 * 8f));
                                            let _e383 = cell[0u];
                                            let _e385 = cell[1u];
                                            odd = (fract(((_e383 + _e385) * 0.5f)) * 2f);
                                            let _e390 = uv;
                                            within = fract(_e390);
                                            let _e392 = odd;
                                            let _e396 = within[0u];
                                            let _e400 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e392)) * vec3<f32>((0.55f + (0.45f * _e396)), (0.55f + (0.45f * _e400)), 0.85f));
                                        } else {
                                            let _e405 = code;
                                            if (_e405 == 11i) {
                                                let _e407 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e407));
                                            } else {
                                                let _e410 = code;
                                                if (_e410 == 12i) {
                                                    let _e412 = v_color_1;
                                                    param_9 = clamp(_e412.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e415 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e415;
                                                } else {
                                                    let _e416 = code;
                                                    let _e418 = code;
                                                    if ((_e416 == 13i) || (_e418 == 14i)) {
                                                        let _e421 = code;
                                                        let _e423 = identity_object;
                                                        let _e424 = identity_material;
                                                        key_1 = select(_e424, _e423, (_e421 == 13i));
                                                        let _e426 = key_1;
                                                        param_10 = _e426;
                                                        let _e427 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e429 = (*s).n_dot_v;
                                                        shown = (_e427 * (0.55f + (0.45f * _e429)));
                                                    } else {
                                                        let _e433 = code;
                                                        if (_e433 == 15i) {
                                                            let _e436 = (*s).albedo;
                                                            param_11 = clamp(_e436, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e438 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e438;
                                                            let _e439 = srgb_1;
                                                            luma = dot(_e439, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e442 = (*s).metallic;
                                                            metal = (_e442 > 0.5f);
                                                            let _e444 = metal;
                                                            let _e446 = luma;
                                                            if (!(_e444) && (_e446 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e449 = metal;
                                                                let _e450 = !(_e449);
                                                                phi_2926_ = _e450;
                                                                if _e450 {
                                                                    let _e452 = srgb_1[0u];
                                                                    let _e454 = srgb_1[1u];
                                                                    let _e456 = srgb_1[2u];
                                                                    phi_2926_ = (max(_e452, max(_e454, _e456)) > 0.9411765f);
                                                                }
                                                                let _e461 = phi_2926_;
                                                                if _e461 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e462 = metal;
                                                                    let _e463 = luma;
                                                                    if (_e462 && (_e463 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e466 = luma;
                                                                        local_8 = vec3(_e466);
                                                                    }
                                                                    let _e468 = local_8;
                                                                    local_7 = _e468;
                                                                }
                                                                let _e469 = local_7;
                                                                local_6 = _e469;
                                                            }
                                                            let _e470 = local_6;
                                                            shown = _e470;
                                                        } else {
                                                            let _e471 = code;
                                                            if (_e471 == 16i) {
                                                                let _e474 = (*s).metallic;
                                                                m = _e474;
                                                                let _e475 = m;
                                                                let _e477 = m;
                                                                if ((_e475 > 0.05f) && (_e477 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e480 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e480 > 0.5f)));
                                                                }
                                                                let _e484 = local_9;
                                                                shown = _e484;
                                                            } else {
                                                                let _e485 = code;
                                                                if (_e485 == 17i) {
                                                                    let _e487 = normal_mapped;
                                                                    if !(_e487) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e489 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e489));
                                                                    }
                                                                    let _e492 = local_10;
                                                                    shown = _e492;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e493 = g_premultiply;
    if _e493 {
        let _e495 = (*s).alpha;
        local_11 = _e495;
    } else {
        local_11 = 1f;
    }
    let _e496 = local_11;
    weight_2 = _e496;
    let _e497 = shown;
    param_12 = _e497;
    let _e498 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e499 = weight_2;
    let _e500 = (_e498 * _e499);
    let _e502 = (*s).alpha;
    frag_color = vec4<f32>(_e500.x, _e500.y, _e500.z, _e502);
    let _e508 = (*s).roughness;
    param_13 = _e508;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_12: f32;

    let _e215 = frag_info.material2_[2u];
    local_12 = floor((_e215 * 0.5f));
    let _e218 = local_12;
    return _e218;
}

fn DirectOcclusion_u0028_struct_u002d_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_1: ptr<function, Surface>) -> f32 {
    var local_13: f32;
    var local_14: f32;

    let _e215 = OcclusionTarget_u0028_();
    if (_e215 > 1.5f) {
        local_13 = 1f;
    } else {
        let _e218 = (*s_1).occlusion;
        local_13 = _e218;
    }
    let _e219 = local_13;
    local_14 = _e219;
    let _e220 = local_14;
    return _e220;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var shininess: f32;
    var specular: f32;

    let _e217 = (*s_2).roughness;
    shininess = mix(256f, 4f, _e217);
    let _e220 = (*light).n_dot_h;
    let _e221 = shininess;
    let _e225 = frag_info.material[3u];
    specular = (pow(_e220, _e221) * _e225);
    let _e228 = (*s_2).albedo;
    let _e229 = specular;
    return (_e228 + vec3(_e229));
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e213 = (*i);
    if (_e213 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e215 = (*i);
    if (_e215 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e217 = (*i);
    if (_e217 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e219 = (*i);
    if (_e219 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e221 = (*i);
    if (_e221 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e223 = (*i);
    if (_e223 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e225 = (*i);
    if (_e225 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e218 = (*i_1);
    param_14 = _e218;
    let _e219 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e219;
    let _e221 = p[0u];
    let _e222 = (*ca);
    let _e225 = p[1u];
    let _e226 = (*sa);
    let _e230 = p[0u];
    let _e231 = (*sa);
    let _e234 = p[1u];
    let _e235 = (*ca);
    let _e239 = (*radius);
    return (vec2<f32>(((_e221 * _e222) - (_e225 * _e226)), ((_e230 * _e231) + (_e234 * _e235))) * _e239);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_15: vec2<f32>;
    var atlas: vec2<f32>;

    let _e221 = point_shadow.params[0u];
    inset = _e221;
    let _e222 = (*uv_1);
    let _e223 = (*offset);
    let _e225 = inset;
    let _e226 = inset;
    local_15 = clamp((_e222 + _e223), vec2(_e225), vec2((1f - _e226)));
    let _e231 = local_15;
    let _e232 = (*tile);
    atlas = ((_e231 + _e232) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e237 = point_shadow.params3_[0u];
    if (_e237 > 0.5f) {
        let _e240 = atlas[1u];
        atlas[1u] = (1f - _e240);
    }
    let _e243 = atlas;
    let _e244 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e243, 0f);
    let _e246 = atlas;
    let _e247 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e246, 0f);
    let _e250 = (*range);
    return (min(_e244.x, _e247.x) * _e250);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e222 = (*uv_2);
    param_15 = _e222;
    let _e223 = (*offset_1);
    param_16 = _e223;
    let _e224 = (*tile_1);
    param_17 = _e224;
    let _e225 = (*range_1);
    param_18 = _e225;
    let _e226 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e226;
    let _e227 = stored;
    let _e228 = (*range_1);
    if (_e227 >= (_e228 * 0.999f)) {
        return 1f;
    }
    let _e231 = (*receiver);
    let _e232 = stored;
    return select(1f, 0f, (_e231 > _e232));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e243 = point_shadow.params2_[1u];
    lightRadius = _e243;
    let _e246 = point_shadow.params2_[0u];
    minRadius = _e246;
    let _e249 = point_shadow.params2_[2u];
    maxRadius = _e249;
    let _e250 = lightRadius;
    if (_e250 <= 0f) {
        let _e252 = (*uv_3);
        param_19 = _e252;
        param_20 = vec2<f32>(0f, 0f);
        let _e253 = (*tile_2);
        param_21 = _e253;
        let _e254 = (*range_2);
        param_22 = _e254;
        let _e255 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e255;
        let _e256 = minRadius;
        return _e256;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e257 = i_2;
        if (_e257 < 8i) {
            let _e259 = i_2;
            param_23 = _e259;
            let _e260 = (*ca_1);
            param_24 = _e260;
            let _e261 = (*sa_1);
            param_25 = _e261;
            let _e262 = maxRadius;
            param_26 = _e262;
            let _e263 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e264 = (*uv_3);
            param_27 = _e264;
            param_28 = _e263;
            let _e265 = (*tile_2);
            param_29 = _e265;
            let _e266 = (*range_2);
            param_30 = _e266;
            let _e267 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e267;
            let _e268 = stored_1;
            let _e269 = (*range_2);
            if (_e268 >= (_e269 * 0.999f)) {
                continue;
            }
            let _e272 = stored_1;
            let _e273 = (*receiver_1);
            if (_e272 >= _e273) {
                continue;
            }
            let _e275 = stored_1;
            let _e276 = sum;
            sum = (_e276 + _e275);
            let _e278 = count;
            count = (_e278 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e280 = i_2;
            i_2 = (_e280 + 1i);
        }
    }
    let _e282 = count;
    if (_e282 < 0.5f) {
        return -1f;
    }
    let _e284 = sum;
    let _e285 = count;
    blocker = max((_e284 / _e285), 0.0001f);
    let _e288 = blocker;
    (*blockerOut) = _e288;
    let _e289 = lightRadius;
    let _e290 = (*receiver_1);
    let _e291 = blocker;
    let _e295 = blocker;
    world = ((_e289 * max((_e290 - _e291), 0f)) / _e295);
    let _e297 = world;
    let _e298 = (*receiver_1);
    let _e300 = (*tanHalf);
    let _e303 = minRadius;
    let _e304 = maxRadius;
    return clamp((_e297 / ((2f * _e298) * _e300)), _e303, _e304);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_16: vec2<f32>;

    let _e214 = (*rows);
    if (_e214 > 0f) {
        let _e217 = gl_FragCoord_1[0u];
        let _e218 = (*rows);
        let _e220 = gl_FragCoord_1[1u];
        local_16 = vec2<f32>(_e217, (_e218 - _e220));
    } else {
        let _e223 = gl_FragCoord_1;
        local_16 = _e223.xy;
    }
    let _e225 = local_16;
    return _e225;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_17: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2255_: bool;
    var phi_2316_: bool;

    let _e266 = (*lightIndex);
    let _e270 = point_shadow.slots[_e266][0u];
    slot = i32((_e270 + 0.5f));
    let _e273 = (*lightIndex);
    let _e277 = point_shadow.slots[_e273][0u];
    if (_e277 < 0f) {
        return 1f;
    }
    let _e281 = point_shadow.params[2u];
    strength = _e281;
    let _e282 = strength;
    if (_e282 <= 0f) {
        return 1f;
    }
    let _e284 = slot;
    let _e287 = point_shadow.lights[_e284];
    let _e289 = (*world_1);
    toLight = (_e287.xyz - _e289);
    let _e291 = toLight;
    toLightLength = max(length(_e291), 0.000001f);
    let _e294 = (*normal);
    let _e295 = toLight;
    let _e296 = toLightLength;
    nDotL = max(dot(_e294, (_e295 / vec3(_e296))), 0.15f);
    let _e301 = nDotL;
    let _e302 = nDotL;
    let _e307 = nDotL;
    let _e308 = nDotL;
    slope = min((sqrt(max((1f - (_e301 * _e302)), 0f)) / (_e307 * _e308)), 8f);
    let _e312 = toLightLength;
    let _e314 = (*lightIndex);
    let _e318 = point_shadow.slots[_e314][2u];
    let _e323 = point_shadow.params3_[1u];
    texel = (((2f * _e312) * max(_e318, 0.0001f)) * _e323);
    let _e325 = (*world_1);
    let _e326 = (*normal);
    let _e327 = texel;
    let _e331 = point_shadow.params[3u];
    let _e333 = slope;
    origin = (_e325 + (((_e326 * _e327) * _e331) * (1f + _e333)));
    let _e337 = origin;
    let _e338 = slot;
    let _e341 = point_shadow.lights[_e338];
    toFragment = (_e337 - _e341.xyz);
    let _e344 = toFragment;
    distance_ = length(_e344);
    let _e346 = slot;
    let _e350 = point_shadow.lights[_e346][3u];
    range_3 = max(_e350, 0.0001f);
    let _e352 = distance_;
    let _e353 = range_3;
    if (_e352 >= _e353) {
        return 1f;
    }
    face = 0i;
    let _e355 = (*lightIndex);
    let _e359 = point_shadow.slots[_e355][1u];
    if (_e359 < 0.5f) {
        let _e361 = toFragment;
        a = abs(_e361);
        let _e364 = a[0u];
        let _e366 = a[1u];
        let _e367 = (_e364 >= _e366);
        phi_2255_ = _e367;
        if _e367 {
            let _e369 = a[0u];
            let _e371 = a[2u];
            phi_2255_ = (_e369 >= _e371);
        }
        let _e374 = phi_2255_;
        if _e374 {
            let _e376 = toFragment[0u];
            face = select(1i, 0i, (_e376 > 0f));
        } else {
            let _e380 = a[1u];
            let _e382 = a[2u];
            if (_e380 >= _e382) {
                let _e385 = toFragment[1u];
                face = select(3i, 2i, (_e385 > 0f));
            } else {
                let _e389 = toFragment[2u];
                face = select(5i, 4i, (_e389 > 0f));
            }
        }
    }
    let _e392 = slot;
    let _e394 = face;
    let _e398 = point_shadow.faces[((_e392 * 6i) + _e394)];
    let _e399 = origin;
    clip = (_e398 * vec4<f32>(_e399.x, _e399.y, _e399.z, 1f));
    let _e406 = clip[3u];
    if (_e406 <= 0f) {
        return 1f;
    }
    let _e408 = clip;
    let _e411 = clip[3u];
    ndc = (_e408.xy / vec2(_e411));
    let _e415 = ndc[0u];
    let _e417 = (abs(_e415) > 1f);
    phi_2316_ = _e417;
    if !(_e417) {
        let _e420 = ndc[1u];
        phi_2316_ = (abs(_e420) > 1f);
    }
    let _e424 = phi_2316_;
    if _e424 {
        return 1f;
    }
    let _e426 = ndc[0u];
    let _e430 = ndc[1u];
    uv_4 = vec2<f32>(((_e426 * 0.5f) + 0.5f), (0.5f - (_e430 * 0.5f)));
    let _e434 = face;
    let _e436 = slot;
    tile_3 = vec2<f32>(f32(_e434), f32(_e436));
    let _e439 = distance_;
    let _e442 = point_shadow.params[1u];
    receiver_2 = (_e439 - _e442);
    let _e446 = frag_info.target_origin[0u];
    param_31 = _e446;
    let _e447 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e447, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e452 = noise;
    angle = (_e452 * 6.2831855f);
    let _e454 = angle;
    ca_2 = cos(_e454);
    let _e456 = angle;
    sa_2 = sin(_e456);
    let _e458 = (*lightIndex);
    let _e462 = point_shadow.slots[_e458][2u];
    tanHalf_1 = max(_e462, 0.0001f);
    blocker_1 = -1f;
    let _e464 = uv_4;
    param_32 = _e464;
    let _e465 = tile_3;
    param_33 = _e465;
    let _e466 = range_3;
    param_34 = _e466;
    let _e467 = receiver_2;
    param_35 = _e467;
    let _e468 = ca_2;
    param_36 = _e468;
    let _e469 = sa_2;
    param_37 = _e469;
    let _e470 = tanHalf_1;
    param_38 = _e470;
    let _e471 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e472 = param_39;
    blocker_1 = _e472;
    radius_1 = _e471;
    let _e475 = point_shadow.params2_[3u];
    if (_e475 > 0.5f) {
        g_debug_surface_on = true;
        let _e477 = radius_1;
        if (_e477 < 0f) {
            local_17 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e479 = radius_1;
            let _e482 = point_shadow.params2_[2u];
            let _e486 = blocker_1;
            let _e487 = range_3;
            local_17 = vec3<f32>(clamp((_e479 / max(_e482, 0.000001f)), 0f, 1f), clamp((_e486 / _e487), 0f, 1f), 0f);
        }
        let _e491 = local_17;
        g_debug_surface = _e491;
    }
    let _e492 = radius_1;
    if (_e492 < 0f) {
        return 1f;
    }
    let _e494 = uv_4;
    param_40 = _e494;
    param_41 = vec2<f32>(0f, 0f);
    let _e495 = tile_3;
    param_42 = _e495;
    let _e496 = range_3;
    param_43 = _e496;
    let _e497 = receiver_2;
    param_44 = _e497;
    let _e498 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e498;
    let _e499 = radius_1;
    if (_e499 > 0f) {
        i_3 = 0i;
        loop {
            let _e501 = i_3;
            if (_e501 < 8i) {
                let _e503 = i_3;
                param_45 = _e503;
                let _e504 = ca_2;
                param_46 = _e504;
                let _e505 = sa_2;
                param_47 = _e505;
                let _e506 = radius_1;
                param_48 = _e506;
                let _e507 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e508 = uv_4;
                param_49 = _e508;
                param_50 = _e507;
                let _e509 = tile_3;
                param_51 = _e509;
                let _e510 = range_3;
                param_52 = _e510;
                let _e511 = receiver_2;
                param_53 = _e511;
                let _e512 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e513 = lit_1;
                lit_1 = (_e513 + _e512);
                continue;
            } else {
                break;
            }
            continuing {
                let _e515 = i_3;
                i_3 = (_e515 + 1i);
            }
        }
        let _e517 = lit_1;
        lit_1 = (_e517 * 0.11111111f);
    }
    let _e519 = lit_1;
    let _e520 = strength;
    return mix(1f, _e519, clamp(_e520, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e217 = (*i_4);
    let _e220 = (*n_1);
    r = sqrt(((f32(_e217) + 0.5f) / f32(_e220)));
    let _e224 = (*i_4);
    let _e227 = (*turn);
    theta = ((f32(_e224) * 2.3999631f) + _e227);
    let _e229 = r;
    let _e230 = theta;
    let _e232 = theta;
    return (vec2<f32>(cos(_e230), sin(_e232)) * _e229);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e216 = frag_info.target_origin[0u];
    param_54 = _e216;
    let _e217 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e220 = frag_info.target_origin[3u];
    at = (_e217 + vec2((5.588238f * max(_e220, 0f))));
    let _e225 = at;
    return fract((52.982918f * fract(dot(_e225, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_18: f32;

    let _e215 = (*mode_1);
    if (_e215 > 0.5f) {
        let _e217 = (*stored_2);
        local_18 = (1f - _e217);
    } else {
        let _e219 = (*stored_2);
        local_18 = _e219;
    }
    let _e220 = local_18;
    return _e220;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e221 = (*moments)[1u];
    let _e223 = (*moments)[0u];
    let _e225 = (*moments)[0u];
    let _e228 = (*minVariance);
    variance = max((_e221 - (_e223 * _e225)), _e228);
    let _e230 = (*t);
    let _e232 = (*moments)[0u];
    d_1 = (_e230 - _e232);
    let _e234 = variance;
    let _e235 = variance;
    let _e236 = d_1;
    let _e237 = d_1;
    pMax = (_e234 / (_e235 + (_e236 * _e237)));
    let _e241 = pMax;
    let _e242 = (*bleed);
    let _e244 = (*bleed);
    reduced = clamp(((_e241 - _e242) / max((1f - _e244), 0.0001f)), 0f, 1f);
    let _e249 = (*t);
    let _e251 = (*moments)[0u];
    let _e253 = reduced;
    return select(_e253, 1f, (_e249 <= _e251));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e214 = (*depth);
    d_2 = ((2f * clamp(_e214, 0f, 1f)) - 1f);
    let _e218 = d_2;
    let _e221 = d_2;
    return vec2<f32>(exp((40f * _e218)), -(exp((-5f * _e221))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e228 = (*depth_1);
    param_55 = _e228;
    let _e229 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e229;
    let _e230 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e230);
    let _e233 = scale[0u];
    let _e235 = scale[0u];
    let _e237 = (*moments_1);
    param_56 = _e237.xy;
    let _e240 = warped[0u];
    param_57 = _e240;
    param_58 = (_e233 * _e235);
    let _e241 = (*bleed_1);
    param_59 = _e241;
    let _e242 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e242;
    let _e244 = scale[1u];
    let _e246 = scale[1u];
    let _e248 = (*moments_1);
    param_60 = _e248.zw;
    let _e251 = warped[1u];
    param_61 = _e251;
    param_62 = (_e244 * _e246);
    let _e252 = (*bleed_1);
    param_63 = _e252;
    let _e253 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e253;
    let _e254 = positive;
    let _e255 = negative;
    return min(_e254, _e255);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e214 = (*depth_2);
    stored_3 = max((1f - _e214), 0.000061035156f);
    let _e217 = stored_3;
    return exp2((floor(log2(_e217)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_19: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_20: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_22: f32;
    var local_23: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3909_: bool;
    var phi_3920_: bool;
    var phi_4077_: bool;
    var phi_4084_: bool;
    var phi_4091_: bool;

    let _e293 = frag_info.shadow_params[3u];
    strength_1 = _e293;
    let _e294 = strength_1;
    if (_e294 <= 0f) {
        return 1f;
    }
    let _e296 = (*lightIndex_1);
    let _e299 = frag_info.frame_params[2u];
    if (_e296 != i32(floor((_e299 + 0.5f)))) {
        return 1f;
    }
    let _e306 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e306 + 0.5f));
    let _e309 = Orthographic_u0028_();
    if _e309 {
        let _e310 = ViewDepth_u0028_();
        local_19 = _e310;
    } else {
        let _e311 = v_world_position_1;
        let _e313 = frag_info.camera_position;
        local_19 = length((_e311 - _e313.xyz));
    }
    let _e317 = local_19;
    viewDistance = _e317;
    cascade = 0i;
    let _e318 = cascadeCount;
    let _e319 = (_e318 > 1i);
    phi_3909_ = _e319;
    if _e319 {
        let _e320 = viewDistance;
        let _e323 = frag_info.shadow_cascades[0u];
        phi_3909_ = (_e320 > _e323);
    }
    let _e326 = phi_3909_;
    if _e326 {
        cascade = 1i;
    }
    let _e327 = cascadeCount;
    let _e328 = (_e327 > 2i);
    phi_3920_ = _e328;
    if _e328 {
        let _e329 = viewDistance;
        let _e332 = frag_info.shadow_cascades[1u];
        phi_3920_ = (_e329 > _e332);
    }
    let _e335 = phi_3920_;
    if _e335 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e336 = attempt;
        if (_e336 < 3i) {
            let _e338 = cascade;
            let _e339 = attempt;
            which = (_e338 + _e339);
            let _e341 = which;
            let _e342 = cascadeCount;
            if (_e341 >= _e342) {
                break;
            }
            let _e344 = which;
            if (_e344 == 0i) {
                let _e347 = frag_info.shadow_matrix;
                local_20 = _e347;
            } else {
                let _e348 = which;
                if (_e348 == 1i) {
                    let _e351 = frag_info.shadow_matrix_far;
                    local_21 = _e351;
                } else {
                    let _e353 = frag_info.shadow_matrix_farthest;
                    local_21 = _e353;
                }
                let _e354 = local_21;
                local_20 = _e354;
            }
            let _e355 = local_20;
            matrix = _e355;
            let _e358 = matrix[0][0u];
            let _e361 = matrix[1][0u];
            let _e364 = matrix[2][0u];
            axisX = vec3<f32>(_e358, _e361, _e364);
            let _e368 = matrix[0][1u];
            let _e371 = matrix[1][1u];
            let _e374 = matrix[2][1u];
            axisY = vec3<f32>(_e368, _e371, _e374);
            let _e376 = axisX;
            rowX = max(length(_e376), 0.000001f);
            let _e379 = axisY;
            rowY = max(length(_e379), 0.000001f);
            let _e384 = frag_info.shadow_cascades[3u];
            let _e386 = rowX;
            texelMetres = ((2f * _e384) / _e386);
            let _e390 = frag_info.shadow_cascades[3u];
            let _e393 = (*s_3).n;
            let _e394 = axisX;
            let _e397 = rowX;
            let _e398 = rowX;
            let _e402 = (*s_3).n;
            let _e403 = axisY;
            let _e406 = rowY;
            let _e407 = rowY;
            reach = ((3f * _e390) * ((abs(dot(_e393, _e394)) / (_e397 * _e398)) + (abs(dot(_e402, _e403)) / (_e406 * _e407))));
            let _e414 = frag_info.shadow_params[2u];
            let _e415 = texelMetres;
            flatOffset = min(_e414, _e415);
            let _e417 = v_world_position_1;
            let _e419 = (*s_3).n;
            let _e420 = flatOffset;
            let _e421 = reach;
            origin_1 = (_e417 + (_e419 * (_e420 + _e421)));
            let _e425 = matrix;
            let _e426 = origin_1;
            lightSpace = (_e425 * vec4<f32>(_e426.x, _e426.y, _e426.z, 1f));
            let _e433 = lightSpace[3u];
            if (_e433 <= 0f) {
                continue;
            }
            let _e435 = lightSpace;
            let _e438 = lightSpace[3u];
            candidate = (_e435.xyz / vec3(_e438));
            let _e442 = candidate[0u];
            let _e446 = candidate[1u];
            inTile = vec2<f32>(((_e442 * 0.5f) + 0.5f), (0.5f - (_e446 * 0.5f)));
            let _e451 = inTile[0u];
            let _e452 = (_e451 < 0f);
            phi_4077_ = _e452;
            if !(_e452) {
                let _e455 = inTile[0u];
                phi_4077_ = (_e455 > 1f);
            }
            let _e458 = phi_4077_;
            phi_4084_ = _e458;
            if !(_e458) {
                let _e461 = inTile[1u];
                phi_4084_ = (_e461 < 0f);
            }
            let _e464 = phi_4084_;
            phi_4091_ = _e464;
            if !(_e464) {
                let _e467 = inTile[1u];
                phi_4091_ = (_e467 > 1f);
            }
            let _e470 = phi_4091_;
            if _e470 {
                continue;
            }
            let _e472 = candidate[2u];
            if (_e472 > 1f) {
                let _e474 = which;
                let _e475 = cascadeCount;
                if (_e474 < (_e475 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e480 = inTile[0u];
            let _e481 = which;
            let _e484 = cascadeCount;
            let _e488 = inTile[1u];
            uv_5 = vec2<f32>(((_e480 + f32(_e481)) / f32(_e484)), _e488);
            let _e490 = candidate;
            projected = _e490;
            let _e491 = which;
            cascade = _e491;
            let _e492 = texelMetres;
            cascadeTexel = _e492;
            let _e495 = matrix[0][2u];
            let _e498 = matrix[1][2u];
            let _e501 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e495, _e498, _e501)), 0.000001f));
            let _e507 = (*s_3).n;
            let _e510 = matrix[0][2u];
            let _e513 = matrix[1][2u];
            let _e516 = matrix[2][2u];
            let _e520 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e507, vec3<f32>(_e510, _e513, _e516))) * _e520), 0.1f, 1f);
            let _e523 = texelMetres;
            let _e524 = cosSlope;
            let _e525 = cosSlope;
            let _e531 = cosSlope;
            let _e533 = cascadeDepth;
            receiverSlope = (((_e523 * sqrt(max((1f - (_e524 * _e525)), 0f))) / _e531) / _e533);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e535 = attempt;
            attempt = (_e535 + 1i);
        }
    }
    let _e537 = found;
    if !(_e537) {
        return 1f;
    }
    let _e539 = cascade;
    if (_e539 == 0i) {
        let _e543 = frag_info.shadow_bias[0u];
        local_22 = _e543;
    } else {
        let _e544 = cascade;
        if (_e544 == 1i) {
            let _e548 = frag_info.shadow_bias[1u];
            local_23 = _e548;
        } else {
            let _e551 = frag_info.shadow_bias[2u];
            local_23 = _e551;
        }
        let _e552 = local_23;
        local_22 = _e552;
    }
    let _e553 = local_22;
    bias = _e553;
    let _e556 = frag_info.shadow_params[1u];
    storage_ = _e556;
    let _e557 = storage_;
    let _e559 = storage_;
    if ((_e557 > 0.5f) && (_e559 < 1.5f)) {
        let _e562 = bias;
        let _e564 = projected[2u];
        param_64 = _e564;
        let _e565 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e562, _e565);
    }
    let _e569 = frag_info.shadow_params[0u];
    let _e572 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e569, _e572);
    let _e574 = cascade;
    let _e576 = cascadeCount;
    let _e580 = texel_1;
    tileLo = (vec2<f32>((f32(_e574) / f32(_e576)), 0f) + (_e580 * 0.5f));
    let _e583 = cascade;
    let _e586 = cascadeCount;
    let _e590 = texel_1;
    tileHi = (vec2<f32>((f32((_e583 + 1i)) / f32(_e586)), 1f) - (_e590 * 0.5f));
    let _e595 = frag_info.shadow_bias[3u];
    if (_e595 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e597 = y;
            if (_e597 <= 1i) {
                x = -1i;
                loop {
                    let _e599 = x;
                    if (_e599 <= 1i) {
                        let _e601 = uv_5;
                        let _e602 = x;
                        let _e604 = y;
                        let _e607 = texel_1;
                        let _e610 = tileLo;
                        let _e611 = tileHi;
                        let _e613 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e601 + (vec2<f32>(f32(_e602), f32(_e604)) * _e607)), _e610, _e611), 0f);
                        let _e614 = stored_4;
                        stored_4 = (_e614 + _e613);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e616 = x;
                        x = (_e616 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e618 = y;
                y = (_e618 + 1i);
            }
        }
        let _e620 = stored_4;
        stored_4 = (_e620 * 0.11111111f);
        let _e623 = stored_4[1u];
        let _e626 = stored_4[2u];
        let _e629 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e623), (1f - _e626), _e629), vec3(0f), vec3(4f));
        let _e634 = through;
        let _e635 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e634, vec3(clamp(_e635, 0f, 1f)));
    }
    let _e641 = frag_info.ambient_ground[3u];
    softness = _e641;
    lit_2 = 0f;
    let _e642 = softness;
    if (_e642 < 0f) {
        let _e644 = uv_5;
        let _e645 = tileLo;
        let _e646 = tileHi;
        let _e648 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e644, _e645, _e646), 0f);
        moments_2 = _e648;
        let _e650 = projected[2u];
        let _e651 = bias;
        let _e653 = softness;
        let _e657 = moments_2;
        param_65 = _e657;
        param_66 = (_e650 - _e651);
        param_67 = clamp((-(_e653) - 1f), 0f, 0.95f);
        let _e658 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e658;
    } else {
        let _e659 = softness;
        if (_e659 <= 0f) {
            y_1 = -1i;
            loop {
                let _e661 = y_1;
                if (_e661 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e663 = x_1;
                        if (_e663 <= 1i) {
                            let _e665 = uv_5;
                            let _e666 = x_1;
                            let _e668 = y_1;
                            let _e671 = texel_1;
                            let _e674 = tileLo;
                            let _e675 = tileHi;
                            let _e677 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e665 + (vec2<f32>(f32(_e666), f32(_e668)) * _e671)), _e674, _e675), 0f);
                            param_68 = _e677.x;
                            let _e679 = storage_;
                            param_69 = _e679;
                            let _e680 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e680;
                            let _e682 = projected[2u];
                            let _e683 = bias;
                            let _e685 = occluder;
                            let _e688 = lit_2;
                            lit_2 = (_e688 + select(1f, 0f, ((_e682 - _e683) > _e685)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e690 = x_1;
                            x_1 = (_e690 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e692 = y_1;
                    y_1 = (_e692 + 1i);
                }
            }
            let _e694 = lit_2;
            lit_2 = (_e694 * 0.11111111f);
        } else {
            let _e696 = softness;
            spread = tan(min(_e696, 0.5f));
            let _e699 = ShadowNoise_u0028_();
            turn_1 = (_e699 * 6.2831855f);
            let _e701 = spread;
            let _e703 = projected[2u];
            let _e705 = cascadeDepth;
            let _e707 = cascadeTexel;
            searchRadius = clamp((((_e701 * _e703) * _e705) / _e707), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e710 = i_5;
                if (_e710 < 16i) {
                    let _e712 = i_5;
                    param_70 = _e712;
                    param_71 = 16i;
                    let _e713 = turn_1;
                    param_72 = _e713;
                    let _e714 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e714;
                    let _e715 = bias;
                    let _e716 = disc;
                    let _e718 = searchRadius;
                    let _e722 = receiverSlope;
                    tapBias = (_e715 + (max(((length(_e716) * _e718) - 1.5f), 0f) * _e722));
                    let _e725 = uv_5;
                    let _e726 = disc;
                    let _e727 = texel_1;
                    let _e729 = searchRadius;
                    let _e732 = tileLo;
                    let _e733 = tileHi;
                    let _e735 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e725 + ((_e726 * _e727) * _e729)), _e732, _e733), 0f);
                    param_73 = _e735.x;
                    let _e737 = storage_;
                    param_74 = _e737;
                    let _e738 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e738;
                    let _e740 = projected[2u];
                    let _e741 = tapBias;
                    let _e743 = occluder_1;
                    if ((_e740 - _e741) > _e743) {
                        let _e745 = occluder_1;
                        let _e746 = blockerSum;
                        blockerSum = (_e746 + _e745);
                        let _e748 = blockerCount;
                        blockerCount = (_e748 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e750 = i_5;
                    i_5 = (_e750 + 1i);
                }
            }
            let _e752 = blockerCount;
            if (_e752 <= 0f) {
                return 1f;
            }
            let _e755 = projected[2u];
            let _e756 = blockerSum;
            let _e757 = blockerCount;
            let _e761 = cascadeDepth;
            gap = (max((_e755 - (_e756 / _e757)), 0f) * _e761);
            let _e763 = spread;
            let _e764 = gap;
            let _e766 = cascadeTexel;
            radius_2 = clamp(((_e763 * _e764) / _e766), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e769 = i_6;
                if (_e769 < 16i) {
                    let _e771 = turn_1;
                    let _e773 = i_6;
                    param_75 = _e773;
                    param_76 = 16i;
                    param_77 = (_e771 + 1f);
                    let _e774 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e774;
                    let _e775 = bias;
                    let _e776 = disc_1;
                    let _e778 = radius_2;
                    let _e782 = receiverSlope;
                    tapBias_1 = (_e775 + (max(((length(_e776) * _e778) - 1.5f), 0f) * _e782));
                    let _e785 = uv_5;
                    let _e786 = disc_1;
                    let _e787 = texel_1;
                    let _e789 = radius_2;
                    let _e792 = tileLo;
                    let _e793 = tileHi;
                    let _e795 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e785 + ((_e786 * _e787) * _e789)), _e792, _e793), 0f);
                    param_78 = _e795.x;
                    let _e797 = storage_;
                    param_79 = _e797;
                    let _e798 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e798;
                    let _e800 = projected[2u];
                    let _e801 = tapBias_1;
                    let _e803 = occluder_2;
                    let _e806 = lit_2;
                    lit_2 = (_e806 + select(1f, 0f, ((_e800 - _e801) > _e803)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e808 = i_6;
                    i_6 = (_e808 + 1i);
                }
            }
            let _e810 = lit_2;
            lit_2 = (_e810 * 0.0625f);
        }
    }
    let _e812 = lit_2;
    let _e813 = strength_1;
    return mix(1f, _e812, clamp(_e813, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e218 = (*s_4);
    param_80 = _e218;
    let _e219 = (*light_2);
    param_81 = _e219;
    let _e220 = (*index);
    param_82 = _e220;
    let _e221 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e221;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e213 = (*index_1);
    return (_e213 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e217 = (*distance_1);
    let _e218 = (*distance_1);
    attenuation = (1f / max((_e217 * _e218), 0.0001f));
    let _e222 = (*range_4);
    if (_e222 > 0f) {
        let _e224 = (*distance_1);
        let _e225 = (*range_4);
        ratio = (_e224 / _e225);
        let _e227 = ratio;
        let _e228 = ratio;
        let _e230 = ratio;
        let _e232 = ratio;
        window = clamp((1f - (((_e227 * _e228) * _e230) * _e232)), 0f, 1f);
        let _e236 = window;
        let _e237 = window;
        let _e239 = attenuation;
        attenuation = (_e239 * (_e236 * _e237));
    }
    let _e241 = attenuation;
    return _e241;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_24: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e229 = (*halfWidth);
    let _e230 = (*halfHeight);
    n_2 = cross(_e229, _e230);
    let _e232 = n_2;
    nLen = length(_e232);
    let _e234 = nLen;
    if (_e234 < 0.000000000001f) {
        let _e236 = (*centre);
        return _e236;
    }
    let _e237 = nLen;
    let _e238 = n_2;
    n_2 = (_e238 / vec3(_e237));
    let _e241 = (*centre);
    let _e242 = (*world_2);
    toPlane = (_e241 - _e242);
    let _e244 = (*mirror);
    let _e245 = n_2;
    denom = dot(_e244, _e245);
    let _e247 = denom;
    if (abs(_e247) < 0.00001f) {
        let _e250 = toPlane;
        let _e251 = n_2;
        let _e252 = toPlane;
        let _e253 = n_2;
        onPlane = (_e250 - (_e251 * dot(_e252, _e253)));
    } else {
        let _e257 = toPlane;
        let _e258 = n_2;
        let _e260 = denom;
        t_1 = (dot(_e257, _e258) / _e260);
        let _e262 = t_1;
        if (_e262 > 0f) {
            let _e264 = (*mirror);
            let _e265 = t_1;
            local_24 = (_e264 * _e265);
        } else {
            let _e267 = toPlane;
            let _e268 = n_2;
            let _e269 = toPlane;
            let _e270 = n_2;
            local_24 = (_e267 - (_e268 * dot(_e269, _e270)));
        }
        let _e274 = local_24;
        onPlane = _e274;
    }
    let _e275 = onPlane;
    let _e276 = toPlane;
    offset_2 = (_e275 - _e276);
    let _e278 = (*halfWidth);
    let _e279 = (*halfWidth);
    wLen2_ = max(dot(_e278, _e279), 0.000000000001f);
    let _e282 = (*halfHeight);
    let _e283 = (*halfHeight);
    hLen2_ = max(dot(_e282, _e283), 0.000000000001f);
    let _e286 = offset_2;
    let _e287 = (*halfWidth);
    let _e289 = wLen2_;
    u = clamp((dot(_e286, _e287) / _e289), -1f, 1f);
    let _e292 = offset_2;
    let _e293 = (*halfHeight);
    let _e295 = hLen2_;
    v = clamp((dot(_e292, _e293) / _e295), -1f, 1f);
    let _e298 = (*centre);
    let _e299 = (*halfWidth);
    let _e300 = u;
    let _e303 = (*halfHeight);
    let _e304 = v;
    return ((_e298 + (_e299 * _e300)) + (_e303 * _e304));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_25: f32;

    let _e221 = (*a_1);
    let _e222 = (*a_1);
    ua = (_e221 / vec3(max(length(_e222), 0.000000000001f)));
    let _e227 = (*b);
    let _e228 = (*b);
    ub = (_e227 / vec3(max(length(_e228), 0.000000000001f)));
    let _e233 = ua;
    let _e234 = ub;
    angle_1 = acos(clamp(dot(_e233, _e234), -1f, 1f));
    let _e238 = ua;
    let _e239 = ub;
    axis = cross(_e238, _e239);
    let _e241 = axis;
    len = length(_e241);
    let _e243 = len;
    if (_e243 > 0.000001f) {
        let _e245 = angle_1;
        let _e246 = axis;
        let _e247 = (*n_3);
        let _e250 = len;
        local_25 = ((_e245 * dot(_e246, _e247)) / _e250);
    } else {
        local_25 = 0f;
    }
    let _e252 = local_25;
    return _e252;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_26: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_27: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_28: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e235 = i_7;
        if (_e235 < 4i) {
            let _e237 = i_7;
            let _e239 = (*corners)[_e237];
            a_2 = _e239;
            let _e240 = i_7;
            if (_e240 == 3i) {
                local_26 = 0i;
            } else {
                let _e242 = i_7;
                local_26 = (_e242 + 1i);
            }
            let _e244 = local_26;
            let _e246 = (*corners)[_e244];
            b_1 = _e246;
            let _e247 = a_2;
            let _e248 = (*n_4);
            ha = dot(_e247, _e248);
            let _e250 = b_1;
            let _e251 = (*n_4);
            hb = dot(_e250, _e251);
            let _e253 = ha;
            let _e254 = hb;
            d_3 = (_e253 - _e254);
            let _e256 = a_2;
            let _e257 = b_1;
            let _e258 = a_2;
            let _e260 = d_3;
            if (abs(_e260) > 0.000000000001f) {
                let _e263 = ha;
                let _e264 = d_3;
                local_27 = (_e263 / _e264);
            } else {
                local_27 = 0f;
            }
            let _e266 = local_27;
            q = (_e256 + ((_e257 - _e258) * _e266));
            let _e269 = ha;
            aAbove = (_e269 > 0f);
            let _e271 = hb;
            bAbove = (_e271 > 0f);
            let _e273 = aAbove;
            let _e274 = bAbove;
            if (_e273 || _e274) {
                let _e276 = aAbove;
                let _e277 = a_2;
                let _e278 = q;
                let _e281 = bAbove;
                let _e282 = b_1;
                let _e283 = q;
                param_83 = select(_e278, _e277, vec3(_e276));
                param_84 = select(_e283, _e282, vec3(_e281));
                let _e286 = (*n_4);
                param_85 = _e286;
                let _e287 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_28 = _e287;
            } else {
                local_28 = 0f;
            }
            let _e288 = local_28;
            let _e289 = total;
            total = (_e289 + _e288);
            let _e291 = aAbove;
            let _e292 = bAbove;
            let _e295 = q;
            let _e296 = exit;
            exit = select(_e296, _e295, vec3((_e291 && !(_e292))));
            let _e299 = aAbove;
            let _e301 = bAbove;
            let _e303 = q;
            let _e304 = entry;
            entry = select(_e304, _e303, vec3((!(_e299) && _e301)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e307 = i_7;
            i_7 = (_e307 + 1i);
        }
    }
    let _e309 = exit;
    param_86 = _e309;
    let _e310 = entry;
    param_87 = _e310;
    let _e311 = (*n_4);
    param_88 = _e311;
    let _e312 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e313 = total;
    total = (_e313 + _e312);
    let _e315 = total;
    return max((-(_e315) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_29: f32;
    var local_30: f32;
    var local_31: f32;

    let _e218 = (*slot_1);
    let _e219 = (*slot_1);
    lane = (_e218 - ((_e219 / 4i) * 4i));
    let _e223 = lane;
    if (_e223 == 0i) {
        let _e226 = (*four)[0u];
        local_29 = _e226;
    } else {
        let _e227 = lane;
        if (_e227 == 1i) {
            let _e230 = (*four)[1u];
            local_30 = _e230;
        } else {
            let _e231 = lane;
            if (_e231 == 2i) {
                let _e234 = (*four)[2u];
                local_31 = _e234;
            } else {
                let _e236 = (*four)[3u];
                local_31 = _e236;
            }
            let _e237 = local_31;
            local_30 = _e237;
        }
        let _e238 = local_30;
        local_29 = _e238;
    }
    let _e239 = local_29;
    return _e239;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e215 = (*slot_2);
    let _e219 = light_list_info.scales[(_e215 / 4i)];
    param_89 = _e219;
    let _e220 = (*slot_2);
    param_90 = _e220;
    let _e221 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e221;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e217 = light_list_info.slot_rows[0i];
    let _e218 = (*row);
    a_3 = abs((_e217 - vec4(_e218)));
    let _e224 = light_list_info.slot_rows[1i];
    let _e225 = (*row);
    b_2 = abs((_e224 - vec4(_e225)));
    let _e230 = a_3[0u];
    let _e232 = a_3[1u];
    let _e235 = a_3[2u];
    let _e237 = a_3[3u];
    let _e241 = b_2[0u];
    let _e243 = b_2[1u];
    let _e246 = b_2[2u];
    let _e248 = b_2[3u];
    return (min(min(min(_e230, _e232), min(_e235, _e237)), min(min(_e241, _e243), min(_e246, _e248))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e215 = (*slot_3);
    let _e219 = light_list_info.indices[(_e215 / 4i)];
    param_91 = _e219;
    let _e220 = (*slot_3);
    param_92 = _e220;
    let _e221 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e221;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e214 = (*texel_2);
    let _e218 = light_list_info.list[1u];
    let _e220 = (*row_1);
    let _e224 = light_list_info.list[2u];
    let _e227 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e214 + 0.5f) * _e218), ((_e220 + 0.5f) * _e224)), 0f);
    return _e227;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e222 = g_cluster_offset;
    let _e223 = (*slot_4);
    entry_1 = (_e222 + f32(_e223));
    let _e226 = entry_1;
    row_2 = floor((_e226 / 16f));
    let _e229 = entry_1;
    let _e230 = row_2;
    within_1 = (_e229 - (_e230 * 16f));
    let _e233 = within_1;
    texel_3 = floor((_e233 / 4f));
    let _e238 = light_list_info.cluster_depth[3u];
    let _e239 = row_2;
    let _e241 = texel_3;
    param_93 = _e241;
    param_94 = (_e238 + _e239);
    let _e242 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e242;
    let _e243 = within_1;
    let _e244 = texel_3;
    let _e249 = four_1;
    param_95 = _e249;
    param_96 = i32(((_e243 - (_e244 * 4f)) + 0.5f));
    let _e250 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e250;
}

fn Clustered_u0028_() -> bool {
    let _e214 = light_list_info.cluster_grid[3u];
    return (_e214 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_32: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_33: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_34: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_35: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_36: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e266 = (*index_2);
    if (_e266 < 8i) {
        let _e268 = (*index_2);
        let _e271 = frag_info.light_position[_e268];
        position = _e271;
        let _e272 = (*index_2);
        let _e275 = frag_info.light_color[_e272];
        color_1 = _e275;
        let _e276 = (*index_2);
        let _e279 = frag_info.light_direction[_e276];
        direction = _e279;
        let _e280 = (*index_2);
        let _e283 = frag_info.light_cone[_e280];
        cone = _e283;
    } else {
        let _e284 = (*index_2);
        slot_5 = (_e284 - 8i);
        let _e286 = Clustered_u0028_();
        clustered = _e286;
        let _e287 = clustered;
        if _e287 {
            let _e288 = slot_5;
            param_97 = _e288;
            let _e289 = ClusterRow_u0028_i1_u003b((&param_97));
            local_32 = _e289;
        } else {
            let _e290 = slot_5;
            param_98 = _e290;
            let _e291 = LightListRow_u0028_i1_u003b((&param_98));
            local_32 = _e291;
        }
        let _e292 = local_32;
        listRow = _e292;
        let _e293 = listRow;
        let _e297 = light_list_info.list[2u];
        v_1 = ((_e293 + 0.5f) * _e297);
        let _e301 = light_list_info.list[1u];
        u_1 = _e301;
        let _e302 = u_1;
        let _e304 = v_1;
        let _e306 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e302), _e304), 0f);
        position = _e306;
        let _e307 = u_1;
        let _e309 = v_1;
        let _e311 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e307), _e309), 0f);
        color_1 = _e311;
        let _e312 = u_1;
        let _e314 = v_1;
        let _e316 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e312), _e314), 0f);
        direction = _e316;
        let _e317 = u_1;
        let _e319 = v_1;
        let _e321 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e317), _e319), 0f);
        cone = _e321;
        let _e322 = clustered;
        if _e322 {
            let _e323 = listRow;
            param_99 = _e323;
            let _e324 = InSlots_u0028_f1_u003b((&param_99));
            local_33 = select(1f, 0f, _e324);
        } else {
            let _e326 = slot_5;
            param_100 = _e326;
            let _e327 = LightListScale_u0028_i1_u003b((&param_100));
            local_33 = _e327;
        }
        let _e328 = local_33;
        let _e330 = color_1[3u];
        color_1[3u] = (_e330 * _e328);
    }
    let _e334 = position[3u];
    type_39 = _e334;
    let _e335 = type_39;
    if (_e335 > 15.5f) {
        let _e338 = (*s_5).n;
        light_3.l = _e338;
        let _e341 = (*s_5).n;
        light_3.h = _e341;
        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 _e347 = light_3;
        return _e347;
    }
    let _e348 = type_39;
    if (_e348 > 2.5f) {
        let _e350 = direction;
        halfWidth_1 = _e350.xyz;
        let _e352 = cone;
        halfHeight_1 = _e352.xyz;
        let _e354 = position;
        let _e356 = v_world_position_1;
        toCentre = (_e354.xyz - _e356);
        let _e358 = toCentre;
        let _e359 = halfWidth_1;
        let _e361 = halfHeight_1;
        corners_1[0i] = ((_e358 - _e359) - _e361);
        let _e364 = toCentre;
        let _e365 = halfWidth_1;
        let _e367 = halfHeight_1;
        corners_1[1i] = ((_e364 + _e365) - _e367);
        let _e370 = toCentre;
        let _e371 = halfWidth_1;
        let _e373 = halfHeight_1;
        corners_1[2i] = ((_e370 + _e371) + _e373);
        let _e376 = toCentre;
        let _e377 = halfWidth_1;
        let _e379 = halfHeight_1;
        corners_1[3i] = ((_e376 - _e377) + _e379);
        let _e382 = toCentre;
        let _e383 = halfWidth_1;
        let _e384 = halfHeight_1;
        behind = (dot(_e382, cross(_e383, _e384)) >= 0f);
        let _e388 = behind;
        if _e388 {
            local_34 = 0f;
        } else {
            let _e389 = corners_1;
            param_101 = _e389;
            let _e391 = (*s_5).n;
            param_102 = _e391;
            let _e392 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_34 = _e392;
        }
        let _e393 = local_34;
        formFactor = _e393;
        let _e394 = halfWidth_1;
        let _e395 = halfHeight_1;
        area = (length(cross(_e394, _e395)) * 4f);
        let _e399 = area;
        if (_e399 > 0.000000001f) {
            let _e401 = area;
            local_35 = (1f / _e401);
        } else {
            local_35 = 0f;
        }
        let _e403 = local_35;
        radiance = _e403;
        let _e404 = toCentre;
        distance_2 = length(_e404);
        let _e407 = direction[3u];
        if (_e407 > 0f) {
            let _e409 = distance_2;
            let _e411 = direction[3u];
            ratio_1 = (_e409 / _e411);
            let _e413 = ratio_1;
            let _e414 = ratio_1;
            let _e416 = ratio_1;
            let _e418 = ratio_1;
            window_1 = clamp((1f - (((_e413 * _e414) * _e416) * _e418)), 0f, 1f);
            let _e422 = window_1;
            let _e423 = window_1;
            let _e425 = radiance;
            radiance = (_e425 * (_e422 * _e423));
        }
        let _e428 = (*s_5).v;
        let _e431 = (*s_5).n;
        mirror_1 = reflect(-(_e428), _e431);
        let _e433 = position;
        param_103 = _e433.xyz;
        let _e435 = halfWidth_1;
        param_104 = _e435;
        let _e436 = halfHeight_1;
        param_105 = _e436;
        let _e437 = v_world_position_1;
        param_106 = _e437;
        let _e438 = mirror_1;
        param_107 = _e438;
        let _e439 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e439;
        let _e440 = representative;
        let _e441 = v_world_position_1;
        toPoint = (_e440 - _e441);
        let _e443 = toPoint;
        pointDistance = length(_e443);
        let _e445 = pointDistance;
        if (_e445 > 0.000001f) {
            let _e447 = toPoint;
            let _e448 = pointDistance;
            local_36 = (_e447 / vec3(_e448));
        } else {
            let _e452 = (*s_5).n;
            local_36 = _e452;
        }
        let _e453 = local_36;
        light_3.l = _e453;
        let _e456 = light_3.l;
        let _e458 = (*s_5).v;
        light_3.h = normalize((_e456 + _e458));
        let _e462 = formFactor;
        light_3.n_dot_l = _e462;
        let _e465 = (*s_5).n;
        let _e467 = light_3.h;
        light_3.n_dot_h = max(dot(_e465, _e467), 0f);
        let _e472 = (*s_5).v;
        let _e474 = light_3.h;
        light_3.v_dot_h = max(dot(_e472, _e474), 0f);
        let _e478 = color_1;
        let _e481 = color_1[3u];
        let _e483 = radiance;
        light_3.radiance = ((_e478.xyz * _e481) * _e483);
        let _e486 = light_3;
        return _e486;
    }
    let _e487 = direction;
    aim = normalize(_e487.xyz);
    attenuation_1 = 1f;
    let _e490 = type_39;
    if (_e490 < 0.5f) {
        let _e492 = aim;
        light_3.l = -(_e492);
    } else {
        let _e495 = position;
        let _e497 = v_world_position_1;
        toLight_1 = (_e495.xyz - _e497);
        let _e499 = toLight_1;
        distance_3 = length(_e499);
        let _e501 = distance_3;
        if (_e501 < 0.000001f) {
            let _e504 = (*s_5).n;
            light_3.l = _e504;
            let _e507 = (*s_5).n;
            light_3.h = _e507;
            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 _e513 = light_3;
            return _e513;
        }
        let _e514 = toLight_1;
        let _e515 = distance_3;
        light_3.l = (_e514 / vec3(_e515));
        let _e519 = distance_3;
        param_108 = _e519;
        let _e521 = direction[3u];
        param_109 = _e521;
        let _e522 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e522;
        let _e523 = type_39;
        if (_e523 > 1.5f) {
            let _e525 = aim;
            let _e527 = light_3.l;
            cosAngle = dot(_e525, -(_e527));
            let _e530 = cosAngle;
            let _e532 = cone[1u];
            let _e535 = cone[0u];
            let _e537 = cone[1u];
            ramp = clamp(((_e530 - _e532) / (_e535 - _e537)), 0f, 1f);
            let _e541 = ramp;
            let _e542 = ramp;
            let _e544 = attenuation_1;
            attenuation_1 = (_e544 * (_e541 * _e542));
        }
    }
    let _e547 = light_3.l;
    let _e549 = (*s_5).v;
    light_3.h = normalize((_e547 + _e549));
    let _e554 = (*s_5).n;
    let _e556 = light_3.l;
    light_3.n_dot_l = max(dot(_e554, _e556), 0f);
    let _e561 = (*s_5).n;
    let _e563 = light_3.h;
    light_3.n_dot_h = max(dot(_e561, _e563), 0f);
    let _e568 = (*s_5).v;
    let _e570 = light_3.h;
    light_3.v_dot_h = max(dot(_e568, _e570), 0f);
    let _e574 = color_1;
    let _e577 = color_1[3u];
    let _e579 = attenuation_1;
    light_3.radiance = ((_e574.xyz * _e577) * _e579);
    let _e582 = light_3;
    return _e582;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_37: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e227 = light_list_info.cluster_view_projection;
    let _e228 = (*world_3);
    clip_1 = (_e227 * vec4<f32>(_e228.x, _e228.y, _e228.z, 1f));
    let _e234 = clip_1;
    let _e237 = clip_1[3u];
    ndc_1 = (_e234.xy / vec2(max(_e237, 0.000001f)));
    let _e242 = light_list_info.cluster_grid;
    grid = _e242.xyz;
    let _e246 = light_list_info.cluster_depth[0u];
    near_1 = _e246;
    let _e248 = ndc_1[0u];
    let _e252 = grid[0u];
    let _e256 = grid[0u];
    tx = clamp(floor((((_e248 * 0.5f) + 0.5f) * _e252)), 0f, (_e256 - 1f));
    let _e260 = ndc_1[1u];
    let _e264 = grid[1u];
    let _e268 = grid[1u];
    ty = clamp(floor((((_e260 * 0.5f) + 0.5f) * _e264)), 0f, (_e268 - 1f));
    let _e272 = clip_1[3u];
    let _e273 = near_1;
    if (_e272 <= _e273) {
        local_37 = 0f;
    } else {
        let _e276 = clip_1[3u];
        let _e277 = near_1;
        let _e282 = light_list_info.cluster_depth[1u];
        let _e286 = grid[2u];
        local_37 = clamp(floor((log((_e276 / _e277)) * _e282)), 0f, (_e286 - 1f));
    }
    let _e289 = local_37;
    tz = _e289;
    let _e290 = tx;
    let _e291 = ty;
    let _e293 = grid[0u];
    let _e296 = tz;
    let _e298 = grid[0u];
    let _e301 = grid[1u];
    cell_1 = ((_e290 + (_e291 * _e293)) + ((_e296 * _e298) * _e301));
    let _e304 = cell_1;
    row_3 = floor((_e304 / 4f));
    let _e307 = cell_1;
    let _e308 = row_3;
    let _e313 = light_list_info.cluster_depth[2u];
    let _e314 = row_3;
    param_110 = (_e307 - (_e308 * 4f));
    param_111 = (_e313 + _e314);
    let _e316 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e316;
    let _e318 = header[0u];
    g_cluster_offset = _e318;
    let _e320 = header[1u];
    g_cluster_count = _e320;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e216 = light_list_info.list[0u];
    tail = _e216;
    let _e217 = Clustered_u0028_();
    if _e217 {
        let _e218 = v_world_position_1;
        param_112 = _e218;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e219 = g_cluster_count;
        tail = _e219;
    }
    let _e222 = frag_info.frame_params[1u];
    let _e226 = tail;
    return (clamp(i32((_e222 + 0.5f)), 0i, 8i) + clamp(i32((_e226 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_38: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e230 = LightCount_u0028_();
    count_1 = _e230;
    i_8 = 0i;
    loop {
        let _e231 = i_8;
        if (_e231 < 32i) {
            let _e233 = i_8;
            let _e234 = count_1;
            if (_e233 >= _e234) {
                break;
            }
            let _e236 = i_8;
            param_113 = _e236;
            let _e237 = (*s_6);
            param_114 = _e237;
            let _e238 = 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((&param_113), (&param_114));
            light_4 = _e238;
            let _e240 = light_4.n_dot_l;
            if (_e240 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e242 = i_8;
            param_115 = _e242;
            let _e243 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e243 {
                let _e244 = (*s_6);
                param_116 = _e244;
                let _e245 = light_4;
                param_117 = _e245;
                let _e246 = i_8;
                param_118 = _e246;
                let _e247 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e248 = v_world_position_1;
                param_119 = _e248;
                let _e250 = (*s_6).n;
                param_120 = _e250;
                let _e251 = i_8;
                param_121 = _e251;
                let _e252 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_38 = (_e247 * _e252);
            } else {
                local_38 = 1f;
            }
            let _e254 = local_38;
            visibility = _e254;
            let _e255 = visibility;
            if (_e255 <= 0f) {
                continue;
            }
            let _e257 = (*s_6);
            param_122 = _e257;
            let _e258 = light_4;
            param_123 = _e258;
            let _e259 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e261 = light_4.radiance;
            let _e264 = light_4.n_dot_l;
            let _e266 = visibility;
            let _e268 = light_transmittance;
            let _e270 = total_1;
            total_1 = (_e270 + ((((_e259 * _e261) * _e264) * _e266) * _e268));
            continue;
        } else {
            break;
        }
        continuing {
            let _e272 = i_8;
            i_8 = (_e272 + 1i);
        }
    }
    let _e274 = total_1;
    return _e274;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_39: f32;
    var local_40: f32;

    let _e216 = OcclusionTarget_u0028_();
    target_ = _e216;
    let _e217 = target_;
    let _e219 = target_;
    if ((_e217 > 0.5f) && (_e219 < 1.5f)) {
        local_39 = 1f;
    } else {
        let _e223 = (*s_7).occlusion;
        local_39 = _e223;
    }
    let _e224 = local_39;
    local_40 = _e224;
    let _e225 = local_40;
    return _e225;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e213 = v_lightmap_uv_1;
    let _e214 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e213);
    texel_4 = _e214;
    let _e215 = texel_4;
    let _e218 = texel_4[3u];
    return ((_e215.xyz * _e218) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e214 = frag_info.target_origin[1u];
    return _e214;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e214 = v_texcoord_1;
    let _e215 = MaterialLodBias_u0028_();
    let _e216 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e214, _e215);
    orm = _e216.xyz;
    let _e219 = (*s_8).metallic;
    let _e221 = orm[2u];
    (*s_8).metallic = clamp((_e219 * _e221), 0f, 1f);
    let _e226 = (*s_8).roughness;
    let _e228 = orm[1u];
    (*s_8).roughness = clamp((_e226 * _e228), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_124: vec3<f32>;

    let _e215 = v_texcoord_1;
    let _e216 = MaterialLodBias_u0028_();
    let _e217 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e215, _e216);
    param_124 = _e217.xyz;
    let _e219 = SrgbToLinear_u0028_vf3_u003b((&param_124));
    emissive = _e219;
    let _e220 = emissive;
    let _e222 = frag_info.emissive;
    let _e227 = frag_info.material2_[3u];
    (*s_9).emissive = ((_e220 * _e222.xyz) * _e227);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e215 = v_texcoord_1;
    let _e216 = MaterialLodBias_u0028_();
    let _e217 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e215, _e216);
    occlusion = _e217.x;
    let _e221 = frag_info.material2_[2u];
    let _e222 = OcclusionTarget_u0028_();
    strength_2 = (_e221 - (2f * _e222));
    let _e225 = occlusion;
    let _e226 = strength_2;
    (*s_10).occlusion = mix(1f, _e225, clamp(_e226, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e217 = v_texcoord_1;
    let _e218 = MaterialLodBias_u0028_();
    let _e219 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e217, _e218);
    sampledTexel = _e219;
    let _e220 = v_tangent_1;
    t_2 = _e220.xyz;
    let _e222 = t_2;
    let _e224 = (*s_11).n;
    let _e226 = (*s_11).n;
    let _e227 = t_2;
    t_2 = (_e222 - (_e224 * dot(_e226, _e227)));
    let _e231 = t_2;
    let _e232 = t_2;
    if (dot(_e231, _e232) < 0.000000000001f) {
        return;
    }
    let _e235 = t_2;
    t_2 = normalize(_e235);
    let _e238 = (*s_11).n;
    let _e239 = t_2;
    let _e242 = v_tangent_1[3u];
    b_3 = (cross(_e238, _e239) * _e242);
    let _e244 = gl_FrontFacing_1;
    if !(_e244) {
        let _e246 = t_2;
        t_2 = -(_e246);
    }
    let _e248 = sampledTexel;
    sampled = ((_e248.xyz * 2f) - vec3(1f));
    let _e255 = frag_info.emissive[3u];
    if (_e255 > 0.5f) {
        let _e257 = sampled;
        let _e259 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e257.xy, _e259.xy)), 0f));
    }
    let _e268 = frag_info.material2_[1u];
    let _e269 = sampled;
    let _e271 = (_e269.xy * _e268);
    sampled[0u] = _e271.x;
    sampled[1u] = _e271.y;
    let _e276 = t_2;
    let _e278 = sampled[0u];
    let _e280 = b_3;
    let _e282 = sampled[1u];
    let _e286 = (*s_11).n;
    let _e288 = sampled[2u];
    (*s_11).n = normalize((((_e276 * _e278) + (_e280 * _e282)) + (_e286 * _e288)));
    let _e294 = (*s_11).n;
    let _e296 = (*s_11).v;
    (*s_11).n_dot_v = max(dot(_e294, _e296), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e213 = (*texel_5);
    let _e217 = irradiance_info.atlas;
    let _e220 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e213 + vec2(0.5f)) * _e217.xy), 0f);
    return _e220;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_125: vec2<f32>;
    var b_4: vec4<f32>;
    var param_126: vec2<f32>;
    var c_1: vec4<f32>;
    var param_127: vec2<f32>;
    var d_4: vec4<f32>;
    var param_128: vec2<f32>;

    let _e226 = (*uv_6);
    let _e227 = (*interior);
    at_1 = ((vec2(1f) + (_e226 * _e227)) - vec2(0.5f));
    let _e233 = at_1;
    low = floor(_e233);
    let _e235 = at_1;
    let _e236 = low;
    f = (_e235 - _e236);
    let _e238 = (*corner);
    let _e239 = low;
    param_125 = (_e238 + _e239);
    let _e241 = AtlasTexel_u0028_vf2_u003b((&param_125));
    a_4 = _e241;
    let _e242 = (*corner);
    let _e243 = low;
    param_126 = ((_e242 + _e243) + vec2<f32>(1f, 0f));
    let _e246 = AtlasTexel_u0028_vf2_u003b((&param_126));
    b_4 = _e246;
    let _e247 = (*corner);
    let _e248 = low;
    param_127 = ((_e247 + _e248) + vec2<f32>(0f, 1f));
    let _e251 = AtlasTexel_u0028_vf2_u003b((&param_127));
    c_1 = _e251;
    let _e252 = (*corner);
    let _e253 = low;
    param_128 = ((_e252 + _e253) + vec2<f32>(1f, 1f));
    let _e256 = AtlasTexel_u0028_vf2_u003b((&param_128));
    d_4 = _e256;
    let _e257 = a_4;
    let _e258 = b_4;
    let _e260 = f[0u];
    let _e263 = c_1;
    let _e264 = d_4;
    let _e266 = f[0u];
    let _e270 = f[1u];
    return mix(mix(_e257, _e258, vec4(_e260)), mix(_e263, _e264, vec4(_e266)), vec4(_e270));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e217 = (*direction_1)[0u];
    let _e220 = (*direction_1)[1u];
    let _e224 = (*direction_1)[2u];
    sum_1 = ((abs(_e217) + abs(_e220)) + abs(_e224));
    let _e227 = sum_1;
    if (_e227 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e229 = (*direction_1);
    let _e230 = sum_1;
    n_5 = (_e229 / vec3(_e230));
    let _e233 = n_5;
    xy = _e233.xy;
    let _e236 = n_5[2u];
    if (_e236 < 0f) {
        let _e239 = n_5[1u];
        let _e243 = n_5[0u];
        let _e248 = n_5[0u];
        let _e252 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e239)) * select(-1f, 1f, (_e243 >= 0f))), ((1f - abs(_e248)) * select(-1f, 1f, (_e252 >= 0f))));
    }
    let _e257 = xy;
    return ((_e257 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_129: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_130: vec3<f32>;
    var param_131: vec2<f32>;
    var param_132: f32;
    var param_133: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_134: vec3<f32>;
    var param_135: vec2<f32>;
    var param_136: f32;
    var param_137: vec2<f32>;
    var local_41: vec3<f32>;

    let _e259 = irradiance_info.origin;
    origin_2 = _e259.xyz;
    let _e262 = irradiance_info.spacing;
    spacing = _e262.xyz;
    let _e265 = irradiance_info.counts;
    counts = _e265.xyz;
    let _e269 = irradiance_info.tiles[0u];
    irradianceTile = _e269;
    let _e272 = irradiance_info.tiles[1u];
    depthTile = _e272;
    let _e275 = irradiance_info.tiles[2u];
    columns = _e275;
    let _e278 = irradiance_info.tiles[3u];
    momentsTop = _e278;
    let _e279 = (*normal_1);
    unit = normalize(_e279);
    let _e281 = (*world_4);
    let _e282 = unit;
    let _e285 = irradiance_info.spacing[3u];
    let _e288 = (*view_1);
    let _e291 = irradiance_info.counts[3u];
    biased = ((_e281 + (_e282 * _e285)) + (_e288 * _e291));
    let _e294 = biased;
    let _e295 = origin_2;
    let _e297 = spacing;
    grid_1 = ((_e294 - _e295) / _e297);
    let _e299 = grid_1;
    let _e301 = counts;
    base = clamp(floor(_e299), vec3<f32>(0f, 0f, 0f), (_e301 - vec3(2f)));
    let _e305 = grid_1;
    let _e306 = base;
    f_1 = clamp((_e305 - _e306), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e309 = corner_1;
        if (_e309 < 8i) {
            let _e311 = corner_1;
            let _e314 = corner_1;
            let _e319 = corner_1;
            offset_3 = vec3<f32>(f32((_e311 & 1i)), f32(((_e314 >> bitcast<u32>(1i)) & 1i)), f32(((_e319 >> bitcast<u32>(2i)) & 1i)));
            let _e325 = base;
            let _e326 = offset_3;
            cell_2 = (_e325 + _e326);
            let _e329 = cell_2[2u];
            let _e331 = counts[1u];
            let _e334 = cell_2[1u];
            let _e337 = counts[0u];
            let _e340 = cell_2[0u];
            probe = ((((_e329 * _e331) + _e334) * _e337) + _e340);
            let _e342 = probe;
            let _e343 = columns;
            let _e348 = probe;
            let _e349 = columns;
            tile_4 = vec2<f32>((_e342 - (floor((_e342 / _e343)) * _e343)), floor((_e348 / _e349)));
            let _e353 = tile_4;
            let _e354 = irradianceTile;
            irradianceCorner = (_e353 * (_e354 + 2f));
            let _e358 = tile_4[0u];
            let _e359 = depthTile;
            let _e362 = momentsTop;
            let _e364 = tile_4[1u];
            let _e365 = depthTile;
            momentCorner = vec2<f32>((_e358 * (_e359 + 2f)), (_e362 + (_e364 * (_e365 + 2f))));
            let _e370 = irradianceCorner;
            param_129 = (_e370 + vec2(1f));
            let _e373 = AtlasTexel_u0028_vf2_u003b((&param_129));
            if (_e373.w < 0.5f) {
                continue;
            }
            let _e376 = f_1;
            let _e378 = f_1;
            let _e379 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e376), _e378, _e379);
            let _e382 = trilinear[0u];
            let _e384 = trilinear[1u];
            let _e387 = trilinear[2u];
            weight_3 = max(((_e382 * _e384) * _e387), 0.001f);
            let _e390 = origin_2;
            let _e391 = spacing;
            let _e392 = cell_2;
            probePosition = (_e390 + (_e391 * _e392));
            let _e395 = probePosition;
            let _e396 = biased;
            toProbe = (_e395 - _e396);
            let _e398 = toProbe;
            distance_4 = length(_e398);
            let _e400 = distance_4;
            if (_e400 > 0.000001f) {
                let _e402 = toProbe;
                let _e403 = distance_4;
                direction_2 = (_e402 / vec3(_e403));
                let _e406 = unit;
                let _e407 = probePosition;
                let _e408 = (*world_4);
                facing = ((dot(_e406, normalize((_e407 - _e408))) * 0.5f) + 0.5f);
                let _e414 = facing;
                let _e415 = facing;
                probeWeight = ((_e414 * _e415) + 0.2f);
                let _e418 = direction_2;
                param_130 = -(_e418);
                let _e420 = ProbeOctahedral_u0028_vf3_u003b((&param_130));
                let _e421 = momentCorner;
                param_131 = _e421;
                let _e422 = depthTile;
                param_132 = _e422;
                param_133 = _e420;
                let _e423 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_131), (&param_132), (&param_133));
                moments_3 = _e423.xy;
                chebyshev = 1f;
                let _e425 = distance_4;
                let _e427 = moments_3[0u];
                if (_e425 > _e427) {
                    let _e430 = moments_3[1u];
                    let _e432 = moments_3[0u];
                    let _e434 = moments_3[0u];
                    variance_1 = max((_e430 - (_e432 * _e434)), 0.000001f);
                    let _e438 = distance_4;
                    let _e440 = moments_3[0u];
                    difference = (_e438 - _e440);
                    let _e442 = variance_1;
                    let _e443 = variance_1;
                    let _e444 = difference;
                    let _e445 = difference;
                    chebyshev = (_e442 / (_e443 + (_e444 * _e445)));
                    let _e449 = chebyshev;
                    let _e450 = chebyshev;
                    let _e452 = chebyshev;
                    chebyshev = ((_e449 * _e450) * _e452);
                }
                let _e454 = probeWeight;
                let _e455 = chebyshev;
                probeWeight = max((_e454 * max(_e455, 0.05f)), 0.000001f);
                let _e459 = probeWeight;
                if (_e459 < 0.2f) {
                    let _e461 = probeWeight;
                    let _e462 = probeWeight;
                    let _e465 = probeWeight;
                    probeWeight = (_e465 * ((_e461 * _e462) * 25f));
                }
                let _e467 = probeWeight;
                let _e468 = weight_3;
                weight_3 = (_e468 * _e467);
            }
            let _e470 = unit;
            param_134 = _e470;
            let _e471 = ProbeOctahedral_u0028_vf3_u003b((&param_134));
            let _e472 = irradianceCorner;
            param_135 = _e472;
            let _e473 = irradianceTile;
            param_136 = _e473;
            param_137 = _e471;
            let _e474 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_135), (&param_136), (&param_137));
            let _e476 = weight_3;
            let _e478 = total_2;
            total_2 = (_e478 + (_e474.xyz * _e476));
            let _e480 = weight_3;
            let _e481 = weights;
            weights = (_e481 + _e480);
            continue;
        } else {
            break;
        }
        continuing {
            let _e483 = corner_1;
            corner_1 = (_e483 + 1i);
        }
    }
    let _e485 = weights;
    if (_e485 > 0f) {
        let _e487 = total_2;
        let _e488 = weights;
        local_41 = (_e487 / vec3(_e488));
    } else {
        local_41 = vec3<f32>(0f, 0f, 0f);
    }
    let _e491 = local_41;
    return _e491;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e214 = irradiance_info.origin[3u];
    return (_e214 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: Surface;

    let _e219 = IrradianceEnabled_u0028_();
    if _e219 {
        let _e220 = v_world_position_1;
        param_138 = _e220;
        let _e222 = (*s_12).n;
        param_139 = _e222;
        let _e224 = (*s_12).v;
        param_140 = _e224;
        let _e225 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_138), (&param_139), (&param_140));
        let _e228 = frag_info.material[2u];
        (*s_12).ambient = (_e225 * _e228);
    }
    let _e231 = (*s_12);
    param_141 = _e231;
    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((&param_141));
    let _e232 = param_141;
    (*s_12) = _e232;
    let _e233 = (*s_12);
    param_142 = _e233;
    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((&param_142));
    let _e234 = param_142;
    (*s_12) = _e234;
    let _e235 = (*s_12);
    param_143 = _e235;
    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((&param_143));
    let _e236 = param_143;
    (*s_12) = _e236;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_42: vec3<f32>;

    let _e213 = Orthographic_u0028_();
    if _e213 {
        let _e215 = fog_info.forward;
        local_42 = -(_e215.xyz);
    } else {
        let _e219 = fog_info.eye;
        let _e221 = v_world_position_1;
        local_42 = normalize((_e219.xyz - _e221));
    }
    let _e224 = local_42;
    return _e224;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_13: Surface;
    var param_144: vec3<f32>;
    var param_145: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e218 = v_texcoord_1;
    let _e219 = MaterialLodBias_u0028_();
    let _e220 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e218, _e219);
    texel_6 = _e220;
    let _e221 = texel_6;
    param_144 = _e221.xyz;
    let _e223 = SrgbToLinear_u0028_vf3_u003b((&param_144));
    let _e225 = frag_info.base_color;
    param_145 = _e225.xyz;
    let _e227 = SrgbToLinear_u0028_vf3_u003b((&param_145));
    let _e229 = v_color_1;
    s_13.albedo = ((_e223 * _e227) * _e229.xyz);
    let _e234 = texel_6[3u];
    let _e237 = frag_info.base_color[3u];
    let _e240 = v_color_1[3u];
    s_13.alpha = ((_e234 * _e237) * _e240);
    let _e244 = s_13.albedo;
    g_albedo = _e244;
    let _e247 = frag_info.material2_[0u];
    cutoff = _e247;
    let _e248 = cutoff;
    if (_e248 > 1f) {
        let _e250 = cutoff;
        edge = (_e250 - 1f);
        let _e253 = s_13.alpha;
        let _e254 = edge;
        let _e257 = s_13.alpha;
        let _e258 = fwidth(_e257);
        s_13.alpha = clamp((((_e253 - _e254) / max(_e258, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e264 = cutoff;
        if (_e264 >= 0f) {
            s_13.alpha = 1f;
        }
    }
    let _e267 = cutoff;
    let _e269 = cutoff;
    g_premultiply = ((_e267 < 0f) && (_e269 > -0.75f));
    let _e272 = v_normal_1;
    s_13.n = normalize(_e272);
    let _e275 = gl_FrontFacing_1;
    if !(_e275) {
        let _e278 = s_13.n;
        s_13.n = -(_e278);
    }
    let _e281 = TowardsEye_u0028_();
    s_13.v = _e281;
    let _e284 = s_13.n;
    let _e286 = s_13.v;
    s_13.n_dot_v = max(dot(_e284, _e286), 0.0001f);
    let _e292 = frag_info.material[0u];
    s_13.metallic = clamp(_e292, 0f, 1f);
    let _e297 = frag_info.material[1u];
    s_13.roughness = clamp(_e297, 0.02f, 1f);
    let _e301 = frag_info.ambient_ground;
    let _e304 = frag_info.ambient_sky;
    let _e308 = s_13.n[1u];
    let _e315 = frag_info.material[2u];
    s_13.ambient = (mix(_e301.xyz, _e304.xyz, vec3(((_e308 * 0.5f) + 0.5f))) * _e315);
    let _e320 = frag_info.frame_params[0u];
    s_13.exposure = max(_e320, 0f);
    s_13.occlusion = 1f;
    s_13.emissive = vec3<f32>(0f, 0f, 0f);
    let _e325 = s_13;
    return _e325;
}

fn main_1() {
    var s_14: Surface;
    var param_146: Surface;
    var param_147: Surface;
    var ambient: vec3<f32>;
    var param_148: Surface;
    var lit_3: vec3<f32>;
    var param_149: Surface;
    var param_150: Surface;
    var param_151: Surface;
    var param_152: vec3<f32>;
    var param_153: vec3<f32>;
    var param_154: f32;
    var param_155: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e225 = ReadSurface_u0028_();
    s_14 = _e225;
    let _e226 = s_14;
    param_146 = _e226;
    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((&param_146));
    let _e227 = param_146;
    s_14 = _e227;
    let _e228 = s_14;
    param_147 = _e228;
    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((&param_147));
    let _e229 = param_147;
    s_14 = _e229;
    let _e231 = s_14.albedo;
    let _e233 = s_14.ambient;
    let _e234 = SampleLightmap_u0028_();
    let _e237 = s_14;
    param_148 = _e237;
    let _e238 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_148));
    ambient = ((_e231 * (_e233 + _e234)) * _e238);
    let _e240 = s_14;
    param_149 = _e240;
    let _e241 = 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((&param_149));
    let _e242 = s_14;
    param_150 = _e242;
    let _e243 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_150));
    let _e245 = ambient;
    let _e248 = s_14.emissive;
    lit_3 = (((_e241 * _e243) + _e245) + _e248);
    let _e250 = s_14;
    param_151 = _e250;
    let _e251 = lit_3;
    param_152 = _e251;
    let _e252 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_151), (&param_152));
    if _e252 {
        return;
    }
    let _e253 = lit_3;
    param_153 = _e253;
    let _e255 = s_14.alpha;
    param_154 = _e255;
    let _e257 = s_14.roughness;
    param_155 = _e257;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_153), (&param_154), (&param_155));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrOpaqueDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(13)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(17)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var ltc_texture_smp: sampler;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(27)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(28)
var point_shadow_texture_smp: sampler;
@group(1) @binding(25)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(11)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var irradiance_texture_smp: sampler;
@group(1) @binding(15)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(19)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(23)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(21)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var normal_texture_smp: sampler;
@group(1) @binding(29)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(30)
var shadow_texture_smp: sampler;
@group(1) @binding(9)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(10)
var environment_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e231 = v_world_position_1;
    let _e233 = fog_info.eye;
    let _e237 = fog_info.forward;
    return dot((_e231 - _e233.xyz), _e237.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e236 = ViewDepth_u0028_();
    z = abs(_e236);
    let _e238 = z;
    near = (_e238 / 5f);
    let _e240 = z;
    far = (_e240 / 200f);
    let _e242 = far;
    let _e243 = far;
    let _e245 = far;
    far3_ = ((_e242 * _e243) * _e245);
    let _e247 = (*alpha);
    let _e248 = near;
    let _e249 = near;
    let _e252 = far3_;
    let _e253 = far3_;
    return (_e247 * clamp((10f / ((0.00001f + (_e248 * _e249)) + (_e252 * _e253))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e240 = fog_info.forward[3u];
    mode = _e240;
    let _e241 = mode;
    if (_e241 > 0.5f) {
        let _e244 = frag_color[3u];
        alpha_1 = _e244;
        let _e245 = alpha_1;
        param = _e245;
        let _e246 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e246;
        let _e247 = frag_color;
        let _e249 = weight;
        let _e250 = (_e247.xyz * _e249);
        let _e251 = alpha_1;
        let _e252 = weight;
        accumulate = vec4<f32>(_e250.x, _e250.y, _e250.z, (_e251 * _e252));
        let _e258 = mode;
        let _e260 = mode;
        revealage = ((_e258 > 1.5f) && (_e260 < 2.5f));
        let _e263 = revealage;
        if _e263 {
            let _e264 = alpha_1;
            local = vec4(_e264);
        } else {
            let _e266 = accumulate;
            local = _e266;
        }
        let _e267 = local;
        frag_color = _e267;
        let _e268 = mode;
        if (_e268 > 2.5f) {
            let _e270 = alpha_1;
            frag_surface = vec4(_e270);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e234 = (*n)[0u];
    let _e237 = (*n)[1u];
    let _e241 = (*n)[2u];
    let _e244 = (*n);
    (*n) = (_e244 / vec3(((abs(_e234) + abs(_e237)) + abs(_e241))));
    let _e247 = (*n);
    e = _e247.xy;
    let _e250 = (*n)[2u];
    if (_e250 < 0f) {
        let _e252 = (*n);
        let _e258 = (*n)[0u];
        let _e262 = (*n)[1u];
        e = ((vec2(1f) - abs(_e252.yx)) * vec2<f32>(select(-1f, 1f, (_e258 >= 0f)), select(-1f, 1f, (_e262 >= 0f))));
    }
    let _e267 = e;
    return ((_e267 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e232 = (*linear);
    let _e234 = (*linear);
    let _e238 = (*linear);
    return mix((_e232 * 12.92f), ((pow(_e234, 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), _e238));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e235 = g_albedo;
    param_1 = clamp(_e235, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e237 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e237.x, _e237.y, _e237.z, 1f);
    let _e242 = g_debug_surface_on;
    if _e242 {
        let _e243 = g_debug_surface;
        let _e244 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e243.x, _e243.y, _e243.z, _e244);
        return;
    }
    let _e249 = v_normal_1;
    geometric = normalize(_e249);
    let _e251 = gl_FrontFacing_1;
    if !(_e251) {
        let _e253 = geometric;
        geometric = -(_e253);
    }
    let _e255 = geometric;
    param_2 = _e255;
    let _e256 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e257 = (*roughness);
    let _e259 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e256.x, _e256.y, clamp(_e257, 0f, 1f), _e259);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e233 = fog_info.projection[0u];
    return (_e233 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e232 = Orthographic_u0028_();
    if _e232 {
        let _e233 = ViewDepth_u0028_();
        local_1 = max(_e233, 0f);
    } else {
        let _e235 = v_world_position_1;
        let _e237 = fog_info.eye;
        local_1 = distance(_e235, _e237.xyz);
    }
    let _e240 = local_1;
    return _e240;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e239 = fog_info.fog[3u];
    density = _e239;
    let _e240 = density;
    if (_e240 <= 0f) {
        let _e242 = (*color);
        return _e242;
    }
    let _e243 = EyeDistance_u0028_();
    d = _e243;
    let _e246 = fog_info.eye[3u];
    falloff = _e246;
    let _e247 = falloff;
    if (_e247 > 0f) {
        let _e249 = falloff;
        let _e251 = v_world_position_1[1u];
        let _e254 = fog_info.eye[1u];
        k = (_e249 * (_e251 - _e254));
        let _e257 = k;
        if (abs(_e257) > 0.001f) {
            let _e260 = k;
            let _e264 = k;
            local_2 = ((1f - exp(-(_e260))) / _e264);
        } else {
            let _e266 = k;
            local_2 = (1f - (0.5f * _e266));
        }
        let _e269 = local_2;
        let _e270 = density;
        density = (_e270 * _e269);
    }
    let _e273 = fog_info.fog;
    let _e275 = (*color);
    let _e276 = density;
    let _e278 = d;
    return mix(_e273.xyz, _e275, vec3(clamp(exp((-(_e276) * _e278)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e237 = g_premultiply;
    let _e238 = (*alpha_2);
    weight_1 = select(1f, _e238, _e237);
    let _e240 = (*linearColor);
    param_3 = _e240;
    let _e241 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e242 = weight_1;
    let _e243 = (_e241 * _e242);
    let _e244 = (*alpha_2);
    let _e245 = g_pass_through;
    frag_color = vec4<f32>(_e243.x, _e243.y, _e243.z, (_e244 * (1f - _e245)));
    let _e252 = (*roughness_1);
    param_4 = _e252;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e232 = (*srgb);
    let _e235 = (*srgb);
    let _e240 = (*srgb);
    return mix((_e232 / vec3(12.92f)), pow(((_e235 + 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), _e240));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e234 = (*key);
    hue = fract(((_e234 * 0.618034f) + 0.13f));
    let _e238 = hue;
    k_1 = clamp((abs(((fract((vec3(_e238) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e251 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e251, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2907_: bool;

    let _e232 = (*c);
    let _e233 = (*c);
    let _e235 = any((_e232 != _e233));
    phi_2907_ = _e235;
    if !(_e235) {
        let _e237 = (*c);
        phi_2907_ = any((abs(_e237) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e242 = phi_2907_;
    return _e242;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2997_: bool;
    var phi_3265_: bool;

    let _e274 = gl_FragCoord_1[0u];
    let _e277 = frag_info.debug_view[1u];
    if (_e274 < _e277) {
        let _e281 = frag_info.debug_view[2u];
        local_3 = _e281;
    } else {
        let _e284 = frag_info.debug_view[0u];
        local_3 = _e284;
    }
    let _e285 = local_3;
    view = _e285;
    let _e286 = view;
    if (_e286 < 0.5f) {
        return false;
    }
    let _e288 = view;
    code = i32((_e288 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e291 = v_normal_1;
    geometric_n = normalize(_e291);
    let _e293 = v_tangent_1;
    let _e295 = geometric_n;
    let _e296 = geometric_n;
    let _e297 = v_tangent_1;
    tangent = (_e293.xyz - (_e295 * dot(_e296, _e297.xyz)));
    let _e302 = tangent;
    let _e303 = tangent;
    let _e305 = (dot(_e302, _e303) > 0.000000000001f);
    phi_2997_ = _e305;
    if _e305 {
        let _e307 = v_tangent_1[3u];
        phi_2997_ = (abs((abs(_e307) - 1f)) < 0.01f);
    }
    let _e313 = phi_2997_;
    tangent_usable = _e313;
    let _e316 = frag_info.debug_view[3u];
    identity = _e316;
    let _e317 = identity;
    identity_object = floor((_e317 / 8192f));
    let _e320 = identity;
    let _e321 = identity_object;
    identity_rest = (_e320 - (_e321 * 8192f));
    let _e324 = identity_rest;
    identity_material = floor((_e324 / 2f));
    let _e327 = identity_rest;
    let _e328 = identity_material;
    normal_mapped = ((_e327 - (_e328 * 2f)) > 0.5f);
    let _e332 = code;
    if (_e332 == 1i) {
        let _e335 = (*s).albedo;
        param_5 = clamp(_e335, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e337 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e337;
    } else {
        let _e338 = code;
        if (_e338 == 2i) {
            let _e341 = (*s).n;
            shown = ((_e341 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e344 = code;
            if (_e344 == 3i) {
                let _e347 = (*s).roughness;
                shown = vec3(clamp(_e347, 0f, 1f));
            } else {
                let _e350 = code;
                if (_e350 == 4i) {
                    let _e353 = (*s).metallic;
                    shown = vec3(clamp(_e353, 0f, 1f));
                } else {
                    let _e356 = code;
                    if (_e356 == 5i) {
                        let _e359 = (*s).occlusion;
                        shown = vec3(clamp(_e359, 0f, 1f));
                    } else {
                        let _e362 = code;
                        if (_e362 == 6i) {
                            let _e365 = (*s).emissive;
                            param_6 = clamp(_e365, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e367 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e367;
                        } else {
                            let _e368 = code;
                            if (_e368 == 7i) {
                                let _e370 = v_texcoord_1;
                                let _e371 = fract(_e370);
                                shown = vec3<f32>(_e371.x, _e371.y, 0f);
                            } else {
                                let _e375 = code;
                                if (_e375 == 8i) {
                                    let _e377 = (*lit);
                                    param_7 = clamp(_e377, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e379 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e379, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e381 = (*lit);
                                    param_8 = _e381;
                                    let _e382 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e382 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e383 = grey;
                                        local_4 = vec3((_e383 * 0.5f));
                                    }
                                    let _e386 = local_4;
                                    shown = _e386;
                                } else {
                                    let _e387 = code;
                                    if (_e387 == 9i) {
                                        let _e389 = tangent_usable;
                                        if _e389 {
                                            let _e390 = tangent;
                                            local_5 = ((normalize(_e390) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e394 = local_5;
                                        shown = _e394;
                                    } else {
                                        let _e395 = code;
                                        if (_e395 == 10i) {
                                            let _e397 = v_texcoord_1;
                                            uv = _e397;
                                            let _e398 = uv;
                                            cell = floor((_e398 * 8f));
                                            let _e402 = cell[0u];
                                            let _e404 = cell[1u];
                                            odd = (fract(((_e402 + _e404) * 0.5f)) * 2f);
                                            let _e409 = uv;
                                            within = fract(_e409);
                                            let _e411 = odd;
                                            let _e415 = within[0u];
                                            let _e419 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e411)) * vec3<f32>((0.55f + (0.45f * _e415)), (0.55f + (0.45f * _e419)), 0.85f));
                                        } else {
                                            let _e424 = code;
                                            if (_e424 == 11i) {
                                                let _e426 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e426));
                                            } else {
                                                let _e429 = code;
                                                if (_e429 == 12i) {
                                                    let _e431 = v_color_1;
                                                    param_9 = clamp(_e431.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e434 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e434;
                                                } else {
                                                    let _e435 = code;
                                                    let _e437 = code;
                                                    if ((_e435 == 13i) || (_e437 == 14i)) {
                                                        let _e440 = code;
                                                        let _e442 = identity_object;
                                                        let _e443 = identity_material;
                                                        key_1 = select(_e443, _e442, (_e440 == 13i));
                                                        let _e445 = key_1;
                                                        param_10 = _e445;
                                                        let _e446 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e448 = (*s).n_dot_v;
                                                        shown = (_e446 * (0.55f + (0.45f * _e448)));
                                                    } else {
                                                        let _e452 = code;
                                                        if (_e452 == 15i) {
                                                            let _e455 = (*s).albedo;
                                                            param_11 = clamp(_e455, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e457 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e457;
                                                            let _e458 = srgb_1;
                                                            luma = dot(_e458, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e461 = (*s).metallic;
                                                            metal = (_e461 > 0.5f);
                                                            let _e463 = metal;
                                                            let _e465 = luma;
                                                            if (!(_e463) && (_e465 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e468 = metal;
                                                                let _e469 = !(_e468);
                                                                phi_3265_ = _e469;
                                                                if _e469 {
                                                                    let _e471 = srgb_1[0u];
                                                                    let _e473 = srgb_1[1u];
                                                                    let _e475 = srgb_1[2u];
                                                                    phi_3265_ = (max(_e471, max(_e473, _e475)) > 0.9411765f);
                                                                }
                                                                let _e480 = phi_3265_;
                                                                if _e480 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e481 = metal;
                                                                    let _e482 = luma;
                                                                    if (_e481 && (_e482 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e485 = luma;
                                                                        local_8 = vec3(_e485);
                                                                    }
                                                                    let _e487 = local_8;
                                                                    local_7 = _e487;
                                                                }
                                                                let _e488 = local_7;
                                                                local_6 = _e488;
                                                            }
                                                            let _e489 = local_6;
                                                            shown = _e489;
                                                        } else {
                                                            let _e490 = code;
                                                            if (_e490 == 16i) {
                                                                let _e493 = (*s).metallic;
                                                                m = _e493;
                                                                let _e494 = m;
                                                                let _e496 = m;
                                                                if ((_e494 > 0.05f) && (_e496 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e499 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e499 > 0.5f)));
                                                                }
                                                                let _e503 = local_9;
                                                                shown = _e503;
                                                            } else {
                                                                let _e504 = code;
                                                                if (_e504 == 17i) {
                                                                    let _e506 = normal_mapped;
                                                                    if !(_e506) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e508 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e508));
                                                                    }
                                                                    let _e511 = local_10;
                                                                    shown = _e511;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e512 = g_premultiply;
    if _e512 {
        let _e514 = (*s).alpha;
        local_11 = _e514;
    } else {
        local_11 = 1f;
    }
    let _e515 = local_11;
    weight_2 = _e515;
    let _e516 = shown;
    param_12 = _e516;
    let _e517 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e518 = weight_2;
    let _e519 = (_e517 * _e518);
    let _e521 = (*s).alpha;
    frag_color = vec4<f32>(_e519.x, _e519.y, _e519.z, _e521);
    let _e527 = (*s).roughness;
    param_13 = _e527;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m_1: f32;
    var g: f32;

    let _e235 = (*mu);
    m_1 = (1f - _e235);
    let _e237 = m_1;
    let _e238 = m_1;
    let _e239 = m_1;
    let _e240 = m_1;
    g = (_e237 * (0.05710853f + (_e238 * (0.49188188f + (_e239 * (-0.33218145f + (_e240 * 0.071443f)))))));
    let _e248 = (*r);
    let _e249 = g;
    let _e252 = (*r);
    return ((1f + (_e248 * _e249)) / (1f + (0.2877934f * _e252)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e233 = (*rho);
    let _e234 = (*rho);
    let _e236 = (*average);
    let _e238 = (*rho);
    let _e239 = (*average);
    return (((_e233 * _e234) * _e236) / (vec3<f32>(1f, 1f, 1f) - (_e238 * (1f - _e239))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e232 = (*r_1);
    let _e235 = (*r_1);
    return ((1f + (0.07248821f * _e232)) / (1f + (0.2877934f * _e235)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s_1: f32;
    var s_over_t: f32;
    var local_12: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_14: f32;
    var multi: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: f32;
    var param_17: f32;
    var param_18: f32;
    var param_19: f32;
    var param_20: f32;

    let _e250 = (*l_dot_v);
    let _e251 = (*mu_i);
    let _e252 = (*mu_o);
    s_1 = (_e250 - (_e251 * _e252));
    let _e255 = s_1;
    if (_e255 > 0f) {
        let _e257 = s_1;
        let _e258 = (*mu_i);
        let _e259 = (*mu_o);
        local_12 = (_e257 / max(_e258, _e259));
    } else {
        let _e262 = s_1;
        local_12 = _e262;
    }
    let _e263 = local_12;
    s_over_t = _e263;
    let _e264 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e264)));
    let _e268 = (*rho_1);
    let _e269 = af;
    let _e270 = (*r_2);
    let _e271 = s_over_t;
    single = (_e268 * (_e269 * (1f + (_e270 * _e271))));
    let _e276 = (*r_2);
    param_14 = _e276;
    let _e277 = FonAverage_u0028_f1_u003b((&param_14));
    average_1 = _e277;
    let _e278 = (*rho_1);
    param_15 = _e278;
    let _e279 = average_1;
    param_16 = _e279;
    let _e280 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_15), (&param_16));
    let _e281 = (*mu_o);
    param_17 = _e281;
    let _e282 = (*r_2);
    param_18 = _e282;
    let _e283 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_17), (&param_18));
    let _e286 = (*mu_i);
    param_19 = _e286;
    let _e287 = (*r_2);
    param_20 = _e287;
    let _e288 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_19), (&param_20));
    let _e292 = average_1;
    multi = (_e280 * ((max((1f - _e283), 0.0000001f) * max((1f - _e288), 0.0000001f)) / max((1f - _e292), 0.0000001f)));
    let _e297 = single;
    let _e298 = multi;
    return ((_e297 + _e298) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e233 = frag_info.ambient_sky[3u];
    return (_e233 > 0.5f);
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e235 = (*x);
    let _e236 = (*y);
    inTable = ((vec2<f32>(_e235, _e236) * 0.984375f) + vec2(0.0078125f));
    let _e242 = inTable[0u];
    let _e244 = inTable[1u];
    let _e245 = (*table);
    return vec2<f32>(_e242, ((_e244 + _e245) * 0.5f));
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_21: f32;
    var param_22: f32;
    var param_23: f32;

    let _e237 = (*roughness_2);
    let _e239 = (*n_dot_v);
    param_21 = clamp(_e237, 0f, 1f);
    param_22 = sqrt(clamp((1f - _e239), 0f, 1f));
    param_23 = 1f;
    let _e243 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_21), (&param_22), (&param_23));
    let _e244 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e243, 0f);
    dfg = _e244.xy;
    let _e247 = dfg[0u];
    let _e249 = dfg[1u];
    let _e252 = dfg[1u];
    return vec2<f32>((_e247 - _e249), _e252);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_2: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_24: f32;
    var param_25: f32;
    var ess: f32;

    let _e238 = (*s_2).roughness;
    param_24 = max(_e238, 0.045f);
    let _e241 = (*s_2).n_dot_v;
    param_25 = _e241;
    let _e242 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_24), (&param_25));
    ab = _e242;
    let _e244 = ab[0u];
    let _e246 = ab[1u];
    ess = max((_e244 + _e246), 0.0001f);
    let _e249 = (*f0_);
    let _e250 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e249 * ((1f / _e250) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e233 = frag_info.target_origin[2u];
    return (_e233 > 0.5f);
}

fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f: f32;

    let _e234 = (*v_dot_h);
    f = pow((1f - _e234), 5f);
    let _e237 = (*f0_1);
    let _e238 = (*f0_1);
    let _e240 = f;
    return (_e237 + ((vec3<f32>(1f, 1f, 1f) - _e238) * _e240));
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e237 = (*alpha_3);
    let _e238 = (*alpha_3);
    a2_ = (_e237 * _e238);
    let _e240 = (*n_dot_l);
    let _e241 = (*n_dot_v_1);
    let _e242 = (*n_dot_v_1);
    let _e244 = a2_;
    let _e247 = a2_;
    lambda_v = (_e240 * sqrt((((_e241 * _e242) * (1f - _e244)) + _e247)));
    let _e251 = (*n_dot_v_1);
    let _e252 = (*n_dot_l);
    let _e253 = (*n_dot_l);
    let _e255 = a2_;
    let _e258 = a2_;
    lambda_l = (_e251 * sqrt((((_e252 * _e253) * (1f - _e255)) + _e258)));
    let _e262 = lambda_v;
    let _e263 = lambda_l;
    return (0.5f / max((_e262 + _e263), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_2: f32;

    let _e235 = (*n_dot_h);
    let _e236 = (*alpha_4);
    a = (_e235 * _e236);
    let _e238 = (*alpha_4);
    let _e239 = (*n_dot_h);
    let _e240 = (*n_dot_h);
    let _e243 = a;
    let _e244 = a;
    k_2 = (_e238 / max(((1f - (_e239 * _e240)) + (_e243 * _e244)), 0.0000001f));
    let _e249 = k_2;
    let _e250 = k_2;
    return ((_e249 * _e250) * 0.31830987f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_3: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var lobe: f32;
    var alpha_5: f32;
    var f0_2: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_1: f32;
    var param_26: f32;
    var param_27: f32;
    var vis: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var f_1: vec3<f32>;
    var param_31: vec3<f32>;
    var param_32: f32;
    var specular: vec3<f32>;
    var param_33: vec3<f32>;
    var param_34: Surface;
    var diffuse: vec3<f32>;
    var param_35: vec3<f32>;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;

    let _e257 = (*s_3).roughness;
    lobe = max(_e257, 0.045f);
    let _e259 = lobe;
    let _e260 = lobe;
    alpha_5 = (_e259 * _e260);
    let _e263 = (*s_3).albedo;
    let _e265 = (*s_3).metallic;
    f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e263, vec3(_e265));
    let _e269 = (*s_3).albedo;
    let _e271 = (*s_3).metallic;
    diffuseColor = (_e269 * (1f - _e271));
    let _e275 = (*light).n_dot_h;
    param_26 = _e275;
    let _e276 = alpha_5;
    param_27 = _e276;
    let _e277 = D_GGX_u0028_f1_u003b_f1_u003b((&param_26), (&param_27));
    d_1 = _e277;
    let _e279 = (*s_3).n_dot_v;
    param_28 = _e279;
    let _e281 = (*light).n_dot_l;
    param_29 = _e281;
    let _e282 = alpha_5;
    param_30 = _e282;
    let _e283 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_28), (&param_29), (&param_30));
    vis = _e283;
    let _e284 = f0_2;
    param_31 = _e284;
    let _e286 = (*light).v_dot_h;
    param_32 = _e286;
    let _e287 = F_Schlick_u0028_vf3_u003b_f1_u003b((&param_31), (&param_32));
    f_1 = _e287;
    let _e288 = d_1;
    let _e289 = vis;
    let _e291 = f_1;
    let _e295 = frag_info.material[3u];
    specular = ((_e291 * (_e288 * _e289)) * _e295);
    let _e298 = (*light).integrated;
    if (_e298 > 0.5f) {
        let _e302 = (*light).ltc[0u];
        let _e303 = f0_2;
        let _e306 = (*light).ltc[1u];
        let _e308 = f0_2;
        let _e313 = (*light).ltc[2u];
        let _e319 = frag_info.material[3u];
        let _e322 = (*light).n_dot_l;
        specular = (((((_e303 * _e306) + ((vec3(1f) - _e308) * _e313)) * _e302) * _e319) / vec3(max(_e322, 0.000001f)));
    }
    let _e326 = EnergyCompensation_u0028_();
    if _e326 {
        let _e327 = f0_2;
        param_33 = _e327;
        let _e328 = (*s_3);
        param_34 = _e328;
        let _e329 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_33), (&param_34));
        let _e330 = specular;
        specular = (_e330 * _e329);
    }
    let _e332 = diffuseColor;
    let _e333 = f_1;
    diffuse = ((_e332 * (vec3<f32>(1f, 1f, 1f) - _e333)) / vec3(3.1415927f));
    let _e338 = EonDiffuse_u0028_();
    if _e338 {
        let _e340 = (*s_3).n;
        let _e342 = (*light).l;
        let _e346 = (*light).l;
        let _e348 = (*s_3).v;
        let _e350 = diffuseColor;
        param_35 = _e350;
        let _e352 = (*s_3).roughness;
        param_36 = _e352;
        param_37 = clamp(dot(_e340, _e342), 0.0001f, 1f);
        let _e354 = (*s_3).n_dot_v;
        param_38 = _e354;
        param_39 = dot(_e346, _e348);
        let _e355 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
        let _e356 = f_1;
        diffuse = (_e355 * (vec3<f32>(1f, 1f, 1f) - _e356));
    }
    let _e359 = diffuse;
    let _e360 = specular;
    return ((_e359 + _e360) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e232 = (*i);
    if (_e232 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e234 = (*i);
    if (_e234 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e236 = (*i);
    if (_e236 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e238 = (*i);
    if (_e238 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e240 = (*i);
    if (_e240 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e242 = (*i);
    if (_e242 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e244 = (*i);
    if (_e244 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_40: i32;

    let _e237 = (*i_1);
    param_40 = _e237;
    let _e238 = PointShadowDiskTap_u0028_i1_u003b((&param_40));
    p = _e238;
    let _e240 = p[0u];
    let _e241 = (*ca);
    let _e244 = p[1u];
    let _e245 = (*sa);
    let _e249 = p[0u];
    let _e250 = (*sa);
    let _e253 = p[1u];
    let _e254 = (*ca);
    let _e258 = (*radius);
    return (vec2<f32>(((_e240 * _e241) - (_e244 * _e245)), ((_e249 * _e250) + (_e253 * _e254))) * _e258);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_13: vec2<f32>;
    var atlas: vec2<f32>;

    let _e240 = point_shadow.params[0u];
    inset = _e240;
    let _e241 = (*uv_1);
    let _e242 = (*offset);
    let _e244 = inset;
    let _e245 = inset;
    local_13 = clamp((_e241 + _e242), vec2(_e244), vec2((1f - _e245)));
    let _e250 = local_13;
    let _e251 = (*tile);
    atlas = ((_e250 + _e251) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e256 = point_shadow.params3_[0u];
    if (_e256 > 0.5f) {
        let _e259 = atlas[1u];
        atlas[1u] = (1f - _e259);
    }
    let _e262 = atlas;
    let _e263 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e262, 0f);
    let _e265 = atlas;
    let _e266 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e265, 0f);
    let _e269 = (*range);
    return (min(_e263.x, _e266.x) * _e269);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: vec2<f32>;
    var param_44: f32;

    let _e241 = (*uv_2);
    param_41 = _e241;
    let _e242 = (*offset_1);
    param_42 = _e242;
    let _e243 = (*tile_1);
    param_43 = _e243;
    let _e244 = (*range_1);
    param_44 = _e244;
    let _e245 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_41), (&param_42), (&param_43), (&param_44));
    stored = _e245;
    let _e246 = stored;
    let _e247 = (*range_1);
    if (_e246 >= (_e247 * 0.999f)) {
        return 1f;
    }
    let _e250 = (*receiver);
    let _e251 = stored;
    return select(1f, 0f, (_e250 > _e251));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_45: vec2<f32>;
    var param_46: vec2<f32>;
    var param_47: vec2<f32>;
    var param_48: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_49: i32;
    var param_50: f32;
    var param_51: f32;
    var param_52: f32;
    var param_53: vec2<f32>;
    var param_54: vec2<f32>;
    var param_55: vec2<f32>;
    var param_56: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e262 = point_shadow.params2_[1u];
    lightRadius = _e262;
    let _e265 = point_shadow.params2_[0u];
    minRadius = _e265;
    let _e268 = point_shadow.params2_[2u];
    maxRadius = _e268;
    let _e269 = lightRadius;
    if (_e269 <= 0f) {
        let _e271 = (*uv_3);
        param_45 = _e271;
        param_46 = vec2<f32>(0f, 0f);
        let _e272 = (*tile_2);
        param_47 = _e272;
        let _e273 = (*range_2);
        param_48 = _e273;
        let _e274 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
        (*blockerOut) = _e274;
        let _e275 = minRadius;
        return _e275;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e276 = i_2;
        if (_e276 < 8i) {
            let _e278 = i_2;
            param_49 = _e278;
            let _e279 = (*ca_1);
            param_50 = _e279;
            let _e280 = (*sa_1);
            param_51 = _e280;
            let _e281 = maxRadius;
            param_52 = _e281;
            let _e282 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52));
            let _e283 = (*uv_3);
            param_53 = _e283;
            param_54 = _e282;
            let _e284 = (*tile_2);
            param_55 = _e284;
            let _e285 = (*range_2);
            param_56 = _e285;
            let _e286 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
            stored_1 = _e286;
            let _e287 = stored_1;
            let _e288 = (*range_2);
            if (_e287 >= (_e288 * 0.999f)) {
                continue;
            }
            let _e291 = stored_1;
            let _e292 = (*receiver_1);
            if (_e291 >= _e292) {
                continue;
            }
            let _e294 = stored_1;
            let _e295 = sum;
            sum = (_e295 + _e294);
            let _e297 = count;
            count = (_e297 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e299 = i_2;
            i_2 = (_e299 + 1i);
        }
    }
    let _e301 = count;
    if (_e301 < 0.5f) {
        return -1f;
    }
    let _e303 = sum;
    let _e304 = count;
    blocker = max((_e303 / _e304), 0.0001f);
    let _e307 = blocker;
    (*blockerOut) = _e307;
    let _e308 = lightRadius;
    let _e309 = (*receiver_1);
    let _e310 = blocker;
    let _e314 = blocker;
    world = ((_e308 * max((_e309 - _e310), 0f)) / _e314);
    let _e316 = world;
    let _e317 = (*receiver_1);
    let _e319 = (*tanHalf);
    let _e322 = minRadius;
    let _e323 = maxRadius;
    return clamp((_e316 / ((2f * _e317) * _e319)), _e322, _e323);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_14: vec2<f32>;

    let _e233 = (*rows);
    if (_e233 > 0f) {
        let _e236 = gl_FragCoord_1[0u];
        let _e237 = (*rows);
        let _e239 = gl_FragCoord_1[1u];
        local_14 = vec2<f32>(_e236, (_e237 - _e239));
    } else {
        let _e242 = gl_FragCoord_1;
        local_14 = _e242.xy;
    }
    let _e244 = local_14;
    return _e244;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_1: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_57: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_58: vec2<f32>;
    var param_59: vec2<f32>;
    var param_60: f32;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;
    var param_64: f32;
    var param_65: f32;
    var local_15: vec3<f32>;
    var lit_1: f32;
    var param_66: vec2<f32>;
    var param_67: vec2<f32>;
    var param_68: vec2<f32>;
    var param_69: f32;
    var param_70: f32;
    var i_3: i32;
    var param_71: i32;
    var param_72: f32;
    var param_73: f32;
    var param_74: f32;
    var param_75: vec2<f32>;
    var param_76: vec2<f32>;
    var param_77: vec2<f32>;
    var param_78: f32;
    var param_79: f32;
    var phi_2596_: bool;
    var phi_2657_: bool;

    let _e285 = (*lightIndex);
    let _e289 = point_shadow.slots[_e285][0u];
    slot = i32((_e289 + 0.5f));
    let _e292 = (*lightIndex);
    let _e296 = point_shadow.slots[_e292][0u];
    if (_e296 < 0f) {
        return 1f;
    }
    let _e300 = point_shadow.params[2u];
    strength = _e300;
    let _e301 = strength;
    if (_e301 <= 0f) {
        return 1f;
    }
    let _e303 = slot;
    let _e306 = point_shadow.lights[_e303];
    let _e308 = (*world_1);
    toLight = (_e306.xyz - _e308);
    let _e310 = toLight;
    toLightLength = max(length(_e310), 0.000001f);
    let _e313 = (*normal);
    let _e314 = toLight;
    let _e315 = toLightLength;
    nDotL = max(dot(_e313, (_e314 / vec3(_e315))), 0.15f);
    let _e320 = nDotL;
    let _e321 = nDotL;
    let _e326 = nDotL;
    let _e327 = nDotL;
    slope = min((sqrt(max((1f - (_e320 * _e321)), 0f)) / (_e326 * _e327)), 8f);
    let _e331 = toLightLength;
    let _e333 = (*lightIndex);
    let _e337 = point_shadow.slots[_e333][2u];
    let _e342 = point_shadow.params3_[1u];
    texel = (((2f * _e331) * max(_e337, 0.0001f)) * _e342);
    let _e344 = (*world_1);
    let _e345 = (*normal);
    let _e346 = texel;
    let _e350 = point_shadow.params[3u];
    let _e352 = slope;
    origin = (_e344 + (((_e345 * _e346) * _e350) * (1f + _e352)));
    let _e356 = origin;
    let _e357 = slot;
    let _e360 = point_shadow.lights[_e357];
    toFragment = (_e356 - _e360.xyz);
    let _e363 = toFragment;
    distance_ = length(_e363);
    let _e365 = slot;
    let _e369 = point_shadow.lights[_e365][3u];
    range_3 = max(_e369, 0.0001f);
    let _e371 = distance_;
    let _e372 = range_3;
    if (_e371 >= _e372) {
        return 1f;
    }
    face = 0i;
    let _e374 = (*lightIndex);
    let _e378 = point_shadow.slots[_e374][1u];
    if (_e378 < 0.5f) {
        let _e380 = toFragment;
        a_1 = abs(_e380);
        let _e383 = a_1[0u];
        let _e385 = a_1[1u];
        let _e386 = (_e383 >= _e385);
        phi_2596_ = _e386;
        if _e386 {
            let _e388 = a_1[0u];
            let _e390 = a_1[2u];
            phi_2596_ = (_e388 >= _e390);
        }
        let _e393 = phi_2596_;
        if _e393 {
            let _e395 = toFragment[0u];
            face = select(1i, 0i, (_e395 > 0f));
        } else {
            let _e399 = a_1[1u];
            let _e401 = a_1[2u];
            if (_e399 >= _e401) {
                let _e404 = toFragment[1u];
                face = select(3i, 2i, (_e404 > 0f));
            } else {
                let _e408 = toFragment[2u];
                face = select(5i, 4i, (_e408 > 0f));
            }
        }
    }
    let _e411 = slot;
    let _e413 = face;
    let _e417 = point_shadow.faces[((_e411 * 6i) + _e413)];
    let _e418 = origin;
    clip = (_e417 * vec4<f32>(_e418.x, _e418.y, _e418.z, 1f));
    let _e425 = clip[3u];
    if (_e425 <= 0f) {
        return 1f;
    }
    let _e427 = clip;
    let _e430 = clip[3u];
    ndc = (_e427.xy / vec2(_e430));
    let _e434 = ndc[0u];
    let _e436 = (abs(_e434) > 1f);
    phi_2657_ = _e436;
    if !(_e436) {
        let _e439 = ndc[1u];
        phi_2657_ = (abs(_e439) > 1f);
    }
    let _e443 = phi_2657_;
    if _e443 {
        return 1f;
    }
    let _e445 = ndc[0u];
    let _e449 = ndc[1u];
    uv_4 = vec2<f32>(((_e445 * 0.5f) + 0.5f), (0.5f - (_e449 * 0.5f)));
    let _e453 = face;
    let _e455 = slot;
    tile_3 = vec2<f32>(f32(_e453), f32(_e455));
    let _e458 = distance_;
    let _e461 = point_shadow.params[1u];
    receiver_2 = (_e458 - _e461);
    let _e465 = frag_info.target_origin[0u];
    param_57 = _e465;
    let _e466 = FragCoordFromTop_u0028_f1_u003b((&param_57));
    noise = fract((52.982918f * fract(dot(_e466, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e471 = noise;
    angle = (_e471 * 6.2831855f);
    let _e473 = angle;
    ca_2 = cos(_e473);
    let _e475 = angle;
    sa_2 = sin(_e475);
    let _e477 = (*lightIndex);
    let _e481 = point_shadow.slots[_e477][2u];
    tanHalf_1 = max(_e481, 0.0001f);
    blocker_1 = -1f;
    let _e483 = uv_4;
    param_58 = _e483;
    let _e484 = tile_3;
    param_59 = _e484;
    let _e485 = range_3;
    param_60 = _e485;
    let _e486 = receiver_2;
    param_61 = _e486;
    let _e487 = ca_2;
    param_62 = _e487;
    let _e488 = sa_2;
    param_63 = _e488;
    let _e489 = tanHalf_1;
    param_64 = _e489;
    let _e490 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_58), (&param_59), (&param_60), (&param_61), (&param_62), (&param_63), (&param_64), (&param_65));
    let _e491 = param_65;
    blocker_1 = _e491;
    radius_1 = _e490;
    let _e494 = point_shadow.params2_[3u];
    if (_e494 > 0.5f) {
        g_debug_surface_on = true;
        let _e496 = radius_1;
        if (_e496 < 0f) {
            local_15 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e498 = radius_1;
            let _e501 = point_shadow.params2_[2u];
            let _e505 = blocker_1;
            let _e506 = range_3;
            local_15 = vec3<f32>(clamp((_e498 / max(_e501, 0.000001f)), 0f, 1f), clamp((_e505 / _e506), 0f, 1f), 0f);
        }
        let _e510 = local_15;
        g_debug_surface = _e510;
    }
    let _e511 = radius_1;
    if (_e511 < 0f) {
        return 1f;
    }
    let _e513 = uv_4;
    param_66 = _e513;
    param_67 = vec2<f32>(0f, 0f);
    let _e514 = tile_3;
    param_68 = _e514;
    let _e515 = range_3;
    param_69 = _e515;
    let _e516 = receiver_2;
    param_70 = _e516;
    let _e517 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_66), (&param_67), (&param_68), (&param_69), (&param_70));
    lit_1 = _e517;
    let _e518 = radius_1;
    if (_e518 > 0f) {
        i_3 = 0i;
        loop {
            let _e520 = i_3;
            if (_e520 < 8i) {
                let _e522 = i_3;
                param_71 = _e522;
                let _e523 = ca_2;
                param_72 = _e523;
                let _e524 = sa_2;
                param_73 = _e524;
                let _e525 = radius_1;
                param_74 = _e525;
                let _e526 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_71), (&param_72), (&param_73), (&param_74));
                let _e527 = uv_4;
                param_75 = _e527;
                param_76 = _e526;
                let _e528 = tile_3;
                param_77 = _e528;
                let _e529 = range_3;
                param_78 = _e529;
                let _e530 = receiver_2;
                param_79 = _e530;
                let _e531 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_75), (&param_76), (&param_77), (&param_78), (&param_79));
                let _e532 = lit_1;
                lit_1 = (_e532 + _e531);
                continue;
            } else {
                break;
            }
            continuing {
                let _e534 = i_3;
                i_3 = (_e534 + 1i);
            }
        }
        let _e536 = lit_1;
        lit_1 = (_e536 * 0.11111111f);
    }
    let _e538 = lit_1;
    let _e539 = strength;
    return mix(1f, _e538, clamp(_e539, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e236 = (*i_4);
    let _e239 = (*n_1);
    r_3 = sqrt(((f32(_e236) + 0.5f) / f32(_e239)));
    let _e243 = (*i_4);
    let _e246 = (*turn);
    theta = ((f32(_e243) * 2.3999631f) + _e246);
    let _e248 = r_3;
    let _e249 = theta;
    let _e251 = theta;
    return (vec2<f32>(cos(_e249), sin(_e251)) * _e248);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_80: f32;

    let _e235 = frag_info.target_origin[0u];
    param_80 = _e235;
    let _e236 = FragCoordFromTop_u0028_f1_u003b((&param_80));
    let _e239 = frag_info.target_origin[3u];
    at = (_e236 + vec2((5.588238f * max(_e239, 0f))));
    let _e244 = at;
    return fract((52.982918f * fract(dot(_e244, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_16: f32;

    let _e234 = (*mode_1);
    if (_e234 > 0.5f) {
        let _e236 = (*stored_2);
        local_16 = (1f - _e236);
    } else {
        let _e238 = (*stored_2);
        local_16 = _e238;
    }
    let _e239 = local_16;
    return _e239;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_2: f32;
    var pMax: f32;
    var reduced: f32;

    let _e240 = (*moments)[1u];
    let _e242 = (*moments)[0u];
    let _e244 = (*moments)[0u];
    let _e247 = (*minVariance);
    variance = max((_e240 - (_e242 * _e244)), _e247);
    let _e249 = (*t);
    let _e251 = (*moments)[0u];
    d_2 = (_e249 - _e251);
    let _e253 = variance;
    let _e254 = variance;
    let _e255 = d_2;
    let _e256 = d_2;
    pMax = (_e253 / (_e254 + (_e255 * _e256)));
    let _e260 = pMax;
    let _e261 = (*bleed);
    let _e263 = (*bleed);
    reduced = clamp(((_e260 - _e261) / max((1f - _e263), 0.0001f)), 0f, 1f);
    let _e268 = (*t);
    let _e270 = (*moments)[0u];
    let _e272 = reduced;
    return select(_e272, 1f, (_e268 <= _e270));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_3: f32;

    let _e233 = (*depth);
    d_3 = ((2f * clamp(_e233, 0f, 1f)) - 1f);
    let _e237 = d_3;
    let _e240 = d_3;
    return vec2<f32>(exp((40f * _e237)), -(exp((-5f * _e240))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_81: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_82: vec2<f32>;
    var param_83: f32;
    var param_84: f32;
    var param_85: f32;
    var negative: f32;
    var param_86: vec2<f32>;
    var param_87: f32;
    var param_88: f32;
    var param_89: f32;

    let _e247 = (*depth_1);
    param_81 = _e247;
    let _e248 = EvsmWarp_u0028_f1_u003b((&param_81));
    warped = _e248;
    let _e249 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e249);
    let _e252 = scale[0u];
    let _e254 = scale[0u];
    let _e256 = (*moments_1);
    param_82 = _e256.xy;
    let _e259 = warped[0u];
    param_83 = _e259;
    param_84 = (_e252 * _e254);
    let _e260 = (*bleed_1);
    param_85 = _e260;
    let _e261 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_82), (&param_83), (&param_84), (&param_85));
    positive = _e261;
    let _e263 = scale[1u];
    let _e265 = scale[1u];
    let _e267 = (*moments_1);
    param_86 = _e267.zw;
    let _e270 = warped[1u];
    param_87 = _e270;
    param_88 = (_e263 * _e265);
    let _e271 = (*bleed_1);
    param_89 = _e271;
    let _e272 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_86), (&param_87), (&param_88), (&param_89));
    negative = _e272;
    let _e273 = positive;
    let _e274 = negative;
    return min(_e273, _e274);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e233 = (*depth_2);
    stored_3 = max((1f - _e233), 0.000061035156f);
    let _e236 = stored_3;
    return exp2((floor(log2(_e236)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_17: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_18: mat4x4<f32>;
    var local_19: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_20: f32;
    var local_21: f32;
    var storage_: f32;
    var param_90: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_91: vec4<f32>;
    var param_92: f32;
    var param_93: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_94: f32;
    var param_95: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_96: i32;
    var param_97: i32;
    var param_98: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_99: f32;
    var param_100: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_101: i32;
    var param_102: i32;
    var param_103: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_104: f32;
    var param_105: f32;
    var phi_4248_: bool;
    var phi_4259_: bool;
    var phi_4416_: bool;
    var phi_4423_: bool;
    var phi_4430_: bool;

    let _e312 = frag_info.shadow_params[3u];
    strength_1 = _e312;
    let _e313 = strength_1;
    if (_e313 <= 0f) {
        return 1f;
    }
    let _e315 = (*lightIndex_1);
    let _e318 = frag_info.frame_params[2u];
    if (_e315 != i32(floor((_e318 + 0.5f)))) {
        return 1f;
    }
    let _e325 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e325 + 0.5f));
    let _e328 = Orthographic_u0028_();
    if _e328 {
        let _e329 = ViewDepth_u0028_();
        local_17 = _e329;
    } else {
        let _e330 = v_world_position_1;
        let _e332 = frag_info.camera_position;
        local_17 = length((_e330 - _e332.xyz));
    }
    let _e336 = local_17;
    viewDistance = _e336;
    cascade = 0i;
    let _e337 = cascadeCount;
    let _e338 = (_e337 > 1i);
    phi_4248_ = _e338;
    if _e338 {
        let _e339 = viewDistance;
        let _e342 = frag_info.shadow_cascades[0u];
        phi_4248_ = (_e339 > _e342);
    }
    let _e345 = phi_4248_;
    if _e345 {
        cascade = 1i;
    }
    let _e346 = cascadeCount;
    let _e347 = (_e346 > 2i);
    phi_4259_ = _e347;
    if _e347 {
        let _e348 = viewDistance;
        let _e351 = frag_info.shadow_cascades[1u];
        phi_4259_ = (_e348 > _e351);
    }
    let _e354 = phi_4259_;
    if _e354 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e355 = attempt;
        if (_e355 < 3i) {
            let _e357 = cascade;
            let _e358 = attempt;
            which = (_e357 + _e358);
            let _e360 = which;
            let _e361 = cascadeCount;
            if (_e360 >= _e361) {
                break;
            }
            let _e363 = which;
            if (_e363 == 0i) {
                let _e366 = frag_info.shadow_matrix;
                local_18 = _e366;
            } else {
                let _e367 = which;
                if (_e367 == 1i) {
                    let _e370 = frag_info.shadow_matrix_far;
                    local_19 = _e370;
                } else {
                    let _e372 = frag_info.shadow_matrix_farthest;
                    local_19 = _e372;
                }
                let _e373 = local_19;
                local_18 = _e373;
            }
            let _e374 = local_18;
            matrix = _e374;
            let _e377 = matrix[0][0u];
            let _e380 = matrix[1][0u];
            let _e383 = matrix[2][0u];
            axisX = vec3<f32>(_e377, _e380, _e383);
            let _e387 = matrix[0][1u];
            let _e390 = matrix[1][1u];
            let _e393 = matrix[2][1u];
            axisY = vec3<f32>(_e387, _e390, _e393);
            let _e395 = axisX;
            rowX = max(length(_e395), 0.000001f);
            let _e398 = axisY;
            rowY = max(length(_e398), 0.000001f);
            let _e403 = frag_info.shadow_cascades[3u];
            let _e405 = rowX;
            texelMetres = ((2f * _e403) / _e405);
            let _e409 = frag_info.shadow_cascades[3u];
            let _e412 = (*s_4).n;
            let _e413 = axisX;
            let _e416 = rowX;
            let _e417 = rowX;
            let _e421 = (*s_4).n;
            let _e422 = axisY;
            let _e425 = rowY;
            let _e426 = rowY;
            reach = ((3f * _e409) * ((abs(dot(_e412, _e413)) / (_e416 * _e417)) + (abs(dot(_e421, _e422)) / (_e425 * _e426))));
            let _e433 = frag_info.shadow_params[2u];
            let _e434 = texelMetres;
            flatOffset = min(_e433, _e434);
            let _e436 = v_world_position_1;
            let _e438 = (*s_4).n;
            let _e439 = flatOffset;
            let _e440 = reach;
            origin_1 = (_e436 + (_e438 * (_e439 + _e440)));
            let _e444 = matrix;
            let _e445 = origin_1;
            lightSpace = (_e444 * vec4<f32>(_e445.x, _e445.y, _e445.z, 1f));
            let _e452 = lightSpace[3u];
            if (_e452 <= 0f) {
                continue;
            }
            let _e454 = lightSpace;
            let _e457 = lightSpace[3u];
            candidate = (_e454.xyz / vec3(_e457));
            let _e461 = candidate[0u];
            let _e465 = candidate[1u];
            inTile = vec2<f32>(((_e461 * 0.5f) + 0.5f), (0.5f - (_e465 * 0.5f)));
            let _e470 = inTile[0u];
            let _e471 = (_e470 < 0f);
            phi_4416_ = _e471;
            if !(_e471) {
                let _e474 = inTile[0u];
                phi_4416_ = (_e474 > 1f);
            }
            let _e477 = phi_4416_;
            phi_4423_ = _e477;
            if !(_e477) {
                let _e480 = inTile[1u];
                phi_4423_ = (_e480 < 0f);
            }
            let _e483 = phi_4423_;
            phi_4430_ = _e483;
            if !(_e483) {
                let _e486 = inTile[1u];
                phi_4430_ = (_e486 > 1f);
            }
            let _e489 = phi_4430_;
            if _e489 {
                continue;
            }
            let _e491 = candidate[2u];
            if (_e491 > 1f) {
                let _e493 = which;
                let _e494 = cascadeCount;
                if (_e493 < (_e494 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e499 = inTile[0u];
            let _e500 = which;
            let _e503 = cascadeCount;
            let _e507 = inTile[1u];
            uv_5 = vec2<f32>(((_e499 + f32(_e500)) / f32(_e503)), _e507);
            let _e509 = candidate;
            projected = _e509;
            let _e510 = which;
            cascade = _e510;
            let _e511 = texelMetres;
            cascadeTexel = _e511;
            let _e514 = matrix[0][2u];
            let _e517 = matrix[1][2u];
            let _e520 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e514, _e517, _e520)), 0.000001f));
            let _e526 = (*s_4).n;
            let _e529 = matrix[0][2u];
            let _e532 = matrix[1][2u];
            let _e535 = matrix[2][2u];
            let _e539 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e526, vec3<f32>(_e529, _e532, _e535))) * _e539), 0.1f, 1f);
            let _e542 = texelMetres;
            let _e543 = cosSlope;
            let _e544 = cosSlope;
            let _e550 = cosSlope;
            let _e552 = cascadeDepth;
            receiverSlope = (((_e542 * sqrt(max((1f - (_e543 * _e544)), 0f))) / _e550) / _e552);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e554 = attempt;
            attempt = (_e554 + 1i);
        }
    }
    let _e556 = found;
    if !(_e556) {
        return 1f;
    }
    let _e558 = cascade;
    if (_e558 == 0i) {
        let _e562 = frag_info.shadow_bias[0u];
        local_20 = _e562;
    } else {
        let _e563 = cascade;
        if (_e563 == 1i) {
            let _e567 = frag_info.shadow_bias[1u];
            local_21 = _e567;
        } else {
            let _e570 = frag_info.shadow_bias[2u];
            local_21 = _e570;
        }
        let _e571 = local_21;
        local_20 = _e571;
    }
    let _e572 = local_20;
    bias = _e572;
    let _e575 = frag_info.shadow_params[1u];
    storage_ = _e575;
    let _e576 = storage_;
    let _e578 = storage_;
    if ((_e576 > 0.5f) && (_e578 < 1.5f)) {
        let _e581 = bias;
        let _e583 = projected[2u];
        param_90 = _e583;
        let _e584 = ShadowStoredStep_u0028_f1_u003b((&param_90));
        bias = max(_e581, _e584);
    }
    let _e588 = frag_info.shadow_params[0u];
    let _e591 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e588, _e591);
    let _e593 = cascade;
    let _e595 = cascadeCount;
    let _e599 = texel_1;
    tileLo = (vec2<f32>((f32(_e593) / f32(_e595)), 0f) + (_e599 * 0.5f));
    let _e602 = cascade;
    let _e605 = cascadeCount;
    let _e609 = texel_1;
    tileHi = (vec2<f32>((f32((_e602 + 1i)) / f32(_e605)), 1f) - (_e609 * 0.5f));
    let _e614 = frag_info.shadow_bias[3u];
    if (_e614 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e616 = y_1;
            if (_e616 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e618 = x_1;
                    if (_e618 <= 1i) {
                        let _e620 = uv_5;
                        let _e621 = x_1;
                        let _e623 = y_1;
                        let _e626 = texel_1;
                        let _e629 = tileLo;
                        let _e630 = tileHi;
                        let _e632 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e620 + (vec2<f32>(f32(_e621), f32(_e623)) * _e626)), _e629, _e630), 0f);
                        let _e633 = stored_4;
                        stored_4 = (_e633 + _e632);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e635 = x_1;
                        x_1 = (_e635 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e637 = y_1;
                y_1 = (_e637 + 1i);
            }
        }
        let _e639 = stored_4;
        stored_4 = (_e639 * 0.11111111f);
        let _e642 = stored_4[1u];
        let _e645 = stored_4[2u];
        let _e648 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e642), (1f - _e645), _e648), vec3(0f), vec3(4f));
        let _e653 = through;
        let _e654 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e653, vec3(clamp(_e654, 0f, 1f)));
    }
    let _e660 = frag_info.ambient_ground[3u];
    softness = _e660;
    lit_2 = 0f;
    let _e661 = softness;
    if (_e661 < 0f) {
        let _e663 = uv_5;
        let _e664 = tileLo;
        let _e665 = tileHi;
        let _e667 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e663, _e664, _e665), 0f);
        moments_2 = _e667;
        let _e669 = projected[2u];
        let _e670 = bias;
        let _e672 = softness;
        let _e676 = moments_2;
        param_91 = _e676;
        param_92 = (_e669 - _e670);
        param_93 = clamp((-(_e672) - 1f), 0f, 0.95f);
        let _e677 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_91), (&param_92), (&param_93));
        lit_2 = _e677;
    } else {
        let _e678 = softness;
        if (_e678 <= 0f) {
            y_2 = -1i;
            loop {
                let _e680 = y_2;
                if (_e680 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e682 = x_2;
                        if (_e682 <= 1i) {
                            let _e684 = uv_5;
                            let _e685 = x_2;
                            let _e687 = y_2;
                            let _e690 = texel_1;
                            let _e693 = tileLo;
                            let _e694 = tileHi;
                            let _e696 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e684 + (vec2<f32>(f32(_e685), f32(_e687)) * _e690)), _e693, _e694), 0f);
                            param_94 = _e696.x;
                            let _e698 = storage_;
                            param_95 = _e698;
                            let _e699 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_94), (&param_95));
                            occluder = _e699;
                            let _e701 = projected[2u];
                            let _e702 = bias;
                            let _e704 = occluder;
                            let _e707 = lit_2;
                            lit_2 = (_e707 + select(1f, 0f, ((_e701 - _e702) > _e704)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e709 = x_2;
                            x_2 = (_e709 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e711 = y_2;
                    y_2 = (_e711 + 1i);
                }
            }
            let _e713 = lit_2;
            lit_2 = (_e713 * 0.11111111f);
        } else {
            let _e715 = softness;
            spread = tan(min(_e715, 0.5f));
            let _e718 = ShadowNoise_u0028_();
            turn_1 = (_e718 * 6.2831855f);
            let _e720 = spread;
            let _e722 = projected[2u];
            let _e724 = cascadeDepth;
            let _e726 = cascadeTexel;
            searchRadius = clamp((((_e720 * _e722) * _e724) / _e726), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e729 = i_5;
                if (_e729 < 16i) {
                    let _e731 = i_5;
                    param_96 = _e731;
                    param_97 = 16i;
                    let _e732 = turn_1;
                    param_98 = _e732;
                    let _e733 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_96), (&param_97), (&param_98));
                    disc = _e733;
                    let _e734 = bias;
                    let _e735 = disc;
                    let _e737 = searchRadius;
                    let _e741 = receiverSlope;
                    tapBias = (_e734 + (max(((length(_e735) * _e737) - 1.5f), 0f) * _e741));
                    let _e744 = uv_5;
                    let _e745 = disc;
                    let _e746 = texel_1;
                    let _e748 = searchRadius;
                    let _e751 = tileLo;
                    let _e752 = tileHi;
                    let _e754 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e744 + ((_e745 * _e746) * _e748)), _e751, _e752), 0f);
                    param_99 = _e754.x;
                    let _e756 = storage_;
                    param_100 = _e756;
                    let _e757 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
                    occluder_1 = _e757;
                    let _e759 = projected[2u];
                    let _e760 = tapBias;
                    let _e762 = occluder_1;
                    if ((_e759 - _e760) > _e762) {
                        let _e764 = occluder_1;
                        let _e765 = blockerSum;
                        blockerSum = (_e765 + _e764);
                        let _e767 = blockerCount;
                        blockerCount = (_e767 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e769 = i_5;
                    i_5 = (_e769 + 1i);
                }
            }
            let _e771 = blockerCount;
            if (_e771 <= 0f) {
                return 1f;
            }
            let _e774 = projected[2u];
            let _e775 = blockerSum;
            let _e776 = blockerCount;
            let _e780 = cascadeDepth;
            gap = (max((_e774 - (_e775 / _e776)), 0f) * _e780);
            let _e782 = spread;
            let _e783 = gap;
            let _e785 = cascadeTexel;
            radius_2 = clamp(((_e782 * _e783) / _e785), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e788 = i_6;
                if (_e788 < 16i) {
                    let _e790 = turn_1;
                    let _e792 = i_6;
                    param_101 = _e792;
                    param_102 = 16i;
                    param_103 = (_e790 + 1f);
                    let _e793 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_101), (&param_102), (&param_103));
                    disc_1 = _e793;
                    let _e794 = bias;
                    let _e795 = disc_1;
                    let _e797 = radius_2;
                    let _e801 = receiverSlope;
                    tapBias_1 = (_e794 + (max(((length(_e795) * _e797) - 1.5f), 0f) * _e801));
                    let _e804 = uv_5;
                    let _e805 = disc_1;
                    let _e806 = texel_1;
                    let _e808 = radius_2;
                    let _e811 = tileLo;
                    let _e812 = tileHi;
                    let _e814 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e804 + ((_e805 * _e806) * _e808)), _e811, _e812), 0f);
                    param_104 = _e814.x;
                    let _e816 = storage_;
                    param_105 = _e816;
                    let _e817 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_104), (&param_105));
                    occluder_2 = _e817;
                    let _e819 = projected[2u];
                    let _e820 = tapBias_1;
                    let _e822 = occluder_2;
                    let _e825 = lit_2;
                    lit_2 = (_e825 + select(1f, 0f, ((_e819 - _e820) > _e822)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e827 = i_6;
                    i_6 = (_e827 + 1i);
                }
            }
            let _e829 = lit_2;
            lit_2 = (_e829 * 0.0625f);
        }
    }
    let _e831 = lit_2;
    let _e832 = strength_1;
    return mix(1f, _e831, clamp(_e832, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_106: Surface;
    var param_107: LightSample;
    var param_108: i32;

    let _e237 = (*s_5);
    param_106 = _e237;
    let _e238 = (*light_2);
    param_107 = _e238;
    let _e239 = (*index);
    param_108 = _e239;
    let _e240 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
    return _e240;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e232 = (*index_1);
    return (_e232 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e236 = (*distance_1);
    let _e237 = (*distance_1);
    attenuation = (1f / max((_e236 * _e237), 0.0001f));
    let _e241 = (*range_4);
    if (_e241 > 0f) {
        let _e243 = (*distance_1);
        let _e244 = (*range_4);
        ratio = (_e243 / _e244);
        let _e246 = ratio;
        let _e247 = ratio;
        let _e249 = ratio;
        let _e251 = ratio;
        window = clamp((1f - (((_e246 * _e247) * _e249) * _e251)), 0f, 1f);
        let _e255 = window;
        let _e256 = window;
        let _e258 = attenuation;
        attenuation = (_e258 * (_e255 * _e256));
    }
    let _e260 = attenuation;
    return _e260;
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle_1: f32;
    var local_22: vec3<f32>;

    let _e237 = (*a_2);
    let _e238 = (*b);
    axis = cross(_e237, _e238);
    let _e240 = axis;
    len = length(_e240);
    let _e242 = (*a_2);
    let _e243 = (*b);
    angle_1 = acos(clamp(dot(_e242, _e243), -1f, 1f));
    let _e247 = len;
    if (_e247 > 0.000001f) {
        let _e249 = axis;
        let _e250 = angle_1;
        let _e251 = len;
        local_22 = (_e249 * (_e250 / (_e251 * 6.2831855f)));
    } else {
        local_22 = vec3<f32>(0f, 0f, 0f);
    }
    let _e255 = local_22;
    return _e255;
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_3: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv_6: vec2<f32>;
    var inverse: vec4<f32>;
    var param_109: f32;
    var param_110: f32;
    var param_111: f32;
    var fit: vec4<f32>;
    var param_112: f32;
    var param_113: f32;
    var param_114: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_23: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i_7: i32;
    var p_1: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f_2: vec3<f32>;
    var param_115: vec3<f32>;
    var param_116: vec3<f32>;
    var param_117: vec3<f32>;
    var param_118: vec3<f32>;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: vec3<f32>;
    var param_122: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_24: f32;
    var sphere: f32;
    var param_123: f32;
    var param_124: f32;
    var param_125: f32;

    let _e269 = (*roughness_3);
    let _e271 = (*n_2);
    let _e272 = (*v);
    uv_6 = vec2<f32>(clamp(_e269, 0f, 1f), sqrt(clamp((1f - dot(_e271, _e272)), 0f, 1f)));
    let _e279 = uv_6[0u];
    param_109 = _e279;
    let _e281 = uv_6[1u];
    param_110 = _e281;
    param_111 = 0f;
    let _e282 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_109), (&param_110), (&param_111));
    let _e283 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e282, 0f);
    inverse = _e283;
    let _e285 = uv_6[0u];
    param_112 = _e285;
    let _e287 = uv_6[1u];
    param_113 = _e287;
    param_114 = 1f;
    let _e288 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_112), (&param_113), (&param_114));
    let _e289 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e288, 0f);
    fit = _e289;
    let _e290 = (*v);
    let _e291 = (*n_2);
    let _e292 = (*v);
    let _e293 = (*n_2);
    along = (_e290 - (_e291 * dot(_e292, _e293)));
    let _e297 = along;
    alongLength = length(_e297);
    let _e299 = alongLength;
    if (_e299 > 0.00001f) {
        let _e301 = along;
        let _e302 = alongLength;
        local_23 = (_e301 / vec3(_e302));
    } else {
        let _e305 = (*n_2);
        let _e307 = (*n_2)[2u];
        local_23 = normalize(cross(_e305, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e307) < 0.999f)))));
    }
    let _e314 = local_23;
    t1_ = _e314;
    let _e315 = (*n_2);
    let _e316 = t1_;
    t2_ = cross(_e315, _e316);
    let _e319 = inverse[0u];
    let _e321 = inverse[1u];
    let _e322 = vec3<f32>(_e319, 0f, _e321);
    let _e324 = inverse[2u];
    let _e326 = inverse[3u];
    let _e327 = vec3<f32>(_e324, 0f, _e326);
    minv = mat3x3<f32>(vec3<f32>(_e322.x, _e322.y, _e322.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e327.x, _e327.y, _e327.z));
    i_7 = 0i;
    loop {
        let _e341 = i_7;
        if (_e341 < 4i) {
            let _e343 = i_7;
            let _e345 = (*corners)[_e343];
            p_1 = _e345;
            let _e346 = i_7;
            let _e347 = minv;
            let _e348 = p_1;
            let _e349 = t1_;
            let _e351 = p_1;
            let _e352 = t2_;
            let _e354 = p_1;
            let _e355 = (*n_2);
            l[_e346] = normalize((_e347 * vec3<f32>(dot(_e348, _e349), dot(_e351, _e352), dot(_e354, _e355))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e361 = i_7;
            i_7 = (_e361 + 1i);
        }
    }
    let _e364 = l[0i];
    param_115 = _e364;
    let _e366 = l[1i];
    param_116 = _e366;
    let _e367 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_115), (&param_116));
    let _e369 = l[1i];
    param_117 = _e369;
    let _e371 = l[2i];
    param_118 = _e371;
    let _e372 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_117), (&param_118));
    let _e375 = l[2i];
    param_119 = _e375;
    let _e377 = l[3i];
    param_120 = _e377;
    let _e378 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_119), (&param_120));
    let _e381 = l[3i];
    param_121 = _e381;
    let _e383 = l[0i];
    param_122 = _e383;
    let _e384 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_121), (&param_122));
    f_2 = -((((_e367 + _e372) + _e378) + _e384));
    let _e387 = f_2;
    len_1 = length(_e387);
    let _e389 = len_1;
    if (_e389 > 0.000000001f) {
        let _e392 = f_2[2u];
        let _e393 = len_1;
        local_24 = (_e392 / _e393);
    } else {
        local_24 = 0f;
    }
    let _e395 = local_24;
    z_1 = _e395;
    let _e396 = z_1;
    let _e399 = len_1;
    param_123 = ((_e396 * 0.5f) + 0.5f);
    param_124 = clamp(_e399, 0f, 1f);
    param_125 = 1f;
    let _e401 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_123), (&param_124), (&param_125));
    let _e402 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e401, 0f);
    sphere = _e402.w;
    let _e404 = len_1;
    let _e405 = sphere;
    let _e409 = fit[0u];
    let _e411 = fit[1u];
    return vec3<f32>(max((_e404 * _e405), 0f), _e409, _e411);
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_25: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e248 = (*halfWidth);
    let _e249 = (*halfHeight);
    n_3 = cross(_e248, _e249);
    let _e251 = n_3;
    nLen = length(_e251);
    let _e253 = nLen;
    if (_e253 < 0.000000000001f) {
        let _e255 = (*centre);
        return _e255;
    }
    let _e256 = nLen;
    let _e257 = n_3;
    n_3 = (_e257 / vec3(_e256));
    let _e260 = (*centre);
    let _e261 = (*world_2);
    toPlane = (_e260 - _e261);
    let _e263 = (*mirror);
    let _e264 = n_3;
    denom = dot(_e263, _e264);
    let _e266 = denom;
    if (abs(_e266) < 0.00001f) {
        let _e269 = toPlane;
        let _e270 = n_3;
        let _e271 = toPlane;
        let _e272 = n_3;
        onPlane = (_e269 - (_e270 * dot(_e271, _e272)));
    } else {
        let _e276 = toPlane;
        let _e277 = n_3;
        let _e279 = denom;
        t_1 = (dot(_e276, _e277) / _e279);
        let _e281 = t_1;
        if (_e281 > 0f) {
            let _e283 = (*mirror);
            let _e284 = t_1;
            local_25 = (_e283 * _e284);
        } else {
            let _e286 = toPlane;
            let _e287 = n_3;
            let _e288 = toPlane;
            let _e289 = n_3;
            local_25 = (_e286 - (_e287 * dot(_e288, _e289)));
        }
        let _e293 = local_25;
        onPlane = _e293;
    }
    let _e294 = onPlane;
    let _e295 = toPlane;
    offset_2 = (_e294 - _e295);
    let _e297 = (*halfWidth);
    let _e298 = (*halfWidth);
    wLen2_ = max(dot(_e297, _e298), 0.000000000001f);
    let _e301 = (*halfHeight);
    let _e302 = (*halfHeight);
    hLen2_ = max(dot(_e301, _e302), 0.000000000001f);
    let _e305 = offset_2;
    let _e306 = (*halfWidth);
    let _e308 = wLen2_;
    u = clamp((dot(_e305, _e306) / _e308), -1f, 1f);
    let _e311 = offset_2;
    let _e312 = (*halfHeight);
    let _e314 = hLen2_;
    v_1 = clamp((dot(_e311, _e312) / _e314), -1f, 1f);
    let _e317 = (*centre);
    let _e318 = (*halfWidth);
    let _e319 = u;
    let _e322 = (*halfHeight);
    let _e323 = v_1;
    return ((_e317 + (_e318 * _e319)) + (_e322 * _e323));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_26: f32;

    let _e240 = (*a_3);
    let _e241 = (*a_3);
    ua = (_e240 / vec3(max(length(_e241), 0.000000000001f)));
    let _e246 = (*b_1);
    let _e247 = (*b_1);
    ub = (_e246 / vec3(max(length(_e247), 0.000000000001f)));
    let _e252 = ua;
    let _e253 = ub;
    angle_2 = acos(clamp(dot(_e252, _e253), -1f, 1f));
    let _e257 = ua;
    let _e258 = ub;
    axis_1 = cross(_e257, _e258);
    let _e260 = axis_1;
    len_2 = length(_e260);
    let _e262 = len_2;
    if (_e262 > 0.000001f) {
        let _e264 = angle_2;
        let _e265 = axis_1;
        let _e266 = (*n_4);
        let _e269 = len_2;
        local_26 = ((_e264 * dot(_e265, _e266)) / _e269);
    } else {
        local_26 = 0f;
    }
    let _e271 = local_26;
    return _e271;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_27: i32;
    var ha: f32;
    var hb: f32;
    var d_4: f32;
    var q: vec3<f32>;
    var local_28: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_29: f32;
    var param_126: vec3<f32>;
    var param_127: vec3<f32>;
    var param_128: vec3<f32>;
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var param_131: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e254 = i_8;
        if (_e254 < 4i) {
            let _e256 = i_8;
            let _e258 = (*corners_1)[_e256];
            a_4 = _e258;
            let _e259 = i_8;
            if (_e259 == 3i) {
                local_27 = 0i;
            } else {
                let _e261 = i_8;
                local_27 = (_e261 + 1i);
            }
            let _e263 = local_27;
            let _e265 = (*corners_1)[_e263];
            b_2 = _e265;
            let _e266 = a_4;
            let _e267 = (*n_5);
            ha = dot(_e266, _e267);
            let _e269 = b_2;
            let _e270 = (*n_5);
            hb = dot(_e269, _e270);
            let _e272 = ha;
            let _e273 = hb;
            d_4 = (_e272 - _e273);
            let _e275 = a_4;
            let _e276 = b_2;
            let _e277 = a_4;
            let _e279 = d_4;
            if (abs(_e279) > 0.000000000001f) {
                let _e282 = ha;
                let _e283 = d_4;
                local_28 = (_e282 / _e283);
            } else {
                local_28 = 0f;
            }
            let _e285 = local_28;
            q = (_e275 + ((_e276 - _e277) * _e285));
            let _e288 = ha;
            aAbove = (_e288 > 0f);
            let _e290 = hb;
            bAbove = (_e290 > 0f);
            let _e292 = aAbove;
            let _e293 = bAbove;
            if (_e292 || _e293) {
                let _e295 = aAbove;
                let _e296 = a_4;
                let _e297 = q;
                let _e300 = bAbove;
                let _e301 = b_2;
                let _e302 = q;
                param_126 = select(_e297, _e296, vec3(_e295));
                param_127 = select(_e302, _e301, vec3(_e300));
                let _e305 = (*n_5);
                param_128 = _e305;
                let _e306 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_126), (&param_127), (&param_128));
                local_29 = _e306;
            } else {
                local_29 = 0f;
            }
            let _e307 = local_29;
            let _e308 = total;
            total = (_e308 + _e307);
            let _e310 = aAbove;
            let _e311 = bAbove;
            let _e314 = q;
            let _e315 = exit;
            exit = select(_e315, _e314, vec3((_e310 && !(_e311))));
            let _e318 = aAbove;
            let _e320 = bAbove;
            let _e322 = q;
            let _e323 = entry;
            entry = select(_e323, _e322, vec3((!(_e318) && _e320)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e326 = i_8;
            i_8 = (_e326 + 1i);
        }
    }
    let _e328 = exit;
    param_129 = _e328;
    let _e329 = entry;
    param_130 = _e329;
    let _e330 = (*n_5);
    param_131 = _e330;
    let _e331 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_129), (&param_130), (&param_131));
    let _e332 = total;
    total = (_e332 + _e331);
    let _e334 = total;
    return max((-(_e334) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_30: f32;
    var local_31: f32;
    var local_32: f32;

    let _e237 = (*slot_1);
    let _e238 = (*slot_1);
    lane = (_e237 - ((_e238 / 4i) * 4i));
    let _e242 = lane;
    if (_e242 == 0i) {
        let _e245 = (*four)[0u];
        local_30 = _e245;
    } else {
        let _e246 = lane;
        if (_e246 == 1i) {
            let _e249 = (*four)[1u];
            local_31 = _e249;
        } else {
            let _e250 = lane;
            if (_e250 == 2i) {
                let _e253 = (*four)[2u];
                local_32 = _e253;
            } else {
                let _e255 = (*four)[3u];
                local_32 = _e255;
            }
            let _e256 = local_32;
            local_31 = _e256;
        }
        let _e257 = local_31;
        local_30 = _e257;
    }
    let _e258 = local_30;
    return _e258;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_132: vec4<f32>;
    var param_133: i32;

    let _e234 = (*slot_2);
    let _e238 = light_list_info.scales[(_e234 / 4i)];
    param_132 = _e238;
    let _e239 = (*slot_2);
    param_133 = _e239;
    let _e240 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_132), (&param_133));
    return _e240;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e236 = light_list_info.slot_rows[0i];
    let _e237 = (*row);
    a_5 = abs((_e236 - vec4(_e237)));
    let _e243 = light_list_info.slot_rows[1i];
    let _e244 = (*row);
    b_3 = abs((_e243 - vec4(_e244)));
    let _e249 = a_5[0u];
    let _e251 = a_5[1u];
    let _e254 = a_5[2u];
    let _e256 = a_5[3u];
    let _e260 = b_3[0u];
    let _e262 = b_3[1u];
    let _e265 = b_3[2u];
    let _e267 = b_3[3u];
    return (min(min(min(_e249, _e251), min(_e254, _e256)), min(min(_e260, _e262), min(_e265, _e267))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_134: vec4<f32>;
    var param_135: i32;

    let _e234 = (*slot_3);
    let _e238 = light_list_info.indices[(_e234 / 4i)];
    param_134 = _e238;
    let _e239 = (*slot_3);
    param_135 = _e239;
    let _e240 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_134), (&param_135));
    return _e240;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e233 = (*texel_2);
    let _e237 = light_list_info.list[1u];
    let _e239 = (*row_1);
    let _e243 = light_list_info.list[2u];
    let _e246 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e233 + 0.5f) * _e237), ((_e239 + 0.5f) * _e243)), 0f);
    return _e246;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_136: f32;
    var param_137: f32;
    var param_138: vec4<f32>;
    var param_139: i32;

    let _e241 = g_cluster_offset;
    let _e242 = (*slot_4);
    entry_1 = (_e241 + f32(_e242));
    let _e245 = entry_1;
    row_2 = floor((_e245 / 16f));
    let _e248 = entry_1;
    let _e249 = row_2;
    within_1 = (_e248 - (_e249 * 16f));
    let _e252 = within_1;
    texel_3 = floor((_e252 / 4f));
    let _e257 = light_list_info.cluster_depth[3u];
    let _e258 = row_2;
    let _e260 = texel_3;
    param_136 = _e260;
    param_137 = (_e257 + _e258);
    let _e261 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_136), (&param_137));
    four_1 = _e261;
    let _e262 = within_1;
    let _e263 = texel_3;
    let _e268 = four_1;
    param_138 = _e268;
    param_139 = i32(((_e262 - (_e263 * 4f)) + 0.5f));
    let _e269 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_138), (&param_139));
    return _e269;
}

fn Clustered_u0028_() -> bool {
    let _e233 = light_list_info.cluster_grid[3u];
    return (_e233 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_6: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_33: f32;
    var param_140: i32;
    var param_141: i32;
    var v_2: f32;
    var u_1: f32;
    var local_34: f32;
    var param_142: f32;
    var param_143: i32;
    var type_42: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_35: f32;
    var param_144: array<vec3<f32>, 4>;
    var param_145: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_36: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_146: vec3<f32>;
    var param_147: vec3<f32>;
    var param_148: vec3<f32>;
    var param_149: vec3<f32>;
    var param_150: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_37: vec3<f32>;
    var param_151: vec3<f32>;
    var param_152: vec3<f32>;
    var param_153: f32;
    var param_154: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_155: f32;
    var param_156: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e289 = (*index_2);
    if (_e289 < 8i) {
        let _e291 = (*index_2);
        let _e294 = frag_info.light_position[_e291];
        position = _e294;
        let _e295 = (*index_2);
        let _e298 = frag_info.light_color[_e295];
        color_1 = _e298;
        let _e299 = (*index_2);
        let _e302 = frag_info.light_direction[_e299];
        direction = _e302;
        let _e303 = (*index_2);
        let _e306 = frag_info.light_cone[_e303];
        cone = _e306;
    } else {
        let _e307 = (*index_2);
        slot_5 = (_e307 - 8i);
        let _e309 = Clustered_u0028_();
        clustered = _e309;
        let _e310 = clustered;
        if _e310 {
            let _e311 = slot_5;
            param_140 = _e311;
            let _e312 = ClusterRow_u0028_i1_u003b((&param_140));
            local_33 = _e312;
        } else {
            let _e313 = slot_5;
            param_141 = _e313;
            let _e314 = LightListRow_u0028_i1_u003b((&param_141));
            local_33 = _e314;
        }
        let _e315 = local_33;
        listRow = _e315;
        let _e316 = listRow;
        let _e320 = light_list_info.list[2u];
        v_2 = ((_e316 + 0.5f) * _e320);
        let _e324 = light_list_info.list[1u];
        u_1 = _e324;
        let _e325 = u_1;
        let _e327 = v_2;
        let _e329 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e325), _e327), 0f);
        position = _e329;
        let _e330 = u_1;
        let _e332 = v_2;
        let _e334 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e330), _e332), 0f);
        color_1 = _e334;
        let _e335 = u_1;
        let _e337 = v_2;
        let _e339 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e335), _e337), 0f);
        direction = _e339;
        let _e340 = u_1;
        let _e342 = v_2;
        let _e344 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e340), _e342), 0f);
        cone = _e344;
        let _e345 = clustered;
        if _e345 {
            let _e346 = listRow;
            param_142 = _e346;
            let _e347 = InSlots_u0028_f1_u003b((&param_142));
            local_34 = select(1f, 0f, _e347);
        } else {
            let _e349 = slot_5;
            param_143 = _e349;
            let _e350 = LightListScale_u0028_i1_u003b((&param_143));
            local_34 = _e350;
        }
        let _e351 = local_34;
        let _e353 = color_1[3u];
        color_1[3u] = (_e353 * _e351);
    }
    let _e357 = position[3u];
    type_42 = _e357;
    let _e358 = type_42;
    if (_e358 > 15.5f) {
        let _e361 = (*s_6).n;
        light_3.l = _e361;
        let _e364 = (*s_6).n;
        light_3.h = _e364;
        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 _e370 = light_3;
        return _e370;
    }
    let _e371 = type_42;
    if (_e371 > 2.5f) {
        let _e373 = direction;
        halfWidth_1 = _e373.xyz;
        let _e375 = cone;
        halfHeight_1 = _e375.xyz;
        let _e377 = position;
        let _e379 = v_world_position_1;
        toCentre = (_e377.xyz - _e379);
        let _e381 = toCentre;
        let _e382 = halfWidth_1;
        let _e384 = halfHeight_1;
        corners_2[0i] = ((_e381 - _e382) - _e384);
        let _e387 = toCentre;
        let _e388 = halfWidth_1;
        let _e390 = halfHeight_1;
        corners_2[1i] = ((_e387 + _e388) - _e390);
        let _e393 = toCentre;
        let _e394 = halfWidth_1;
        let _e396 = halfHeight_1;
        corners_2[2i] = ((_e393 + _e394) + _e396);
        let _e399 = toCentre;
        let _e400 = halfWidth_1;
        let _e402 = halfHeight_1;
        corners_2[3i] = ((_e399 - _e400) + _e402);
        let _e405 = toCentre;
        let _e406 = halfWidth_1;
        let _e407 = halfHeight_1;
        behind = (dot(_e405, cross(_e406, _e407)) >= 0f);
        let _e411 = behind;
        if _e411 {
            local_35 = 0f;
        } else {
            let _e412 = corners_2;
            param_144 = _e412;
            let _e414 = (*s_6).n;
            param_145 = _e414;
            let _e415 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_144), (&param_145));
            local_35 = _e415;
        }
        let _e416 = local_35;
        formFactor = _e416;
        let _e417 = halfWidth_1;
        let _e418 = halfHeight_1;
        area = (length(cross(_e417, _e418)) * 4f);
        let _e422 = area;
        if (_e422 > 0.000000001f) {
            let _e424 = area;
            local_36 = (1f / _e424);
        } else {
            local_36 = 0f;
        }
        let _e426 = local_36;
        radiance = _e426;
        let _e427 = toCentre;
        distance_2 = length(_e427);
        let _e430 = direction[3u];
        if (_e430 > 0f) {
            let _e432 = distance_2;
            let _e434 = direction[3u];
            ratio_1 = (_e432 / _e434);
            let _e436 = ratio_1;
            let _e437 = ratio_1;
            let _e439 = ratio_1;
            let _e441 = ratio_1;
            window_1 = clamp((1f - (((_e436 * _e437) * _e439) * _e441)), 0f, 1f);
            let _e445 = window_1;
            let _e446 = window_1;
            let _e448 = radiance;
            radiance = (_e448 * (_e445 * _e446));
        }
        let _e451 = (*s_6).v;
        let _e454 = (*s_6).n;
        mirror_1 = reflect(-(_e451), _e454);
        let _e456 = position;
        param_146 = _e456.xyz;
        let _e458 = halfWidth_1;
        param_147 = _e458;
        let _e459 = halfHeight_1;
        param_148 = _e459;
        let _e460 = v_world_position_1;
        param_149 = _e460;
        let _e461 = mirror_1;
        param_150 = _e461;
        let _e462 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_146), (&param_147), (&param_148), (&param_149), (&param_150));
        representative = _e462;
        let _e463 = representative;
        let _e464 = v_world_position_1;
        toPoint = (_e463 - _e464);
        let _e466 = toPoint;
        pointDistance = length(_e466);
        let _e468 = pointDistance;
        if (_e468 > 0.000001f) {
            let _e470 = toPoint;
            let _e471 = pointDistance;
            local_37 = (_e470 / vec3(_e471));
        } else {
            let _e475 = (*s_6).n;
            local_37 = _e475;
        }
        let _e476 = local_37;
        light_3.l = _e476;
        let _e479 = light_3.l;
        let _e481 = (*s_6).v;
        light_3.h = normalize((_e479 + _e481));
        let _e485 = formFactor;
        light_3.n_dot_l = _e485;
        let _e488 = (*s_6).n;
        let _e490 = light_3.h;
        light_3.n_dot_h = max(dot(_e488, _e490), 0f);
        let _e495 = (*s_6).v;
        let _e497 = light_3.h;
        light_3.v_dot_h = max(dot(_e495, _e497), 0f);
        let _e501 = color_1;
        let _e504 = color_1[3u];
        let _e506 = radiance;
        light_3.radiance = ((_e501.xyz * _e504) * _e506);
        light_3.integrated = 1f;
        let _e511 = (*s_6).n;
        param_151 = _e511;
        let _e513 = (*s_6).v;
        param_152 = _e513;
        let _e515 = (*s_6).roughness;
        param_153 = _e515;
        let _e516 = corners_2;
        param_154 = _e516;
        let _e517 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_151), (&param_152), (&param_153), (&param_154));
        light_3.ltc = _e517;
        let _e519 = light_3;
        return _e519;
    }
    let _e520 = direction;
    aim = normalize(_e520.xyz);
    attenuation_1 = 1f;
    let _e523 = type_42;
    if (_e523 < 0.5f) {
        let _e525 = aim;
        light_3.l = -(_e525);
    } else {
        let _e528 = position;
        let _e530 = v_world_position_1;
        toLight_1 = (_e528.xyz - _e530);
        let _e532 = toLight_1;
        distance_3 = length(_e532);
        let _e534 = distance_3;
        if (_e534 < 0.000001f) {
            let _e537 = (*s_6).n;
            light_3.l = _e537;
            let _e540 = (*s_6).n;
            light_3.h = _e540;
            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 _e546 = light_3;
            return _e546;
        }
        let _e547 = toLight_1;
        let _e548 = distance_3;
        light_3.l = (_e547 / vec3(_e548));
        let _e552 = distance_3;
        param_155 = _e552;
        let _e554 = direction[3u];
        param_156 = _e554;
        let _e555 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_155), (&param_156));
        attenuation_1 = _e555;
        let _e556 = type_42;
        if (_e556 > 1.5f) {
            let _e558 = aim;
            let _e560 = light_3.l;
            cosAngle = dot(_e558, -(_e560));
            let _e563 = cosAngle;
            let _e565 = cone[1u];
            let _e568 = cone[0u];
            let _e570 = cone[1u];
            ramp = clamp(((_e563 - _e565) / (_e568 - _e570)), 0f, 1f);
            let _e574 = ramp;
            let _e575 = ramp;
            let _e577 = attenuation_1;
            attenuation_1 = (_e577 * (_e574 * _e575));
        }
    }
    let _e580 = light_3.l;
    let _e582 = (*s_6).v;
    light_3.h = normalize((_e580 + _e582));
    let _e587 = (*s_6).n;
    let _e589 = light_3.l;
    light_3.n_dot_l = max(dot(_e587, _e589), 0f);
    let _e594 = (*s_6).n;
    let _e596 = light_3.h;
    light_3.n_dot_h = max(dot(_e594, _e596), 0f);
    let _e601 = (*s_6).v;
    let _e603 = light_3.h;
    light_3.v_dot_h = max(dot(_e601, _e603), 0f);
    let _e607 = color_1;
    let _e610 = color_1[3u];
    let _e612 = attenuation_1;
    light_3.radiance = ((_e607.xyz * _e610) * _e612);
    let _e615 = light_3;
    return _e615;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_38: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_157: f32;
    var param_158: f32;

    let _e246 = light_list_info.cluster_view_projection;
    let _e247 = (*world_3);
    clip_1 = (_e246 * vec4<f32>(_e247.x, _e247.y, _e247.z, 1f));
    let _e253 = clip_1;
    let _e256 = clip_1[3u];
    ndc_1 = (_e253.xy / vec2(max(_e256, 0.000001f)));
    let _e261 = light_list_info.cluster_grid;
    grid = _e261.xyz;
    let _e265 = light_list_info.cluster_depth[0u];
    near_1 = _e265;
    let _e267 = ndc_1[0u];
    let _e271 = grid[0u];
    let _e275 = grid[0u];
    tx = clamp(floor((((_e267 * 0.5f) + 0.5f) * _e271)), 0f, (_e275 - 1f));
    let _e279 = ndc_1[1u];
    let _e283 = grid[1u];
    let _e287 = grid[1u];
    ty = clamp(floor((((_e279 * 0.5f) + 0.5f) * _e283)), 0f, (_e287 - 1f));
    let _e291 = clip_1[3u];
    let _e292 = near_1;
    if (_e291 <= _e292) {
        local_38 = 0f;
    } else {
        let _e295 = clip_1[3u];
        let _e296 = near_1;
        let _e301 = light_list_info.cluster_depth[1u];
        let _e305 = grid[2u];
        local_38 = clamp(floor((log((_e295 / _e296)) * _e301)), 0f, (_e305 - 1f));
    }
    let _e308 = local_38;
    tz = _e308;
    let _e309 = tx;
    let _e310 = ty;
    let _e312 = grid[0u];
    let _e315 = tz;
    let _e317 = grid[0u];
    let _e320 = grid[1u];
    cell_1 = ((_e309 + (_e310 * _e312)) + ((_e315 * _e317) * _e320));
    let _e323 = cell_1;
    row_3 = floor((_e323 / 4f));
    let _e326 = cell_1;
    let _e327 = row_3;
    let _e332 = light_list_info.cluster_depth[2u];
    let _e333 = row_3;
    param_157 = (_e326 - (_e327 * 4f));
    param_158 = (_e332 + _e333);
    let _e335 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_157), (&param_158));
    header = _e335;
    let _e337 = header[0u];
    g_cluster_offset = _e337;
    let _e339 = header[1u];
    g_cluster_count = _e339;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_159: vec3<f32>;

    let _e235 = light_list_info.list[0u];
    tail = _e235;
    let _e236 = Clustered_u0028_();
    if _e236 {
        let _e237 = v_world_position_1;
        param_159 = _e237;
        FindCluster_u0028_vf3_u003b((&param_159));
        let _e238 = g_cluster_count;
        tail = _e238;
    }
    let _e241 = frag_info.frame_params[1u];
    let _e245 = tail;
    return (clamp(i32((_e241 + 0.5f)), 0i, 8i) + clamp(i32((_e245 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_4: LightSample;
    var param_160: i32;
    var param_161: Surface;
    var visibility: f32;
    var param_162: i32;
    var local_39: f32;
    var param_163: Surface;
    var param_164: LightSample;
    var param_165: i32;
    var param_166: vec3<f32>;
    var param_167: vec3<f32>;
    var param_168: i32;
    var param_169: Surface;
    var param_170: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e249 = LightCount_u0028_();
    count_1 = _e249;
    i_9 = 0i;
    loop {
        let _e250 = i_9;
        if (_e250 < 32i) {
            let _e252 = i_9;
            let _e253 = count_1;
            if (_e252 >= _e253) {
                break;
            }
            let _e255 = i_9;
            param_160 = _e255;
            let _e256 = (*s_7);
            param_161 = _e256;
            let _e257 = 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((&param_160), (&param_161));
            light_4 = _e257;
            let _e259 = light_4.n_dot_l;
            if (_e259 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e261 = i_9;
            param_162 = _e261;
            let _e262 = LightHasShadow_u0028_i1_u003b((&param_162));
            if _e262 {
                let _e263 = (*s_7);
                param_163 = _e263;
                let _e264 = light_4;
                param_164 = _e264;
                let _e265 = i_9;
                param_165 = _e265;
                let _e266 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_163), (&param_164), (&param_165));
                let _e267 = v_world_position_1;
                param_166 = _e267;
                let _e269 = (*s_7).n;
                param_167 = _e269;
                let _e270 = i_9;
                param_168 = _e270;
                let _e271 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_166), (&param_167), (&param_168));
                local_39 = (_e266 * _e271);
            } else {
                local_39 = 1f;
            }
            let _e273 = local_39;
            visibility = _e273;
            let _e274 = visibility;
            if (_e274 <= 0f) {
                continue;
            }
            let _e276 = (*s_7);
            param_169 = _e276;
            let _e277 = light_4;
            param_170 = _e277;
            let _e278 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_169), (&param_170));
            let _e280 = light_4.radiance;
            let _e283 = light_4.n_dot_l;
            let _e285 = visibility;
            let _e287 = light_transmittance;
            let _e289 = total_1;
            total_1 = (_e289 + ((((_e278 * _e280) * _e283) * _e285) * _e287));
            continue;
        } else {
            break;
        }
        continuing {
            let _e291 = i_9;
            i_9 = (_e291 + 1i);
        }
    }
    let _e293 = total_1;
    return _e293;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e232 = v_lightmap_uv_1;
    let _e233 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e232);
    texel_4 = _e233;
    let _e234 = texel_4;
    let _e237 = texel_4[3u];
    return ((_e234.xyz * _e237) * 8f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_40: f32;

    let _e234 = frag_info.material2_[2u];
    local_40 = floor((_e234 * 0.5f));
    let _e237 = local_40;
    return _e237;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_41: f32;
    var local_42: f32;

    let _e235 = OcclusionTarget_u0028_();
    target_ = _e235;
    let _e236 = target_;
    let _e238 = target_;
    if ((_e236 > 0.5f) && (_e238 < 1.5f)) {
        local_41 = 1f;
    } else {
        let _e242 = (*s_8).occlusion;
        local_41 = _e242;
    }
    let _e243 = local_41;
    local_42 = _e243;
    let _e244 = local_42;
    return _e244;
}

fn DirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var local_43: f32;
    var local_44: f32;

    let _e234 = OcclusionTarget_u0028_();
    if (_e234 > 1.5f) {
        local_43 = 1f;
    } else {
        let _e237 = (*s_9).occlusion;
        local_43 = _e237;
    }
    let _e238 = local_43;
    local_44 = _e238;
    let _e239 = local_44;
    return _e239;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_171: f32;
    var param_172: f32;
    var param_173: f32;
    var param_174: vec3<f32>;
    var param_175: f32;

    let _e240 = (*mu_1);
    param_171 = _e240;
    let _e241 = (*r_4);
    param_172 = _e241;
    let _e242 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_171), (&param_172));
    e_1 = _e242;
    let _e243 = (*rho_2);
    let _e244 = e_1;
    let _e246 = (*r_4);
    param_173 = _e246;
    let _e247 = FonAverage_u0028_f1_u003b((&param_173));
    let _e248 = (*rho_2);
    param_174 = _e248;
    param_175 = _e247;
    let _e249 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_174), (&param_175));
    let _e250 = e_1;
    return ((_e243 * _e244) + (_e249 * (1f - _e250)));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e233 = frag_info.target_origin[1u];
    return _e233;
}

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_10: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e233 = v_texcoord_1;
    let _e234 = MaterialLodBias_u0028_();
    let _e235 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e233, _e234);
    orm = _e235.xyz;
    let _e238 = (*s_10).metallic;
    let _e240 = orm[2u];
    (*s_10).metallic = clamp((_e238 * _e240), 0f, 1f);
    let _e245 = (*s_10).roughness;
    let _e247 = orm[1u];
    (*s_10).roughness = clamp((_e245 * _e247), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_176: vec3<f32>;

    let _e234 = v_texcoord_1;
    let _e235 = MaterialLodBias_u0028_();
    let _e236 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e234, _e235);
    param_176 = _e236.xyz;
    let _e238 = SrgbToLinear_u0028_vf3_u003b((&param_176));
    emissive = _e238;
    let _e239 = emissive;
    let _e241 = frag_info.emissive;
    let _e246 = frag_info.material2_[3u];
    (*s_11).emissive = ((_e239 * _e241.xyz) * _e246);
    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_12: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e234 = v_texcoord_1;
    let _e235 = MaterialLodBias_u0028_();
    let _e236 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e234, _e235);
    occlusion = _e236.x;
    let _e240 = frag_info.material2_[2u];
    let _e241 = OcclusionTarget_u0028_();
    strength_2 = (_e240 - (2f * _e241));
    let _e244 = occlusion;
    let _e245 = strength_2;
    (*s_12).occlusion = mix(1f, _e244, clamp(_e245, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_4: vec3<f32>;
    var sampled: vec3<f32>;

    let _e236 = v_texcoord_1;
    let _e237 = MaterialLodBias_u0028_();
    let _e238 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e236, _e237);
    sampledTexel = _e238;
    let _e239 = v_tangent_1;
    t_2 = _e239.xyz;
    let _e241 = t_2;
    let _e243 = (*s_13).n;
    let _e245 = (*s_13).n;
    let _e246 = t_2;
    t_2 = (_e241 - (_e243 * dot(_e245, _e246)));
    let _e250 = t_2;
    let _e251 = t_2;
    if (dot(_e250, _e251) < 0.000000000001f) {
        return;
    }
    let _e254 = t_2;
    t_2 = normalize(_e254);
    let _e257 = (*s_13).n;
    let _e258 = t_2;
    let _e261 = v_tangent_1[3u];
    b_4 = (cross(_e257, _e258) * _e261);
    let _e263 = gl_FrontFacing_1;
    if !(_e263) {
        let _e265 = t_2;
        t_2 = -(_e265);
    }
    let _e267 = sampledTexel;
    sampled = ((_e267.xyz * 2f) - vec3(1f));
    let _e274 = frag_info.emissive[3u];
    if (_e274 > 0.5f) {
        let _e276 = sampled;
        let _e278 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e276.xy, _e278.xy)), 0f));
    }
    let _e287 = frag_info.material2_[1u];
    let _e288 = sampled;
    let _e290 = (_e288.xy * _e287);
    sampled[0u] = _e290.x;
    sampled[1u] = _e290.y;
    let _e295 = t_2;
    let _e297 = sampled[0u];
    let _e299 = b_4;
    let _e301 = sampled[1u];
    let _e305 = (*s_13).n;
    let _e307 = sampled[2u];
    (*s_13).n = normalize((((_e295 * _e297) + (_e299 * _e301)) + (_e305 * _e307)));
    let _e313 = (*s_13).n;
    let _e315 = (*s_13).v;
    (*s_13).n_dot_v = max(dot(_e313, _e315), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e232 = (*texel_5);
    let _e236 = irradiance_info.atlas;
    let _e239 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e232 + vec2(0.5f)) * _e236.xy), 0f);
    return _e239;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_7: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f_3: vec2<f32>;
    var a_6: vec4<f32>;
    var param_177: vec2<f32>;
    var b_5: vec4<f32>;
    var param_178: vec2<f32>;
    var c_1: vec4<f32>;
    var param_179: vec2<f32>;
    var d_5: vec4<f32>;
    var param_180: vec2<f32>;

    let _e245 = (*uv_7);
    let _e246 = (*interior);
    at_1 = ((vec2(1f) + (_e245 * _e246)) - vec2(0.5f));
    let _e252 = at_1;
    low = floor(_e252);
    let _e254 = at_1;
    let _e255 = low;
    f_3 = (_e254 - _e255);
    let _e257 = (*corner);
    let _e258 = low;
    param_177 = (_e257 + _e258);
    let _e260 = AtlasTexel_u0028_vf2_u003b((&param_177));
    a_6 = _e260;
    let _e261 = (*corner);
    let _e262 = low;
    param_178 = ((_e261 + _e262) + vec2<f32>(1f, 0f));
    let _e265 = AtlasTexel_u0028_vf2_u003b((&param_178));
    b_5 = _e265;
    let _e266 = (*corner);
    let _e267 = low;
    param_179 = ((_e266 + _e267) + vec2<f32>(0f, 1f));
    let _e270 = AtlasTexel_u0028_vf2_u003b((&param_179));
    c_1 = _e270;
    let _e271 = (*corner);
    let _e272 = low;
    param_180 = ((_e271 + _e272) + vec2<f32>(1f, 1f));
    let _e275 = AtlasTexel_u0028_vf2_u003b((&param_180));
    d_5 = _e275;
    let _e276 = a_6;
    let _e277 = b_5;
    let _e279 = f_3[0u];
    let _e282 = c_1;
    let _e283 = d_5;
    let _e285 = f_3[0u];
    let _e289 = f_3[1u];
    return mix(mix(_e276, _e277, vec4(_e279)), mix(_e282, _e283, vec4(_e285)), vec4(_e289));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e236 = (*direction_1)[0u];
    let _e239 = (*direction_1)[1u];
    let _e243 = (*direction_1)[2u];
    sum_1 = ((abs(_e236) + abs(_e239)) + abs(_e243));
    let _e246 = sum_1;
    if (_e246 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e248 = (*direction_1);
    let _e249 = sum_1;
    n_6 = (_e248 / vec3(_e249));
    let _e252 = n_6;
    xy = _e252.xy;
    let _e255 = n_6[2u];
    if (_e255 < 0f) {
        let _e258 = n_6[1u];
        let _e262 = n_6[0u];
        let _e267 = n_6[0u];
        let _e271 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e258)) * select(-1f, 1f, (_e262 >= 0f))), ((1f - abs(_e267)) * select(-1f, 1f, (_e271 >= 0f))));
    }
    let _e276 = xy;
    return ((_e276 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_4: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_181: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_182: vec3<f32>;
    var param_183: vec2<f32>;
    var param_184: f32;
    var param_185: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_186: vec3<f32>;
    var param_187: vec2<f32>;
    var param_188: f32;
    var param_189: vec2<f32>;
    var local_45: vec3<f32>;

    let _e278 = irradiance_info.origin;
    origin_2 = _e278.xyz;
    let _e281 = irradiance_info.spacing;
    spacing = _e281.xyz;
    let _e284 = irradiance_info.counts;
    counts = _e284.xyz;
    let _e288 = irradiance_info.tiles[0u];
    irradianceTile = _e288;
    let _e291 = irradiance_info.tiles[1u];
    depthTile = _e291;
    let _e294 = irradiance_info.tiles[2u];
    columns = _e294;
    let _e297 = irradiance_info.tiles[3u];
    momentsTop = _e297;
    let _e298 = (*normal_1);
    unit = normalize(_e298);
    let _e300 = (*world_4);
    let _e301 = unit;
    let _e304 = irradiance_info.spacing[3u];
    let _e307 = (*view_1);
    let _e310 = irradiance_info.counts[3u];
    biased = ((_e300 + (_e301 * _e304)) + (_e307 * _e310));
    let _e313 = biased;
    let _e314 = origin_2;
    let _e316 = spacing;
    grid_1 = ((_e313 - _e314) / _e316);
    let _e318 = grid_1;
    let _e320 = counts;
    base = clamp(floor(_e318), vec3<f32>(0f, 0f, 0f), (_e320 - vec3(2f)));
    let _e324 = grid_1;
    let _e325 = base;
    f_4 = clamp((_e324 - _e325), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e328 = corner_1;
        if (_e328 < 8i) {
            let _e330 = corner_1;
            let _e333 = corner_1;
            let _e338 = corner_1;
            offset_3 = vec3<f32>(f32((_e330 & 1i)), f32(((_e333 >> bitcast<u32>(1i)) & 1i)), f32(((_e338 >> bitcast<u32>(2i)) & 1i)));
            let _e344 = base;
            let _e345 = offset_3;
            cell_2 = (_e344 + _e345);
            let _e348 = cell_2[2u];
            let _e350 = counts[1u];
            let _e353 = cell_2[1u];
            let _e356 = counts[0u];
            let _e359 = cell_2[0u];
            probe = ((((_e348 * _e350) + _e353) * _e356) + _e359);
            let _e361 = probe;
            let _e362 = columns;
            let _e367 = probe;
            let _e368 = columns;
            tile_4 = vec2<f32>((_e361 - (floor((_e361 / _e362)) * _e362)), floor((_e367 / _e368)));
            let _e372 = tile_4;
            let _e373 = irradianceTile;
            irradianceCorner = (_e372 * (_e373 + 2f));
            let _e377 = tile_4[0u];
            let _e378 = depthTile;
            let _e381 = momentsTop;
            let _e383 = tile_4[1u];
            let _e384 = depthTile;
            momentCorner = vec2<f32>((_e377 * (_e378 + 2f)), (_e381 + (_e383 * (_e384 + 2f))));
            let _e389 = irradianceCorner;
            param_181 = (_e389 + vec2(1f));
            let _e392 = AtlasTexel_u0028_vf2_u003b((&param_181));
            if (_e392.w < 0.5f) {
                continue;
            }
            let _e395 = f_4;
            let _e397 = f_4;
            let _e398 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e395), _e397, _e398);
            let _e401 = trilinear[0u];
            let _e403 = trilinear[1u];
            let _e406 = trilinear[2u];
            weight_3 = max(((_e401 * _e403) * _e406), 0.001f);
            let _e409 = origin_2;
            let _e410 = spacing;
            let _e411 = cell_2;
            probePosition = (_e409 + (_e410 * _e411));
            let _e414 = probePosition;
            let _e415 = biased;
            toProbe = (_e414 - _e415);
            let _e417 = toProbe;
            distance_4 = length(_e417);
            let _e419 = distance_4;
            if (_e419 > 0.000001f) {
                let _e421 = toProbe;
                let _e422 = distance_4;
                direction_2 = (_e421 / vec3(_e422));
                let _e425 = unit;
                let _e426 = probePosition;
                let _e427 = (*world_4);
                facing = ((dot(_e425, normalize((_e426 - _e427))) * 0.5f) + 0.5f);
                let _e433 = facing;
                let _e434 = facing;
                probeWeight = ((_e433 * _e434) + 0.2f);
                let _e437 = direction_2;
                param_182 = -(_e437);
                let _e439 = ProbeOctahedral_u0028_vf3_u003b((&param_182));
                let _e440 = momentCorner;
                param_183 = _e440;
                let _e441 = depthTile;
                param_184 = _e441;
                param_185 = _e439;
                let _e442 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_183), (&param_184), (&param_185));
                moments_3 = _e442.xy;
                chebyshev = 1f;
                let _e444 = distance_4;
                let _e446 = moments_3[0u];
                if (_e444 > _e446) {
                    let _e449 = moments_3[1u];
                    let _e451 = moments_3[0u];
                    let _e453 = moments_3[0u];
                    variance_1 = max((_e449 - (_e451 * _e453)), 0.000001f);
                    let _e457 = distance_4;
                    let _e459 = moments_3[0u];
                    difference = (_e457 - _e459);
                    let _e461 = variance_1;
                    let _e462 = variance_1;
                    let _e463 = difference;
                    let _e464 = difference;
                    chebyshev = (_e461 / (_e462 + (_e463 * _e464)));
                    let _e468 = chebyshev;
                    let _e469 = chebyshev;
                    let _e471 = chebyshev;
                    chebyshev = ((_e468 * _e469) * _e471);
                }
                let _e473 = probeWeight;
                let _e474 = chebyshev;
                probeWeight = max((_e473 * max(_e474, 0.05f)), 0.000001f);
                let _e478 = probeWeight;
                if (_e478 < 0.2f) {
                    let _e480 = probeWeight;
                    let _e481 = probeWeight;
                    let _e484 = probeWeight;
                    probeWeight = (_e484 * ((_e480 * _e481) * 25f));
                }
                let _e486 = probeWeight;
                let _e487 = weight_3;
                weight_3 = (_e487 * _e486);
            }
            let _e489 = unit;
            param_186 = _e489;
            let _e490 = ProbeOctahedral_u0028_vf3_u003b((&param_186));
            let _e491 = irradianceCorner;
            param_187 = _e491;
            let _e492 = irradianceTile;
            param_188 = _e492;
            param_189 = _e490;
            let _e493 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_187), (&param_188), (&param_189));
            let _e495 = weight_3;
            let _e497 = total_2;
            total_2 = (_e497 + (_e493.xyz * _e495));
            let _e499 = weight_3;
            let _e500 = weights;
            weights = (_e500 + _e499);
            continue;
        } else {
            break;
        }
        continuing {
            let _e502 = corner_1;
            corner_1 = (_e502 + 1i);
        }
    }
    let _e504 = weights;
    if (_e504 > 0f) {
        let _e506 = total_2;
        let _e507 = weights;
        local_45 = (_e506 / vec3(_e507));
    } else {
        local_45 = vec3<f32>(0f, 0f, 0f);
    }
    let _e510 = local_45;
    return _e510;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e233 = irradiance_info.origin[3u];
    return (_e233 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_14: ptr<function, Surface>) {
    var param_190: vec3<f32>;
    var param_191: vec3<f32>;
    var param_192: vec3<f32>;
    var param_193: Surface;
    var param_194: Surface;
    var param_195: Surface;

    let _e238 = IrradianceEnabled_u0028_();
    if _e238 {
        let _e239 = v_world_position_1;
        param_190 = _e239;
        let _e241 = (*s_14).n;
        param_191 = _e241;
        let _e243 = (*s_14).v;
        param_192 = _e243;
        let _e244 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_190), (&param_191), (&param_192));
        let _e247 = frag_info.material[2u];
        (*s_14).ambient = (_e244 * _e247);
    }
    let _e250 = (*s_14);
    param_193 = _e250;
    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((&param_193));
    let _e251 = param_193;
    (*s_14) = _e251;
    let _e252 = (*s_14);
    param_194 = _e252;
    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((&param_194));
    let _e253 = param_194;
    (*s_14) = _e253;
    let _e254 = (*s_14);
    param_195 = _e254;
    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((&param_195));
    let _e255 = param_195;
    (*s_14) = _e255;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_46: vec3<f32>;

    let _e232 = Orthographic_u0028_();
    if _e232 {
        let _e234 = fog_info.forward;
        local_46 = -(_e234.xyz);
    } else {
        let _e238 = fog_info.eye;
        let _e240 = v_world_position_1;
        local_46 = normalize((_e238.xyz - _e240));
    }
    let _e243 = local_46;
    return _e243;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_15: Surface;
    var param_196: vec3<f32>;
    var param_197: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e237 = v_texcoord_1;
    let _e238 = MaterialLodBias_u0028_();
    let _e239 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e237, _e238);
    texel_6 = _e239;
    let _e240 = texel_6;
    param_196 = _e240.xyz;
    let _e242 = SrgbToLinear_u0028_vf3_u003b((&param_196));
    let _e244 = frag_info.base_color;
    param_197 = _e244.xyz;
    let _e246 = SrgbToLinear_u0028_vf3_u003b((&param_197));
    let _e248 = v_color_1;
    s_15.albedo = ((_e242 * _e246) * _e248.xyz);
    let _e253 = texel_6[3u];
    let _e256 = frag_info.base_color[3u];
    let _e259 = v_color_1[3u];
    s_15.alpha = ((_e253 * _e256) * _e259);
    let _e263 = s_15.albedo;
    g_albedo = _e263;
    let _e266 = frag_info.material2_[0u];
    cutoff = _e266;
    let _e267 = cutoff;
    if (_e267 > 1f) {
        let _e269 = cutoff;
        edge = (_e269 - 1f);
        let _e272 = s_15.alpha;
        let _e273 = edge;
        let _e276 = s_15.alpha;
        let _e277 = fwidth(_e276);
        s_15.alpha = clamp((((_e272 - _e273) / max(_e277, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e283 = cutoff;
        if (_e283 >= 0f) {
            s_15.alpha = 1f;
        }
    }
    let _e286 = cutoff;
    let _e288 = cutoff;
    g_premultiply = ((_e286 < 0f) && (_e288 > -0.75f));
    let _e291 = v_normal_1;
    s_15.n = normalize(_e291);
    let _e294 = gl_FrontFacing_1;
    if !(_e294) {
        let _e297 = s_15.n;
        s_15.n = -(_e297);
    }
    let _e300 = TowardsEye_u0028_();
    s_15.v = _e300;
    let _e303 = s_15.n;
    let _e305 = s_15.v;
    s_15.n_dot_v = max(dot(_e303, _e305), 0.0001f);
    let _e311 = frag_info.material[0u];
    s_15.metallic = clamp(_e311, 0f, 1f);
    let _e316 = frag_info.material[1u];
    s_15.roughness = clamp(_e316, 0.02f, 1f);
    let _e320 = frag_info.ambient_ground;
    let _e323 = frag_info.ambient_sky;
    let _e327 = s_15.n[1u];
    let _e334 = frag_info.material[2u];
    s_15.ambient = (mix(_e320.xyz, _e323.xyz, vec3(((_e327 * 0.5f) + 0.5f))) * _e334);
    let _e339 = frag_info.frame_params[0u];
    s_15.exposure = max(_e339, 0f);
    s_15.occlusion = 1f;
    s_15.emissive = vec3<f32>(0f, 0f, 0f);
    let _e344 = s_15;
    return _e344;
}

fn main_1() {
    var s_16: Surface;
    var param_198: Surface;
    var param_199: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_200: vec3<f32>;
    var param_201: f32;
    var param_202: f32;
    var directOcclusion: f32;
    var param_203: Surface;
    var indirectOcclusion: f32;
    var param_204: Surface;
    var ambient: vec3<f32>;
    var levels: f32;
    var f0_3: vec3<f32>;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_1: vec2<f32>;
    var param_205: f32;
    var param_206: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var lit_3: vec3<f32>;
    var param_207: Surface;
    var param_208: Surface;
    var param_209: vec3<f32>;
    var param_210: vec3<f32>;
    var param_211: f32;
    var param_212: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e264 = ReadSurface_u0028_();
    s_16 = _e264;
    let _e265 = s_16;
    param_198 = _e265;
    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((&param_198));
    let _e266 = param_198;
    s_16 = _e266;
    let _e267 = s_16;
    param_199 = _e267;
    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((&param_199));
    let _e268 = param_199;
    s_16 = _e268;
    let _e270 = s_16.metallic;
    metallic = clamp(_e270, 0f, 1f);
    let _e273 = s_16.albedo;
    let _e274 = metallic;
    diffuseColor_1 = (_e273 * (1f - _e274));
    let _e277 = EonDiffuse_u0028_();
    if _e277 {
        let _e278 = diffuseColor_1;
        param_200 = _e278;
        let _e280 = s_16.roughness;
        param_201 = _e280;
        let _e282 = s_16.n_dot_v;
        param_202 = _e282;
        let _e283 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_200), (&param_201), (&param_202));
        diffuseColor_1 = _e283;
    }
    let _e284 = s_16;
    param_203 = _e284;
    let _e285 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_203));
    directOcclusion = _e285;
    let _e286 = s_16;
    param_204 = _e286;
    let _e287 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_204));
    indirectOcclusion = _e287;
    let _e288 = diffuseColor_1;
    let _e290 = s_16.ambient;
    let _e292 = indirectOcclusion;
    ambient = ((_e288 * _e290) * _e292);
    let _e296 = frag_info.frame_params[3u];
    levels = _e296;
    let _e297 = levels;
    if (_e297 > 0f) {
        let _e300 = s_16.albedo;
        let _e301 = metallic;
        f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e300, vec3(_e301));
        let _e305 = s_16.v;
        let _e308 = s_16.n;
        reflected = reflect(-(_e305), _e308);
        let _e311 = s_16.n;
        let _e312 = levels;
        let _e313 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e311, _e312);
        irradiance = _e313.xyz;
        let _e315 = reflected;
        let _e317 = s_16.roughness;
        let _e318 = levels;
        let _e320 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e315, (_e317 * _e318));
        prefiltered = _e320.xyz;
        let _e323 = s_16.roughness;
        param_205 = _e323;
        let _e325 = s_16.n_dot_v;
        param_206 = _e325;
        let _e326 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_205), (&param_206));
        ab_1 = _e326;
        let _e327 = f0_3;
        let _e329 = ab_1[0u];
        let _e332 = ab_1[1u];
        single_1 = ((_e327 * _e329) + vec3(_e332));
        let _e335 = prefiltered;
        let _e336 = single_1;
        specular_1 = (_e335 * _e336);
        let _e338 = EnergyCompensation_u0028_();
        if _e338 {
            let _e340 = ab_1[0u];
            let _e342 = ab_1[1u];
            missed = (1f - (_e340 + _e342));
            let _e345 = f0_3;
            let _e346 = f0_3;
            average_2 = (_e345 + ((vec3<f32>(1f, 1f, 1f) - _e346) / vec3(21f)));
            let _e351 = single_1;
            let _e352 = average_2;
            let _e354 = missed;
            let _e355 = average_2;
            multiple = ((_e351 * _e352) / (vec3<f32>(1f, 1f, 1f) - (_e355 * _e354)));
            let _e359 = multiple;
            let _e360 = missed;
            let _e362 = irradiance;
            let _e364 = specular_1;
            specular_1 = (_e364 + ((_e359 * _e360) * _e362));
        }
        let _e366 = diffuseColor_1;
        let _e367 = irradiance;
        let _e369 = specular_1;
        let _e373 = frag_info.material[2u];
        let _e375 = indirectOcclusion;
        ambient = ((((_e366 * _e367) + _e369) * _e373) * _e375);
    }
    let _e377 = diffuseColor_1;
    let _e378 = SampleLightmap_u0028_();
    let _e380 = indirectOcclusion;
    let _e382 = ambient;
    ambient = (_e382 + ((_e377 * _e378) * _e380));
    let _e384 = s_16;
    param_207 = _e384;
    let _e385 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_207));
    let _e386 = directOcclusion;
    let _e388 = ambient;
    let _e391 = s_16.emissive;
    lit_3 = (((_e385 * _e386) + _e388) + _e391);
    let _e393 = s_16;
    param_208 = _e393;
    let _e394 = lit_3;
    param_209 = _e394;
    let _e395 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_208), (&param_209));
    if _e395 {
        return;
    }
    let _e396 = lit_3;
    param_210 = _e396;
    let _e398 = s_16.alpha;
    param_211 = _e398;
    let _e400 = s_16.roughness;
    param_212 = _e400;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_210), (&param_211), (&param_212));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 27,
          samplerBinding: 28,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 29,
          samplerBinding: 30,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'PbrLayeredOpaqueDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct LayerInfo {
    specular: vec4<f32>,
    coat: vec4<f32>,
    sheen: vec4<f32>,
    anisotropy: vec4<f32>,
    transmission: vec4<f32>,
    attenuation: vec4<f32>,
    iridescence: vec4<f32>,
    uv_transform: array<vec4<f32>, 10>,
    scene_color: vec4<f32>,
    scene_viewport: vec4<f32>,
    scene_levels: array<vec4<f32>, 6>,
    scene_view_projection: mat4x4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
var<private> g_f0_dielectric: vec3<f32>;
var<private> g_f90_: f32;
var<private> g_coat: f32;
var<private> g_coat_roughness: f32;
var<private> g_coat_n: vec3<f32>;
var<private> g_coat_n_dot_v: f32;
var<private> g_coat_through: f32;
var<private> g_sheen: vec3<f32>;
var<private> g_sheen_roughness: f32;
var<private> g_sheen_albedo: f32;
var<private> g_sheen_scale: f32;
var<private> g_aniso: f32;
var<private> g_aniso_t: vec3<f32>;
var<private> g_aniso_b: vec3<f32>;
var<private> g_transmission: f32;
var<private> g_thickness: f32;
var<private> g_transmittance: vec3<f32>;
var<private> g_iridescence: f32;
var<private> g_irid_fresnel: vec3<f32>;
var<private> g_pane: bool;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(16)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(17)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(6)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var base_color_texture_smp: sampler;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(20)
var ltc_texture_tex: texture_2d<f32>;
@group(1) @binding(21)
var ltc_texture_smp: sampler;
var<private> g_rect_corners: array<vec3<f32>, 4>;
@group(1) @binding(5)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(30)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(31)
var point_shadow_texture_smp: sampler;
@group(1) @binding(28)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(29)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(14)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var irradiance_texture_smp: sampler;
@group(1) @binding(18)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(19)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(22)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(23)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(26)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(27)
var occlusion_texture_smp: sampler;
@group(1) @binding(10)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var emissive_texture_smp: sampler;
@group(1) @binding(24)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(25)
var normal_texture_smp: sampler;
@group(1) @binding(34)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(35)
var shadow_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(3)
var<uniform> layer_info: LayerInfo;
@group(1) @binding(8)
var coat_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var coat_texture_smp: sampler;
@group(1) @binding(36)
var sheen_texture_tex: texture_2d<f32>;
@group(1) @binding(37)
var sheen_texture_smp: sampler;
@group(1) @binding(12)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(13)
var environment_texture_smp: sampler;
@group(1) @binding(32)
var scene_color_texture_tex: texture_2d<f32>;
@group(1) @binding(33)
var scene_color_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e298 = v_world_position_1;
    let _e300 = fog_info.eye;
    let _e304 = fog_info.forward;
    return dot((_e298 - _e300.xyz), _e304.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e303 = ViewDepth_u0028_();
    z = abs(_e303);
    let _e305 = z;
    near = (_e305 / 5f);
    let _e307 = z;
    far = (_e307 / 200f);
    let _e309 = far;
    let _e310 = far;
    let _e312 = far;
    far3_ = ((_e309 * _e310) * _e312);
    let _e314 = (*alpha);
    let _e315 = near;
    let _e316 = near;
    let _e319 = far3_;
    let _e320 = far3_;
    return (_e314 * clamp((10f / ((0.00001f + (_e315 * _e316)) + (_e319 * _e320))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e307 = fog_info.forward[3u];
    mode = _e307;
    let _e308 = mode;
    if (_e308 > 0.5f) {
        let _e311 = frag_color[3u];
        alpha_1 = _e311;
        let _e312 = alpha_1;
        param = _e312;
        let _e313 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e313;
        let _e314 = frag_color;
        let _e316 = weight;
        let _e317 = (_e314.xyz * _e316);
        let _e318 = alpha_1;
        let _e319 = weight;
        accumulate = vec4<f32>(_e317.x, _e317.y, _e317.z, (_e318 * _e319));
        let _e325 = mode;
        let _e327 = mode;
        revealage = ((_e325 > 1.5f) && (_e327 < 2.5f));
        let _e330 = revealage;
        if _e330 {
            let _e331 = alpha_1;
            local = vec4(_e331);
        } else {
            let _e333 = accumulate;
            local = _e333;
        }
        let _e334 = local;
        frag_color = _e334;
        let _e335 = mode;
        if (_e335 > 2.5f) {
            let _e337 = alpha_1;
            frag_surface = vec4(_e337);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e301 = (*n)[0u];
    let _e304 = (*n)[1u];
    let _e308 = (*n)[2u];
    let _e311 = (*n);
    (*n) = (_e311 / vec3(((abs(_e301) + abs(_e304)) + abs(_e308))));
    let _e314 = (*n);
    e = _e314.xy;
    let _e317 = (*n)[2u];
    if (_e317 < 0f) {
        let _e319 = (*n);
        let _e325 = (*n)[0u];
        let _e329 = (*n)[1u];
        e = ((vec2(1f) - abs(_e319.yx)) * vec2<f32>(select(-1f, 1f, (_e325 >= 0f)), select(-1f, 1f, (_e329 >= 0f))));
    }
    let _e334 = e;
    return ((_e334 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e299 = (*linear);
    let _e301 = (*linear);
    let _e305 = (*linear);
    return mix((_e299 * 12.92f), ((pow(_e301, 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), _e305));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e302 = g_albedo;
    param_1 = clamp(_e302, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e304 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e304.x, _e304.y, _e304.z, 1f);
    let _e309 = g_debug_surface_on;
    if _e309 {
        let _e310 = g_debug_surface;
        let _e311 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e310.x, _e310.y, _e310.z, _e311);
        return;
    }
    let _e316 = v_normal_1;
    geometric = normalize(_e316);
    let _e318 = gl_FrontFacing_1;
    if !(_e318) {
        let _e320 = geometric;
        geometric = -(_e320);
    }
    let _e322 = geometric;
    param_2 = _e322;
    let _e323 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e324 = (*roughness);
    let _e326 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e323.x, _e323.y, clamp(_e324, 0f, 1f), _e326);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e300 = fog_info.projection[0u];
    return (_e300 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e299 = Orthographic_u0028_();
    if _e299 {
        let _e300 = ViewDepth_u0028_();
        local_1 = max(_e300, 0f);
    } else {
        let _e302 = v_world_position_1;
        let _e304 = fog_info.eye;
        local_1 = distance(_e302, _e304.xyz);
    }
    let _e307 = local_1;
    return _e307;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e306 = fog_info.fog[3u];
    density = _e306;
    let _e307 = density;
    if (_e307 <= 0f) {
        let _e309 = (*color);
        return _e309;
    }
    let _e310 = EyeDistance_u0028_();
    d = _e310;
    let _e313 = fog_info.eye[3u];
    falloff = _e313;
    let _e314 = falloff;
    if (_e314 > 0f) {
        let _e316 = falloff;
        let _e318 = v_world_position_1[1u];
        let _e321 = fog_info.eye[1u];
        k = (_e316 * (_e318 - _e321));
        let _e324 = k;
        if (abs(_e324) > 0.001f) {
            let _e327 = k;
            let _e331 = k;
            local_2 = ((1f - exp(-(_e327))) / _e331);
        } else {
            let _e333 = k;
            local_2 = (1f - (0.5f * _e333));
        }
        let _e336 = local_2;
        let _e337 = density;
        density = (_e337 * _e336);
    }
    let _e340 = fog_info.fog;
    let _e342 = (*color);
    let _e343 = density;
    let _e345 = d;
    return mix(_e340.xyz, _e342, vec3(clamp(exp((-(_e343) * _e345)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e304 = g_premultiply;
    let _e305 = (*alpha_2);
    weight_1 = select(1f, _e305, _e304);
    let _e307 = (*linearColor);
    param_3 = _e307;
    let _e308 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e309 = weight_1;
    let _e310 = (_e308 * _e309);
    let _e311 = (*alpha_2);
    let _e312 = g_pass_through;
    frag_color = vec4<f32>(_e310.x, _e310.y, _e310.z, (_e311 * (1f - _e312)));
    let _e319 = (*roughness_1);
    param_4 = _e319;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e299 = (*srgb);
    let _e302 = (*srgb);
    let _e307 = (*srgb);
    return mix((_e299 / vec3(12.92f)), pow(((_e302 + 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), _e307));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e301 = (*key);
    hue = fract(((_e301 * 0.618034f) + 0.13f));
    let _e305 = hue;
    k_1 = clamp((abs(((fract((vec3(_e305) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e318 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e318, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_3020_: bool;

    let _e299 = (*c);
    let _e300 = (*c);
    let _e302 = any((_e299 != _e300));
    phi_3020_ = _e302;
    if !(_e302) {
        let _e304 = (*c);
        phi_3020_ = any((abs(_e304) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e309 = phi_3020_;
    return _e309;
}

fn MapUv_u0028_i1_u003b(slot: ptr<function, i32>) -> vec2<f32> {
    var uvw: vec3<f32>;

    let _e300 = v_texcoord_1;
    uvw = vec3<f32>(_e300.x, _e300.y, 1f);
    let _e304 = (*slot);
    let _e308 = layer_info.uv_transform[(_e304 * 2i)];
    let _e310 = uvw;
    let _e312 = (*slot);
    let _e317 = layer_info.uv_transform[((_e312 * 2i) + 1i)];
    let _e319 = uvw;
    return vec2<f32>(dot(_e308.xyz, _e310), dot(_e317.xyz, _e319));
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var param_7: i32;
    var grey: f32;
    var param_8: vec3<f32>;
    var param_9: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var param_10: i32;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_11: vec3<f32>;
    var key_1: f32;
    var param_12: f32;
    var srgb_1: vec3<f32>;
    var param_13: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_14: vec3<f32>;
    var param_15: f32;
    var phi_3110_: bool;
    var phi_3380_: bool;

    let _e343 = gl_FragCoord_1[0u];
    let _e346 = frag_info.debug_view[1u];
    if (_e343 < _e346) {
        let _e350 = frag_info.debug_view[2u];
        local_3 = _e350;
    } else {
        let _e353 = frag_info.debug_view[0u];
        local_3 = _e353;
    }
    let _e354 = local_3;
    view = _e354;
    let _e355 = view;
    if (_e355 < 0.5f) {
        return false;
    }
    let _e357 = view;
    code = i32((_e357 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e360 = v_normal_1;
    geometric_n = normalize(_e360);
    let _e362 = v_tangent_1;
    let _e364 = geometric_n;
    let _e365 = geometric_n;
    let _e366 = v_tangent_1;
    tangent = (_e362.xyz - (_e364 * dot(_e365, _e366.xyz)));
    let _e371 = tangent;
    let _e372 = tangent;
    let _e374 = (dot(_e371, _e372) > 0.000000000001f);
    phi_3110_ = _e374;
    if _e374 {
        let _e376 = v_tangent_1[3u];
        phi_3110_ = (abs((abs(_e376) - 1f)) < 0.01f);
    }
    let _e382 = phi_3110_;
    tangent_usable = _e382;
    let _e385 = frag_info.debug_view[3u];
    identity = _e385;
    let _e386 = identity;
    identity_object = floor((_e386 / 8192f));
    let _e389 = identity;
    let _e390 = identity_object;
    identity_rest = (_e389 - (_e390 * 8192f));
    let _e393 = identity_rest;
    identity_material = floor((_e393 / 2f));
    let _e396 = identity_rest;
    let _e397 = identity_material;
    normal_mapped = ((_e396 - (_e397 * 2f)) > 0.5f);
    let _e401 = code;
    if (_e401 == 1i) {
        let _e404 = (*s).albedo;
        param_5 = clamp(_e404, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e406 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e406;
    } else {
        let _e407 = code;
        if (_e407 == 2i) {
            let _e410 = (*s).n;
            shown = ((_e410 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e413 = code;
            if (_e413 == 3i) {
                let _e416 = (*s).roughness;
                shown = vec3(clamp(_e416, 0f, 1f));
            } else {
                let _e419 = code;
                if (_e419 == 4i) {
                    let _e422 = (*s).metallic;
                    shown = vec3(clamp(_e422, 0f, 1f));
                } else {
                    let _e425 = code;
                    if (_e425 == 5i) {
                        let _e428 = (*s).occlusion;
                        shown = vec3(clamp(_e428, 0f, 1f));
                    } else {
                        let _e431 = code;
                        if (_e431 == 6i) {
                            let _e434 = (*s).emissive;
                            param_6 = clamp(_e434, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e436 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e436;
                        } else {
                            let _e437 = code;
                            if (_e437 == 7i) {
                                param_7 = 0i;
                                let _e439 = MapUv_u0028_i1_u003b((&param_7));
                                let _e440 = fract(_e439);
                                shown = vec3<f32>(_e440.x, _e440.y, 0f);
                            } else {
                                let _e444 = code;
                                if (_e444 == 8i) {
                                    let _e446 = (*lit);
                                    param_8 = clamp(_e446, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e448 = LinearToSrgb_u0028_vf3_u003b((&param_8));
                                    grey = dot(_e448, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e450 = (*lit);
                                    param_9 = _e450;
                                    let _e451 = NonFinite_u0028_vf3_u003b((&param_9));
                                    if _e451 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e452 = grey;
                                        local_4 = vec3((_e452 * 0.5f));
                                    }
                                    let _e455 = local_4;
                                    shown = _e455;
                                } else {
                                    let _e456 = code;
                                    if (_e456 == 9i) {
                                        let _e458 = tangent_usable;
                                        if _e458 {
                                            let _e459 = tangent;
                                            local_5 = ((normalize(_e459) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e463 = local_5;
                                        shown = _e463;
                                    } else {
                                        let _e464 = code;
                                        if (_e464 == 10i) {
                                            param_10 = 0i;
                                            let _e466 = MapUv_u0028_i1_u003b((&param_10));
                                            uv = _e466;
                                            let _e467 = uv;
                                            cell = floor((_e467 * 8f));
                                            let _e471 = cell[0u];
                                            let _e473 = cell[1u];
                                            odd = (fract(((_e471 + _e473) * 0.5f)) * 2f);
                                            let _e478 = uv;
                                            within = fract(_e478);
                                            let _e480 = odd;
                                            let _e484 = within[0u];
                                            let _e488 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e480)) * vec3<f32>((0.55f + (0.45f * _e484)), (0.55f + (0.45f * _e488)), 0.85f));
                                        } else {
                                            let _e493 = code;
                                            if (_e493 == 11i) {
                                                let _e495 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e495));
                                            } else {
                                                let _e498 = code;
                                                if (_e498 == 12i) {
                                                    let _e500 = v_color_1;
                                                    param_11 = clamp(_e500.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e503 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                    shown = _e503;
                                                } else {
                                                    let _e504 = code;
                                                    let _e506 = code;
                                                    if ((_e504 == 13i) || (_e506 == 14i)) {
                                                        let _e509 = code;
                                                        let _e511 = identity_object;
                                                        let _e512 = identity_material;
                                                        key_1 = select(_e512, _e511, (_e509 == 13i));
                                                        let _e514 = key_1;
                                                        param_12 = _e514;
                                                        let _e515 = DebugIdentityColour_u0028_f1_u003b((&param_12));
                                                        let _e517 = (*s).n_dot_v;
                                                        shown = (_e515 * (0.55f + (0.45f * _e517)));
                                                    } else {
                                                        let _e521 = code;
                                                        if (_e521 == 15i) {
                                                            let _e524 = (*s).albedo;
                                                            param_13 = clamp(_e524, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e526 = LinearToSrgb_u0028_vf3_u003b((&param_13));
                                                            srgb_1 = _e526;
                                                            let _e527 = srgb_1;
                                                            luma = dot(_e527, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e530 = (*s).metallic;
                                                            metal = (_e530 > 0.5f);
                                                            let _e532 = metal;
                                                            let _e534 = luma;
                                                            if (!(_e532) && (_e534 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e537 = metal;
                                                                let _e538 = !(_e537);
                                                                phi_3380_ = _e538;
                                                                if _e538 {
                                                                    let _e540 = srgb_1[0u];
                                                                    let _e542 = srgb_1[1u];
                                                                    let _e544 = srgb_1[2u];
                                                                    phi_3380_ = (max(_e540, max(_e542, _e544)) > 0.9411765f);
                                                                }
                                                                let _e549 = phi_3380_;
                                                                if _e549 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e550 = metal;
                                                                    let _e551 = luma;
                                                                    if (_e550 && (_e551 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e554 = luma;
                                                                        local_8 = vec3(_e554);
                                                                    }
                                                                    let _e556 = local_8;
                                                                    local_7 = _e556;
                                                                }
                                                                let _e557 = local_7;
                                                                local_6 = _e557;
                                                            }
                                                            let _e558 = local_6;
                                                            shown = _e558;
                                                        } else {
                                                            let _e559 = code;
                                                            if (_e559 == 16i) {
                                                                let _e562 = (*s).metallic;
                                                                m = _e562;
                                                                let _e563 = m;
                                                                let _e565 = m;
                                                                if ((_e563 > 0.05f) && (_e565 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e568 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e568 > 0.5f)));
                                                                }
                                                                let _e572 = local_9;
                                                                shown = _e572;
                                                            } else {
                                                                let _e573 = code;
                                                                if (_e573 == 17i) {
                                                                    let _e575 = normal_mapped;
                                                                    if !(_e575) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e577 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e577));
                                                                    }
                                                                    let _e580 = local_10;
                                                                    shown = _e580;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e581 = g_premultiply;
    if _e581 {
        let _e583 = (*s).alpha;
        local_11 = _e583;
    } else {
        local_11 = 1f;
    }
    let _e584 = local_11;
    weight_2 = _e584;
    let _e585 = shown;
    param_14 = _e585;
    let _e586 = SrgbToLinear_u0028_vf3_u003b((&param_14));
    let _e587 = weight_2;
    let _e588 = (_e586 * _e587);
    let _e590 = (*s).alpha;
    frag_color = vec4<f32>(_e588.x, _e588.y, _e588.z, _e590);
    let _e596 = (*s).roughness;
    param_15 = _e596;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_15));
    WriteWeightedBlended_u0028_();
    return true;
}

fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
    var a2_: f32;
    var lambda_v: f32;
    var lambda_l: f32;

    let _e304 = (*alpha_3);
    let _e305 = (*alpha_3);
    a2_ = (_e304 * _e305);
    let _e307 = (*n_dot_l);
    let _e308 = (*n_dot_v);
    let _e309 = (*n_dot_v);
    let _e311 = a2_;
    let _e314 = a2_;
    lambda_v = (_e307 * sqrt((((_e308 * _e309) * (1f - _e311)) + _e314)));
    let _e318 = (*n_dot_v);
    let _e319 = (*n_dot_l);
    let _e320 = (*n_dot_l);
    let _e322 = a2_;
    let _e325 = a2_;
    lambda_l = (_e318 * sqrt((((_e319 * _e320) * (1f - _e322)) + _e325)));
    let _e329 = lambda_v;
    let _e330 = lambda_l;
    return (0.5f / max((_e329 + _e330), 0.00001f));
}

fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
    var a: f32;
    var k_2: f32;

    let _e302 = (*n_dot_h);
    let _e303 = (*alpha_4);
    a = (_e302 * _e303);
    let _e305 = (*alpha_4);
    let _e306 = (*n_dot_h);
    let _e307 = (*n_dot_h);
    let _e310 = a;
    let _e311 = a;
    k_2 = (_e305 / max(((1f - (_e306 * _e307)) + (_e310 * _e311)), 0.0000001f));
    let _e316 = k_2;
    let _e317 = k_2;
    return ((_e316 * _e317) * 0.31830987f);
}

fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
    var axis: vec3<f32>;
    var len: f32;
    var angle: f32;
    var local_12: vec3<f32>;

    let _e304 = (*a_1);
    let _e305 = (*b);
    axis = cross(_e304, _e305);
    let _e307 = axis;
    len = length(_e307);
    let _e309 = (*a_1);
    let _e310 = (*b);
    angle = acos(clamp(dot(_e309, _e310), -1f, 1f));
    let _e314 = len;
    if (_e314 > 0.000001f) {
        let _e316 = axis;
        let _e317 = angle;
        let _e318 = len;
        local_12 = (_e316 * (_e317 / (_e318 * 6.2831855f)));
    } else {
        local_12 = vec3<f32>(0f, 0f, 0f);
    }
    let _e322 = local_12;
    return _e322;
}

fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
    var inTable: vec2<f32>;

    let _e302 = (*x);
    let _e303 = (*y);
    inTable = ((vec2<f32>(_e302, _e303) * 0.984375f) + vec2(0.0078125f));
    let _e309 = inTable[0u];
    let _e311 = inTable[1u];
    let _e312 = (*table);
    return vec2<f32>(_e309, ((_e311 + _e312) * 0.5f));
}

fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_2: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
    var uv_1: vec2<f32>;
    var inverse: vec4<f32>;
    var param_16: f32;
    var param_17: f32;
    var param_18: f32;
    var fit: vec4<f32>;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;
    var along: vec3<f32>;
    var alongLength: f32;
    var t1_: vec3<f32>;
    var local_13: vec3<f32>;
    var t2_: vec3<f32>;
    var minv: mat3x3<f32>;
    var i: i32;
    var p: vec3<f32>;
    var l: array<vec3<f32>, 4>;
    var f: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: vec3<f32>;
    var param_25: vec3<f32>;
    var param_26: vec3<f32>;
    var param_27: vec3<f32>;
    var param_28: vec3<f32>;
    var param_29: vec3<f32>;
    var len_1: f32;
    var z_1: f32;
    var local_14: f32;
    var sphere: f32;
    var param_30: f32;
    var param_31: f32;
    var param_32: f32;

    let _e336 = (*roughness_2);
    let _e338 = (*n_1);
    let _e339 = (*v);
    uv_1 = vec2<f32>(clamp(_e336, 0f, 1f), sqrt(clamp((1f - dot(_e338, _e339)), 0f, 1f)));
    let _e346 = uv_1[0u];
    param_16 = _e346;
    let _e348 = uv_1[1u];
    param_17 = _e348;
    param_18 = 0f;
    let _e349 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_16), (&param_17), (&param_18));
    let _e350 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e349, 0f);
    inverse = _e350;
    let _e352 = uv_1[0u];
    param_19 = _e352;
    let _e354 = uv_1[1u];
    param_20 = _e354;
    param_21 = 1f;
    let _e355 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21));
    let _e356 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e355, 0f);
    fit = _e356;
    let _e357 = (*v);
    let _e358 = (*n_1);
    let _e359 = (*v);
    let _e360 = (*n_1);
    along = (_e357 - (_e358 * dot(_e359, _e360)));
    let _e364 = along;
    alongLength = length(_e364);
    let _e366 = alongLength;
    if (_e366 > 0.00001f) {
        let _e368 = along;
        let _e369 = alongLength;
        local_13 = (_e368 / vec3(_e369));
    } else {
        let _e372 = (*n_1);
        let _e374 = (*n_1)[2u];
        local_13 = normalize(cross(_e372, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e374) < 0.999f)))));
    }
    let _e381 = local_13;
    t1_ = _e381;
    let _e382 = (*n_1);
    let _e383 = t1_;
    t2_ = cross(_e382, _e383);
    let _e386 = inverse[0u];
    let _e388 = inverse[1u];
    let _e389 = vec3<f32>(_e386, 0f, _e388);
    let _e391 = inverse[2u];
    let _e393 = inverse[3u];
    let _e394 = vec3<f32>(_e391, 0f, _e393);
    minv = mat3x3<f32>(vec3<f32>(_e389.x, _e389.y, _e389.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e394.x, _e394.y, _e394.z));
    i = 0i;
    loop {
        let _e408 = i;
        if (_e408 < 4i) {
            let _e410 = i;
            let _e412 = (*corners)[_e410];
            p = _e412;
            let _e413 = i;
            let _e414 = minv;
            let _e415 = p;
            let _e416 = t1_;
            let _e418 = p;
            let _e419 = t2_;
            let _e421 = p;
            let _e422 = (*n_1);
            l[_e413] = normalize((_e414 * vec3<f32>(dot(_e415, _e416), dot(_e418, _e419), dot(_e421, _e422))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e428 = i;
            i = (_e428 + 1i);
        }
    }
    let _e431 = l[0i];
    param_22 = _e431;
    let _e433 = l[1i];
    param_23 = _e433;
    let _e434 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_22), (&param_23));
    let _e436 = l[1i];
    param_24 = _e436;
    let _e438 = l[2i];
    param_25 = _e438;
    let _e439 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_24), (&param_25));
    let _e442 = l[2i];
    param_26 = _e442;
    let _e444 = l[3i];
    param_27 = _e444;
    let _e445 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_26), (&param_27));
    let _e448 = l[3i];
    param_28 = _e448;
    let _e450 = l[0i];
    param_29 = _e450;
    let _e451 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_28), (&param_29));
    f = -((((_e434 + _e439) + _e445) + _e451));
    let _e454 = f;
    len_1 = length(_e454);
    let _e456 = len_1;
    if (_e456 > 0.000000001f) {
        let _e459 = f[2u];
        let _e460 = len_1;
        local_14 = (_e459 / _e460);
    } else {
        local_14 = 0f;
    }
    let _e462 = local_14;
    z_1 = _e462;
    let _e463 = z_1;
    let _e466 = len_1;
    param_30 = ((_e463 * 0.5f) + 0.5f);
    param_31 = clamp(_e466, 0f, 1f);
    param_32 = 1f;
    let _e468 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_30), (&param_31), (&param_32));
    let _e469 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e468, 0f);
    sphere = _e469.w;
    let _e471 = len_1;
    let _e472 = sphere;
    let _e476 = fit[0u];
    let _e478 = fit[1u];
    return vec3<f32>(max((_e471 * _e472), 0f), _e476, _e478);
}

fn CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
    var ltc: vec3<f32>;
    var param_33: vec3<f32>;
    var param_34: vec3<f32>;
    var param_35: f32;
    var param_36: array<vec3<f32>, 4>;
    var lobe: f32;
    var alpha_5: f32;
    var n_dot_l_1: f32;
    var n_dot_h_1: f32;
    var d_1: f32;
    var param_37: f32;
    var param_38: f32;
    var vis: f32;
    var param_39: f32;
    var param_40: f32;
    var param_41: f32;
    var f_1: f32;

    let _e318 = (*light).integrated;
    if (_e318 > 0.5f) {
        let _e320 = g_coat_n;
        param_33 = _e320;
        let _e322 = (*s_1).v;
        param_34 = _e322;
        let _e323 = g_coat_roughness;
        param_35 = _e323;
        let _e324 = g_rect_corners;
        param_36 = _e324;
        let _e325 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_33), (&param_34), (&param_35), (&param_36));
        ltc = _e325;
        let _e327 = ltc[0u];
        let _e329 = ltc[1u];
        let _e332 = ltc[2u];
        let _e338 = frag_info.material[3u];
        let _e341 = (*light).n_dot_l;
        return (((_e327 * ((0.04f * _e329) + (0.96f * _e332))) * _e338) / max(_e341, 0.000001f));
    }
    let _e344 = g_coat_roughness;
    lobe = max(_e344, 0.045f);
    let _e346 = lobe;
    let _e347 = lobe;
    alpha_5 = (_e346 * _e347);
    let _e349 = g_coat_n;
    let _e351 = (*light).l;
    n_dot_l_1 = max(dot(_e349, _e351), 0f);
    let _e354 = g_coat_n;
    let _e356 = (*light).h;
    n_dot_h_1 = max(dot(_e354, _e356), 0f);
    let _e359 = n_dot_h_1;
    param_37 = _e359;
    let _e360 = alpha_5;
    param_38 = _e360;
    let _e361 = D_GGX_u0028_f1_u003b_f1_u003b((&param_37), (&param_38));
    d_1 = _e361;
    let _e362 = g_coat_n_dot_v;
    param_39 = _e362;
    let _e363 = n_dot_l_1;
    param_40 = _e363;
    let _e364 = alpha_5;
    param_41 = _e364;
    let _e365 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_39), (&param_40), (&param_41));
    vis = _e365;
    let _e367 = (*light).v_dot_h;
    f_1 = (0.04f + (0.96f * pow((1f - _e367), 5f)));
    let _e372 = d_1;
    let _e373 = vis;
    let _e375 = f_1;
    let _e379 = frag_info.material[3u];
    let _e381 = n_dot_l_1;
    let _e384 = (*light).n_dot_l;
    return (((((_e372 * _e373) * _e375) * _e379) * _e381) / max(_e384, 0.000001f));
}

fn V_Neubelt_u0028_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l_2: ptr<function, f32>) -> f32 {
    let _e300 = (*n_dot_l_2);
    let _e301 = (*n_dot_v_1);
    let _e303 = (*n_dot_l_2);
    let _e304 = (*n_dot_v_1);
    return (1f / (4f * ((_e300 + _e301) - (_e303 * _e304))));
}

fn D_Charlie_u0028_f1_u003b_f1_u003b(roughness_3: ptr<function, f32>, n_dot_h_2: ptr<function, f32>) -> f32 {
    var inv_alpha: f32;
    var sin2h: f32;

    let _e302 = (*roughness_3);
    let _e303 = (*roughness_3);
    inv_alpha = (1f / (_e302 * _e303));
    let _e306 = (*n_dot_h_2);
    let _e307 = (*n_dot_h_2);
    sin2h = max((1f - (_e306 * _e307)), 0.0078125f);
    let _e311 = inv_alpha;
    let _e313 = sin2h;
    let _e314 = inv_alpha;
    return (((2f + _e311) * pow(_e313, (_e314 * 0.5f))) / 6.2831855f);
}

fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
    var m_1: f32;
    var g: f32;

    let _e302 = (*mu);
    m_1 = (1f - _e302);
    let _e304 = m_1;
    let _e305 = m_1;
    let _e306 = m_1;
    let _e307 = m_1;
    g = (_e304 * (0.05710853f + (_e305 * (0.49188188f + (_e306 * (-0.33218145f + (_e307 * 0.071443f)))))));
    let _e315 = (*r);
    let _e316 = g;
    let _e319 = (*r);
    return ((1f + (_e315 * _e316)) / (1f + (0.2877934f * _e319)));
}

fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
    let _e300 = (*rho);
    let _e301 = (*rho);
    let _e303 = (*average);
    let _e305 = (*rho);
    let _e306 = (*average);
    return (((_e300 * _e301) * _e303) / (vec3<f32>(1f, 1f, 1f) - (_e305 * (1f - _e306))));
}

fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
    let _e299 = (*r_1);
    let _e302 = (*r_1);
    return ((1f + (0.07248821f * _e299)) / (1f + (0.2877934f * _e302)));
}

fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
    var s_2: f32;
    var s_over_t: f32;
    var local_15: f32;
    var af: f32;
    var single: vec3<f32>;
    var average_1: f32;
    var param_42: f32;
    var multi: vec3<f32>;
    var param_43: vec3<f32>;
    var param_44: f32;
    var param_45: f32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;

    let _e317 = (*l_dot_v);
    let _e318 = (*mu_i);
    let _e319 = (*mu_o);
    s_2 = (_e317 - (_e318 * _e319));
    let _e322 = s_2;
    if (_e322 > 0f) {
        let _e324 = s_2;
        let _e325 = (*mu_i);
        let _e326 = (*mu_o);
        local_15 = (_e324 / max(_e325, _e326));
    } else {
        let _e329 = s_2;
        local_15 = _e329;
    }
    let _e330 = local_15;
    s_over_t = _e330;
    let _e331 = (*r_2);
    af = (1f / (1f + (0.2877934f * _e331)));
    let _e335 = (*rho_1);
    let _e336 = af;
    let _e337 = (*r_2);
    let _e338 = s_over_t;
    single = (_e335 * (_e336 * (1f + (_e337 * _e338))));
    let _e343 = (*r_2);
    param_42 = _e343;
    let _e344 = FonAverage_u0028_f1_u003b((&param_42));
    average_1 = _e344;
    let _e345 = (*rho_1);
    param_43 = _e345;
    let _e346 = average_1;
    param_44 = _e346;
    let _e347 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_43), (&param_44));
    let _e348 = (*mu_o);
    param_45 = _e348;
    let _e349 = (*r_2);
    param_46 = _e349;
    let _e350 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_45), (&param_46));
    let _e353 = (*mu_i);
    param_47 = _e353;
    let _e354 = (*r_2);
    param_48 = _e354;
    let _e355 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_47), (&param_48));
    let _e359 = average_1;
    multi = (_e347 * ((max((1f - _e350), 0.0000001f) * max((1f - _e355), 0.0000001f)) / max((1f - _e359), 0.0000001f)));
    let _e364 = single;
    let _e365 = multi;
    return ((_e364 + _e365) / vec3(3.1415927f));
}

fn EonDiffuse_u0028_() -> bool {
    let _e300 = frag_info.ambient_sky[3u];
    return (_e300 > 0.5f);
}

fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: ptr<function, f32>) -> vec2<f32> {
    var dfg: vec2<f32>;
    var param_49: f32;
    var param_50: f32;
    var param_51: f32;

    let _e304 = (*roughness_4);
    let _e306 = (*n_dot_v_2);
    param_49 = clamp(_e304, 0f, 1f);
    param_50 = sqrt(clamp((1f - _e306), 0f, 1f));
    param_51 = 1f;
    let _e310 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51));
    let _e311 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e310, 0f);
    dfg = _e311.xy;
    let _e314 = dfg[0u];
    let _e316 = dfg[1u];
    let _e319 = dfg[1u];
    return vec2<f32>((_e314 - _e316), _e319);
}

fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_3: ptr<function, Surface>) -> vec3<f32> {
    var ab: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var ess: f32;

    let _e305 = (*s_3).roughness;
    param_52 = max(_e305, 0.045f);
    let _e308 = (*s_3).n_dot_v;
    param_53 = _e308;
    let _e309 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_52), (&param_53));
    ab = _e309;
    let _e311 = ab[0u];
    let _e313 = ab[1u];
    ess = max((_e311 + _e313), 0.0001f);
    let _e316 = (*f0_);
    let _e317 = ess;
    return (vec3<f32>(1f, 1f, 1f) + (_e316 * ((1f / _e317) - 1f)));
}

fn EnergyCompensation_u0028_() -> bool {
    let _e300 = frag_info.target_origin[2u];
    return (_e300 > 0.5f);
}

fn F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, f90_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
    var f_2: f32;

    let _e302 = (*v_dot_h);
    f_2 = pow((1f - _e302), 5f);
    let _e305 = (*f0_1);
    let _e306 = (*f90_);
    let _e307 = (*f0_1);
    let _e309 = f_2;
    return (_e305 + ((_e306 - _e307) * _e309));
}

fn V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_l_3: ptr<function, f32>, n_dot_v_3: ptr<function, f32>, b_dot_v: ptr<function, f32>, t_dot_v: ptr<function, f32>, t_dot_l: ptr<function, f32>, b_dot_l: ptr<function, f32>, at: ptr<function, f32>, ab_1: ptr<function, f32>) -> f32 {
    var ggx_v: f32;
    var ggx_l: f32;

    let _e308 = (*n_dot_l_3);
    let _e309 = (*at);
    let _e310 = (*t_dot_v);
    let _e312 = (*ab_1);
    let _e313 = (*b_dot_v);
    let _e315 = (*n_dot_v_3);
    ggx_v = (_e308 * length(vec3<f32>((_e309 * _e310), (_e312 * _e313), _e315)));
    let _e319 = (*n_dot_v_3);
    let _e320 = (*at);
    let _e321 = (*t_dot_l);
    let _e323 = (*ab_1);
    let _e324 = (*b_dot_l);
    let _e326 = (*n_dot_l_3);
    ggx_l = (_e319 * length(vec3<f32>((_e320 * _e321), (_e323 * _e324), _e326)));
    let _e330 = ggx_v;
    let _e331 = ggx_l;
    return clamp((0.5f / max((_e330 + _e331), 0.00001f)), 0f, 1f);
}

fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3: ptr<function, f32>, t_dot_h: ptr<function, f32>, b_dot_h: ptr<function, f32>, at_1: ptr<function, f32>, ab_2: ptr<function, f32>) -> f32 {
    var a2_1: f32;
    var f_3: vec3<f32>;
    var w2_: f32;

    let _e306 = (*at_1);
    let _e307 = (*ab_2);
    a2_1 = (_e306 * _e307);
    let _e309 = (*ab_2);
    let _e310 = (*t_dot_h);
    let _e312 = (*at_1);
    let _e313 = (*b_dot_h);
    let _e315 = a2_1;
    let _e316 = (*n_dot_h_3);
    f_3 = vec3<f32>((_e309 * _e310), (_e312 * _e313), (_e315 * _e316));
    let _e319 = a2_1;
    let _e320 = f_3;
    let _e321 = f_3;
    w2_ = (_e319 / max(dot(_e320, _e321), 0.000000000001f));
    let _e325 = a2_1;
    let _e326 = w2_;
    let _e328 = w2_;
    return (((_e325 * _e326) * _e328) / 3.1415927f);
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_4: ptr<function, Surface>, light_1: ptr<function, LightSample>) -> vec3<f32> {
    var lobe_1: f32;
    var alpha_6: f32;
    var f0_2: vec3<f32>;
    var f90_1: vec3<f32>;
    var diffuseColor: vec3<f32>;
    var d_2: f32;
    var param_54: f32;
    var param_55: f32;
    var vis_1: f32;
    var param_56: f32;
    var param_57: f32;
    var param_58: f32;
    var at_2: f32;
    var ab_3: f32;
    var param_59: f32;
    var param_60: f32;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;
    var param_64: f32;
    var param_65: f32;
    var param_66: f32;
    var param_67: f32;
    var param_68: f32;
    var param_69: f32;
    var param_70: f32;
    var param_71: f32;
    var f_4: vec3<f32>;
    var param_72: vec3<f32>;
    var param_73: vec3<f32>;
    var param_74: f32;
    var specular: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: Surface;
    var diffuse: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: f32;
    var param_79: f32;
    var param_80: f32;
    var param_81: f32;
    var sheen: vec3<f32>;
    var param_82: f32;
    var param_83: f32;
    var param_84: f32;
    var param_85: f32;
    var param_86: Surface;
    var param_87: LightSample;

    let _e348 = (*s_4).roughness;
    lobe_1 = max(_e348, 0.045f);
    let _e350 = lobe_1;
    let _e351 = lobe_1;
    alpha_6 = (_e350 * _e351);
    let _e353 = g_f0_dielectric;
    let _e355 = (*s_4).albedo;
    let _e357 = (*s_4).metallic;
    f0_2 = mix(_e353, _e355, vec3(_e357));
    let _e360 = g_f90_;
    let _e362 = (*s_4).metallic;
    f90_1 = vec3(mix(_e360, 1f, _e362));
    let _e366 = (*s_4).albedo;
    let _e368 = (*s_4).metallic;
    diffuseColor = (_e366 * (1f - _e368));
    let _e372 = (*light_1).n_dot_h;
    param_54 = _e372;
    let _e373 = alpha_6;
    param_55 = _e373;
    let _e374 = D_GGX_u0028_f1_u003b_f1_u003b((&param_54), (&param_55));
    d_2 = _e374;
    let _e376 = (*s_4).n_dot_v;
    param_56 = _e376;
    let _e378 = (*light_1).n_dot_l;
    param_57 = _e378;
    let _e379 = alpha_6;
    param_58 = _e379;
    let _e380 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
    vis_1 = _e380;
    let _e381 = g_aniso;
    if (_e381 > 0f) {
        let _e383 = alpha_6;
        let _e384 = g_aniso;
        let _e385 = g_aniso;
        at_2 = mix(_e383, 1f, (_e384 * _e385));
        let _e388 = alpha_6;
        ab_3 = max(_e388, 0.001f);
        let _e390 = g_aniso_t;
        let _e392 = (*light_1).h;
        let _e394 = g_aniso_b;
        let _e396 = (*light_1).h;
        let _e399 = (*light_1).n_dot_h;
        param_59 = _e399;
        param_60 = dot(_e390, _e392);
        param_61 = dot(_e394, _e396);
        let _e400 = at_2;
        param_62 = _e400;
        let _e401 = ab_3;
        param_63 = _e401;
        let _e402 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_59), (&param_60), (&param_61), (&param_62), (&param_63));
        d_2 = _e402;
        let _e403 = g_aniso_b;
        let _e405 = (*s_4).v;
        let _e407 = g_aniso_t;
        let _e409 = (*s_4).v;
        let _e411 = g_aniso_t;
        let _e413 = (*light_1).l;
        let _e415 = g_aniso_b;
        let _e417 = (*light_1).l;
        let _e420 = (*light_1).n_dot_l;
        param_64 = _e420;
        let _e422 = (*s_4).n_dot_v;
        param_65 = _e422;
        param_66 = dot(_e403, _e405);
        param_67 = dot(_e407, _e409);
        param_68 = dot(_e411, _e413);
        param_69 = dot(_e415, _e417);
        let _e423 = at_2;
        param_70 = _e423;
        let _e424 = ab_3;
        param_71 = _e424;
        let _e425 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_64), (&param_65), (&param_66), (&param_67), (&param_68), (&param_69), (&param_70), (&param_71));
        vis_1 = _e425;
    }
    let _e426 = f0_2;
    param_72 = _e426;
    let _e427 = f90_1;
    param_73 = _e427;
    let _e429 = (*light_1).v_dot_h;
    param_74 = _e429;
    let _e430 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_72), (&param_73), (&param_74));
    f_4 = _e430;
    let _e431 = f_4;
    let _e432 = g_irid_fresnel;
    let _e433 = g_iridescence;
    f_4 = mix(_e431, _e432, vec3(_e433));
    let _e436 = d_2;
    let _e437 = vis_1;
    let _e439 = f_4;
    let _e443 = frag_info.material[3u];
    specular = ((_e439 * (_e436 * _e437)) * _e443);
    let _e446 = (*light_1).integrated;
    if (_e446 > 0.5f) {
        let _e450 = (*light_1).ltc[0u];
        let _e451 = f0_2;
        let _e454 = (*light_1).ltc[1u];
        let _e456 = f90_1;
        let _e457 = f0_2;
        let _e461 = (*light_1).ltc[2u];
        let _e467 = frag_info.material[3u];
        let _e470 = (*light_1).n_dot_l;
        specular = (((((_e451 * _e454) + ((_e456 - _e457) * _e461)) * _e450) * _e467) / vec3(max(_e470, 0.000001f)));
    }
    let _e474 = EnergyCompensation_u0028_();
    if _e474 {
        let _e475 = f0_2;
        param_75 = _e475;
        let _e476 = (*s_4);
        param_76 = _e476;
        let _e477 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_75), (&param_76));
        let _e478 = specular;
        specular = (_e478 * _e477);
    }
    let _e480 = diffuseColor;
    let _e481 = f_4;
    diffuse = ((_e480 * (vec3<f32>(1f, 1f, 1f) - _e481)) / vec3(3.1415927f));
    let _e486 = EonDiffuse_u0028_();
    if _e486 {
        let _e488 = (*s_4).n;
        let _e490 = (*light_1).l;
        let _e494 = (*light_1).l;
        let _e496 = (*s_4).v;
        let _e498 = diffuseColor;
        param_77 = _e498;
        let _e500 = (*s_4).roughness;
        param_78 = _e500;
        param_79 = clamp(dot(_e488, _e490), 0.0001f, 1f);
        let _e502 = (*s_4).n_dot_v;
        param_80 = _e502;
        param_81 = dot(_e494, _e496);
        let _e503 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_77), (&param_78), (&param_79), (&param_80), (&param_81));
        let _e504 = f_4;
        diffuse = (_e503 * (vec3<f32>(1f, 1f, 1f) - _e504));
    }
    let _e507 = g_transmission;
    let _e509 = diffuse;
    diffuse = (_e509 * (1f - _e507));
    let _e511 = g_sheen;
    let _e512 = g_sheen_roughness;
    param_82 = _e512;
    let _e514 = (*light_1).n_dot_h;
    param_83 = _e514;
    let _e515 = D_Charlie_u0028_f1_u003b_f1_u003b((&param_82), (&param_83));
    let _e518 = (*s_4).n;
    let _e520 = (*light_1).l;
    let _e524 = (*s_4).n_dot_v;
    param_84 = _e524;
    param_85 = clamp(dot(_e518, _e520), 0f, 1f);
    let _e525 = V_Neubelt_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    sheen = ((_e511 * _e515) * _e525);
    let _e527 = diffuse;
    let _e528 = specular;
    let _e530 = g_sheen_scale;
    let _e532 = sheen;
    let _e534 = g_coat_through;
    let _e536 = g_coat;
    let _e537 = (*s_4);
    param_86 = _e537;
    let _e538 = (*light_1);
    param_87 = _e538;
    let _e539 = CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_86), (&param_87));
    return ((((((_e527 + _e528) * _e530) + _e532) * _e534) + vec3((_e536 * _e539))) * 3.1415927f);
}

fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
    let _e299 = (*i_1);
    if (_e299 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e301 = (*i_1);
    if (_e301 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e303 = (*i_1);
    if (_e303 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e305 = (*i_1);
    if (_e305 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e307 = (*i_1);
    if (_e307 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e309 = (*i_1);
    if (_e309 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e311 = (*i_1);
    if (_e311 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_2: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p_1: vec2<f32>;
    var param_88: i32;

    let _e304 = (*i_2);
    param_88 = _e304;
    let _e305 = PointShadowDiskTap_u0028_i1_u003b((&param_88));
    p_1 = _e305;
    let _e307 = p_1[0u];
    let _e308 = (*ca);
    let _e311 = p_1[1u];
    let _e312 = (*sa);
    let _e316 = p_1[0u];
    let _e317 = (*sa);
    let _e320 = p_1[1u];
    let _e321 = (*ca);
    let _e325 = (*radius);
    return (vec2<f32>(((_e307 * _e308) - (_e311 * _e312)), ((_e316 * _e317) + (_e320 * _e321))) * _e325);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_16: vec2<f32>;
    var atlas: vec2<f32>;

    let _e307 = point_shadow.params[0u];
    inset = _e307;
    let _e308 = (*uv_2);
    let _e309 = (*offset);
    let _e311 = inset;
    let _e312 = inset;
    local_16 = clamp((_e308 + _e309), vec2(_e311), vec2((1f - _e312)));
    let _e317 = local_16;
    let _e318 = (*tile);
    atlas = ((_e317 + _e318) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e323 = point_shadow.params3_[0u];
    if (_e323 > 0.5f) {
        let _e326 = atlas[1u];
        atlas[1u] = (1f - _e326);
    }
    let _e329 = atlas;
    let _e330 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e329, 0f);
    let _e332 = atlas;
    let _e333 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e332, 0f);
    let _e336 = (*range);
    return (min(_e330.x, _e333.x) * _e336);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_89: vec2<f32>;
    var param_90: vec2<f32>;
    var param_91: vec2<f32>;
    var param_92: f32;

    let _e308 = (*uv_3);
    param_89 = _e308;
    let _e309 = (*offset_1);
    param_90 = _e309;
    let _e310 = (*tile_1);
    param_91 = _e310;
    let _e311 = (*range_1);
    param_92 = _e311;
    let _e312 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_89), (&param_90), (&param_91), (&param_92));
    stored = _e312;
    let _e313 = stored;
    let _e314 = (*range_1);
    if (_e313 >= (_e314 * 0.999f)) {
        return 1f;
    }
    let _e317 = (*receiver);
    let _e318 = stored;
    return select(1f, 0f, (_e317 > _e318));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_4: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_93: vec2<f32>;
    var param_94: vec2<f32>;
    var param_95: vec2<f32>;
    var param_96: f32;
    var sum: f32;
    var count: f32;
    var i_3: i32;
    var stored_1: f32;
    var param_97: i32;
    var param_98: f32;
    var param_99: f32;
    var param_100: f32;
    var param_101: vec2<f32>;
    var param_102: vec2<f32>;
    var param_103: vec2<f32>;
    var param_104: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e329 = point_shadow.params2_[1u];
    lightRadius = _e329;
    let _e332 = point_shadow.params2_[0u];
    minRadius = _e332;
    let _e335 = point_shadow.params2_[2u];
    maxRadius = _e335;
    let _e336 = lightRadius;
    if (_e336 <= 0f) {
        let _e338 = (*uv_4);
        param_93 = _e338;
        param_94 = vec2<f32>(0f, 0f);
        let _e339 = (*tile_2);
        param_95 = _e339;
        let _e340 = (*range_2);
        param_96 = _e340;
        let _e341 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_93), (&param_94), (&param_95), (&param_96));
        (*blockerOut) = _e341;
        let _e342 = minRadius;
        return _e342;
    }
    sum = 0f;
    count = 0f;
    i_3 = 0i;
    loop {
        let _e343 = i_3;
        if (_e343 < 8i) {
            let _e345 = i_3;
            param_97 = _e345;
            let _e346 = (*ca_1);
            param_98 = _e346;
            let _e347 = (*sa_1);
            param_99 = _e347;
            let _e348 = maxRadius;
            param_100 = _e348;
            let _e349 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_97), (&param_98), (&param_99), (&param_100));
            let _e350 = (*uv_4);
            param_101 = _e350;
            param_102 = _e349;
            let _e351 = (*tile_2);
            param_103 = _e351;
            let _e352 = (*range_2);
            param_104 = _e352;
            let _e353 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_101), (&param_102), (&param_103), (&param_104));
            stored_1 = _e353;
            let _e354 = stored_1;
            let _e355 = (*range_2);
            if (_e354 >= (_e355 * 0.999f)) {
                continue;
            }
            let _e358 = stored_1;
            let _e359 = (*receiver_1);
            if (_e358 >= _e359) {
                continue;
            }
            let _e361 = stored_1;
            let _e362 = sum;
            sum = (_e362 + _e361);
            let _e364 = count;
            count = (_e364 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e366 = i_3;
            i_3 = (_e366 + 1i);
        }
    }
    let _e368 = count;
    if (_e368 < 0.5f) {
        return -1f;
    }
    let _e370 = sum;
    let _e371 = count;
    blocker = max((_e370 / _e371), 0.0001f);
    let _e374 = blocker;
    (*blockerOut) = _e374;
    let _e375 = lightRadius;
    let _e376 = (*receiver_1);
    let _e377 = blocker;
    let _e381 = blocker;
    world = ((_e375 * max((_e376 - _e377), 0f)) / _e381);
    let _e383 = world;
    let _e384 = (*receiver_1);
    let _e386 = (*tanHalf);
    let _e389 = minRadius;
    let _e390 = maxRadius;
    return clamp((_e383 / ((2f * _e384) * _e386)), _e389, _e390);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_17: vec2<f32>;

    let _e300 = (*rows);
    if (_e300 > 0f) {
        let _e303 = gl_FragCoord_1[0u];
        let _e304 = (*rows);
        let _e306 = gl_FragCoord_1[1u];
        local_17 = vec2<f32>(_e303, (_e304 - _e306));
    } else {
        let _e309 = gl_FragCoord_1;
        local_17 = _e309.xy;
    }
    let _e311 = local_17;
    return _e311;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot_1: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a_2: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_5: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_105: f32;
    var angle_1: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_106: vec2<f32>;
    var param_107: vec2<f32>;
    var param_108: f32;
    var param_109: f32;
    var param_110: f32;
    var param_111: f32;
    var param_112: f32;
    var param_113: f32;
    var local_18: vec3<f32>;
    var lit_1: f32;
    var param_114: vec2<f32>;
    var param_115: vec2<f32>;
    var param_116: vec2<f32>;
    var param_117: f32;
    var param_118: f32;
    var i_4: i32;
    var param_119: i32;
    var param_120: f32;
    var param_121: f32;
    var param_122: f32;
    var param_123: vec2<f32>;
    var param_124: vec2<f32>;
    var param_125: vec2<f32>;
    var param_126: f32;
    var param_127: f32;
    var phi_2709_: bool;
    var phi_2770_: bool;

    let _e352 = (*lightIndex);
    let _e356 = point_shadow.slots[_e352][0u];
    slot_1 = i32((_e356 + 0.5f));
    let _e359 = (*lightIndex);
    let _e363 = point_shadow.slots[_e359][0u];
    if (_e363 < 0f) {
        return 1f;
    }
    let _e367 = point_shadow.params[2u];
    strength = _e367;
    let _e368 = strength;
    if (_e368 <= 0f) {
        return 1f;
    }
    let _e370 = slot_1;
    let _e373 = point_shadow.lights[_e370];
    let _e375 = (*world_1);
    toLight = (_e373.xyz - _e375);
    let _e377 = toLight;
    toLightLength = max(length(_e377), 0.000001f);
    let _e380 = (*normal);
    let _e381 = toLight;
    let _e382 = toLightLength;
    nDotL = max(dot(_e380, (_e381 / vec3(_e382))), 0.15f);
    let _e387 = nDotL;
    let _e388 = nDotL;
    let _e393 = nDotL;
    let _e394 = nDotL;
    slope = min((sqrt(max((1f - (_e387 * _e388)), 0f)) / (_e393 * _e394)), 8f);
    let _e398 = toLightLength;
    let _e400 = (*lightIndex);
    let _e404 = point_shadow.slots[_e400][2u];
    let _e409 = point_shadow.params3_[1u];
    texel = (((2f * _e398) * max(_e404, 0.0001f)) * _e409);
    let _e411 = (*world_1);
    let _e412 = (*normal);
    let _e413 = texel;
    let _e417 = point_shadow.params[3u];
    let _e419 = slope;
    origin = (_e411 + (((_e412 * _e413) * _e417) * (1f + _e419)));
    let _e423 = origin;
    let _e424 = slot_1;
    let _e427 = point_shadow.lights[_e424];
    toFragment = (_e423 - _e427.xyz);
    let _e430 = toFragment;
    distance_ = length(_e430);
    let _e432 = slot_1;
    let _e436 = point_shadow.lights[_e432][3u];
    range_3 = max(_e436, 0.0001f);
    let _e438 = distance_;
    let _e439 = range_3;
    if (_e438 >= _e439) {
        return 1f;
    }
    face = 0i;
    let _e441 = (*lightIndex);
    let _e445 = point_shadow.slots[_e441][1u];
    if (_e445 < 0.5f) {
        let _e447 = toFragment;
        a_2 = abs(_e447);
        let _e450 = a_2[0u];
        let _e452 = a_2[1u];
        let _e453 = (_e450 >= _e452);
        phi_2709_ = _e453;
        if _e453 {
            let _e455 = a_2[0u];
            let _e457 = a_2[2u];
            phi_2709_ = (_e455 >= _e457);
        }
        let _e460 = phi_2709_;
        if _e460 {
            let _e462 = toFragment[0u];
            face = select(1i, 0i, (_e462 > 0f));
        } else {
            let _e466 = a_2[1u];
            let _e468 = a_2[2u];
            if (_e466 >= _e468) {
                let _e471 = toFragment[1u];
                face = select(3i, 2i, (_e471 > 0f));
            } else {
                let _e475 = toFragment[2u];
                face = select(5i, 4i, (_e475 > 0f));
            }
        }
    }
    let _e478 = slot_1;
    let _e480 = face;
    let _e484 = point_shadow.faces[((_e478 * 6i) + _e480)];
    let _e485 = origin;
    clip = (_e484 * vec4<f32>(_e485.x, _e485.y, _e485.z, 1f));
    let _e492 = clip[3u];
    if (_e492 <= 0f) {
        return 1f;
    }
    let _e494 = clip;
    let _e497 = clip[3u];
    ndc = (_e494.xy / vec2(_e497));
    let _e501 = ndc[0u];
    let _e503 = (abs(_e501) > 1f);
    phi_2770_ = _e503;
    if !(_e503) {
        let _e506 = ndc[1u];
        phi_2770_ = (abs(_e506) > 1f);
    }
    let _e510 = phi_2770_;
    if _e510 {
        return 1f;
    }
    let _e512 = ndc[0u];
    let _e516 = ndc[1u];
    uv_5 = vec2<f32>(((_e512 * 0.5f) + 0.5f), (0.5f - (_e516 * 0.5f)));
    let _e520 = face;
    let _e522 = slot_1;
    tile_3 = vec2<f32>(f32(_e520), f32(_e522));
    let _e525 = distance_;
    let _e528 = point_shadow.params[1u];
    receiver_2 = (_e525 - _e528);
    let _e532 = frag_info.target_origin[0u];
    param_105 = _e532;
    let _e533 = FragCoordFromTop_u0028_f1_u003b((&param_105));
    noise = fract((52.982918f * fract(dot(_e533, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e538 = noise;
    angle_1 = (_e538 * 6.2831855f);
    let _e540 = angle_1;
    ca_2 = cos(_e540);
    let _e542 = angle_1;
    sa_2 = sin(_e542);
    let _e544 = (*lightIndex);
    let _e548 = point_shadow.slots[_e544][2u];
    tanHalf_1 = max(_e548, 0.0001f);
    blocker_1 = -1f;
    let _e550 = uv_5;
    param_106 = _e550;
    let _e551 = tile_3;
    param_107 = _e551;
    let _e552 = range_3;
    param_108 = _e552;
    let _e553 = receiver_2;
    param_109 = _e553;
    let _e554 = ca_2;
    param_110 = _e554;
    let _e555 = sa_2;
    param_111 = _e555;
    let _e556 = tanHalf_1;
    param_112 = _e556;
    let _e557 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_106), (&param_107), (&param_108), (&param_109), (&param_110), (&param_111), (&param_112), (&param_113));
    let _e558 = param_113;
    blocker_1 = _e558;
    radius_1 = _e557;
    let _e561 = point_shadow.params2_[3u];
    if (_e561 > 0.5f) {
        g_debug_surface_on = true;
        let _e563 = radius_1;
        if (_e563 < 0f) {
            local_18 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e565 = radius_1;
            let _e568 = point_shadow.params2_[2u];
            let _e572 = blocker_1;
            let _e573 = range_3;
            local_18 = vec3<f32>(clamp((_e565 / max(_e568, 0.000001f)), 0f, 1f), clamp((_e572 / _e573), 0f, 1f), 0f);
        }
        let _e577 = local_18;
        g_debug_surface = _e577;
    }
    let _e578 = radius_1;
    if (_e578 < 0f) {
        return 1f;
    }
    let _e580 = uv_5;
    param_114 = _e580;
    param_115 = vec2<f32>(0f, 0f);
    let _e581 = tile_3;
    param_116 = _e581;
    let _e582 = range_3;
    param_117 = _e582;
    let _e583 = receiver_2;
    param_118 = _e583;
    let _e584 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_114), (&param_115), (&param_116), (&param_117), (&param_118));
    lit_1 = _e584;
    let _e585 = radius_1;
    if (_e585 > 0f) {
        i_4 = 0i;
        loop {
            let _e587 = i_4;
            if (_e587 < 8i) {
                let _e589 = i_4;
                param_119 = _e589;
                let _e590 = ca_2;
                param_120 = _e590;
                let _e591 = sa_2;
                param_121 = _e591;
                let _e592 = radius_1;
                param_122 = _e592;
                let _e593 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_119), (&param_120), (&param_121), (&param_122));
                let _e594 = uv_5;
                param_123 = _e594;
                param_124 = _e593;
                let _e595 = tile_3;
                param_125 = _e595;
                let _e596 = range_3;
                param_126 = _e596;
                let _e597 = receiver_2;
                param_127 = _e597;
                let _e598 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_123), (&param_124), (&param_125), (&param_126), (&param_127));
                let _e599 = lit_1;
                lit_1 = (_e599 + _e598);
                continue;
            } else {
                break;
            }
            continuing {
                let _e601 = i_4;
                i_4 = (_e601 + 1i);
            }
        }
        let _e603 = lit_1;
        lit_1 = (_e603 * 0.11111111f);
    }
    let _e605 = lit_1;
    let _e606 = strength;
    return mix(1f, _e605, clamp(_e606, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_5: ptr<function, i32>, n_2: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r_3: f32;
    var theta: f32;

    let _e303 = (*i_5);
    let _e306 = (*n_2);
    r_3 = sqrt(((f32(_e303) + 0.5f) / f32(_e306)));
    let _e310 = (*i_5);
    let _e313 = (*turn);
    theta = ((f32(_e310) * 2.3999631f) + _e313);
    let _e315 = r_3;
    let _e316 = theta;
    let _e318 = theta;
    return (vec2<f32>(cos(_e316), sin(_e318)) * _e315);
}

fn ShadowNoise_u0028_() -> f32 {
    var at_3: vec2<f32>;
    var param_128: f32;

    let _e302 = frag_info.target_origin[0u];
    param_128 = _e302;
    let _e303 = FragCoordFromTop_u0028_f1_u003b((&param_128));
    let _e306 = frag_info.target_origin[3u];
    at_3 = (_e303 + vec2((5.588238f * max(_e306, 0f))));
    let _e311 = at_3;
    return fract((52.982918f * fract(dot(_e311, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_19: f32;

    let _e301 = (*mode_1);
    if (_e301 > 0.5f) {
        let _e303 = (*stored_2);
        local_19 = (1f - _e303);
    } else {
        let _e305 = (*stored_2);
        local_19 = _e305;
    }
    let _e306 = local_19;
    return _e306;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_3: f32;
    var pMax: f32;
    var reduced: f32;

    let _e307 = (*moments)[1u];
    let _e309 = (*moments)[0u];
    let _e311 = (*moments)[0u];
    let _e314 = (*minVariance);
    variance = max((_e307 - (_e309 * _e311)), _e314);
    let _e316 = (*t);
    let _e318 = (*moments)[0u];
    d_3 = (_e316 - _e318);
    let _e320 = variance;
    let _e321 = variance;
    let _e322 = d_3;
    let _e323 = d_3;
    pMax = (_e320 / (_e321 + (_e322 * _e323)));
    let _e327 = pMax;
    let _e328 = (*bleed);
    let _e330 = (*bleed);
    reduced = clamp(((_e327 - _e328) / max((1f - _e330), 0.0001f)), 0f, 1f);
    let _e335 = (*t);
    let _e337 = (*moments)[0u];
    let _e339 = reduced;
    return select(_e339, 1f, (_e335 <= _e337));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_4: f32;

    let _e300 = (*depth);
    d_4 = ((2f * clamp(_e300, 0f, 1f)) - 1f);
    let _e304 = d_4;
    let _e307 = d_4;
    return vec2<f32>(exp((40f * _e304)), -(exp((-5f * _e307))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_129: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_130: vec2<f32>;
    var param_131: f32;
    var param_132: f32;
    var param_133: f32;
    var negative: f32;
    var param_134: vec2<f32>;
    var param_135: f32;
    var param_136: f32;
    var param_137: f32;

    let _e314 = (*depth_1);
    param_129 = _e314;
    let _e315 = EvsmWarp_u0028_f1_u003b((&param_129));
    warped = _e315;
    let _e316 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e316);
    let _e319 = scale[0u];
    let _e321 = scale[0u];
    let _e323 = (*moments_1);
    param_130 = _e323.xy;
    let _e326 = warped[0u];
    param_131 = _e326;
    param_132 = (_e319 * _e321);
    let _e327 = (*bleed_1);
    param_133 = _e327;
    let _e328 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_130), (&param_131), (&param_132), (&param_133));
    positive = _e328;
    let _e330 = scale[1u];
    let _e332 = scale[1u];
    let _e334 = (*moments_1);
    param_134 = _e334.zw;
    let _e337 = warped[1u];
    param_135 = _e337;
    param_136 = (_e330 * _e332);
    let _e338 = (*bleed_1);
    param_137 = _e338;
    let _e339 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_134), (&param_135), (&param_136), (&param_137));
    negative = _e339;
    let _e340 = positive;
    let _e341 = negative;
    return min(_e340, _e341);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e300 = (*depth_2);
    stored_3 = max((1f - _e300), 0.000061035156f);
    let _e303 = stored_3;
    return exp2((floor(log2(_e303)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_2: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_20: f32;
    var cascade: i32;
    var uv_6: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var local_22: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_23: f32;
    var local_24: f32;
    var storage_: f32;
    var param_138: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y_1: i32;
    var x_1: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_139: vec4<f32>;
    var param_140: f32;
    var param_141: f32;
    var y_2: i32;
    var x_2: i32;
    var occluder: f32;
    var param_142: f32;
    var param_143: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_6: i32;
    var disc: vec2<f32>;
    var param_144: i32;
    var param_145: i32;
    var param_146: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_147: f32;
    var param_148: f32;
    var gap: f32;
    var radius_2: f32;
    var i_7: i32;
    var disc_1: vec2<f32>;
    var param_149: i32;
    var param_150: i32;
    var param_151: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_152: f32;
    var param_153: f32;
    var phi_4466_: bool;
    var phi_4477_: bool;
    var phi_4634_: bool;
    var phi_4641_: bool;
    var phi_4648_: bool;

    let _e379 = frag_info.shadow_params[3u];
    strength_1 = _e379;
    let _e380 = strength_1;
    if (_e380 <= 0f) {
        return 1f;
    }
    let _e382 = (*lightIndex_1);
    let _e385 = frag_info.frame_params[2u];
    if (_e382 != i32(floor((_e385 + 0.5f)))) {
        return 1f;
    }
    let _e392 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e392 + 0.5f));
    let _e395 = Orthographic_u0028_();
    if _e395 {
        let _e396 = ViewDepth_u0028_();
        local_20 = _e396;
    } else {
        let _e397 = v_world_position_1;
        let _e399 = frag_info.camera_position;
        local_20 = length((_e397 - _e399.xyz));
    }
    let _e403 = local_20;
    viewDistance = _e403;
    cascade = 0i;
    let _e404 = cascadeCount;
    let _e405 = (_e404 > 1i);
    phi_4466_ = _e405;
    if _e405 {
        let _e406 = viewDistance;
        let _e409 = frag_info.shadow_cascades[0u];
        phi_4466_ = (_e406 > _e409);
    }
    let _e412 = phi_4466_;
    if _e412 {
        cascade = 1i;
    }
    let _e413 = cascadeCount;
    let _e414 = (_e413 > 2i);
    phi_4477_ = _e414;
    if _e414 {
        let _e415 = viewDistance;
        let _e418 = frag_info.shadow_cascades[1u];
        phi_4477_ = (_e415 > _e418);
    }
    let _e421 = phi_4477_;
    if _e421 {
        cascade = 2i;
    }
    uv_6 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e422 = attempt;
        if (_e422 < 3i) {
            let _e424 = cascade;
            let _e425 = attempt;
            which = (_e424 + _e425);
            let _e427 = which;
            let _e428 = cascadeCount;
            if (_e427 >= _e428) {
                break;
            }
            let _e430 = which;
            if (_e430 == 0i) {
                let _e433 = frag_info.shadow_matrix;
                local_21 = _e433;
            } else {
                let _e434 = which;
                if (_e434 == 1i) {
                    let _e437 = frag_info.shadow_matrix_far;
                    local_22 = _e437;
                } else {
                    let _e439 = frag_info.shadow_matrix_farthest;
                    local_22 = _e439;
                }
                let _e440 = local_22;
                local_21 = _e440;
            }
            let _e441 = local_21;
            matrix = _e441;
            let _e444 = matrix[0][0u];
            let _e447 = matrix[1][0u];
            let _e450 = matrix[2][0u];
            axisX = vec3<f32>(_e444, _e447, _e450);
            let _e454 = matrix[0][1u];
            let _e457 = matrix[1][1u];
            let _e460 = matrix[2][1u];
            axisY = vec3<f32>(_e454, _e457, _e460);
            let _e462 = axisX;
            rowX = max(length(_e462), 0.000001f);
            let _e465 = axisY;
            rowY = max(length(_e465), 0.000001f);
            let _e470 = frag_info.shadow_cascades[3u];
            let _e472 = rowX;
            texelMetres = ((2f * _e470) / _e472);
            let _e476 = frag_info.shadow_cascades[3u];
            let _e479 = (*s_5).n;
            let _e480 = axisX;
            let _e483 = rowX;
            let _e484 = rowX;
            let _e488 = (*s_5).n;
            let _e489 = axisY;
            let _e492 = rowY;
            let _e493 = rowY;
            reach = ((3f * _e476) * ((abs(dot(_e479, _e480)) / (_e483 * _e484)) + (abs(dot(_e488, _e489)) / (_e492 * _e493))));
            let _e500 = frag_info.shadow_params[2u];
            let _e501 = texelMetres;
            flatOffset = min(_e500, _e501);
            let _e503 = v_world_position_1;
            let _e505 = (*s_5).n;
            let _e506 = flatOffset;
            let _e507 = reach;
            origin_1 = (_e503 + (_e505 * (_e506 + _e507)));
            let _e511 = matrix;
            let _e512 = origin_1;
            lightSpace = (_e511 * vec4<f32>(_e512.x, _e512.y, _e512.z, 1f));
            let _e519 = lightSpace[3u];
            if (_e519 <= 0f) {
                continue;
            }
            let _e521 = lightSpace;
            let _e524 = lightSpace[3u];
            candidate = (_e521.xyz / vec3(_e524));
            let _e528 = candidate[0u];
            let _e532 = candidate[1u];
            inTile = vec2<f32>(((_e528 * 0.5f) + 0.5f), (0.5f - (_e532 * 0.5f)));
            let _e537 = inTile[0u];
            let _e538 = (_e537 < 0f);
            phi_4634_ = _e538;
            if !(_e538) {
                let _e541 = inTile[0u];
                phi_4634_ = (_e541 > 1f);
            }
            let _e544 = phi_4634_;
            phi_4641_ = _e544;
            if !(_e544) {
                let _e547 = inTile[1u];
                phi_4641_ = (_e547 < 0f);
            }
            let _e550 = phi_4641_;
            phi_4648_ = _e550;
            if !(_e550) {
                let _e553 = inTile[1u];
                phi_4648_ = (_e553 > 1f);
            }
            let _e556 = phi_4648_;
            if _e556 {
                continue;
            }
            let _e558 = candidate[2u];
            if (_e558 > 1f) {
                let _e560 = which;
                let _e561 = cascadeCount;
                if (_e560 < (_e561 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e566 = inTile[0u];
            let _e567 = which;
            let _e570 = cascadeCount;
            let _e574 = inTile[1u];
            uv_6 = vec2<f32>(((_e566 + f32(_e567)) / f32(_e570)), _e574);
            let _e576 = candidate;
            projected = _e576;
            let _e577 = which;
            cascade = _e577;
            let _e578 = texelMetres;
            cascadeTexel = _e578;
            let _e581 = matrix[0][2u];
            let _e584 = matrix[1][2u];
            let _e587 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e581, _e584, _e587)), 0.000001f));
            let _e593 = (*s_5).n;
            let _e596 = matrix[0][2u];
            let _e599 = matrix[1][2u];
            let _e602 = matrix[2][2u];
            let _e606 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e593, vec3<f32>(_e596, _e599, _e602))) * _e606), 0.1f, 1f);
            let _e609 = texelMetres;
            let _e610 = cosSlope;
            let _e611 = cosSlope;
            let _e617 = cosSlope;
            let _e619 = cascadeDepth;
            receiverSlope = (((_e609 * sqrt(max((1f - (_e610 * _e611)), 0f))) / _e617) / _e619);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e621 = attempt;
            attempt = (_e621 + 1i);
        }
    }
    let _e623 = found;
    if !(_e623) {
        return 1f;
    }
    let _e625 = cascade;
    if (_e625 == 0i) {
        let _e629 = frag_info.shadow_bias[0u];
        local_23 = _e629;
    } else {
        let _e630 = cascade;
        if (_e630 == 1i) {
            let _e634 = frag_info.shadow_bias[1u];
            local_24 = _e634;
        } else {
            let _e637 = frag_info.shadow_bias[2u];
            local_24 = _e637;
        }
        let _e638 = local_24;
        local_23 = _e638;
    }
    let _e639 = local_23;
    bias = _e639;
    let _e642 = frag_info.shadow_params[1u];
    storage_ = _e642;
    let _e643 = storage_;
    let _e645 = storage_;
    if ((_e643 > 0.5f) && (_e645 < 1.5f)) {
        let _e648 = bias;
        let _e650 = projected[2u];
        param_138 = _e650;
        let _e651 = ShadowStoredStep_u0028_f1_u003b((&param_138));
        bias = max(_e648, _e651);
    }
    let _e655 = frag_info.shadow_params[0u];
    let _e658 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e655, _e658);
    let _e660 = cascade;
    let _e662 = cascadeCount;
    let _e666 = texel_1;
    tileLo = (vec2<f32>((f32(_e660) / f32(_e662)), 0f) + (_e666 * 0.5f));
    let _e669 = cascade;
    let _e672 = cascadeCount;
    let _e676 = texel_1;
    tileHi = (vec2<f32>((f32((_e669 + 1i)) / f32(_e672)), 1f) - (_e676 * 0.5f));
    let _e681 = frag_info.shadow_bias[3u];
    if (_e681 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y_1 = -1i;
        loop {
            let _e683 = y_1;
            if (_e683 <= 1i) {
                x_1 = -1i;
                loop {
                    let _e685 = x_1;
                    if (_e685 <= 1i) {
                        let _e687 = uv_6;
                        let _e688 = x_1;
                        let _e690 = y_1;
                        let _e693 = texel_1;
                        let _e696 = tileLo;
                        let _e697 = tileHi;
                        let _e699 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e687 + (vec2<f32>(f32(_e688), f32(_e690)) * _e693)), _e696, _e697), 0f);
                        let _e700 = stored_4;
                        stored_4 = (_e700 + _e699);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e702 = x_1;
                        x_1 = (_e702 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e704 = y_1;
                y_1 = (_e704 + 1i);
            }
        }
        let _e706 = stored_4;
        stored_4 = (_e706 * 0.11111111f);
        let _e709 = stored_4[1u];
        let _e712 = stored_4[2u];
        let _e715 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e709), (1f - _e712), _e715), vec3(0f), vec3(4f));
        let _e720 = through;
        let _e721 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e720, vec3(clamp(_e721, 0f, 1f)));
    }
    let _e727 = frag_info.ambient_ground[3u];
    softness = _e727;
    lit_2 = 0f;
    let _e728 = softness;
    if (_e728 < 0f) {
        let _e730 = uv_6;
        let _e731 = tileLo;
        let _e732 = tileHi;
        let _e734 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e730, _e731, _e732), 0f);
        moments_2 = _e734;
        let _e736 = projected[2u];
        let _e737 = bias;
        let _e739 = softness;
        let _e743 = moments_2;
        param_139 = _e743;
        param_140 = (_e736 - _e737);
        param_141 = clamp((-(_e739) - 1f), 0f, 0.95f);
        let _e744 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_139), (&param_140), (&param_141));
        lit_2 = _e744;
    } else {
        let _e745 = softness;
        if (_e745 <= 0f) {
            y_2 = -1i;
            loop {
                let _e747 = y_2;
                if (_e747 <= 1i) {
                    x_2 = -1i;
                    loop {
                        let _e749 = x_2;
                        if (_e749 <= 1i) {
                            let _e751 = uv_6;
                            let _e752 = x_2;
                            let _e754 = y_2;
                            let _e757 = texel_1;
                            let _e760 = tileLo;
                            let _e761 = tileHi;
                            let _e763 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e751 + (vec2<f32>(f32(_e752), f32(_e754)) * _e757)), _e760, _e761), 0f);
                            param_142 = _e763.x;
                            let _e765 = storage_;
                            param_143 = _e765;
                            let _e766 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_142), (&param_143));
                            occluder = _e766;
                            let _e768 = projected[2u];
                            let _e769 = bias;
                            let _e771 = occluder;
                            let _e774 = lit_2;
                            lit_2 = (_e774 + select(1f, 0f, ((_e768 - _e769) > _e771)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e776 = x_2;
                            x_2 = (_e776 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e778 = y_2;
                    y_2 = (_e778 + 1i);
                }
            }
            let _e780 = lit_2;
            lit_2 = (_e780 * 0.11111111f);
        } else {
            let _e782 = softness;
            spread = tan(min(_e782, 0.5f));
            let _e785 = ShadowNoise_u0028_();
            turn_1 = (_e785 * 6.2831855f);
            let _e787 = spread;
            let _e789 = projected[2u];
            let _e791 = cascadeDepth;
            let _e793 = cascadeTexel;
            searchRadius = clamp((((_e787 * _e789) * _e791) / _e793), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_6 = 0i;
            loop {
                let _e796 = i_6;
                if (_e796 < 16i) {
                    let _e798 = i_6;
                    param_144 = _e798;
                    param_145 = 16i;
                    let _e799 = turn_1;
                    param_146 = _e799;
                    let _e800 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_144), (&param_145), (&param_146));
                    disc = _e800;
                    let _e801 = bias;
                    let _e802 = disc;
                    let _e804 = searchRadius;
                    let _e808 = receiverSlope;
                    tapBias = (_e801 + (max(((length(_e802) * _e804) - 1.5f), 0f) * _e808));
                    let _e811 = uv_6;
                    let _e812 = disc;
                    let _e813 = texel_1;
                    let _e815 = searchRadius;
                    let _e818 = tileLo;
                    let _e819 = tileHi;
                    let _e821 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e811 + ((_e812 * _e813) * _e815)), _e818, _e819), 0f);
                    param_147 = _e821.x;
                    let _e823 = storage_;
                    param_148 = _e823;
                    let _e824 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_147), (&param_148));
                    occluder_1 = _e824;
                    let _e826 = projected[2u];
                    let _e827 = tapBias;
                    let _e829 = occluder_1;
                    if ((_e826 - _e827) > _e829) {
                        let _e831 = occluder_1;
                        let _e832 = blockerSum;
                        blockerSum = (_e832 + _e831);
                        let _e834 = blockerCount;
                        blockerCount = (_e834 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e836 = i_6;
                    i_6 = (_e836 + 1i);
                }
            }
            let _e838 = blockerCount;
            if (_e838 <= 0f) {
                return 1f;
            }
            let _e841 = projected[2u];
            let _e842 = blockerSum;
            let _e843 = blockerCount;
            let _e847 = cascadeDepth;
            gap = (max((_e841 - (_e842 / _e843)), 0f) * _e847);
            let _e849 = spread;
            let _e850 = gap;
            let _e852 = cascadeTexel;
            radius_2 = clamp(((_e849 * _e850) / _e852), 1f, 16f);
            i_7 = 0i;
            loop {
                let _e855 = i_7;
                if (_e855 < 16i) {
                    let _e857 = turn_1;
                    let _e859 = i_7;
                    param_149 = _e859;
                    param_150 = 16i;
                    param_151 = (_e857 + 1f);
                    let _e860 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_149), (&param_150), (&param_151));
                    disc_1 = _e860;
                    let _e861 = bias;
                    let _e862 = disc_1;
                    let _e864 = radius_2;
                    let _e868 = receiverSlope;
                    tapBias_1 = (_e861 + (max(((length(_e862) * _e864) - 1.5f), 0f) * _e868));
                    let _e871 = uv_6;
                    let _e872 = disc_1;
                    let _e873 = texel_1;
                    let _e875 = radius_2;
                    let _e878 = tileLo;
                    let _e879 = tileHi;
                    let _e881 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e871 + ((_e872 * _e873) * _e875)), _e878, _e879), 0f);
                    param_152 = _e881.x;
                    let _e883 = storage_;
                    param_153 = _e883;
                    let _e884 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_152), (&param_153));
                    occluder_2 = _e884;
                    let _e886 = projected[2u];
                    let _e887 = tapBias_1;
                    let _e889 = occluder_2;
                    let _e892 = lit_2;
                    lit_2 = (_e892 + select(1f, 0f, ((_e886 - _e887) > _e889)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e894 = i_7;
                    i_7 = (_e894 + 1i);
                }
            }
            let _e896 = lit_2;
            lit_2 = (_e896 * 0.0625f);
        }
    }
    let _e898 = lit_2;
    let _e899 = strength_1;
    return mix(1f, _e898, clamp(_e899, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_6: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_154: Surface;
    var param_155: LightSample;
    var param_156: i32;

    let _e304 = (*s_6);
    param_154 = _e304;
    let _e305 = (*light_3);
    param_155 = _e305;
    let _e306 = (*index);
    param_156 = _e306;
    let _e307 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_154), (&param_155), (&param_156));
    return _e307;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e299 = (*index_1);
    return (_e299 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e303 = (*distance_1);
    let _e304 = (*distance_1);
    attenuation = (1f / max((_e303 * _e304), 0.0001f));
    let _e308 = (*range_4);
    if (_e308 > 0f) {
        let _e310 = (*distance_1);
        let _e311 = (*range_4);
        ratio = (_e310 / _e311);
        let _e313 = ratio;
        let _e314 = ratio;
        let _e316 = ratio;
        let _e318 = ratio;
        window = clamp((1f - (((_e313 * _e314) * _e316) * _e318)), 0f, 1f);
        let _e322 = window;
        let _e323 = window;
        let _e325 = attenuation;
        attenuation = (_e325 * (_e322 * _e323));
    }
    let _e327 = attenuation;
    return _e327;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_3: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_25: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v_1: f32;

    let _e315 = (*halfWidth);
    let _e316 = (*halfHeight);
    n_3 = cross(_e315, _e316);
    let _e318 = n_3;
    nLen = length(_e318);
    let _e320 = nLen;
    if (_e320 < 0.000000000001f) {
        let _e322 = (*centre);
        return _e322;
    }
    let _e323 = nLen;
    let _e324 = n_3;
    n_3 = (_e324 / vec3(_e323));
    let _e327 = (*centre);
    let _e328 = (*world_2);
    toPlane = (_e327 - _e328);
    let _e330 = (*mirror);
    let _e331 = n_3;
    denom = dot(_e330, _e331);
    let _e333 = denom;
    if (abs(_e333) < 0.00001f) {
        let _e336 = toPlane;
        let _e337 = n_3;
        let _e338 = toPlane;
        let _e339 = n_3;
        onPlane = (_e336 - (_e337 * dot(_e338, _e339)));
    } else {
        let _e343 = toPlane;
        let _e344 = n_3;
        let _e346 = denom;
        t_1 = (dot(_e343, _e344) / _e346);
        let _e348 = t_1;
        if (_e348 > 0f) {
            let _e350 = (*mirror);
            let _e351 = t_1;
            local_25 = (_e350 * _e351);
        } else {
            let _e353 = toPlane;
            let _e354 = n_3;
            let _e355 = toPlane;
            let _e356 = n_3;
            local_25 = (_e353 - (_e354 * dot(_e355, _e356)));
        }
        let _e360 = local_25;
        onPlane = _e360;
    }
    let _e361 = onPlane;
    let _e362 = toPlane;
    offset_2 = (_e361 - _e362);
    let _e364 = (*halfWidth);
    let _e365 = (*halfWidth);
    wLen2_ = max(dot(_e364, _e365), 0.000000000001f);
    let _e368 = (*halfHeight);
    let _e369 = (*halfHeight);
    hLen2_ = max(dot(_e368, _e369), 0.000000000001f);
    let _e372 = offset_2;
    let _e373 = (*halfWidth);
    let _e375 = wLen2_;
    u = clamp((dot(_e372, _e373) / _e375), -1f, 1f);
    let _e378 = offset_2;
    let _e379 = (*halfHeight);
    let _e381 = hLen2_;
    v_1 = clamp((dot(_e378, _e379) / _e381), -1f, 1f);
    let _e384 = (*centre);
    let _e385 = (*halfWidth);
    let _e386 = u;
    let _e389 = (*halfHeight);
    let _e390 = v_1;
    return ((_e384 + (_e385 * _e386)) + (_e389 * _e390));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_2: f32;
    var axis_1: vec3<f32>;
    var len_2: f32;
    var local_26: f32;

    let _e307 = (*a_3);
    let _e308 = (*a_3);
    ua = (_e307 / vec3(max(length(_e308), 0.000000000001f)));
    let _e313 = (*b_1);
    let _e314 = (*b_1);
    ub = (_e313 / vec3(max(length(_e314), 0.000000000001f)));
    let _e319 = ua;
    let _e320 = ub;
    angle_2 = acos(clamp(dot(_e319, _e320), -1f, 1f));
    let _e324 = ua;
    let _e325 = ub;
    axis_1 = cross(_e324, _e325);
    let _e327 = axis_1;
    len_2 = length(_e327);
    let _e329 = len_2;
    if (_e329 > 0.000001f) {
        let _e331 = angle_2;
        let _e332 = axis_1;
        let _e333 = (*n_4);
        let _e336 = len_2;
        local_26 = ((_e331 * dot(_e332, _e333)) / _e336);
    } else {
        local_26 = 0f;
    }
    let _e338 = local_26;
    return _e338;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_8: i32;
    var a_4: vec3<f32>;
    var b_2: vec3<f32>;
    var local_27: i32;
    var ha: f32;
    var hb: f32;
    var d_5: f32;
    var q: vec3<f32>;
    var local_28: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_29: f32;
    var param_157: vec3<f32>;
    var param_158: vec3<f32>;
    var param_159: vec3<f32>;
    var param_160: vec3<f32>;
    var param_161: vec3<f32>;
    var param_162: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_8 = 0i;
    loop {
        let _e321 = i_8;
        if (_e321 < 4i) {
            let _e323 = i_8;
            let _e325 = (*corners_1)[_e323];
            a_4 = _e325;
            let _e326 = i_8;
            if (_e326 == 3i) {
                local_27 = 0i;
            } else {
                let _e328 = i_8;
                local_27 = (_e328 + 1i);
            }
            let _e330 = local_27;
            let _e332 = (*corners_1)[_e330];
            b_2 = _e332;
            let _e333 = a_4;
            let _e334 = (*n_5);
            ha = dot(_e333, _e334);
            let _e336 = b_2;
            let _e337 = (*n_5);
            hb = dot(_e336, _e337);
            let _e339 = ha;
            let _e340 = hb;
            d_5 = (_e339 - _e340);
            let _e342 = a_4;
            let _e343 = b_2;
            let _e344 = a_4;
            let _e346 = d_5;
            if (abs(_e346) > 0.000000000001f) {
                let _e349 = ha;
                let _e350 = d_5;
                local_28 = (_e349 / _e350);
            } else {
                local_28 = 0f;
            }
            let _e352 = local_28;
            q = (_e342 + ((_e343 - _e344) * _e352));
            let _e355 = ha;
            aAbove = (_e355 > 0f);
            let _e357 = hb;
            bAbove = (_e357 > 0f);
            let _e359 = aAbove;
            let _e360 = bAbove;
            if (_e359 || _e360) {
                let _e362 = aAbove;
                let _e363 = a_4;
                let _e364 = q;
                let _e367 = bAbove;
                let _e368 = b_2;
                let _e369 = q;
                param_157 = select(_e364, _e363, vec3(_e362));
                param_158 = select(_e369, _e368, vec3(_e367));
                let _e372 = (*n_5);
                param_159 = _e372;
                let _e373 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_157), (&param_158), (&param_159));
                local_29 = _e373;
            } else {
                local_29 = 0f;
            }
            let _e374 = local_29;
            let _e375 = total;
            total = (_e375 + _e374);
            let _e377 = aAbove;
            let _e378 = bAbove;
            let _e381 = q;
            let _e382 = exit;
            exit = select(_e382, _e381, vec3((_e377 && !(_e378))));
            let _e385 = aAbove;
            let _e387 = bAbove;
            let _e389 = q;
            let _e390 = entry;
            entry = select(_e390, _e389, vec3((!(_e385) && _e387)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e393 = i_8;
            i_8 = (_e393 + 1i);
        }
    }
    let _e395 = exit;
    param_160 = _e395;
    let _e396 = entry;
    param_161 = _e396;
    let _e397 = (*n_5);
    param_162 = _e397;
    let _e398 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_160), (&param_161), (&param_162));
    let _e399 = total;
    total = (_e399 + _e398);
    let _e401 = total;
    return max((-(_e401) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_2: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_30: f32;
    var local_31: f32;
    var local_32: f32;

    let _e304 = (*slot_2);
    let _e305 = (*slot_2);
    lane = (_e304 - ((_e305 / 4i) * 4i));
    let _e309 = lane;
    if (_e309 == 0i) {
        let _e312 = (*four)[0u];
        local_30 = _e312;
    } else {
        let _e313 = lane;
        if (_e313 == 1i) {
            let _e316 = (*four)[1u];
            local_31 = _e316;
        } else {
            let _e317 = lane;
            if (_e317 == 2i) {
                let _e320 = (*four)[2u];
                local_32 = _e320;
            } else {
                let _e322 = (*four)[3u];
                local_32 = _e322;
            }
            let _e323 = local_32;
            local_31 = _e323;
        }
        let _e324 = local_31;
        local_30 = _e324;
    }
    let _e325 = local_30;
    return _e325;
}

fn LightListScale_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_163: vec4<f32>;
    var param_164: i32;

    let _e301 = (*slot_3);
    let _e305 = light_list_info.scales[(_e301 / 4i)];
    param_163 = _e305;
    let _e306 = (*slot_3);
    param_164 = _e306;
    let _e307 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_163), (&param_164));
    return _e307;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_5: vec4<f32>;
    var b_3: vec4<f32>;

    let _e303 = light_list_info.slot_rows[0i];
    let _e304 = (*row);
    a_5 = abs((_e303 - vec4(_e304)));
    let _e310 = light_list_info.slot_rows[1i];
    let _e311 = (*row);
    b_3 = abs((_e310 - vec4(_e311)));
    let _e316 = a_5[0u];
    let _e318 = a_5[1u];
    let _e321 = a_5[2u];
    let _e323 = a_5[3u];
    let _e327 = b_3[0u];
    let _e329 = b_3[1u];
    let _e332 = b_3[2u];
    let _e334 = b_3[3u];
    return (min(min(min(_e316, _e318), min(_e321, _e323)), min(min(_e327, _e329), min(_e332, _e334))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var param_165: vec4<f32>;
    var param_166: i32;

    let _e301 = (*slot_4);
    let _e305 = light_list_info.indices[(_e301 / 4i)];
    param_165 = _e305;
    let _e306 = (*slot_4);
    param_166 = _e306;
    let _e307 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_165), (&param_166));
    return _e307;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e300 = (*texel_2);
    let _e304 = light_list_info.list[1u];
    let _e306 = (*row_1);
    let _e310 = light_list_info.list[2u];
    let _e313 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e300 + 0.5f) * _e304), ((_e306 + 0.5f) * _e310)), 0f);
    return _e313;
}

fn ClusterRow_u0028_i1_u003b(slot_5: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_167: f32;
    var param_168: f32;
    var param_169: vec4<f32>;
    var param_170: i32;

    let _e308 = g_cluster_offset;
    let _e309 = (*slot_5);
    entry_1 = (_e308 + f32(_e309));
    let _e312 = entry_1;
    row_2 = floor((_e312 / 16f));
    let _e315 = entry_1;
    let _e316 = row_2;
    within_1 = (_e315 - (_e316 * 16f));
    let _e319 = within_1;
    texel_3 = floor((_e319 / 4f));
    let _e324 = light_list_info.cluster_depth[3u];
    let _e325 = row_2;
    let _e327 = texel_3;
    param_167 = _e327;
    param_168 = (_e324 + _e325);
    let _e328 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_167), (&param_168));
    four_1 = _e328;
    let _e329 = within_1;
    let _e330 = texel_3;
    let _e335 = four_1;
    param_169 = _e335;
    param_170 = i32(((_e329 - (_e330 * 4f)) + 0.5f));
    let _e336 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_169), (&param_170));
    return _e336;
}

fn Clustered_u0028_() -> bool {
    let _e300 = light_list_info.cluster_grid[3u];
    return (_e300 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_7: ptr<function, Surface>) -> LightSample {
    var light_4: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_6: i32;
    var clustered: bool;
    var listRow: f32;
    var local_33: f32;
    var param_171: i32;
    var param_172: i32;
    var v_2: f32;
    var u_1: f32;
    var local_34: f32;
    var param_173: f32;
    var param_174: i32;
    var type_45: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_2: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_35: f32;
    var param_175: array<vec3<f32>, 4>;
    var param_176: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_36: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_177: vec3<f32>;
    var param_178: vec3<f32>;
    var param_179: vec3<f32>;
    var param_180: vec3<f32>;
    var param_181: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_37: vec3<f32>;
    var param_182: vec3<f32>;
    var param_183: vec3<f32>;
    var param_184: f32;
    var param_185: array<vec3<f32>, 4>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_186: f32;
    var param_187: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_4.integrated = 0f;
    light_4.ltc = vec3<f32>(0f, 0f, 0f);
    let _e356 = (*index_2);
    if (_e356 < 8i) {
        let _e358 = (*index_2);
        let _e361 = frag_info.light_position[_e358];
        position = _e361;
        let _e362 = (*index_2);
        let _e365 = frag_info.light_color[_e362];
        color_1 = _e365;
        let _e366 = (*index_2);
        let _e369 = frag_info.light_direction[_e366];
        direction = _e369;
        let _e370 = (*index_2);
        let _e373 = frag_info.light_cone[_e370];
        cone = _e373;
    } else {
        let _e374 = (*index_2);
        slot_6 = (_e374 - 8i);
        let _e376 = Clustered_u0028_();
        clustered = _e376;
        let _e377 = clustered;
        if _e377 {
            let _e378 = slot_6;
            param_171 = _e378;
            let _e379 = ClusterRow_u0028_i1_u003b((&param_171));
            local_33 = _e379;
        } else {
            let _e380 = slot_6;
            param_172 = _e380;
            let _e381 = LightListRow_u0028_i1_u003b((&param_172));
            local_33 = _e381;
        }
        let _e382 = local_33;
        listRow = _e382;
        let _e383 = listRow;
        let _e387 = light_list_info.list[2u];
        v_2 = ((_e383 + 0.5f) * _e387);
        let _e391 = light_list_info.list[1u];
        u_1 = _e391;
        let _e392 = u_1;
        let _e394 = v_2;
        let _e396 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e392), _e394), 0f);
        position = _e396;
        let _e397 = u_1;
        let _e399 = v_2;
        let _e401 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e397), _e399), 0f);
        color_1 = _e401;
        let _e402 = u_1;
        let _e404 = v_2;
        let _e406 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e402), _e404), 0f);
        direction = _e406;
        let _e407 = u_1;
        let _e409 = v_2;
        let _e411 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e407), _e409), 0f);
        cone = _e411;
        let _e412 = clustered;
        if _e412 {
            let _e413 = listRow;
            param_173 = _e413;
            let _e414 = InSlots_u0028_f1_u003b((&param_173));
            local_34 = select(1f, 0f, _e414);
        } else {
            let _e416 = slot_6;
            param_174 = _e416;
            let _e417 = LightListScale_u0028_i1_u003b((&param_174));
            local_34 = _e417;
        }
        let _e418 = local_34;
        let _e420 = color_1[3u];
        color_1[3u] = (_e420 * _e418);
    }
    let _e424 = position[3u];
    type_45 = _e424;
    let _e425 = type_45;
    if (_e425 > 15.5f) {
        let _e428 = (*s_7).n;
        light_4.l = _e428;
        let _e431 = (*s_7).n;
        light_4.h = _e431;
        light_4.radiance = vec3<f32>(0f, 0f, 0f);
        light_4.n_dot_l = 0f;
        light_4.n_dot_h = 0f;
        light_4.v_dot_h = 0f;
        let _e437 = light_4;
        return _e437;
    }
    let _e438 = type_45;
    if (_e438 > 2.5f) {
        let _e440 = direction;
        halfWidth_1 = _e440.xyz;
        let _e442 = cone;
        halfHeight_1 = _e442.xyz;
        let _e444 = position;
        let _e446 = v_world_position_1;
        toCentre = (_e444.xyz - _e446);
        let _e448 = toCentre;
        let _e449 = halfWidth_1;
        let _e451 = halfHeight_1;
        corners_2[0i] = ((_e448 - _e449) - _e451);
        let _e454 = toCentre;
        let _e455 = halfWidth_1;
        let _e457 = halfHeight_1;
        corners_2[1i] = ((_e454 + _e455) - _e457);
        let _e460 = toCentre;
        let _e461 = halfWidth_1;
        let _e463 = halfHeight_1;
        corners_2[2i] = ((_e460 + _e461) + _e463);
        let _e466 = toCentre;
        let _e467 = halfWidth_1;
        let _e469 = halfHeight_1;
        corners_2[3i] = ((_e466 - _e467) + _e469);
        let _e472 = toCentre;
        let _e473 = halfWidth_1;
        let _e474 = halfHeight_1;
        behind = (dot(_e472, cross(_e473, _e474)) >= 0f);
        let _e478 = behind;
        if _e478 {
            local_35 = 0f;
        } else {
            let _e479 = corners_2;
            param_175 = _e479;
            let _e481 = (*s_7).n;
            param_176 = _e481;
            let _e482 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_175), (&param_176));
            local_35 = _e482;
        }
        let _e483 = local_35;
        formFactor = _e483;
        let _e484 = halfWidth_1;
        let _e485 = halfHeight_1;
        area = (length(cross(_e484, _e485)) * 4f);
        let _e489 = area;
        if (_e489 > 0.000000001f) {
            let _e491 = area;
            local_36 = (1f / _e491);
        } else {
            local_36 = 0f;
        }
        let _e493 = local_36;
        radiance = _e493;
        let _e494 = toCentre;
        distance_2 = length(_e494);
        let _e497 = direction[3u];
        if (_e497 > 0f) {
            let _e499 = distance_2;
            let _e501 = direction[3u];
            ratio_1 = (_e499 / _e501);
            let _e503 = ratio_1;
            let _e504 = ratio_1;
            let _e506 = ratio_1;
            let _e508 = ratio_1;
            window_1 = clamp((1f - (((_e503 * _e504) * _e506) * _e508)), 0f, 1f);
            let _e512 = window_1;
            let _e513 = window_1;
            let _e515 = radiance;
            radiance = (_e515 * (_e512 * _e513));
        }
        let _e518 = (*s_7).v;
        let _e521 = (*s_7).n;
        mirror_1 = reflect(-(_e518), _e521);
        let _e523 = position;
        param_177 = _e523.xyz;
        let _e525 = halfWidth_1;
        param_178 = _e525;
        let _e526 = halfHeight_1;
        param_179 = _e526;
        let _e527 = v_world_position_1;
        param_180 = _e527;
        let _e528 = mirror_1;
        param_181 = _e528;
        let _e529 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_177), (&param_178), (&param_179), (&param_180), (&param_181));
        representative = _e529;
        let _e530 = representative;
        let _e531 = v_world_position_1;
        toPoint = (_e530 - _e531);
        let _e533 = toPoint;
        pointDistance = length(_e533);
        let _e535 = pointDistance;
        if (_e535 > 0.000001f) {
            let _e537 = toPoint;
            let _e538 = pointDistance;
            local_37 = (_e537 / vec3(_e538));
        } else {
            let _e542 = (*s_7).n;
            local_37 = _e542;
        }
        let _e543 = local_37;
        light_4.l = _e543;
        let _e546 = light_4.l;
        let _e548 = (*s_7).v;
        light_4.h = normalize((_e546 + _e548));
        let _e552 = formFactor;
        light_4.n_dot_l = _e552;
        let _e555 = (*s_7).n;
        let _e557 = light_4.h;
        light_4.n_dot_h = max(dot(_e555, _e557), 0f);
        let _e562 = (*s_7).v;
        let _e564 = light_4.h;
        light_4.v_dot_h = max(dot(_e562, _e564), 0f);
        let _e568 = color_1;
        let _e571 = color_1[3u];
        let _e573 = radiance;
        light_4.radiance = ((_e568.xyz * _e571) * _e573);
        light_4.integrated = 1f;
        let _e578 = (*s_7).n;
        param_182 = _e578;
        let _e580 = (*s_7).v;
        param_183 = _e580;
        let _e582 = (*s_7).roughness;
        param_184 = _e582;
        let _e583 = corners_2;
        param_185 = _e583;
        let _e584 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_182), (&param_183), (&param_184), (&param_185));
        light_4.ltc = _e584;
        let _e586 = corners_2;
        g_rect_corners = _e586;
        let _e587 = light_4;
        return _e587;
    }
    let _e588 = direction;
    aim = normalize(_e588.xyz);
    attenuation_1 = 1f;
    let _e591 = type_45;
    if (_e591 < 0.5f) {
        let _e593 = aim;
        light_4.l = -(_e593);
    } else {
        let _e596 = position;
        let _e598 = v_world_position_1;
        toLight_1 = (_e596.xyz - _e598);
        let _e600 = toLight_1;
        distance_3 = length(_e600);
        let _e602 = distance_3;
        if (_e602 < 0.000001f) {
            let _e605 = (*s_7).n;
            light_4.l = _e605;
            let _e608 = (*s_7).n;
            light_4.h = _e608;
            light_4.radiance = vec3<f32>(0f, 0f, 0f);
            light_4.n_dot_l = 0f;
            light_4.n_dot_h = 0f;
            light_4.v_dot_h = 0f;
            let _e614 = light_4;
            return _e614;
        }
        let _e615 = toLight_1;
        let _e616 = distance_3;
        light_4.l = (_e615 / vec3(_e616));
        let _e620 = distance_3;
        param_186 = _e620;
        let _e622 = direction[3u];
        param_187 = _e622;
        let _e623 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_186), (&param_187));
        attenuation_1 = _e623;
        let _e624 = type_45;
        if (_e624 > 1.5f) {
            let _e626 = aim;
            let _e628 = light_4.l;
            cosAngle = dot(_e626, -(_e628));
            let _e631 = cosAngle;
            let _e633 = cone[1u];
            let _e636 = cone[0u];
            let _e638 = cone[1u];
            ramp = clamp(((_e631 - _e633) / (_e636 - _e638)), 0f, 1f);
            let _e642 = ramp;
            let _e643 = ramp;
            let _e645 = attenuation_1;
            attenuation_1 = (_e645 * (_e642 * _e643));
        }
    }
    let _e648 = light_4.l;
    let _e650 = (*s_7).v;
    light_4.h = normalize((_e648 + _e650));
    let _e655 = (*s_7).n;
    let _e657 = light_4.l;
    light_4.n_dot_l = max(dot(_e655, _e657), 0f);
    let _e662 = (*s_7).n;
    let _e664 = light_4.h;
    light_4.n_dot_h = max(dot(_e662, _e664), 0f);
    let _e669 = (*s_7).v;
    let _e671 = light_4.h;
    light_4.v_dot_h = max(dot(_e669, _e671), 0f);
    let _e675 = color_1;
    let _e678 = color_1[3u];
    let _e680 = attenuation_1;
    light_4.radiance = ((_e675.xyz * _e678) * _e680);
    let _e683 = light_4;
    return _e683;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_38: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_188: f32;
    var param_189: f32;

    let _e313 = light_list_info.cluster_view_projection;
    let _e314 = (*world_3);
    clip_1 = (_e313 * vec4<f32>(_e314.x, _e314.y, _e314.z, 1f));
    let _e320 = clip_1;
    let _e323 = clip_1[3u];
    ndc_1 = (_e320.xy / vec2(max(_e323, 0.000001f)));
    let _e328 = light_list_info.cluster_grid;
    grid = _e328.xyz;
    let _e332 = light_list_info.cluster_depth[0u];
    near_1 = _e332;
    let _e334 = ndc_1[0u];
    let _e338 = grid[0u];
    let _e342 = grid[0u];
    tx = clamp(floor((((_e334 * 0.5f) + 0.5f) * _e338)), 0f, (_e342 - 1f));
    let _e346 = ndc_1[1u];
    let _e350 = grid[1u];
    let _e354 = grid[1u];
    ty = clamp(floor((((_e346 * 0.5f) + 0.5f) * _e350)), 0f, (_e354 - 1f));
    let _e358 = clip_1[3u];
    let _e359 = near_1;
    if (_e358 <= _e359) {
        local_38 = 0f;
    } else {
        let _e362 = clip_1[3u];
        let _e363 = near_1;
        let _e368 = light_list_info.cluster_depth[1u];
        let _e372 = grid[2u];
        local_38 = clamp(floor((log((_e362 / _e363)) * _e368)), 0f, (_e372 - 1f));
    }
    let _e375 = local_38;
    tz = _e375;
    let _e376 = tx;
    let _e377 = ty;
    let _e379 = grid[0u];
    let _e382 = tz;
    let _e384 = grid[0u];
    let _e387 = grid[1u];
    cell_1 = ((_e376 + (_e377 * _e379)) + ((_e382 * _e384) * _e387));
    let _e390 = cell_1;
    row_3 = floor((_e390 / 4f));
    let _e393 = cell_1;
    let _e394 = row_3;
    let _e399 = light_list_info.cluster_depth[2u];
    let _e400 = row_3;
    param_188 = (_e393 - (_e394 * 4f));
    param_189 = (_e399 + _e400);
    let _e402 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_188), (&param_189));
    header = _e402;
    let _e404 = header[0u];
    g_cluster_offset = _e404;
    let _e406 = header[1u];
    g_cluster_count = _e406;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_190: vec3<f32>;

    let _e302 = light_list_info.list[0u];
    tail = _e302;
    let _e303 = Clustered_u0028_();
    if _e303 {
        let _e304 = v_world_position_1;
        param_190 = _e304;
        FindCluster_u0028_vf3_u003b((&param_190));
        let _e305 = g_cluster_count;
        tail = _e305;
    }
    let _e308 = frag_info.frame_params[1u];
    let _e312 = tail;
    return (clamp(i32((_e308 + 0.5f)), 0i, 8i) + clamp(i32((_e312 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_9: i32;
    var light_5: LightSample;
    var param_191: i32;
    var param_192: Surface;
    var visibility: f32;
    var param_193: i32;
    var local_39: f32;
    var param_194: Surface;
    var param_195: LightSample;
    var param_196: i32;
    var param_197: vec3<f32>;
    var param_198: vec3<f32>;
    var param_199: i32;
    var param_200: Surface;
    var param_201: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e316 = LightCount_u0028_();
    count_1 = _e316;
    i_9 = 0i;
    loop {
        let _e317 = i_9;
        if (_e317 < 32i) {
            let _e319 = i_9;
            let _e320 = count_1;
            if (_e319 >= _e320) {
                break;
            }
            let _e322 = i_9;
            param_191 = _e322;
            let _e323 = (*s_8);
            param_192 = _e323;
            let _e324 = 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((&param_191), (&param_192));
            light_5 = _e324;
            let _e326 = light_5.n_dot_l;
            if (_e326 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e328 = i_9;
            param_193 = _e328;
            let _e329 = LightHasShadow_u0028_i1_u003b((&param_193));
            if _e329 {
                let _e330 = (*s_8);
                param_194 = _e330;
                let _e331 = light_5;
                param_195 = _e331;
                let _e332 = i_9;
                param_196 = _e332;
                let _e333 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_194), (&param_195), (&param_196));
                let _e334 = v_world_position_1;
                param_197 = _e334;
                let _e336 = (*s_8).n;
                param_198 = _e336;
                let _e337 = i_9;
                param_199 = _e337;
                let _e338 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_197), (&param_198), (&param_199));
                local_39 = (_e333 * _e338);
            } else {
                local_39 = 1f;
            }
            let _e340 = local_39;
            visibility = _e340;
            let _e341 = visibility;
            if (_e341 <= 0f) {
                continue;
            }
            let _e343 = (*s_8);
            param_200 = _e343;
            let _e344 = light_5;
            param_201 = _e344;
            let _e345 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_200), (&param_201));
            let _e347 = light_5.radiance;
            let _e350 = light_5.n_dot_l;
            let _e352 = visibility;
            let _e354 = light_transmittance;
            let _e356 = total_1;
            total_1 = (_e356 + ((((_e345 * _e347) * _e350) * _e352) * _e354));
            continue;
        } else {
            break;
        }
        continuing {
            let _e358 = i_9;
            i_9 = (_e358 + 1i);
        }
    }
    let _e360 = total_1;
    return _e360;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e299 = v_lightmap_uv_1;
    let _e300 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e299);
    texel_4 = _e300;
    let _e301 = texel_4;
    let _e304 = texel_4[3u];
    return ((_e301.xyz * _e304) * 8f);
}

fn SceneColorLevel_u0028_vf2_u003b_i1_u003b(uv_7: ptr<function, vec2<f32>>, level: ptr<function, i32>) -> vec3<f32> {
    var rect: vec4<f32>;
    var inset_1: vec2<f32>;
    var at_4: vec2<f32>;

    let _e303 = (*level);
    let _e306 = layer_info.scene_levels[_e303];
    rect = _e306;
    let _e308 = layer_info.scene_color;
    inset_1 = (_e308.yz * 0.5f);
    let _e311 = rect;
    let _e313 = (*uv_7);
    let _e314 = rect;
    let _e317 = inset_1;
    let _e318 = rect;
    let _e320 = inset_1;
    let _e322 = inset_1;
    at_4 = (_e311.xy + clamp((_e313 * _e314.zw), _e317, max((_e318.zw - _e320), _e322)));
    let _e326 = at_4;
    let _e327 = textureSampleLevel(scene_color_texture_tex, scene_color_texture_smp, _e326, 0f);
    return _e327.xyz;
}

fn SceneColorAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod: ptr<function, f32>) -> vec3<f32> {
    var clip_2: vec4<f32>;
    var ndc_2: vec2<f32>;
    var view_1: vec2<f32>;
    var uv_8: vec2<f32>;
    var top: f32;
    var level_1: f32;
    var lower: f32;
    var near_2: vec3<f32>;
    var param_202: vec2<f32>;
    var param_203: i32;
    var far_1: vec3<f32>;
    var param_204: vec2<f32>;
    var param_205: i32;

    let _e314 = layer_info.scene_view_projection;
    let _e315 = (*world_4);
    clip_2 = (_e314 * vec4<f32>(_e315.x, _e315.y, _e315.z, 1f));
    let _e321 = clip_2;
    let _e324 = clip_2[3u];
    ndc_2 = (_e321.xy / vec2(max(_e324, 0.000001f)));
    let _e329 = ndc_2[0u];
    let _e333 = ndc_2[1u];
    view_1 = clamp(vec2<f32>(((_e329 * 0.5f) + 0.5f), (0.5f - (_e333 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
    let _e339 = layer_info.scene_viewport;
    let _e341 = view_1;
    let _e343 = layer_info.scene_viewport;
    uv_8 = (_e339.xy + (_e341 * _e343.zw));
    let _e349 = layer_info.scene_color[0u];
    top = (_e349 - 1f);
    let _e351 = (*lod);
    let _e352 = top;
    level_1 = clamp(_e351, 0f, _e352);
    let _e354 = level_1;
    lower = floor(_e354);
    let _e356 = lower;
    let _e358 = uv_8;
    param_202 = _e358;
    param_203 = i32(_e356);
    let _e359 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_202), (&param_203));
    near_2 = _e359;
    let _e360 = lower;
    let _e362 = top;
    let _e365 = uv_8;
    param_204 = _e365;
    param_205 = i32(min((_e360 + 1f), _e362));
    let _e366 = SceneColorLevel_u0028_vf2_u003b_i1_u003b((&param_204), (&param_205));
    far_1 = _e366;
    let _e367 = near_2;
    let _e368 = far_1;
    let _e369 = level_1;
    let _e370 = lower;
    return mix(_e367, _e368, vec3((_e369 - _e370)));
}

fn IorInfinite_u0028_() -> bool {
    let _e300 = layer_info.coat[2u];
    return (_e300 == 0f);
}

fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
    var local_40: f32;

    let _e300 = IorInfinite_u0028_();
    if _e300 {
        local_40 = 0f;
    } else {
        let _e301 = (*ior);
        let _e306 = layer_info.transmission[3u];
        local_40 = (((_e301 - 1f) * 0.025f) * _e306);
    }
    let _e308 = local_40;
    return _e308;
}

fn RefractionIor_u0028_() -> f32 {
    var local_41: f32;

    let _e299 = IorInfinite_u0028_();
    if _e299 {
        local_41 = 10000f;
    } else {
        let _e302 = layer_info.coat[2u];
        local_41 = max(_e302, 1f);
    }
    let _e304 = local_41;
    return _e304;
}

fn SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) -> vec3<f32> {
    var ior_1: f32;
    var spread_1: f32;
    var param_206: f32;
    var width: f32;
    var lod_1: f32;
    var thin: bool;
    var red: vec3<f32>;
    var local_42: vec3<f32>;
    var green: vec3<f32>;
    var local_43: vec3<f32>;
    var blue: vec3<f32>;
    var local_44: vec3<f32>;
    var param_207: vec3<f32>;
    var param_208: f32;
    var param_209: vec3<f32>;
    var param_210: f32;
    var param_211: vec3<f32>;
    var param_212: f32;

    let _e317 = RefractionIor_u0028_();
    ior_1 = _e317;
    let _e318 = ior_1;
    param_206 = _e318;
    let _e319 = DispersionSpread_u0028_f1_u003b((&param_206));
    spread_1 = _e319;
    let _e323 = layer_info.scene_levels[0i][2u];
    let _e326 = layer_info.scene_color[1u];
    width = (_e323 / max(_e326, 0.000000001f));
    let _e329 = width;
    let _e333 = (*s_9).roughness;
    let _e335 = ior_1;
    lod_1 = ((log2(max(_e329, 1f)) * _e333) * clamp(((_e335 * 2f) - 2f), 0f, 1f));
    let _e340 = g_thickness;
    thin = (_e340 <= 0f);
    let _e342 = thin;
    if _e342 {
        let _e344 = (*s_9).v;
        local_42 = -(_e344);
    } else {
        let _e347 = (*s_9).v;
        let _e350 = (*s_9).n;
        let _e351 = ior_1;
        let _e352 = spread_1;
        local_42 = refract(-(_e347), _e350, (1f / max((_e351 - _e352), 1f)));
    }
    let _e357 = local_42;
    red = _e357;
    let _e358 = thin;
    if _e358 {
        let _e360 = (*s_9).v;
        local_43 = -(_e360);
    } else {
        let _e363 = (*s_9).v;
        let _e366 = (*s_9).n;
        let _e367 = ior_1;
        local_43 = refract(-(_e363), _e366, (1f / _e367));
    }
    let _e370 = local_43;
    green = _e370;
    let _e371 = thin;
    if _e371 {
        let _e373 = (*s_9).v;
        local_44 = -(_e373);
    } else {
        let _e376 = (*s_9).v;
        let _e379 = (*s_9).n;
        let _e380 = ior_1;
        let _e381 = spread_1;
        local_44 = refract(-(_e376), _e379, (1f / (_e380 + _e381)));
    }
    let _e385 = local_44;
    blue = _e385;
    let _e386 = v_world_position_1;
    let _e387 = red;
    let _e388 = g_thickness;
    param_207 = (_e386 + (_e387 * _e388));
    let _e391 = lod_1;
    param_208 = _e391;
    let _e392 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_207), (&param_208));
    let _e394 = v_world_position_1;
    let _e395 = green;
    let _e396 = g_thickness;
    param_209 = (_e394 + (_e395 * _e396));
    let _e399 = lod_1;
    param_210 = _e399;
    let _e400 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_209), (&param_210));
    let _e402 = v_world_position_1;
    let _e403 = blue;
    let _e404 = g_thickness;
    param_211 = (_e402 + (_e403 * _e404));
    let _e407 = lod_1;
    param_212 = _e407;
    let _e408 = SceneColorAt_u0028_vf3_u003b_f1_u003b((&param_211), (&param_212));
    return vec3<f32>(_e392.x, _e400.y, _e408.z);
}

fn TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b(s_10: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
    var ior_2: f32;
    var spread_2: f32;
    var param_213: f32;
    var lod_2: f32;
    var thin_1: bool;
    var red_1: vec3<f32>;
    var local_45: vec3<f32>;
    var green_1: vec3<f32>;
    var local_46: vec3<f32>;
    var blue_1: vec3<f32>;
    var local_47: vec3<f32>;

    let _e311 = RefractionIor_u0028_();
    ior_2 = _e311;
    let _e312 = ior_2;
    param_213 = _e312;
    let _e313 = DispersionSpread_u0028_f1_u003b((&param_213));
    spread_2 = _e313;
    let _e315 = (*s_10).roughness;
    let _e316 = ior_2;
    let _e321 = (*levels);
    lod_2 = ((_e315 * clamp(((_e316 * 2f) - 2f), 0f, 1f)) * _e321);
    let _e323 = g_thickness;
    thin_1 = (_e323 <= 0f);
    let _e325 = thin_1;
    if _e325 {
        let _e327 = (*s_10).v;
        local_45 = -(_e327);
    } else {
        let _e330 = (*s_10).v;
        let _e333 = (*s_10).n;
        let _e334 = ior_2;
        let _e335 = spread_2;
        local_45 = refract(-(_e330), _e333, (1f / max((_e334 - _e335), 1f)));
    }
    let _e340 = local_45;
    red_1 = _e340;
    let _e341 = thin_1;
    if _e341 {
        let _e343 = (*s_10).v;
        local_46 = -(_e343);
    } else {
        let _e346 = (*s_10).v;
        let _e349 = (*s_10).n;
        let _e350 = ior_2;
        local_46 = refract(-(_e346), _e349, (1f / _e350));
    }
    let _e353 = local_46;
    green_1 = _e353;
    let _e354 = thin_1;
    if _e354 {
        let _e356 = (*s_10).v;
        local_47 = -(_e356);
    } else {
        let _e359 = (*s_10).v;
        let _e362 = (*s_10).n;
        let _e363 = ior_2;
        let _e364 = spread_2;
        local_47 = refract(-(_e359), _e362, (1f / (_e363 + _e364)));
    }
    let _e368 = local_47;
    blue_1 = _e368;
    let _e369 = red_1;
    let _e370 = lod_2;
    let _e371 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e369, _e370);
    let _e373 = green_1;
    let _e374 = lod_2;
    let _e375 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e373, _e374);
    let _e377 = blue_1;
    let _e378 = lod_2;
    let _e379 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e377, _e378);
    return vec3<f32>(_e371.x, _e375.y, _e379.z);
}

fn SceneColorBound_u0028_() -> bool {
    let _e300 = layer_info.scene_color[0u];
    return (_e300 > 0f);
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_48: f32;

    let _e301 = frag_info.material2_[2u];
    local_48 = floor((_e301 * 0.5f));
    let _e304 = local_48;
    return _e304;
}

fn IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) -> f32 {
    var target_: f32;
    var local_49: f32;
    var local_50: f32;

    let _e302 = OcclusionTarget_u0028_();
    target_ = _e302;
    let _e303 = target_;
    let _e305 = target_;
    if ((_e303 > 0.5f) && (_e305 < 1.5f)) {
        local_49 = 1f;
    } else {
        let _e309 = (*s_11).occlusion;
        local_49 = _e309;
    }
    let _e310 = local_49;
    local_50 = _e310;
    let _e311 = local_50;
    return _e311;
}

fn DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) -> f32 {
    var local_51: f32;
    var local_52: f32;

    let _e301 = OcclusionTarget_u0028_();
    if (_e301 > 1.5f) {
        local_51 = 1f;
    } else {
        let _e304 = (*s_12).occlusion;
        local_51 = _e304;
    }
    let _e305 = local_51;
    local_52 = _e305;
    let _e306 = local_52;
    return _e306;
}

fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
    var e_1: f32;
    var param_214: f32;
    var param_215: f32;
    var param_216: f32;
    var param_217: vec3<f32>;
    var param_218: f32;

    let _e307 = (*mu_1);
    param_214 = _e307;
    let _e308 = (*r_4);
    param_215 = _e308;
    let _e309 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_214), (&param_215));
    e_1 = _e309;
    let _e310 = (*rho_2);
    let _e311 = e_1;
    let _e313 = (*r_4);
    param_216 = _e313;
    let _e314 = FonAverage_u0028_f1_u003b((&param_216));
    let _e315 = (*rho_2);
    param_217 = _e315;
    param_218 = _e314;
    let _e316 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_217), (&param_218));
    let _e317 = e_1;
    return ((_e310 * _e311) + (_e316 * (1f - _e317)));
}

fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shift: ptr<function, vec3<f32>>) -> vec3<f32> {
    var phase: f32;
    var val: vec3<f32>;
    var pos: vec3<f32>;
    var variance_1: vec3<f32>;
    var xyz: vec3<f32>;

    let _e305 = (*opd);
    phase = ((6.2831855f * _e305) * 0.000000001f);
    val = vec3<f32>(0.00000000000054856f, 0.00000000000044201f, 0.00000000000052481f);
    pos = vec3<f32>(1681000f, 1795300f, 2208400f);
    variance_1 = vec3<f32>(4327800000f, 9304600000f, 6612100000f);
    let _e308 = val;
    let _e309 = variance_1;
    let _e313 = pos;
    let _e314 = phase;
    let _e316 = (*shift);
    let _e320 = phase;
    let _e321 = phase;
    let _e324 = variance_1;
    xyz = (((_e308 * sqrt((_e309 * 6.2831855f))) * cos(((_e313 * _e314) + _e316))) * exp((_e324 * -((_e320 * _e321)))));
    let _e328 = phase;
    let _e331 = (*shift)[0u];
    let _e335 = phase;
    let _e337 = phase;
    let _e342 = xyz[0u];
    xyz[0u] = (_e342 + ((0.00000001644083f * cos(((2239900f * _e328) + _e331))) * exp(((-4528200000f * _e335) * _e337))));
    let _e345 = xyz;
    xyz = (_e345 / vec3(0.00000010685f));
    let _e348 = xyz;
    return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e348);
}

fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<function, f32>, cos1_: ptr<function, f32>, thickness: ptr<function, f32>, base: ptr<function, vec3<f32>>) -> vec3<f32> {
    var eta2_: f32;
    var sin2Sq: f32;
    var cos2Sq: f32;
    var cos2_: f32;
    var r0_: f32;
    var r12_: f32;
    var t121_: f32;
    var phi12_: f32;
    var phi21_: f32;
    var sqrtBase: vec3<f32>;
    var baseIor: vec3<f32>;
    var r1_: vec3<f32>;
    var r23_: vec3<f32>;
    var phi23_: vec3<f32>;
    var opd_1: f32;
    var phi: vec3<f32>;
    var r123_: vec3<f32>;
    var rootR123_: vec3<f32>;
    var rs: vec3<f32>;
    var total_2: vec3<f32>;
    var cm: vec3<f32>;
    var m_2: i32;
    var param_219: f32;
    var param_220: vec3<f32>;
    var local_53: vec3<f32>;

    let _e327 = (*film);
    let _e328 = (*thickness);
    eta2_ = mix(1f, _e327, smoothstep(0f, 0.03f, _e328));
    let _e331 = (*cos1_);
    let _e332 = (*cos1_);
    let _e335 = eta2_;
    let _e336 = eta2_;
    sin2Sq = ((1f - (_e331 * _e332)) / (_e335 * _e336));
    let _e339 = sin2Sq;
    cos2Sq = (1f - _e339);
    let _e341 = cos2Sq;
    cos2_ = sqrt(max(_e341, 0f));
    let _e344 = eta2_;
    let _e346 = eta2_;
    r0_ = ((_e344 - 1f) / (_e346 + 1f));
    let _e349 = r0_;
    let _e350 = r0_;
    let _e352 = r0_;
    let _e353 = r0_;
    let _e356 = (*cos1_);
    r12_ = ((_e349 * _e350) + ((1f - (_e352 * _e353)) * pow((1f - _e356), 5f)));
    let _e361 = r12_;
    t121_ = (1f - _e361);
    let _e363 = eta2_;
    phi12_ = select(0f, 3.1415927f, (_e363 < 1f));
    let _e366 = phi12_;
    phi21_ = (3.1415927f - _e366);
    let _e368 = (*base);
    sqrtBase = sqrt(clamp(_e368, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
    let _e371 = sqrtBase;
    let _e373 = sqrtBase;
    baseIor = ((vec3<f32>(1f, 1f, 1f) + _e371) / (vec3<f32>(1f, 1f, 1f) - _e373));
    let _e376 = baseIor;
    let _e377 = eta2_;
    let _e380 = baseIor;
    let _e381 = eta2_;
    r1_ = ((_e376 - vec3(_e377)) / (_e380 + vec3(_e381)));
    let _e385 = r1_;
    let _e386 = r1_;
    r1_ = (_e386 * _e385);
    let _e388 = r1_;
    let _e389 = r1_;
    let _e391 = cos2_;
    r23_ = (_e388 + ((vec3<f32>(1f, 1f, 1f) - _e389) * pow((1f - _e391), 5f)));
    let _e397 = baseIor[0u];
    let _e398 = eta2_;
    let _e402 = baseIor[1u];
    let _e403 = eta2_;
    let _e407 = baseIor[2u];
    let _e408 = eta2_;
    phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e397 < _e398)), select(0f, 3.1415927f, (_e402 < _e403)), select(0f, 3.1415927f, (_e407 < _e408)));
    let _e412 = eta2_;
    let _e414 = (*thickness);
    let _e416 = cos2_;
    opd_1 = (((2f * _e412) * _e414) * _e416);
    let _e418 = phi21_;
    let _e420 = phi23_;
    phi = (vec3(_e418) + _e420);
    let _e422 = r12_;
    let _e423 = r23_;
    r123_ = clamp((_e423 * _e422), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
    let _e426 = r123_;
    rootR123_ = sqrt(_e426);
    let _e428 = t121_;
    let _e429 = t121_;
    let _e431 = r23_;
    let _e433 = r123_;
    rs = ((_e431 * (_e428 * _e429)) / (vec3<f32>(1f, 1f, 1f) - _e433));
    let _e436 = r12_;
    let _e438 = rs;
    total_2 = (vec3(_e436) + _e438);
    let _e440 = rs;
    let _e441 = t121_;
    cm = (_e440 - vec3(_e441));
    m_2 = 1i;
    loop {
        let _e444 = m_2;
        if (_e444 <= 2i) {
            let _e446 = rootR123_;
            let _e447 = cm;
            cm = (_e447 * _e446);
            let _e449 = cm;
            let _e451 = m_2;
            let _e453 = opd_1;
            let _e455 = m_2;
            let _e457 = phi;
            param_219 = (f32(_e451) * _e453);
            param_220 = (_e457 * f32(_e455));
            let _e459 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((&param_219), (&param_220));
            let _e461 = total_2;
            total_2 = (_e461 + ((_e449 * 2f) * _e459));
            continue;
        } else {
            break;
        }
        continuing {
            let _e463 = m_2;
            m_2 = (_e463 + 1i);
        }
    }
    let _e465 = cos2Sq;
    if (_e465 < 0f) {
        local_53 = vec3<f32>(1f, 1f, 1f);
    } else {
        let _e467 = total_2;
        local_53 = max(_e467, vec3<f32>(0f, 0f, 0f));
    }
    let _e469 = local_53;
    return _e469;
}

fn ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
    var f0_3: vec3<f32>;
    var param_221: f32;
    var param_222: f32;
    var param_223: f32;
    var param_224: vec3<f32>;

    let _e304 = g_f0_dielectric;
    let _e306 = (*s_13).albedo;
    let _e308 = (*s_13).metallic;
    f0_3 = mix(_e304, _e306, vec3(clamp(_e308, 0f, 1f)));
    let _e314 = layer_info.iridescence[1u];
    param_221 = _e314;
    let _e316 = (*s_13).n_dot_v;
    param_222 = _e316;
    let _e319 = layer_info.iridescence[2u];
    param_223 = _e319;
    let _e320 = f0_3;
    param_224 = _e320;
    let _e321 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((&param_221), (&param_222), (&param_223), (&param_224));
    g_irid_fresnel = _e321;
    return;
}

fn ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_14: ptr<function, Surface>) {
    var param_225: f32;
    var param_226: f32;
    var param_227: f32;
    var t_2: vec3<f32>;
    var usable: bool;
    var local_54: vec3<f32>;
    var b_4: vec3<f32>;
    var turn_2: vec2<f32>;
    var along_1: vec3<f32>;
    var local_55: f32;
    var local_56: vec3<f32>;
    var phi_5440_: bool;

    let _e311 = (*s_14).n_dot_v;
    let _e315 = g_sheen_roughness;
    param_225 = _e315;
    param_226 = sqrt(clamp((1f - _e311), 0f, 1f));
    param_227 = 1f;
    let _e316 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_225), (&param_226), (&param_227));
    let _e317 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e316, 0f);
    g_sheen_albedo = _e317.z;
    let _e320 = g_sheen[0u];
    let _e322 = g_sheen[1u];
    let _e325 = g_sheen[2u];
    let _e327 = g_sheen_albedo;
    g_sheen_scale = (1f - (max(max(_e320, _e322), _e325) * _e327));
    let _e330 = v_tangent_1;
    let _e333 = (*s_14).n;
    let _e335 = (*s_14).n;
    let _e336 = v_tangent_1;
    t_2 = (_e330.xyz - (_e333 * dot(_e335, _e336.xyz)));
    let _e341 = t_2;
    let _e342 = t_2;
    usable = (dot(_e341, _e342) > 0.000000000001f);
    let _e345 = usable;
    if _e345 {
        let _e346 = t_2;
        local_54 = normalize(_e346);
    } else {
        local_54 = vec3<f32>(1f, 0f, 0f);
    }
    let _e348 = local_54;
    t_2 = _e348;
    let _e350 = (*s_14).n;
    let _e351 = t_2;
    let _e354 = v_tangent_1[3u];
    b_4 = (cross(_e350, _e351) * _e354);
    let _e356 = gl_FrontFacing_1;
    if !(_e356) {
        let _e358 = t_2;
        t_2 = -(_e358);
    }
    let _e361 = layer_info.anisotropy;
    turn_2 = _e361.yz;
    let _e363 = t_2;
    let _e365 = turn_2[0u];
    let _e367 = b_4;
    let _e369 = turn_2[1u];
    along_1 = ((_e363 * _e365) + (_e367 * _e369));
    let _e372 = usable;
    phi_5440_ = _e372;
    if _e372 {
        let _e373 = along_1;
        let _e374 = along_1;
        phi_5440_ = (dot(_e373, _e374) > 0.000000000001f);
    }
    let _e378 = phi_5440_;
    if _e378 {
        let _e381 = layer_info.anisotropy[0u];
        local_55 = clamp(_e381, 0f, 1f);
    } else {
        local_55 = 0f;
    }
    let _e383 = local_55;
    g_aniso = _e383;
    let _e384 = g_aniso;
    if (_e384 > 0f) {
        let _e386 = along_1;
        local_56 = normalize(_e386);
    } else {
        let _e388 = t_2;
        local_56 = _e388;
    }
    let _e389 = local_56;
    g_aniso_t = _e389;
    let _e391 = (*s_14).n;
    let _e392 = g_aniso_t;
    g_aniso_b = cross(_e391, _e392);
    return;
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e300 = frag_info.target_origin[1u];
    return _e300;
}

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_15: ptr<function, Surface>) {
    var orm: vec3<f32>;
    var param_228: i32;

    param_228 = 1i;
    let _e301 = MapUv_u0028_i1_u003b((&param_228));
    let _e302 = MaterialLodBias_u0028_();
    let _e303 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e301, _e302);
    orm = _e303.xyz;
    let _e306 = (*s_15).metallic;
    let _e308 = orm[2u];
    (*s_15).metallic = clamp((_e306 * _e308), 0f, 1f);
    let _e313 = (*s_15).roughness;
    let _e315 = orm[1u];
    (*s_15).roughness = clamp((_e313 * _e315), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_16: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_229: i32;
    var param_230: vec3<f32>;

    param_229 = 4i;
    let _e302 = MapUv_u0028_i1_u003b((&param_229));
    let _e303 = MaterialLodBias_u0028_();
    let _e304 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e302, _e303);
    param_230 = _e304.xyz;
    let _e306 = SrgbToLinear_u0028_vf3_u003b((&param_230));
    emissive = _e306;
    let _e307 = emissive;
    let _e309 = frag_info.emissive;
    let _e314 = frag_info.material2_[3u];
    (*s_16).emissive = ((_e307 * _e309.xyz) * _e314);
    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_17: ptr<function, Surface>) {
    var occlusion: f32;
    var param_231: i32;
    var strength_2: f32;

    param_231 = 3i;
    let _e302 = MapUv_u0028_i1_u003b((&param_231));
    let _e303 = MaterialLodBias_u0028_();
    let _e304 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e302, _e303);
    occlusion = _e304.x;
    let _e308 = frag_info.material2_[2u];
    let _e309 = OcclusionTarget_u0028_();
    strength_2 = (_e308 - (2f * _e309));
    let _e312 = occlusion;
    let _e313 = strength_2;
    (*s_17).occlusion = mix(1f, _e312, clamp(_e313, 0f, 1f));
    return;
}

fn MapMatrix_u0028_i1_u003b(slot_7: ptr<function, i32>) -> vec4<f32> {
    var u_2: vec4<f32>;
    var v_3: vec4<f32>;

    let _e301 = (*slot_7);
    let _e305 = layer_info.uv_transform[(_e301 * 2i)];
    u_2 = _e305;
    let _e306 = (*slot_7);
    let _e311 = layer_info.uv_transform[((_e306 * 2i) + 1i)];
    v_3 = _e311;
    let _e313 = u_2[0u];
    let _e315 = u_2[1u];
    let _e317 = v_3[0u];
    let _e319 = v_3[1u];
    return vec4<f32>(_e313, _e315, _e317, _e319);
}

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_18: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var param_232: i32;
    var t_3: vec3<f32>;
    var b_5: vec3<f32>;
    var m_3: vec4<f32>;
    var param_233: i32;
    var det: f32;
    var flip: f32;
    var front: vec3<f32>;
    var local_57: vec3<f32>;
    var turned: vec3<f32>;
    var turns: bool;
    var local_58: vec3<f32>;
    var local_59: vec3<f32>;
    var sampled: vec3<f32>;
    var phi_4114_: bool;
    var phi_4121_: bool;
    var phi_4128_: bool;
    var phi_4135_: bool;

    param_232 = 2i;
    let _e314 = MapUv_u0028_i1_u003b((&param_232));
    let _e315 = MaterialLodBias_u0028_();
    let _e316 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e314, _e315);
    sampledTexel = _e316;
    let _e317 = v_tangent_1;
    t_3 = _e317.xyz;
    let _e319 = t_3;
    let _e321 = (*s_18).n;
    let _e323 = (*s_18).n;
    let _e324 = t_3;
    t_3 = (_e319 - (_e321 * dot(_e323, _e324)));
    let _e328 = t_3;
    let _e329 = t_3;
    if (dot(_e328, _e329) < 0.000000000001f) {
        return;
    }
    let _e332 = t_3;
    t_3 = normalize(_e332);
    let _e335 = (*s_18).n;
    let _e336 = t_3;
    let _e339 = v_tangent_1[3u];
    b_5 = (cross(_e335, _e336) * _e339);
    param_233 = 2i;
    let _e341 = MapMatrix_u0028_i1_u003b((&param_233));
    m_3 = _e341;
    let _e343 = m_3[0u];
    let _e345 = m_3[3u];
    let _e348 = m_3[1u];
    let _e350 = m_3[2u];
    det = ((_e343 * _e345) - (_e348 * _e350));
    let _e353 = det;
    flip = select(1f, -1f, (_e353 < 0f));
    let _e356 = gl_FrontFacing_1;
    if _e356 {
        let _e357 = b_5;
        local_57 = _e357;
    } else {
        let _e358 = b_5;
        local_57 = -(_e358);
    }
    let _e360 = local_57;
    front = _e360;
    let _e361 = t_3;
    let _e363 = m_3[3u];
    let _e365 = front;
    let _e367 = m_3[2u];
    let _e370 = flip;
    turned = (((_e361 * _e363) + (_e365 * _e367)) * _e370);
    let _e373 = m_3[1u];
    let _e374 = (_e373 != 0f);
    phi_4114_ = _e374;
    if !(_e374) {
        let _e377 = m_3[2u];
        phi_4114_ = (_e377 != 0f);
    }
    let _e380 = phi_4114_;
    phi_4121_ = _e380;
    if !(_e380) {
        let _e383 = m_3[0u];
        phi_4121_ = (_e383 < 0f);
    }
    let _e386 = phi_4121_;
    phi_4128_ = _e386;
    if !(_e386) {
        let _e389 = m_3[3u];
        phi_4128_ = (_e389 < 0f);
    }
    let _e392 = phi_4128_;
    phi_4135_ = _e392;
    if _e392 {
        let _e393 = turned;
        let _e394 = turned;
        phi_4135_ = (dot(_e393, _e394) > 0.000000000001f);
    }
    let _e398 = phi_4135_;
    turns = _e398;
    let _e399 = turns;
    if _e399 {
        let _e400 = turned;
        local_58 = normalize(_e400);
    } else {
        let _e402 = t_3;
        local_58 = _e402;
    }
    let _e403 = local_58;
    t_3 = _e403;
    let _e404 = turns;
    if _e404 {
        let _e406 = (*s_18).n;
        let _e407 = t_3;
        let _e410 = v_tangent_1[3u];
        let _e412 = flip;
        local_59 = ((cross(_e406, _e407) * _e410) * _e412);
    } else {
        let _e414 = b_5;
        local_59 = _e414;
    }
    let _e415 = local_59;
    b_5 = _e415;
    let _e416 = gl_FrontFacing_1;
    if !(_e416) {
        let _e418 = t_3;
        t_3 = -(_e418);
    }
    let _e420 = sampledTexel;
    sampled = ((_e420.xyz * 2f) - vec3(1f));
    let _e427 = frag_info.emissive[3u];
    if (_e427 > 0.5f) {
        let _e429 = sampled;
        let _e431 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e429.xy, _e431.xy)), 0f));
    }
    let _e440 = frag_info.material2_[1u];
    let _e441 = sampled;
    let _e443 = (_e441.xy * _e440);
    sampled[0u] = _e443.x;
    sampled[1u] = _e443.y;
    let _e448 = t_3;
    let _e450 = sampled[0u];
    let _e452 = b_5;
    let _e454 = sampled[1u];
    let _e458 = (*s_18).n;
    let _e460 = sampled[2u];
    (*s_18).n = normalize((((_e448 * _e450) + (_e452 * _e454)) + (_e458 * _e460)));
    let _e466 = (*s_18).n;
    let _e468 = (*s_18).v;
    (*s_18).n_dot_v = max(dot(_e466, _e468), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e299 = (*texel_5);
    let _e303 = irradiance_info.atlas;
    let _e306 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e299 + vec2(0.5f)) * _e303.xy), 0f);
    return _e306;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_9: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_5: vec2<f32>;
    var low: vec2<f32>;
    var f_5: vec2<f32>;
    var a_6: vec4<f32>;
    var param_234: vec2<f32>;
    var b_6: vec4<f32>;
    var param_235: vec2<f32>;
    var c_1: vec4<f32>;
    var param_236: vec2<f32>;
    var d_6: vec4<f32>;
    var param_237: vec2<f32>;

    let _e312 = (*uv_9);
    let _e313 = (*interior);
    at_5 = ((vec2(1f) + (_e312 * _e313)) - vec2(0.5f));
    let _e319 = at_5;
    low = floor(_e319);
    let _e321 = at_5;
    let _e322 = low;
    f_5 = (_e321 - _e322);
    let _e324 = (*corner);
    let _e325 = low;
    param_234 = (_e324 + _e325);
    let _e327 = AtlasTexel_u0028_vf2_u003b((&param_234));
    a_6 = _e327;
    let _e328 = (*corner);
    let _e329 = low;
    param_235 = ((_e328 + _e329) + vec2<f32>(1f, 0f));
    let _e332 = AtlasTexel_u0028_vf2_u003b((&param_235));
    b_6 = _e332;
    let _e333 = (*corner);
    let _e334 = low;
    param_236 = ((_e333 + _e334) + vec2<f32>(0f, 1f));
    let _e337 = AtlasTexel_u0028_vf2_u003b((&param_236));
    c_1 = _e337;
    let _e338 = (*corner);
    let _e339 = low;
    param_237 = ((_e338 + _e339) + vec2<f32>(1f, 1f));
    let _e342 = AtlasTexel_u0028_vf2_u003b((&param_237));
    d_6 = _e342;
    let _e343 = a_6;
    let _e344 = b_6;
    let _e346 = f_5[0u];
    let _e349 = c_1;
    let _e350 = d_6;
    let _e352 = f_5[0u];
    let _e356 = f_5[1u];
    return mix(mix(_e343, _e344, vec4(_e346)), mix(_e349, _e350, vec4(_e352)), vec4(_e356));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_6: vec3<f32>;
    var xy: vec2<f32>;

    let _e303 = (*direction_1)[0u];
    let _e306 = (*direction_1)[1u];
    let _e310 = (*direction_1)[2u];
    sum_1 = ((abs(_e303) + abs(_e306)) + abs(_e310));
    let _e313 = sum_1;
    if (_e313 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e315 = (*direction_1);
    let _e316 = sum_1;
    n_6 = (_e315 / vec3(_e316));
    let _e319 = n_6;
    xy = _e319.xy;
    let _e322 = n_6[2u];
    if (_e322 < 0f) {
        let _e325 = n_6[1u];
        let _e329 = n_6[0u];
        let _e334 = n_6[0u];
        let _e338 = n_6[1u];
        xy = vec2<f32>(((1f - abs(_e325)) * select(-1f, 1f, (_e329 >= 0f))), ((1f - abs(_e334)) * select(-1f, 1f, (_e338 >= 0f))));
    }
    let _e343 = xy;
    return ((_e343 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_2: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base_1: vec3<f32>;
    var f_6: vec3<f32>;
    var total_3: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_238: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_239: vec3<f32>;
    var param_240: vec2<f32>;
    var param_241: f32;
    var param_242: vec2<f32>;
    var chebyshev: f32;
    var variance_2: f32;
    var difference: f32;
    var param_243: vec3<f32>;
    var param_244: vec2<f32>;
    var param_245: f32;
    var param_246: vec2<f32>;
    var local_60: vec3<f32>;

    let _e345 = irradiance_info.origin;
    origin_2 = _e345.xyz;
    let _e348 = irradiance_info.spacing;
    spacing = _e348.xyz;
    let _e351 = irradiance_info.counts;
    counts = _e351.xyz;
    let _e355 = irradiance_info.tiles[0u];
    irradianceTile = _e355;
    let _e358 = irradiance_info.tiles[1u];
    depthTile = _e358;
    let _e361 = irradiance_info.tiles[2u];
    columns = _e361;
    let _e364 = irradiance_info.tiles[3u];
    momentsTop = _e364;
    let _e365 = (*normal_1);
    unit = normalize(_e365);
    let _e367 = (*world_5);
    let _e368 = unit;
    let _e371 = irradiance_info.spacing[3u];
    let _e374 = (*view_2);
    let _e377 = irradiance_info.counts[3u];
    biased = ((_e367 + (_e368 * _e371)) + (_e374 * _e377));
    let _e380 = biased;
    let _e381 = origin_2;
    let _e383 = spacing;
    grid_1 = ((_e380 - _e381) / _e383);
    let _e385 = grid_1;
    let _e387 = counts;
    base_1 = clamp(floor(_e385), vec3<f32>(0f, 0f, 0f), (_e387 - vec3(2f)));
    let _e391 = grid_1;
    let _e392 = base_1;
    f_6 = clamp((_e391 - _e392), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_3 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e395 = corner_1;
        if (_e395 < 8i) {
            let _e397 = corner_1;
            let _e400 = corner_1;
            let _e405 = corner_1;
            offset_3 = vec3<f32>(f32((_e397 & 1i)), f32(((_e400 >> bitcast<u32>(1i)) & 1i)), f32(((_e405 >> bitcast<u32>(2i)) & 1i)));
            let _e411 = base_1;
            let _e412 = offset_3;
            cell_2 = (_e411 + _e412);
            let _e415 = cell_2[2u];
            let _e417 = counts[1u];
            let _e420 = cell_2[1u];
            let _e423 = counts[0u];
            let _e426 = cell_2[0u];
            probe = ((((_e415 * _e417) + _e420) * _e423) + _e426);
            let _e428 = probe;
            let _e429 = columns;
            let _e434 = probe;
            let _e435 = columns;
            tile_4 = vec2<f32>((_e428 - (floor((_e428 / _e429)) * _e429)), floor((_e434 / _e435)));
            let _e439 = tile_4;
            let _e440 = irradianceTile;
            irradianceCorner = (_e439 * (_e440 + 2f));
            let _e444 = tile_4[0u];
            let _e445 = depthTile;
            let _e448 = momentsTop;
            let _e450 = tile_4[1u];
            let _e451 = depthTile;
            momentCorner = vec2<f32>((_e444 * (_e445 + 2f)), (_e448 + (_e450 * (_e451 + 2f))));
            let _e456 = irradianceCorner;
            param_238 = (_e456 + vec2(1f));
            let _e459 = AtlasTexel_u0028_vf2_u003b((&param_238));
            if (_e459.w < 0.5f) {
                continue;
            }
            let _e462 = f_6;
            let _e464 = f_6;
            let _e465 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e462), _e464, _e465);
            let _e468 = trilinear[0u];
            let _e470 = trilinear[1u];
            let _e473 = trilinear[2u];
            weight_3 = max(((_e468 * _e470) * _e473), 0.001f);
            let _e476 = origin_2;
            let _e477 = spacing;
            let _e478 = cell_2;
            probePosition = (_e476 + (_e477 * _e478));
            let _e481 = probePosition;
            let _e482 = biased;
            toProbe = (_e481 - _e482);
            let _e484 = toProbe;
            distance_4 = length(_e484);
            let _e486 = distance_4;
            if (_e486 > 0.000001f) {
                let _e488 = toProbe;
                let _e489 = distance_4;
                direction_2 = (_e488 / vec3(_e489));
                let _e492 = unit;
                let _e493 = probePosition;
                let _e494 = (*world_5);
                facing = ((dot(_e492, normalize((_e493 - _e494))) * 0.5f) + 0.5f);
                let _e500 = facing;
                let _e501 = facing;
                probeWeight = ((_e500 * _e501) + 0.2f);
                let _e504 = direction_2;
                param_239 = -(_e504);
                let _e506 = ProbeOctahedral_u0028_vf3_u003b((&param_239));
                let _e507 = momentCorner;
                param_240 = _e507;
                let _e508 = depthTile;
                param_241 = _e508;
                param_242 = _e506;
                let _e509 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_240), (&param_241), (&param_242));
                moments_3 = _e509.xy;
                chebyshev = 1f;
                let _e511 = distance_4;
                let _e513 = moments_3[0u];
                if (_e511 > _e513) {
                    let _e516 = moments_3[1u];
                    let _e518 = moments_3[0u];
                    let _e520 = moments_3[0u];
                    variance_2 = max((_e516 - (_e518 * _e520)), 0.000001f);
                    let _e524 = distance_4;
                    let _e526 = moments_3[0u];
                    difference = (_e524 - _e526);
                    let _e528 = variance_2;
                    let _e529 = variance_2;
                    let _e530 = difference;
                    let _e531 = difference;
                    chebyshev = (_e528 / (_e529 + (_e530 * _e531)));
                    let _e535 = chebyshev;
                    let _e536 = chebyshev;
                    let _e538 = chebyshev;
                    chebyshev = ((_e535 * _e536) * _e538);
                }
                let _e540 = probeWeight;
                let _e541 = chebyshev;
                probeWeight = max((_e540 * max(_e541, 0.05f)), 0.000001f);
                let _e545 = probeWeight;
                if (_e545 < 0.2f) {
                    let _e547 = probeWeight;
                    let _e548 = probeWeight;
                    let _e551 = probeWeight;
                    probeWeight = (_e551 * ((_e547 * _e548) * 25f));
                }
                let _e553 = probeWeight;
                let _e554 = weight_3;
                weight_3 = (_e554 * _e553);
            }
            let _e556 = unit;
            param_243 = _e556;
            let _e557 = ProbeOctahedral_u0028_vf3_u003b((&param_243));
            let _e558 = irradianceCorner;
            param_244 = _e558;
            let _e559 = irradianceTile;
            param_245 = _e559;
            param_246 = _e557;
            let _e560 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_244), (&param_245), (&param_246));
            let _e562 = weight_3;
            let _e564 = total_3;
            total_3 = (_e564 + (_e560.xyz * _e562));
            let _e566 = weight_3;
            let _e567 = weights;
            weights = (_e567 + _e566);
            continue;
        } else {
            break;
        }
        continuing {
            let _e569 = corner_1;
            corner_1 = (_e569 + 1i);
        }
    }
    let _e571 = weights;
    if (_e571 > 0f) {
        let _e573 = total_3;
        let _e574 = weights;
        local_60 = (_e573 / vec3(_e574));
    } else {
        local_60 = vec3<f32>(0f, 0f, 0f);
    }
    let _e577 = local_60;
    return _e577;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e300 = irradiance_info.origin[3u];
    return (_e300 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_19: ptr<function, Surface>) {
    var param_247: vec3<f32>;
    var param_248: vec3<f32>;
    var param_249: vec3<f32>;
    var param_250: Surface;
    var param_251: Surface;
    var param_252: Surface;

    let _e305 = IrradianceEnabled_u0028_();
    if _e305 {
        let _e306 = v_world_position_1;
        param_247 = _e306;
        let _e308 = (*s_19).n;
        param_248 = _e308;
        let _e310 = (*s_19).v;
        param_249 = _e310;
        let _e311 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_247), (&param_248), (&param_249));
        let _e314 = frag_info.material[2u];
        (*s_19).ambient = (_e311 * _e314);
    }
    let _e317 = (*s_19);
    param_250 = _e317;
    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((&param_250));
    let _e318 = param_250;
    (*s_19) = _e318;
    let _e319 = (*s_19);
    param_251 = _e319;
    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((&param_251));
    let _e320 = param_251;
    (*s_19) = _e320;
    let _e321 = (*s_19);
    param_252 = _e321;
    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((&param_252));
    let _e322 = param_252;
    (*s_19) = _e322;
    return;
}

fn ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_20: ptr<function, Surface>) {
    var coatTexel: vec4<f32>;
    var sheenTexel: vec4<f32>;
    var param_253: vec3<f32>;
    var ior_3: f32;
    var r_5: f32;
    var local_61: f32;
    var bent: vec3<f32>;
    var distance_5: f32;
    var local_62: vec3<f32>;
    var fc: f32;

    let _e309 = v_texcoord_1;
    let _e310 = MaterialLodBias_u0028_();
    let _e311 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e309, _e310);
    coatTexel = _e311;
    let _e312 = v_texcoord_1;
    let _e313 = MaterialLodBias_u0028_();
    let _e314 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e312, _e313);
    sheenTexel = _e314;
    let _e316 = layer_info.sheen;
    let _e318 = sheenTexel;
    param_253 = _e318.xyz;
    let _e320 = SrgbToLinear_u0028_vf3_u003b((&param_253));
    g_sheen = (_e316.xyz * _e320);
    let _e324 = layer_info.sheen[3u];
    let _e326 = sheenTexel[3u];
    g_sheen_roughness = clamp((_e324 * _e326), 0.07f, 1f);
    let _e331 = layer_info.coat[2u];
    ior_3 = max(_e331, 1f);
    let _e333 = IorInfinite_u0028_();
    if _e333 {
        local_61 = 1f;
    } else {
        let _e334 = ior_3;
        let _e336 = ior_3;
        local_61 = ((_e334 - 1f) / (_e336 + 1f));
    }
    let _e339 = local_61;
    r_5 = _e339;
    let _e340 = r_5;
    let _e341 = r_5;
    let _e345 = layer_info.specular;
    let _e351 = layer_info.specular[3u];
    g_f0_dielectric = (min((vec3((_e340 * _e341)) * _e345.xyz), vec3<f32>(1f, 1f, 1f)) * _e351);
    let _e355 = layer_info.specular[3u];
    g_f90_ = _e355;
    let _e358 = layer_info.coat[0u];
    let _e360 = coatTexel[0u];
    g_coat = clamp((_e358 * _e360), 0f, 1f);
    let _e365 = layer_info.coat[1u];
    let _e367 = coatTexel[1u];
    g_coat_roughness = clamp((_e365 * _e367), 0.02f, 1f);
    let _e372 = layer_info.transmission[0u];
    let _e374 = coatTexel[2u];
    g_transmission = clamp((_e372 * _e374), 0f, 1f);
    let _e379 = layer_info.transmission[1u];
    let _e381 = coatTexel[3u];
    g_thickness = max((_e379 * _e381), 0f);
    let _e386 = layer_info.attenuation[3u];
    let _e388 = g_thickness;
    if ((_e386 > 0.5f) && (_e388 > 0f)) {
        let _e392 = (*s_20).v;
        let _e395 = (*s_20).n;
        let _e396 = RefractionIor_u0028_();
        bent = refract(-(_e392), _e395, (1f / _e396));
        let _e399 = g_thickness;
        let _e401 = (*s_20).n;
        let _e402 = bent;
        let _e407 = g_thickness;
        g_thickness = max((_e399 * max(-(dot(_e401, _e402)), 0f)), (0.0001f * _e407));
    }
    let _e412 = layer_info.transmission[2u];
    distance_5 = _e412;
    let _e413 = distance_5;
    if (_e413 > 0f) {
        let _e416 = layer_info.attenuation;
        let _e419 = g_thickness;
        let _e420 = distance_5;
        local_62 = pow(max(_e416.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e419 / _e420)));
    } else {
        local_62 = vec3<f32>(1f, 1f, 1f);
    }
    let _e424 = local_62;
    g_transmittance = _e424;
    let _e427 = layer_info.iridescence[0u];
    g_iridescence = clamp(_e427, 0f, 1f);
    let _e430 = (*s_20).n;
    g_coat_n = _e430;
    let _e432 = (*s_20).n;
    let _e434 = (*s_20).v;
    g_coat_n_dot_v = max(dot(_e432, _e434), 0.0001f);
    let _e437 = g_coat_n_dot_v;
    fc = (0.04f + (0.96f * pow((1f - _e437), 5f)));
    let _e442 = g_coat;
    let _e443 = fc;
    g_coat_through = (1f - (_e442 * _e443));
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_63: vec3<f32>;

    let _e299 = Orthographic_u0028_();
    if _e299 {
        let _e301 = fog_info.forward;
        local_63 = -(_e301.xyz);
    } else {
        let _e305 = fog_info.eye;
        let _e307 = v_world_position_1;
        local_63 = normalize((_e305.xyz - _e307));
    }
    let _e310 = local_63;
    return _e310;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var param_254: i32;
    var s_21: Surface;
    var param_255: vec3<f32>;
    var param_256: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    param_254 = 0i;
    let _e305 = MapUv_u0028_i1_u003b((&param_254));
    let _e306 = MaterialLodBias_u0028_();
    let _e307 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e305, _e306);
    texel_6 = _e307;
    let _e308 = texel_6;
    param_255 = _e308.xyz;
    let _e310 = SrgbToLinear_u0028_vf3_u003b((&param_255));
    let _e312 = frag_info.base_color;
    param_256 = _e312.xyz;
    let _e314 = SrgbToLinear_u0028_vf3_u003b((&param_256));
    let _e316 = v_color_1;
    s_21.albedo = ((_e310 * _e314) * _e316.xyz);
    let _e321 = texel_6[3u];
    let _e324 = frag_info.base_color[3u];
    let _e327 = v_color_1[3u];
    s_21.alpha = ((_e321 * _e324) * _e327);
    let _e331 = s_21.albedo;
    g_albedo = _e331;
    let _e334 = frag_info.material2_[0u];
    cutoff = _e334;
    let _e335 = cutoff;
    if (_e335 > 1f) {
        let _e337 = cutoff;
        edge = (_e337 - 1f);
        let _e340 = s_21.alpha;
        let _e341 = edge;
        let _e344 = s_21.alpha;
        let _e345 = fwidth(_e344);
        s_21.alpha = clamp((((_e340 - _e341) / max(_e345, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e351 = cutoff;
        if (_e351 >= 0f) {
            s_21.alpha = 1f;
        }
    }
    let _e354 = cutoff;
    let _e356 = cutoff;
    g_premultiply = ((_e354 < 0f) && (_e356 > -0.75f));
    let _e359 = v_normal_1;
    s_21.n = normalize(_e359);
    let _e362 = gl_FrontFacing_1;
    if !(_e362) {
        let _e365 = s_21.n;
        s_21.n = -(_e365);
    }
    let _e368 = TowardsEye_u0028_();
    s_21.v = _e368;
    let _e371 = s_21.n;
    let _e373 = s_21.v;
    s_21.n_dot_v = max(dot(_e371, _e373), 0.0001f);
    let _e379 = frag_info.material[0u];
    s_21.metallic = clamp(_e379, 0f, 1f);
    let _e384 = frag_info.material[1u];
    s_21.roughness = clamp(_e384, 0.02f, 1f);
    let _e388 = frag_info.ambient_ground;
    let _e391 = frag_info.ambient_sky;
    let _e395 = s_21.n[1u];
    let _e402 = frag_info.material[2u];
    s_21.ambient = (mix(_e388.xyz, _e391.xyz, vec3(((_e395 * 0.5f) + 0.5f))) * _e402);
    let _e407 = frag_info.frame_params[0u];
    s_21.exposure = max(_e407, 0f);
    s_21.occlusion = 1f;
    s_21.emissive = vec3<f32>(0f, 0f, 0f);
    let _e412 = s_21;
    return _e412;
}

fn main_1() {
    var s_22: Surface;
    var param_257: Surface;
    var param_258: Surface;
    var param_259: Surface;
    var param_260: Surface;
    var param_261: Surface;
    var metallic: f32;
    var diffuseColor_1: vec3<f32>;
    var param_262: vec3<f32>;
    var param_263: f32;
    var param_264: f32;
    var directOcclusion: f32;
    var param_265: Surface;
    var indirectOcclusion: f32;
    var param_266: Surface;
    var ambient: vec3<f32>;
    var levels_1: f32;
    var coatAmbient: vec3<f32>;
    var sheenIncoming: vec3<f32>;
    var f0_4: vec3<f32>;
    var f90_2: f32;
    var bent_1: vec3<f32>;
    var across: vec3<f32>;
    var anisoN: vec3<f32>;
    var bend: f32;
    var bend4_: f32;
    var reflected: vec3<f32>;
    var irradiance: vec3<f32>;
    var prefiltered: vec3<f32>;
    var ab_4: vec2<f32>;
    var param_267: f32;
    var param_268: f32;
    var single_1: vec3<f32>;
    var specular_1: vec3<f32>;
    var missed: f32;
    var average_2: vec3<f32>;
    var multiple: vec3<f32>;
    var reflects: vec3<f32>;
    var through_1: vec3<f32>;
    var local_64: vec3<f32>;
    var param_269: Surface;
    var param_270: f32;
    var coatPrefiltered: vec3<f32>;
    var coatAb: vec2<f32>;
    var param_271: f32;
    var param_272: f32;
    var sceneAb: vec2<f32>;
    var param_273: f32;
    var param_274: f32;
    var sceneReflects: vec3<f32>;
    var passes: vec3<f32>;
    var param_275: Surface;
    var sheenAmbient: vec3<f32>;
    var lit_3: vec3<f32>;
    var param_276: Surface;
    var param_277: Surface;
    var param_278: vec3<f32>;
    var param_279: vec3<f32>;
    var param_280: f32;
    var param_281: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    g_f0_dielectric = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_f90_ = 1f;
    g_coat = 0f;
    g_coat_roughness = 0.02f;
    g_coat_n = vec3<f32>(0f, 0f, 1f);
    g_coat_n_dot_v = 1f;
    g_coat_through = 1f;
    g_sheen = vec3<f32>(0f, 0f, 0f);
    g_sheen_roughness = 0.07f;
    g_sheen_albedo = 0f;
    g_sheen_scale = 1f;
    g_aniso = 0f;
    g_aniso_t = vec3<f32>(1f, 0f, 0f);
    g_aniso_b = vec3<f32>(0f, 1f, 0f);
    g_transmission = 0f;
    g_thickness = 0f;
    g_transmittance = vec3<f32>(1f, 1f, 1f);
    g_iridescence = 0f;
    g_irid_fresnel = vec3<f32>(0.04f, 0.04f, 0.04f);
    g_pane = false;
    let _e358 = ReadSurface_u0028_();
    s_22 = _e358;
    let _e359 = s_22;
    param_257 = _e359;
    ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_257));
    let _e360 = s_22;
    param_258 = _e360;
    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((&param_258));
    let _e361 = param_258;
    s_22 = _e361;
    let _e362 = s_22;
    param_259 = _e362;
    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((&param_259));
    let _e363 = param_259;
    s_22 = _e363;
    let _e364 = s_22;
    param_260 = _e364;
    ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_260));
    let _e365 = s_22;
    param_261 = _e365;
    ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_261));
    let _e367 = s_22.metallic;
    metallic = clamp(_e367, 0f, 1f);
    let _e370 = s_22.albedo;
    let _e371 = metallic;
    diffuseColor_1 = (_e370 * (1f - _e371));
    let _e374 = EonDiffuse_u0028_();
    if _e374 {
        let _e375 = diffuseColor_1;
        param_262 = _e375;
        let _e377 = s_22.roughness;
        param_263 = _e377;
        let _e379 = s_22.n_dot_v;
        param_264 = _e379;
        let _e380 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_262), (&param_263), (&param_264));
        diffuseColor_1 = _e380;
    }
    let _e381 = s_22;
    param_265 = _e381;
    let _e382 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_265));
    directOcclusion = _e382;
    let _e383 = s_22;
    param_266 = _e383;
    let _e384 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_266));
    indirectOcclusion = _e384;
    let _e385 = diffuseColor_1;
    let _e387 = s_22.ambient;
    let _e389 = indirectOcclusion;
    ambient = ((_e385 * _e387) * _e389);
    let _e391 = g_premultiply;
    let _e392 = g_transmission;
    let _e395 = g_thickness;
    g_pane = ((_e391 && (_e392 > 0f)) && (_e395 <= 0f));
    let _e398 = SceneColorBound_u0028_();
    let _e399 = g_pane;
    let _e401 = g_transmittance;
    let _e404 = g_transmission;
    let _e407 = ambient;
    ambient = (_e407 * mix(vec3<f32>(1f, 1f, 1f), select(_e401, vec3<f32>(0f, 0f, 0f), vec3((_e398 || _e399))), vec3(_e404)));
    let _e411 = frag_info.frame_params[3u];
    levels_1 = _e411;
    coatAmbient = vec3<f32>(0f, 0f, 0f);
    let _e413 = s_22.ambient;
    sheenIncoming = _e413;
    let _e414 = levels_1;
    if (_e414 > 0f) {
        let _e416 = g_f0_dielectric;
        let _e418 = s_22.albedo;
        let _e419 = metallic;
        f0_4 = mix(_e416, _e418, vec3(_e419));
        let _e422 = g_f90_;
        let _e423 = metallic;
        f90_2 = mix(_e422, 1f, _e423);
        let _e426 = s_22.n;
        bent_1 = _e426;
        let _e427 = g_aniso;
        if (_e427 > 0f) {
            let _e429 = g_aniso_t;
            let _e431 = s_22.v;
            across = cross(_e429, _e431);
            let _e433 = across;
            let _e434 = g_aniso_t;
            anisoN = cross(_e433, _e434);
            let _e436 = g_aniso;
            let _e438 = s_22.roughness;
            bend = (1f - (_e436 * (1f - _e438)));
            let _e442 = bend;
            let _e443 = bend;
            let _e445 = bend;
            let _e447 = bend;
            bend4_ = (((_e442 * _e443) * _e445) * _e447);
            let _e449 = anisoN;
            let _e451 = s_22.n;
            let _e452 = bend4_;
            bent_1 = normalize(mix(_e449, _e451, vec3(_e452)));
        }
        let _e457 = s_22.v;
        let _e459 = bent_1;
        reflected = reflect(-(_e457), _e459);
        let _e462 = s_22.n;
        let _e463 = levels_1;
        let _e464 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e462, _e463);
        irradiance = _e464.xyz;
        let _e466 = reflected;
        let _e468 = s_22.roughness;
        let _e469 = levels_1;
        let _e471 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e466, (_e468 * _e469));
        prefiltered = _e471.xyz;
        let _e474 = s_22.roughness;
        param_267 = _e474;
        let _e476 = s_22.n_dot_v;
        param_268 = _e476;
        let _e477 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_267), (&param_268));
        ab_4 = _e477;
        let _e478 = f0_4;
        let _e479 = g_irid_fresnel;
        let _e480 = g_iridescence;
        let _e484 = ab_4[0u];
        let _e486 = f90_2;
        let _e488 = ab_4[1u];
        single_1 = ((mix(_e478, _e479, vec3(_e480)) * _e484) + vec3((_e486 * _e488)));
        let _e492 = prefiltered;
        let _e493 = single_1;
        specular_1 = (_e492 * _e493);
        let _e495 = EnergyCompensation_u0028_();
        if _e495 {
            let _e497 = ab_4[0u];
            let _e499 = ab_4[1u];
            missed = (1f - (_e497 + _e499));
            let _e502 = f0_4;
            let _e503 = f0_4;
            average_2 = (_e502 + ((vec3<f32>(1f, 1f, 1f) - _e503) / vec3(21f)));
            let _e508 = single_1;
            let _e509 = average_2;
            let _e511 = missed;
            let _e512 = average_2;
            multiple = ((_e508 * _e509) / (vec3<f32>(1f, 1f, 1f) - (_e512 * _e511)));
            let _e516 = multiple;
            let _e517 = missed;
            let _e519 = irradiance;
            let _e521 = specular_1;
            specular_1 = (_e521 + ((_e516 * _e517) * _e519));
        }
        let _e523 = diffuseColor_1;
        let _e524 = irradiance;
        let _e526 = specular_1;
        let _e530 = frag_info.material[2u];
        let _e532 = indirectOcclusion;
        ambient = ((((_e523 * _e524) + _e526) * _e530) * _e532);
        let _e534 = g_f0_dielectric;
        let _e535 = g_irid_fresnel;
        let _e536 = g_iridescence;
        let _e540 = ab_4[0u];
        let _e542 = g_f90_;
        let _e544 = ab_4[1u];
        reflects = ((mix(_e534, _e535, vec3(_e536)) * _e540) + vec3((_e542 * _e544)));
        let _e548 = SceneColorBound_u0028_();
        let _e549 = g_pane;
        if (_e548 || _e549) {
            local_64 = vec3<f32>(0f, 0f, 0f);
        } else {
            let _e551 = s_22;
            param_269 = _e551;
            let _e552 = levels_1;
            param_270 = _e552;
            let _e553 = TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b((&param_269), (&param_270));
            let _e554 = g_transmittance;
            let _e556 = reflects;
            local_64 = ((_e553 * _e554) * (vec3<f32>(1f, 1f, 1f) - min(_e556, vec3<f32>(1f, 1f, 1f))));
        }
        let _e560 = local_64;
        through_1 = _e560;
        let _e561 = diffuseColor_1;
        let _e562 = through_1;
        let _e563 = irradiance;
        let _e566 = g_transmission;
        let _e570 = frag_info.material[2u];
        let _e572 = indirectOcclusion;
        let _e574 = ambient;
        ambient = (_e574 + ((((_e561 * (_e562 - _e563)) * _e566) * _e570) * _e572));
        let _e577 = s_22.v;
        let _e579 = g_coat_n;
        let _e581 = g_coat_roughness;
        let _e582 = levels_1;
        let _e584 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e577), _e579), (_e581 * _e582));
        coatPrefiltered = _e584.xyz;
        let _e586 = g_coat_roughness;
        param_271 = _e586;
        let _e587 = g_coat_n_dot_v;
        param_272 = _e587;
        let _e588 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_271), (&param_272));
        coatAb = _e588;
        let _e589 = coatPrefiltered;
        let _e591 = coatAb[0u];
        let _e594 = coatAb[1u];
        let _e597 = g_coat;
        let _e601 = frag_info.material[2u];
        let _e603 = indirectOcclusion;
        coatAmbient = ((((_e589 * ((0.04f * _e591) + _e594)) * _e597) * _e601) * _e603);
        let _e606 = s_22.n;
        let _e607 = g_sheen_roughness;
        let _e608 = levels_1;
        let _e610 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e606, (_e607 * _e608));
        let _e614 = frag_info.material[2u];
        sheenIncoming = (_e610.xyz * _e614);
    }
    let _e617 = s_22.roughness;
    param_273 = _e617;
    let _e619 = s_22.n_dot_v;
    param_274 = _e619;
    let _e620 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_273), (&param_274));
    sceneAb = _e620;
    let _e621 = g_f0_dielectric;
    let _e622 = g_irid_fresnel;
    let _e623 = g_iridescence;
    let _e627 = sceneAb[0u];
    let _e629 = g_f90_;
    let _e631 = sceneAb[1u];
    sceneReflects = ((mix(_e621, _e622, vec3(_e623)) * _e627) + vec3((_e629 * _e631)));
    let _e635 = diffuseColor_1;
    let _e636 = g_transmittance;
    let _e638 = sceneReflects;
    let _e642 = g_transmission;
    passes = (((_e635 * _e636) * (vec3<f32>(1f, 1f, 1f) - min(_e638, vec3<f32>(1f, 1f, 1f)))) * _e642);
    let _e644 = g_pane;
    if _e644 {
        let _e646 = passes[0u];
        let _e648 = passes[1u];
        let _e651 = passes[2u];
        g_pass_through = clamp((((_e646 + _e648) + _e651) / 3f), 0f, 1f);
    } else {
        let _e655 = SceneColorBound_u0028_();
        if _e655 {
            let _e656 = s_22;
            param_275 = _e656;
            let _e657 = SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_275));
            let _e658 = passes;
            let _e660 = ambient;
            ambient = (_e660 + (_e657 * _e658));
        }
    }
    let _e662 = diffuseColor_1;
    let _e663 = SampleLightmap_u0028_();
    let _e665 = indirectOcclusion;
    let _e667 = ambient;
    ambient = (_e667 + ((_e662 * _e663) * _e665));
    let _e669 = g_sheen;
    let _e670 = g_sheen_albedo;
    let _e672 = sheenIncoming;
    let _e674 = indirectOcclusion;
    sheenAmbient = (((_e669 * _e670) * _e672) * _e674);
    let _e676 = s_22;
    param_276 = _e676;
    let _e677 = 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((&param_276));
    let _e678 = directOcclusion;
    let _e680 = ambient;
    let _e681 = g_sheen_scale;
    let _e683 = sheenAmbient;
    let _e686 = s_22.emissive;
    let _e688 = g_coat_through;
    let _e691 = coatAmbient;
    lit_3 = (((_e677 * _e678) + ((((_e680 * _e681) + _e683) + _e686) * _e688)) + _e691);
    let _e693 = s_22;
    param_277 = _e693;
    let _e694 = lit_3;
    param_278 = _e694;
    let _e695 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_277), (&param_278));
    if _e695 {
        return;
    }
    let _e696 = lit_3;
    param_279 = _e696;
    let _e698 = s_22.alpha;
    param_280 = _e698;
    let _e700 = s_22.roughness;
    param_281 = _e700;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_279), (&param_280), (&param_281));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>, @location(5) v_texcoord: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    v_texcoord_1 = v_texcoord;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LayerInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 464,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'specular',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'coat', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'sheen',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'anisotropy',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'transmission',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'attenuation',
              offsetInBytes: 80,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'iridescence',
              offsetInBytes: 96,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'uv_transform',
              offsetInBytes: 112,
              sizeInBytes: 160,
            ),
            WebGpuBlockMember(
              name: 'scene_color',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_viewport',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scene_levels',
              offsetInBytes: 304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scene_view_projection',
              offsetInBytes: 400,
              sizeInBytes: 64,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 4,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 5,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'coat_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 16,
          samplerBinding: 17,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 18,
          samplerBinding: 19,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'ltc_texture',
          group: 1,
          textureBinding: 20,
          samplerBinding: 21,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 22,
          samplerBinding: 23,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 24,
          samplerBinding: 25,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 26,
          samplerBinding: 27,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 28,
          samplerBinding: 29,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 30,
          samplerBinding: 31,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_color_texture',
          group: 1,
          textureBinding: 32,
          samplerBinding: 33,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 34,
          samplerBinding: 35,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'sheen_texture',
          group: 1,
          textureBinding: 36,
          samplerBinding: 37,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ToonOpaqueDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct IrradianceInfo {
    origin: vec4<f32>,
    spacing: vec4<f32>,
    counts: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(11)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(5)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(23)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(24)
var point_shadow_texture_smp: sampler;
@group(1) @binding(21)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(22)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> irradiance_info: IrradianceInfo;
@group(1) @binding(9)
var irradiance_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var irradiance_texture_smp: sampler;
@group(1) @binding(13)
var lightmap_texture_tex: texture_2d<f32>;
@group(1) @binding(14)
var lightmap_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;
@group(1) @binding(15)
var metallic_roughness_texture_tex: texture_2d<f32>;
@group(1) @binding(16)
var metallic_roughness_texture_smp: sampler;
@group(1) @binding(19)
var occlusion_texture_tex: texture_2d<f32>;
@group(1) @binding(20)
var occlusion_texture_smp: sampler;
@group(1) @binding(7)
var emissive_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var emissive_texture_smp: sampler;
@group(1) @binding(17)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(18)
var normal_texture_smp: sampler;
@group(1) @binding(25)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(26)
var shadow_texture_smp: sampler;

fn ViewDepth_u0028_() -> f32 {
    let _e211 = v_world_position_1;
    let _e213 = fog_info.eye;
    let _e217 = fog_info.forward;
    return dot((_e211 - _e213.xyz), _e217.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e216 = ViewDepth_u0028_();
    z = abs(_e216);
    let _e218 = z;
    near = (_e218 / 5f);
    let _e220 = z;
    far = (_e220 / 200f);
    let _e222 = far;
    let _e223 = far;
    let _e225 = far;
    far3_ = ((_e222 * _e223) * _e225);
    let _e227 = (*alpha);
    let _e228 = near;
    let _e229 = near;
    let _e232 = far3_;
    let _e233 = far3_;
    return (_e227 * clamp((10f / ((0.00001f + (_e228 * _e229)) + (_e232 * _e233))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e220 = fog_info.forward[3u];
    mode = _e220;
    let _e221 = mode;
    if (_e221 > 0.5f) {
        let _e224 = frag_color[3u];
        alpha_1 = _e224;
        let _e225 = alpha_1;
        param = _e225;
        let _e226 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e226;
        let _e227 = frag_color;
        let _e229 = weight;
        let _e230 = (_e227.xyz * _e229);
        let _e231 = alpha_1;
        let _e232 = weight;
        accumulate = vec4<f32>(_e230.x, _e230.y, _e230.z, (_e231 * _e232));
        let _e238 = mode;
        let _e240 = mode;
        revealage = ((_e238 > 1.5f) && (_e240 < 2.5f));
        let _e243 = revealage;
        if _e243 {
            let _e244 = alpha_1;
            local = vec4(_e244);
        } else {
            let _e246 = accumulate;
            local = _e246;
        }
        let _e247 = local;
        frag_color = _e247;
        let _e248 = mode;
        if (_e248 > 2.5f) {
            let _e250 = alpha_1;
            frag_surface = vec4(_e250);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e214 = (*n)[0u];
    let _e217 = (*n)[1u];
    let _e221 = (*n)[2u];
    let _e224 = (*n);
    (*n) = (_e224 / vec3(((abs(_e214) + abs(_e217)) + abs(_e221))));
    let _e227 = (*n);
    e = _e227.xy;
    let _e230 = (*n)[2u];
    if (_e230 < 0f) {
        let _e232 = (*n);
        let _e238 = (*n)[0u];
        let _e242 = (*n)[1u];
        e = ((vec2(1f) - abs(_e232.yx)) * vec2<f32>(select(-1f, 1f, (_e238 >= 0f)), select(-1f, 1f, (_e242 >= 0f))));
    }
    let _e247 = e;
    return ((_e247 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e212 = (*linear);
    let _e214 = (*linear);
    let _e218 = (*linear);
    return mix((_e212 * 12.92f), ((pow(_e214, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e218));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e215 = g_albedo;
    param_1 = clamp(_e215, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e217 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e217.x, _e217.y, _e217.z, 1f);
    let _e222 = g_debug_surface_on;
    if _e222 {
        let _e223 = g_debug_surface;
        let _e224 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e223.x, _e223.y, _e223.z, _e224);
        return;
    }
    let _e229 = v_normal_1;
    geometric = normalize(_e229);
    let _e231 = gl_FrontFacing_1;
    if !(_e231) {
        let _e233 = geometric;
        geometric = -(_e233);
    }
    let _e235 = geometric;
    param_2 = _e235;
    let _e236 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e237 = (*roughness);
    let _e239 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e236.x, _e236.y, clamp(_e237, 0f, 1f), _e239);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e213 = fog_info.projection[0u];
    return (_e213 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e212 = Orthographic_u0028_();
    if _e212 {
        let _e213 = ViewDepth_u0028_();
        local_1 = max(_e213, 0f);
    } else {
        let _e215 = v_world_position_1;
        let _e217 = fog_info.eye;
        local_1 = distance(_e215, _e217.xyz);
    }
    let _e220 = local_1;
    return _e220;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e219 = fog_info.fog[3u];
    density = _e219;
    let _e220 = density;
    if (_e220 <= 0f) {
        let _e222 = (*color);
        return _e222;
    }
    let _e223 = EyeDistance_u0028_();
    d = _e223;
    let _e226 = fog_info.eye[3u];
    falloff = _e226;
    let _e227 = falloff;
    if (_e227 > 0f) {
        let _e229 = falloff;
        let _e231 = v_world_position_1[1u];
        let _e234 = fog_info.eye[1u];
        k = (_e229 * (_e231 - _e234));
        let _e237 = k;
        if (abs(_e237) > 0.001f) {
            let _e240 = k;
            let _e244 = k;
            local_2 = ((1f - exp(-(_e240))) / _e244);
        } else {
            let _e246 = k;
            local_2 = (1f - (0.5f * _e246));
        }
        let _e249 = local_2;
        let _e250 = density;
        density = (_e250 * _e249);
    }
    let _e253 = fog_info.fog;
    let _e255 = (*color);
    let _e256 = density;
    let _e258 = d;
    return mix(_e253.xyz, _e255, vec3(clamp(exp((-(_e256) * _e258)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e217 = g_premultiply;
    let _e218 = (*alpha_2);
    weight_1 = select(1f, _e218, _e217);
    let _e220 = (*linearColor);
    param_3 = _e220;
    let _e221 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e222 = weight_1;
    let _e223 = (_e221 * _e222);
    let _e224 = (*alpha_2);
    let _e225 = g_pass_through;
    frag_color = vec4<f32>(_e223.x, _e223.y, _e223.z, (_e224 * (1f - _e225)));
    let _e232 = (*roughness_1);
    param_4 = _e232;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e212 = (*srgb);
    let _e215 = (*srgb);
    let _e220 = (*srgb);
    return mix((_e212 / vec3(12.92f)), pow(((_e215 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e220));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e214 = (*key);
    hue = fract(((_e214 * 0.618034f) + 0.13f));
    let _e218 = hue;
    k_1 = clamp((abs(((fract((vec3(_e218) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e231 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e231, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2568_: bool;

    let _e212 = (*c);
    let _e213 = (*c);
    let _e215 = any((_e212 != _e213));
    phi_2568_ = _e215;
    if !(_e215) {
        let _e217 = (*c);
        phi_2568_ = any((abs(_e217) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e222 = phi_2568_;
    return _e222;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2658_: bool;
    var phi_2926_: bool;

    let _e254 = gl_FragCoord_1[0u];
    let _e257 = frag_info.debug_view[1u];
    if (_e254 < _e257) {
        let _e261 = frag_info.debug_view[2u];
        local_3 = _e261;
    } else {
        let _e264 = frag_info.debug_view[0u];
        local_3 = _e264;
    }
    let _e265 = local_3;
    view = _e265;
    let _e266 = view;
    if (_e266 < 0.5f) {
        return false;
    }
    let _e268 = view;
    code = i32((_e268 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e271 = v_normal_1;
    geometric_n = normalize(_e271);
    let _e273 = v_tangent_1;
    let _e275 = geometric_n;
    let _e276 = geometric_n;
    let _e277 = v_tangent_1;
    tangent = (_e273.xyz - (_e275 * dot(_e276, _e277.xyz)));
    let _e282 = tangent;
    let _e283 = tangent;
    let _e285 = (dot(_e282, _e283) > 0.000000000001f);
    phi_2658_ = _e285;
    if _e285 {
        let _e287 = v_tangent_1[3u];
        phi_2658_ = (abs((abs(_e287) - 1f)) < 0.01f);
    }
    let _e293 = phi_2658_;
    tangent_usable = _e293;
    let _e296 = frag_info.debug_view[3u];
    identity = _e296;
    let _e297 = identity;
    identity_object = floor((_e297 / 8192f));
    let _e300 = identity;
    let _e301 = identity_object;
    identity_rest = (_e300 - (_e301 * 8192f));
    let _e304 = identity_rest;
    identity_material = floor((_e304 / 2f));
    let _e307 = identity_rest;
    let _e308 = identity_material;
    normal_mapped = ((_e307 - (_e308 * 2f)) > 0.5f);
    let _e312 = code;
    if (_e312 == 1i) {
        let _e315 = (*s).albedo;
        param_5 = clamp(_e315, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e317 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e317;
    } else {
        let _e318 = code;
        if (_e318 == 2i) {
            let _e321 = (*s).n;
            shown = ((_e321 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e324 = code;
            if (_e324 == 3i) {
                let _e327 = (*s).roughness;
                shown = vec3(clamp(_e327, 0f, 1f));
            } else {
                let _e330 = code;
                if (_e330 == 4i) {
                    let _e333 = (*s).metallic;
                    shown = vec3(clamp(_e333, 0f, 1f));
                } else {
                    let _e336 = code;
                    if (_e336 == 5i) {
                        let _e339 = (*s).occlusion;
                        shown = vec3(clamp(_e339, 0f, 1f));
                    } else {
                        let _e342 = code;
                        if (_e342 == 6i) {
                            let _e345 = (*s).emissive;
                            param_6 = clamp(_e345, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e347 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e347;
                        } else {
                            let _e348 = code;
                            if (_e348 == 7i) {
                                let _e350 = v_texcoord_1;
                                let _e351 = fract(_e350);
                                shown = vec3<f32>(_e351.x, _e351.y, 0f);
                            } else {
                                let _e355 = code;
                                if (_e355 == 8i) {
                                    let _e357 = (*lit);
                                    param_7 = clamp(_e357, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e359 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e359, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e361 = (*lit);
                                    param_8 = _e361;
                                    let _e362 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e362 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e363 = grey;
                                        local_4 = vec3((_e363 * 0.5f));
                                    }
                                    let _e366 = local_4;
                                    shown = _e366;
                                } else {
                                    let _e367 = code;
                                    if (_e367 == 9i) {
                                        let _e369 = tangent_usable;
                                        if _e369 {
                                            let _e370 = tangent;
                                            local_5 = ((normalize(_e370) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e374 = local_5;
                                        shown = _e374;
                                    } else {
                                        let _e375 = code;
                                        if (_e375 == 10i) {
                                            let _e377 = v_texcoord_1;
                                            uv = _e377;
                                            let _e378 = uv;
                                            cell = floor((_e378 * 8f));
                                            let _e382 = cell[0u];
                                            let _e384 = cell[1u];
                                            odd = (fract(((_e382 + _e384) * 0.5f)) * 2f);
                                            let _e389 = uv;
                                            within = fract(_e389);
                                            let _e391 = odd;
                                            let _e395 = within[0u];
                                            let _e399 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e391)) * vec3<f32>((0.55f + (0.45f * _e395)), (0.55f + (0.45f * _e399)), 0.85f));
                                        } else {
                                            let _e404 = code;
                                            if (_e404 == 11i) {
                                                let _e406 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e406));
                                            } else {
                                                let _e409 = code;
                                                if (_e409 == 12i) {
                                                    let _e411 = v_color_1;
                                                    param_9 = clamp(_e411.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e414 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e414;
                                                } else {
                                                    let _e415 = code;
                                                    let _e417 = code;
                                                    if ((_e415 == 13i) || (_e417 == 14i)) {
                                                        let _e420 = code;
                                                        let _e422 = identity_object;
                                                        let _e423 = identity_material;
                                                        key_1 = select(_e423, _e422, (_e420 == 13i));
                                                        let _e425 = key_1;
                                                        param_10 = _e425;
                                                        let _e426 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e428 = (*s).n_dot_v;
                                                        shown = (_e426 * (0.55f + (0.45f * _e428)));
                                                    } else {
                                                        let _e432 = code;
                                                        if (_e432 == 15i) {
                                                            let _e435 = (*s).albedo;
                                                            param_11 = clamp(_e435, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e437 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e437;
                                                            let _e438 = srgb_1;
                                                            luma = dot(_e438, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e441 = (*s).metallic;
                                                            metal = (_e441 > 0.5f);
                                                            let _e443 = metal;
                                                            let _e445 = luma;
                                                            if (!(_e443) && (_e445 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e448 = metal;
                                                                let _e449 = !(_e448);
                                                                phi_2926_ = _e449;
                                                                if _e449 {
                                                                    let _e451 = srgb_1[0u];
                                                                    let _e453 = srgb_1[1u];
                                                                    let _e455 = srgb_1[2u];
                                                                    phi_2926_ = (max(_e451, max(_e453, _e455)) > 0.9411765f);
                                                                }
                                                                let _e460 = phi_2926_;
                                                                if _e460 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e461 = metal;
                                                                    let _e462 = luma;
                                                                    if (_e461 && (_e462 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e465 = luma;
                                                                        local_8 = vec3(_e465);
                                                                    }
                                                                    let _e467 = local_8;
                                                                    local_7 = _e467;
                                                                }
                                                                let _e468 = local_7;
                                                                local_6 = _e468;
                                                            }
                                                            let _e469 = local_6;
                                                            shown = _e469;
                                                        } else {
                                                            let _e470 = code;
                                                            if (_e470 == 16i) {
                                                                let _e473 = (*s).metallic;
                                                                m = _e473;
                                                                let _e474 = m;
                                                                let _e476 = m;
                                                                if ((_e474 > 0.05f) && (_e476 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e479 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e479 > 0.5f)));
                                                                }
                                                                let _e483 = local_9;
                                                                shown = _e483;
                                                            } else {
                                                                let _e484 = code;
                                                                if (_e484 == 17i) {
                                                                    let _e486 = normal_mapped;
                                                                    if !(_e486) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e488 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e488));
                                                                    }
                                                                    let _e491 = local_10;
                                                                    shown = _e491;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e492 = g_premultiply;
    if _e492 {
        let _e494 = (*s).alpha;
        local_11 = _e494;
    } else {
        local_11 = 1f;
    }
    let _e495 = local_11;
    weight_2 = _e495;
    let _e496 = shown;
    param_12 = _e496;
    let _e497 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e498 = weight_2;
    let _e499 = (_e497 * _e498);
    let _e501 = (*s).alpha;
    frag_color = vec4<f32>(_e499.x, _e499.y, _e499.z, _e501);
    let _e507 = (*s).roughness;
    param_13 = _e507;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn OcclusionTarget_u0028_() -> f32 {
    var local_12: f32;

    let _e214 = frag_info.material2_[2u];
    local_12 = floor((_e214 * 0.5f));
    let _e217 = local_12;
    return _e217;
}

fn DirectOcclusion_u0028_struct_u002d_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_1: ptr<function, Surface>) -> f32 {
    var local_13: f32;
    var local_14: f32;

    let _e214 = OcclusionTarget_u0028_();
    if (_e214 > 1.5f) {
        local_13 = 1f;
    } else {
        let _e217 = (*s_1).occlusion;
        local_13 = _e217;
    }
    let _e218 = local_13;
    local_14 = _e218;
    let _e219 = local_14;
    return _e219;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_2: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    var bands: f32;
    var quantized: f32;
    var fraction: f32;
    var ramp: f32;

    let _e218 = (*s_2).roughness;
    bands = mix(5f, 2f, _e218);
    let _e221 = (*light).n_dot_l;
    let _e222 = bands;
    let _e225 = bands;
    quantized = (floor((_e221 * _e222)) / _e225);
    let _e228 = (*light).n_dot_l;
    let _e229 = bands;
    fraction = fract((_e228 * _e229));
    let _e232 = fraction;
    let _e234 = bands;
    let _e236 = quantized;
    quantized = (_e236 + (smoothstep(0.85f, 1f, _e232) / _e234));
    let _e238 = quantized;
    let _e240 = (*light).n_dot_l;
    ramp = (_e238 / max(_e240, 0.001f));
    let _e244 = (*s_2).albedo;
    let _e245 = ramp;
    return (_e244 * _e245);
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e212 = (*i);
    if (_e212 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e214 = (*i);
    if (_e214 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e216 = (*i);
    if (_e216 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e218 = (*i);
    if (_e218 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e220 = (*i);
    if (_e220 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e222 = (*i);
    if (_e222 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e224 = (*i);
    if (_e224 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e217 = (*i_1);
    param_14 = _e217;
    let _e218 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e218;
    let _e220 = p[0u];
    let _e221 = (*ca);
    let _e224 = p[1u];
    let _e225 = (*sa);
    let _e229 = p[0u];
    let _e230 = (*sa);
    let _e233 = p[1u];
    let _e234 = (*ca);
    let _e238 = (*radius);
    return (vec2<f32>(((_e220 * _e221) - (_e224 * _e225)), ((_e229 * _e230) + (_e233 * _e234))) * _e238);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_15: vec2<f32>;
    var atlas: vec2<f32>;

    let _e220 = point_shadow.params[0u];
    inset = _e220;
    let _e221 = (*uv_1);
    let _e222 = (*offset);
    let _e224 = inset;
    let _e225 = inset;
    local_15 = clamp((_e221 + _e222), vec2(_e224), vec2((1f - _e225)));
    let _e230 = local_15;
    let _e231 = (*tile);
    atlas = ((_e230 + _e231) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e236 = point_shadow.params3_[0u];
    if (_e236 > 0.5f) {
        let _e239 = atlas[1u];
        atlas[1u] = (1f - _e239);
    }
    let _e242 = atlas;
    let _e243 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e242, 0f);
    let _e245 = atlas;
    let _e246 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e245, 0f);
    let _e249 = (*range);
    return (min(_e243.x, _e246.x) * _e249);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e221 = (*uv_2);
    param_15 = _e221;
    let _e222 = (*offset_1);
    param_16 = _e222;
    let _e223 = (*tile_1);
    param_17 = _e223;
    let _e224 = (*range_1);
    param_18 = _e224;
    let _e225 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e225;
    let _e226 = stored;
    let _e227 = (*range_1);
    if (_e226 >= (_e227 * 0.999f)) {
        return 1f;
    }
    let _e230 = (*receiver);
    let _e231 = stored;
    return select(1f, 0f, (_e230 > _e231));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e242 = point_shadow.params2_[1u];
    lightRadius = _e242;
    let _e245 = point_shadow.params2_[0u];
    minRadius = _e245;
    let _e248 = point_shadow.params2_[2u];
    maxRadius = _e248;
    let _e249 = lightRadius;
    if (_e249 <= 0f) {
        let _e251 = (*uv_3);
        param_19 = _e251;
        param_20 = vec2<f32>(0f, 0f);
        let _e252 = (*tile_2);
        param_21 = _e252;
        let _e253 = (*range_2);
        param_22 = _e253;
        let _e254 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e254;
        let _e255 = minRadius;
        return _e255;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e256 = i_2;
        if (_e256 < 8i) {
            let _e258 = i_2;
            param_23 = _e258;
            let _e259 = (*ca_1);
            param_24 = _e259;
            let _e260 = (*sa_1);
            param_25 = _e260;
            let _e261 = maxRadius;
            param_26 = _e261;
            let _e262 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e263 = (*uv_3);
            param_27 = _e263;
            param_28 = _e262;
            let _e264 = (*tile_2);
            param_29 = _e264;
            let _e265 = (*range_2);
            param_30 = _e265;
            let _e266 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e266;
            let _e267 = stored_1;
            let _e268 = (*range_2);
            if (_e267 >= (_e268 * 0.999f)) {
                continue;
            }
            let _e271 = stored_1;
            let _e272 = (*receiver_1);
            if (_e271 >= _e272) {
                continue;
            }
            let _e274 = stored_1;
            let _e275 = sum;
            sum = (_e275 + _e274);
            let _e277 = count;
            count = (_e277 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e279 = i_2;
            i_2 = (_e279 + 1i);
        }
    }
    let _e281 = count;
    if (_e281 < 0.5f) {
        return -1f;
    }
    let _e283 = sum;
    let _e284 = count;
    blocker = max((_e283 / _e284), 0.0001f);
    let _e287 = blocker;
    (*blockerOut) = _e287;
    let _e288 = lightRadius;
    let _e289 = (*receiver_1);
    let _e290 = blocker;
    let _e294 = blocker;
    world = ((_e288 * max((_e289 - _e290), 0f)) / _e294);
    let _e296 = world;
    let _e297 = (*receiver_1);
    let _e299 = (*tanHalf);
    let _e302 = minRadius;
    let _e303 = maxRadius;
    return clamp((_e296 / ((2f * _e297) * _e299)), _e302, _e303);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_16: vec2<f32>;

    let _e213 = (*rows);
    if (_e213 > 0f) {
        let _e216 = gl_FragCoord_1[0u];
        let _e217 = (*rows);
        let _e219 = gl_FragCoord_1[1u];
        local_16 = vec2<f32>(_e216, (_e217 - _e219));
    } else {
        let _e222 = gl_FragCoord_1;
        local_16 = _e222.xy;
    }
    let _e224 = local_16;
    return _e224;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_17: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2255_: bool;
    var phi_2316_: bool;

    let _e265 = (*lightIndex);
    let _e269 = point_shadow.slots[_e265][0u];
    slot = i32((_e269 + 0.5f));
    let _e272 = (*lightIndex);
    let _e276 = point_shadow.slots[_e272][0u];
    if (_e276 < 0f) {
        return 1f;
    }
    let _e280 = point_shadow.params[2u];
    strength = _e280;
    let _e281 = strength;
    if (_e281 <= 0f) {
        return 1f;
    }
    let _e283 = slot;
    let _e286 = point_shadow.lights[_e283];
    let _e288 = (*world_1);
    toLight = (_e286.xyz - _e288);
    let _e290 = toLight;
    toLightLength = max(length(_e290), 0.000001f);
    let _e293 = (*normal);
    let _e294 = toLight;
    let _e295 = toLightLength;
    nDotL = max(dot(_e293, (_e294 / vec3(_e295))), 0.15f);
    let _e300 = nDotL;
    let _e301 = nDotL;
    let _e306 = nDotL;
    let _e307 = nDotL;
    slope = min((sqrt(max((1f - (_e300 * _e301)), 0f)) / (_e306 * _e307)), 8f);
    let _e311 = toLightLength;
    let _e313 = (*lightIndex);
    let _e317 = point_shadow.slots[_e313][2u];
    let _e322 = point_shadow.params3_[1u];
    texel = (((2f * _e311) * max(_e317, 0.0001f)) * _e322);
    let _e324 = (*world_1);
    let _e325 = (*normal);
    let _e326 = texel;
    let _e330 = point_shadow.params[3u];
    let _e332 = slope;
    origin = (_e324 + (((_e325 * _e326) * _e330) * (1f + _e332)));
    let _e336 = origin;
    let _e337 = slot;
    let _e340 = point_shadow.lights[_e337];
    toFragment = (_e336 - _e340.xyz);
    let _e343 = toFragment;
    distance_ = length(_e343);
    let _e345 = slot;
    let _e349 = point_shadow.lights[_e345][3u];
    range_3 = max(_e349, 0.0001f);
    let _e351 = distance_;
    let _e352 = range_3;
    if (_e351 >= _e352) {
        return 1f;
    }
    face = 0i;
    let _e354 = (*lightIndex);
    let _e358 = point_shadow.slots[_e354][1u];
    if (_e358 < 0.5f) {
        let _e360 = toFragment;
        a = abs(_e360);
        let _e363 = a[0u];
        let _e365 = a[1u];
        let _e366 = (_e363 >= _e365);
        phi_2255_ = _e366;
        if _e366 {
            let _e368 = a[0u];
            let _e370 = a[2u];
            phi_2255_ = (_e368 >= _e370);
        }
        let _e373 = phi_2255_;
        if _e373 {
            let _e375 = toFragment[0u];
            face = select(1i, 0i, (_e375 > 0f));
        } else {
            let _e379 = a[1u];
            let _e381 = a[2u];
            if (_e379 >= _e381) {
                let _e384 = toFragment[1u];
                face = select(3i, 2i, (_e384 > 0f));
            } else {
                let _e388 = toFragment[2u];
                face = select(5i, 4i, (_e388 > 0f));
            }
        }
    }
    let _e391 = slot;
    let _e393 = face;
    let _e397 = point_shadow.faces[((_e391 * 6i) + _e393)];
    let _e398 = origin;
    clip = (_e397 * vec4<f32>(_e398.x, _e398.y, _e398.z, 1f));
    let _e405 = clip[3u];
    if (_e405 <= 0f) {
        return 1f;
    }
    let _e407 = clip;
    let _e410 = clip[3u];
    ndc = (_e407.xy / vec2(_e410));
    let _e414 = ndc[0u];
    let _e416 = (abs(_e414) > 1f);
    phi_2316_ = _e416;
    if !(_e416) {
        let _e419 = ndc[1u];
        phi_2316_ = (abs(_e419) > 1f);
    }
    let _e423 = phi_2316_;
    if _e423 {
        return 1f;
    }
    let _e425 = ndc[0u];
    let _e429 = ndc[1u];
    uv_4 = vec2<f32>(((_e425 * 0.5f) + 0.5f), (0.5f - (_e429 * 0.5f)));
    let _e433 = face;
    let _e435 = slot;
    tile_3 = vec2<f32>(f32(_e433), f32(_e435));
    let _e438 = distance_;
    let _e441 = point_shadow.params[1u];
    receiver_2 = (_e438 - _e441);
    let _e445 = frag_info.target_origin[0u];
    param_31 = _e445;
    let _e446 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e446, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e451 = noise;
    angle = (_e451 * 6.2831855f);
    let _e453 = angle;
    ca_2 = cos(_e453);
    let _e455 = angle;
    sa_2 = sin(_e455);
    let _e457 = (*lightIndex);
    let _e461 = point_shadow.slots[_e457][2u];
    tanHalf_1 = max(_e461, 0.0001f);
    blocker_1 = -1f;
    let _e463 = uv_4;
    param_32 = _e463;
    let _e464 = tile_3;
    param_33 = _e464;
    let _e465 = range_3;
    param_34 = _e465;
    let _e466 = receiver_2;
    param_35 = _e466;
    let _e467 = ca_2;
    param_36 = _e467;
    let _e468 = sa_2;
    param_37 = _e468;
    let _e469 = tanHalf_1;
    param_38 = _e469;
    let _e470 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e471 = param_39;
    blocker_1 = _e471;
    radius_1 = _e470;
    let _e474 = point_shadow.params2_[3u];
    if (_e474 > 0.5f) {
        g_debug_surface_on = true;
        let _e476 = radius_1;
        if (_e476 < 0f) {
            local_17 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e478 = radius_1;
            let _e481 = point_shadow.params2_[2u];
            let _e485 = blocker_1;
            let _e486 = range_3;
            local_17 = vec3<f32>(clamp((_e478 / max(_e481, 0.000001f)), 0f, 1f), clamp((_e485 / _e486), 0f, 1f), 0f);
        }
        let _e490 = local_17;
        g_debug_surface = _e490;
    }
    let _e491 = radius_1;
    if (_e491 < 0f) {
        return 1f;
    }
    let _e493 = uv_4;
    param_40 = _e493;
    param_41 = vec2<f32>(0f, 0f);
    let _e494 = tile_3;
    param_42 = _e494;
    let _e495 = range_3;
    param_43 = _e495;
    let _e496 = receiver_2;
    param_44 = _e496;
    let _e497 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e497;
    let _e498 = radius_1;
    if (_e498 > 0f) {
        i_3 = 0i;
        loop {
            let _e500 = i_3;
            if (_e500 < 8i) {
                let _e502 = i_3;
                param_45 = _e502;
                let _e503 = ca_2;
                param_46 = _e503;
                let _e504 = sa_2;
                param_47 = _e504;
                let _e505 = radius_1;
                param_48 = _e505;
                let _e506 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e507 = uv_4;
                param_49 = _e507;
                param_50 = _e506;
                let _e508 = tile_3;
                param_51 = _e508;
                let _e509 = range_3;
                param_52 = _e509;
                let _e510 = receiver_2;
                param_53 = _e510;
                let _e511 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e512 = lit_1;
                lit_1 = (_e512 + _e511);
                continue;
            } else {
                break;
            }
            continuing {
                let _e514 = i_3;
                i_3 = (_e514 + 1i);
            }
        }
        let _e516 = lit_1;
        lit_1 = (_e516 * 0.11111111f);
    }
    let _e518 = lit_1;
    let _e519 = strength;
    return mix(1f, _e518, clamp(_e519, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e216 = (*i_4);
    let _e219 = (*n_1);
    r = sqrt(((f32(_e216) + 0.5f) / f32(_e219)));
    let _e223 = (*i_4);
    let _e226 = (*turn);
    theta = ((f32(_e223) * 2.3999631f) + _e226);
    let _e228 = r;
    let _e229 = theta;
    let _e231 = theta;
    return (vec2<f32>(cos(_e229), sin(_e231)) * _e228);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e215 = frag_info.target_origin[0u];
    param_54 = _e215;
    let _e216 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e219 = frag_info.target_origin[3u];
    at = (_e216 + vec2((5.588238f * max(_e219, 0f))));
    let _e224 = at;
    return fract((52.982918f * fract(dot(_e224, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_18: f32;

    let _e214 = (*mode_1);
    if (_e214 > 0.5f) {
        let _e216 = (*stored_2);
        local_18 = (1f - _e216);
    } else {
        let _e218 = (*stored_2);
        local_18 = _e218;
    }
    let _e219 = local_18;
    return _e219;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e220 = (*moments)[1u];
    let _e222 = (*moments)[0u];
    let _e224 = (*moments)[0u];
    let _e227 = (*minVariance);
    variance = max((_e220 - (_e222 * _e224)), _e227);
    let _e229 = (*t);
    let _e231 = (*moments)[0u];
    d_1 = (_e229 - _e231);
    let _e233 = variance;
    let _e234 = variance;
    let _e235 = d_1;
    let _e236 = d_1;
    pMax = (_e233 / (_e234 + (_e235 * _e236)));
    let _e240 = pMax;
    let _e241 = (*bleed);
    let _e243 = (*bleed);
    reduced = clamp(((_e240 - _e241) / max((1f - _e243), 0.0001f)), 0f, 1f);
    let _e248 = (*t);
    let _e250 = (*moments)[0u];
    let _e252 = reduced;
    return select(_e252, 1f, (_e248 <= _e250));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e213 = (*depth);
    d_2 = ((2f * clamp(_e213, 0f, 1f)) - 1f);
    let _e217 = d_2;
    let _e220 = d_2;
    return vec2<f32>(exp((40f * _e217)), -(exp((-5f * _e220))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e227 = (*depth_1);
    param_55 = _e227;
    let _e228 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e228;
    let _e229 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e229);
    let _e232 = scale[0u];
    let _e234 = scale[0u];
    let _e236 = (*moments_1);
    param_56 = _e236.xy;
    let _e239 = warped[0u];
    param_57 = _e239;
    param_58 = (_e232 * _e234);
    let _e240 = (*bleed_1);
    param_59 = _e240;
    let _e241 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e241;
    let _e243 = scale[1u];
    let _e245 = scale[1u];
    let _e247 = (*moments_1);
    param_60 = _e247.zw;
    let _e250 = warped[1u];
    param_61 = _e250;
    param_62 = (_e243 * _e245);
    let _e251 = (*bleed_1);
    param_63 = _e251;
    let _e252 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e252;
    let _e253 = positive;
    let _e254 = negative;
    return min(_e253, _e254);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e213 = (*depth_2);
    stored_3 = max((1f - _e213), 0.000061035156f);
    let _e216 = stored_3;
    return exp2((floor(log2(_e216)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_19: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_20: mat4x4<f32>;
    var local_21: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_22: f32;
    var local_23: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3909_: bool;
    var phi_3920_: bool;
    var phi_4077_: bool;
    var phi_4084_: bool;
    var phi_4091_: bool;

    let _e292 = frag_info.shadow_params[3u];
    strength_1 = _e292;
    let _e293 = strength_1;
    if (_e293 <= 0f) {
        return 1f;
    }
    let _e295 = (*lightIndex_1);
    let _e298 = frag_info.frame_params[2u];
    if (_e295 != i32(floor((_e298 + 0.5f)))) {
        return 1f;
    }
    let _e305 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e305 + 0.5f));
    let _e308 = Orthographic_u0028_();
    if _e308 {
        let _e309 = ViewDepth_u0028_();
        local_19 = _e309;
    } else {
        let _e310 = v_world_position_1;
        let _e312 = frag_info.camera_position;
        local_19 = length((_e310 - _e312.xyz));
    }
    let _e316 = local_19;
    viewDistance = _e316;
    cascade = 0i;
    let _e317 = cascadeCount;
    let _e318 = (_e317 > 1i);
    phi_3909_ = _e318;
    if _e318 {
        let _e319 = viewDistance;
        let _e322 = frag_info.shadow_cascades[0u];
        phi_3909_ = (_e319 > _e322);
    }
    let _e325 = phi_3909_;
    if _e325 {
        cascade = 1i;
    }
    let _e326 = cascadeCount;
    let _e327 = (_e326 > 2i);
    phi_3920_ = _e327;
    if _e327 {
        let _e328 = viewDistance;
        let _e331 = frag_info.shadow_cascades[1u];
        phi_3920_ = (_e328 > _e331);
    }
    let _e334 = phi_3920_;
    if _e334 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e335 = attempt;
        if (_e335 < 3i) {
            let _e337 = cascade;
            let _e338 = attempt;
            which = (_e337 + _e338);
            let _e340 = which;
            let _e341 = cascadeCount;
            if (_e340 >= _e341) {
                break;
            }
            let _e343 = which;
            if (_e343 == 0i) {
                let _e346 = frag_info.shadow_matrix;
                local_20 = _e346;
            } else {
                let _e347 = which;
                if (_e347 == 1i) {
                    let _e350 = frag_info.shadow_matrix_far;
                    local_21 = _e350;
                } else {
                    let _e352 = frag_info.shadow_matrix_farthest;
                    local_21 = _e352;
                }
                let _e353 = local_21;
                local_20 = _e353;
            }
            let _e354 = local_20;
            matrix = _e354;
            let _e357 = matrix[0][0u];
            let _e360 = matrix[1][0u];
            let _e363 = matrix[2][0u];
            axisX = vec3<f32>(_e357, _e360, _e363);
            let _e367 = matrix[0][1u];
            let _e370 = matrix[1][1u];
            let _e373 = matrix[2][1u];
            axisY = vec3<f32>(_e367, _e370, _e373);
            let _e375 = axisX;
            rowX = max(length(_e375), 0.000001f);
            let _e378 = axisY;
            rowY = max(length(_e378), 0.000001f);
            let _e383 = frag_info.shadow_cascades[3u];
            let _e385 = rowX;
            texelMetres = ((2f * _e383) / _e385);
            let _e389 = frag_info.shadow_cascades[3u];
            let _e392 = (*s_3).n;
            let _e393 = axisX;
            let _e396 = rowX;
            let _e397 = rowX;
            let _e401 = (*s_3).n;
            let _e402 = axisY;
            let _e405 = rowY;
            let _e406 = rowY;
            reach = ((3f * _e389) * ((abs(dot(_e392, _e393)) / (_e396 * _e397)) + (abs(dot(_e401, _e402)) / (_e405 * _e406))));
            let _e413 = frag_info.shadow_params[2u];
            let _e414 = texelMetres;
            flatOffset = min(_e413, _e414);
            let _e416 = v_world_position_1;
            let _e418 = (*s_3).n;
            let _e419 = flatOffset;
            let _e420 = reach;
            origin_1 = (_e416 + (_e418 * (_e419 + _e420)));
            let _e424 = matrix;
            let _e425 = origin_1;
            lightSpace = (_e424 * vec4<f32>(_e425.x, _e425.y, _e425.z, 1f));
            let _e432 = lightSpace[3u];
            if (_e432 <= 0f) {
                continue;
            }
            let _e434 = lightSpace;
            let _e437 = lightSpace[3u];
            candidate = (_e434.xyz / vec3(_e437));
            let _e441 = candidate[0u];
            let _e445 = candidate[1u];
            inTile = vec2<f32>(((_e441 * 0.5f) + 0.5f), (0.5f - (_e445 * 0.5f)));
            let _e450 = inTile[0u];
            let _e451 = (_e450 < 0f);
            phi_4077_ = _e451;
            if !(_e451) {
                let _e454 = inTile[0u];
                phi_4077_ = (_e454 > 1f);
            }
            let _e457 = phi_4077_;
            phi_4084_ = _e457;
            if !(_e457) {
                let _e460 = inTile[1u];
                phi_4084_ = (_e460 < 0f);
            }
            let _e463 = phi_4084_;
            phi_4091_ = _e463;
            if !(_e463) {
                let _e466 = inTile[1u];
                phi_4091_ = (_e466 > 1f);
            }
            let _e469 = phi_4091_;
            if _e469 {
                continue;
            }
            let _e471 = candidate[2u];
            if (_e471 > 1f) {
                let _e473 = which;
                let _e474 = cascadeCount;
                if (_e473 < (_e474 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e479 = inTile[0u];
            let _e480 = which;
            let _e483 = cascadeCount;
            let _e487 = inTile[1u];
            uv_5 = vec2<f32>(((_e479 + f32(_e480)) / f32(_e483)), _e487);
            let _e489 = candidate;
            projected = _e489;
            let _e490 = which;
            cascade = _e490;
            let _e491 = texelMetres;
            cascadeTexel = _e491;
            let _e494 = matrix[0][2u];
            let _e497 = matrix[1][2u];
            let _e500 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e494, _e497, _e500)), 0.000001f));
            let _e506 = (*s_3).n;
            let _e509 = matrix[0][2u];
            let _e512 = matrix[1][2u];
            let _e515 = matrix[2][2u];
            let _e519 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e506, vec3<f32>(_e509, _e512, _e515))) * _e519), 0.1f, 1f);
            let _e522 = texelMetres;
            let _e523 = cosSlope;
            let _e524 = cosSlope;
            let _e530 = cosSlope;
            let _e532 = cascadeDepth;
            receiverSlope = (((_e522 * sqrt(max((1f - (_e523 * _e524)), 0f))) / _e530) / _e532);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e534 = attempt;
            attempt = (_e534 + 1i);
        }
    }
    let _e536 = found;
    if !(_e536) {
        return 1f;
    }
    let _e538 = cascade;
    if (_e538 == 0i) {
        let _e542 = frag_info.shadow_bias[0u];
        local_22 = _e542;
    } else {
        let _e543 = cascade;
        if (_e543 == 1i) {
            let _e547 = frag_info.shadow_bias[1u];
            local_23 = _e547;
        } else {
            let _e550 = frag_info.shadow_bias[2u];
            local_23 = _e550;
        }
        let _e551 = local_23;
        local_22 = _e551;
    }
    let _e552 = local_22;
    bias = _e552;
    let _e555 = frag_info.shadow_params[1u];
    storage_ = _e555;
    let _e556 = storage_;
    let _e558 = storage_;
    if ((_e556 > 0.5f) && (_e558 < 1.5f)) {
        let _e561 = bias;
        let _e563 = projected[2u];
        param_64 = _e563;
        let _e564 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e561, _e564);
    }
    let _e568 = frag_info.shadow_params[0u];
    let _e571 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e568, _e571);
    let _e573 = cascade;
    let _e575 = cascadeCount;
    let _e579 = texel_1;
    tileLo = (vec2<f32>((f32(_e573) / f32(_e575)), 0f) + (_e579 * 0.5f));
    let _e582 = cascade;
    let _e585 = cascadeCount;
    let _e589 = texel_1;
    tileHi = (vec2<f32>((f32((_e582 + 1i)) / f32(_e585)), 1f) - (_e589 * 0.5f));
    let _e594 = frag_info.shadow_bias[3u];
    if (_e594 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e596 = y;
            if (_e596 <= 1i) {
                x = -1i;
                loop {
                    let _e598 = x;
                    if (_e598 <= 1i) {
                        let _e600 = uv_5;
                        let _e601 = x;
                        let _e603 = y;
                        let _e606 = texel_1;
                        let _e609 = tileLo;
                        let _e610 = tileHi;
                        let _e612 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e600 + (vec2<f32>(f32(_e601), f32(_e603)) * _e606)), _e609, _e610), 0f);
                        let _e613 = stored_4;
                        stored_4 = (_e613 + _e612);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e615 = x;
                        x = (_e615 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e617 = y;
                y = (_e617 + 1i);
            }
        }
        let _e619 = stored_4;
        stored_4 = (_e619 * 0.11111111f);
        let _e622 = stored_4[1u];
        let _e625 = stored_4[2u];
        let _e628 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e622), (1f - _e625), _e628), vec3(0f), vec3(4f));
        let _e633 = through;
        let _e634 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e633, vec3(clamp(_e634, 0f, 1f)));
    }
    let _e640 = frag_info.ambient_ground[3u];
    softness = _e640;
    lit_2 = 0f;
    let _e641 = softness;
    if (_e641 < 0f) {
        let _e643 = uv_5;
        let _e644 = tileLo;
        let _e645 = tileHi;
        let _e647 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e643, _e644, _e645), 0f);
        moments_2 = _e647;
        let _e649 = projected[2u];
        let _e650 = bias;
        let _e652 = softness;
        let _e656 = moments_2;
        param_65 = _e656;
        param_66 = (_e649 - _e650);
        param_67 = clamp((-(_e652) - 1f), 0f, 0.95f);
        let _e657 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e657;
    } else {
        let _e658 = softness;
        if (_e658 <= 0f) {
            y_1 = -1i;
            loop {
                let _e660 = y_1;
                if (_e660 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e662 = x_1;
                        if (_e662 <= 1i) {
                            let _e664 = uv_5;
                            let _e665 = x_1;
                            let _e667 = y_1;
                            let _e670 = texel_1;
                            let _e673 = tileLo;
                            let _e674 = tileHi;
                            let _e676 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e664 + (vec2<f32>(f32(_e665), f32(_e667)) * _e670)), _e673, _e674), 0f);
                            param_68 = _e676.x;
                            let _e678 = storage_;
                            param_69 = _e678;
                            let _e679 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e679;
                            let _e681 = projected[2u];
                            let _e682 = bias;
                            let _e684 = occluder;
                            let _e687 = lit_2;
                            lit_2 = (_e687 + select(1f, 0f, ((_e681 - _e682) > _e684)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e689 = x_1;
                            x_1 = (_e689 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e691 = y_1;
                    y_1 = (_e691 + 1i);
                }
            }
            let _e693 = lit_2;
            lit_2 = (_e693 * 0.11111111f);
        } else {
            let _e695 = softness;
            spread = tan(min(_e695, 0.5f));
            let _e698 = ShadowNoise_u0028_();
            turn_1 = (_e698 * 6.2831855f);
            let _e700 = spread;
            let _e702 = projected[2u];
            let _e704 = cascadeDepth;
            let _e706 = cascadeTexel;
            searchRadius = clamp((((_e700 * _e702) * _e704) / _e706), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e709 = i_5;
                if (_e709 < 16i) {
                    let _e711 = i_5;
                    param_70 = _e711;
                    param_71 = 16i;
                    let _e712 = turn_1;
                    param_72 = _e712;
                    let _e713 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e713;
                    let _e714 = bias;
                    let _e715 = disc;
                    let _e717 = searchRadius;
                    let _e721 = receiverSlope;
                    tapBias = (_e714 + (max(((length(_e715) * _e717) - 1.5f), 0f) * _e721));
                    let _e724 = uv_5;
                    let _e725 = disc;
                    let _e726 = texel_1;
                    let _e728 = searchRadius;
                    let _e731 = tileLo;
                    let _e732 = tileHi;
                    let _e734 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e724 + ((_e725 * _e726) * _e728)), _e731, _e732), 0f);
                    param_73 = _e734.x;
                    let _e736 = storage_;
                    param_74 = _e736;
                    let _e737 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e737;
                    let _e739 = projected[2u];
                    let _e740 = tapBias;
                    let _e742 = occluder_1;
                    if ((_e739 - _e740) > _e742) {
                        let _e744 = occluder_1;
                        let _e745 = blockerSum;
                        blockerSum = (_e745 + _e744);
                        let _e747 = blockerCount;
                        blockerCount = (_e747 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e749 = i_5;
                    i_5 = (_e749 + 1i);
                }
            }
            let _e751 = blockerCount;
            if (_e751 <= 0f) {
                return 1f;
            }
            let _e754 = projected[2u];
            let _e755 = blockerSum;
            let _e756 = blockerCount;
            let _e760 = cascadeDepth;
            gap = (max((_e754 - (_e755 / _e756)), 0f) * _e760);
            let _e762 = spread;
            let _e763 = gap;
            let _e765 = cascadeTexel;
            radius_2 = clamp(((_e762 * _e763) / _e765), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e768 = i_6;
                if (_e768 < 16i) {
                    let _e770 = turn_1;
                    let _e772 = i_6;
                    param_75 = _e772;
                    param_76 = 16i;
                    param_77 = (_e770 + 1f);
                    let _e773 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e773;
                    let _e774 = bias;
                    let _e775 = disc_1;
                    let _e777 = radius_2;
                    let _e781 = receiverSlope;
                    tapBias_1 = (_e774 + (max(((length(_e775) * _e777) - 1.5f), 0f) * _e781));
                    let _e784 = uv_5;
                    let _e785 = disc_1;
                    let _e786 = texel_1;
                    let _e788 = radius_2;
                    let _e791 = tileLo;
                    let _e792 = tileHi;
                    let _e794 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e784 + ((_e785 * _e786) * _e788)), _e791, _e792), 0f);
                    param_78 = _e794.x;
                    let _e796 = storage_;
                    param_79 = _e796;
                    let _e797 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e797;
                    let _e799 = projected[2u];
                    let _e800 = tapBias_1;
                    let _e802 = occluder_2;
                    let _e805 = lit_2;
                    lit_2 = (_e805 + select(1f, 0f, ((_e799 - _e800) > _e802)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e807 = i_6;
                    i_6 = (_e807 + 1i);
                }
            }
            let _e809 = lit_2;
            lit_2 = (_e809 * 0.0625f);
        }
    }
    let _e811 = lit_2;
    let _e812 = strength_1;
    return mix(1f, _e811, clamp(_e812, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e217 = (*s_4);
    param_80 = _e217;
    let _e218 = (*light_2);
    param_81 = _e218;
    let _e219 = (*index);
    param_82 = _e219;
    let _e220 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e220;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e212 = (*index_1);
    return (_e212 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e216 = (*distance_1);
    let _e217 = (*distance_1);
    attenuation = (1f / max((_e216 * _e217), 0.0001f));
    let _e221 = (*range_4);
    if (_e221 > 0f) {
        let _e223 = (*distance_1);
        let _e224 = (*range_4);
        ratio = (_e223 / _e224);
        let _e226 = ratio;
        let _e227 = ratio;
        let _e229 = ratio;
        let _e231 = ratio;
        window = clamp((1f - (((_e226 * _e227) * _e229) * _e231)), 0f, 1f);
        let _e235 = window;
        let _e236 = window;
        let _e238 = attenuation;
        attenuation = (_e238 * (_e235 * _e236));
    }
    let _e240 = attenuation;
    return _e240;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_24: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e228 = (*halfWidth);
    let _e229 = (*halfHeight);
    n_2 = cross(_e228, _e229);
    let _e231 = n_2;
    nLen = length(_e231);
    let _e233 = nLen;
    if (_e233 < 0.000000000001f) {
        let _e235 = (*centre);
        return _e235;
    }
    let _e236 = nLen;
    let _e237 = n_2;
    n_2 = (_e237 / vec3(_e236));
    let _e240 = (*centre);
    let _e241 = (*world_2);
    toPlane = (_e240 - _e241);
    let _e243 = (*mirror);
    let _e244 = n_2;
    denom = dot(_e243, _e244);
    let _e246 = denom;
    if (abs(_e246) < 0.00001f) {
        let _e249 = toPlane;
        let _e250 = n_2;
        let _e251 = toPlane;
        let _e252 = n_2;
        onPlane = (_e249 - (_e250 * dot(_e251, _e252)));
    } else {
        let _e256 = toPlane;
        let _e257 = n_2;
        let _e259 = denom;
        t_1 = (dot(_e256, _e257) / _e259);
        let _e261 = t_1;
        if (_e261 > 0f) {
            let _e263 = (*mirror);
            let _e264 = t_1;
            local_24 = (_e263 * _e264);
        } else {
            let _e266 = toPlane;
            let _e267 = n_2;
            let _e268 = toPlane;
            let _e269 = n_2;
            local_24 = (_e266 - (_e267 * dot(_e268, _e269)));
        }
        let _e273 = local_24;
        onPlane = _e273;
    }
    let _e274 = onPlane;
    let _e275 = toPlane;
    offset_2 = (_e274 - _e275);
    let _e277 = (*halfWidth);
    let _e278 = (*halfWidth);
    wLen2_ = max(dot(_e277, _e278), 0.000000000001f);
    let _e281 = (*halfHeight);
    let _e282 = (*halfHeight);
    hLen2_ = max(dot(_e281, _e282), 0.000000000001f);
    let _e285 = offset_2;
    let _e286 = (*halfWidth);
    let _e288 = wLen2_;
    u = clamp((dot(_e285, _e286) / _e288), -1f, 1f);
    let _e291 = offset_2;
    let _e292 = (*halfHeight);
    let _e294 = hLen2_;
    v = clamp((dot(_e291, _e292) / _e294), -1f, 1f);
    let _e297 = (*centre);
    let _e298 = (*halfWidth);
    let _e299 = u;
    let _e302 = (*halfHeight);
    let _e303 = v;
    return ((_e297 + (_e298 * _e299)) + (_e302 * _e303));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_25: f32;

    let _e220 = (*a_1);
    let _e221 = (*a_1);
    ua = (_e220 / vec3(max(length(_e221), 0.000000000001f)));
    let _e226 = (*b);
    let _e227 = (*b);
    ub = (_e226 / vec3(max(length(_e227), 0.000000000001f)));
    let _e232 = ua;
    let _e233 = ub;
    angle_1 = acos(clamp(dot(_e232, _e233), -1f, 1f));
    let _e237 = ua;
    let _e238 = ub;
    axis = cross(_e237, _e238);
    let _e240 = axis;
    len = length(_e240);
    let _e242 = len;
    if (_e242 > 0.000001f) {
        let _e244 = angle_1;
        let _e245 = axis;
        let _e246 = (*n_3);
        let _e249 = len;
        local_25 = ((_e244 * dot(_e245, _e246)) / _e249);
    } else {
        local_25 = 0f;
    }
    let _e251 = local_25;
    return _e251;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_26: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_27: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_28: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e234 = i_7;
        if (_e234 < 4i) {
            let _e236 = i_7;
            let _e238 = (*corners)[_e236];
            a_2 = _e238;
            let _e239 = i_7;
            if (_e239 == 3i) {
                local_26 = 0i;
            } else {
                let _e241 = i_7;
                local_26 = (_e241 + 1i);
            }
            let _e243 = local_26;
            let _e245 = (*corners)[_e243];
            b_1 = _e245;
            let _e246 = a_2;
            let _e247 = (*n_4);
            ha = dot(_e246, _e247);
            let _e249 = b_1;
            let _e250 = (*n_4);
            hb = dot(_e249, _e250);
            let _e252 = ha;
            let _e253 = hb;
            d_3 = (_e252 - _e253);
            let _e255 = a_2;
            let _e256 = b_1;
            let _e257 = a_2;
            let _e259 = d_3;
            if (abs(_e259) > 0.000000000001f) {
                let _e262 = ha;
                let _e263 = d_3;
                local_27 = (_e262 / _e263);
            } else {
                local_27 = 0f;
            }
            let _e265 = local_27;
            q = (_e255 + ((_e256 - _e257) * _e265));
            let _e268 = ha;
            aAbove = (_e268 > 0f);
            let _e270 = hb;
            bAbove = (_e270 > 0f);
            let _e272 = aAbove;
            let _e273 = bAbove;
            if (_e272 || _e273) {
                let _e275 = aAbove;
                let _e276 = a_2;
                let _e277 = q;
                let _e280 = bAbove;
                let _e281 = b_1;
                let _e282 = q;
                param_83 = select(_e277, _e276, vec3(_e275));
                param_84 = select(_e282, _e281, vec3(_e280));
                let _e285 = (*n_4);
                param_85 = _e285;
                let _e286 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_28 = _e286;
            } else {
                local_28 = 0f;
            }
            let _e287 = local_28;
            let _e288 = total;
            total = (_e288 + _e287);
            let _e290 = aAbove;
            let _e291 = bAbove;
            let _e294 = q;
            let _e295 = exit;
            exit = select(_e295, _e294, vec3((_e290 && !(_e291))));
            let _e298 = aAbove;
            let _e300 = bAbove;
            let _e302 = q;
            let _e303 = entry;
            entry = select(_e303, _e302, vec3((!(_e298) && _e300)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e306 = i_7;
            i_7 = (_e306 + 1i);
        }
    }
    let _e308 = exit;
    param_86 = _e308;
    let _e309 = entry;
    param_87 = _e309;
    let _e310 = (*n_4);
    param_88 = _e310;
    let _e311 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e312 = total;
    total = (_e312 + _e311);
    let _e314 = total;
    return max((-(_e314) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_29: f32;
    var local_30: f32;
    var local_31: f32;

    let _e217 = (*slot_1);
    let _e218 = (*slot_1);
    lane = (_e217 - ((_e218 / 4i) * 4i));
    let _e222 = lane;
    if (_e222 == 0i) {
        let _e225 = (*four)[0u];
        local_29 = _e225;
    } else {
        let _e226 = lane;
        if (_e226 == 1i) {
            let _e229 = (*four)[1u];
            local_30 = _e229;
        } else {
            let _e230 = lane;
            if (_e230 == 2i) {
                let _e233 = (*four)[2u];
                local_31 = _e233;
            } else {
                let _e235 = (*four)[3u];
                local_31 = _e235;
            }
            let _e236 = local_31;
            local_30 = _e236;
        }
        let _e237 = local_30;
        local_29 = _e237;
    }
    let _e238 = local_29;
    return _e238;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e214 = (*slot_2);
    let _e218 = light_list_info.scales[(_e214 / 4i)];
    param_89 = _e218;
    let _e219 = (*slot_2);
    param_90 = _e219;
    let _e220 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e220;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e216 = light_list_info.slot_rows[0i];
    let _e217 = (*row);
    a_3 = abs((_e216 - vec4(_e217)));
    let _e223 = light_list_info.slot_rows[1i];
    let _e224 = (*row);
    b_2 = abs((_e223 - vec4(_e224)));
    let _e229 = a_3[0u];
    let _e231 = a_3[1u];
    let _e234 = a_3[2u];
    let _e236 = a_3[3u];
    let _e240 = b_2[0u];
    let _e242 = b_2[1u];
    let _e245 = b_2[2u];
    let _e247 = b_2[3u];
    return (min(min(min(_e229, _e231), min(_e234, _e236)), min(min(_e240, _e242), min(_e245, _e247))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e214 = (*slot_3);
    let _e218 = light_list_info.indices[(_e214 / 4i)];
    param_91 = _e218;
    let _e219 = (*slot_3);
    param_92 = _e219;
    let _e220 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e220;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e213 = (*texel_2);
    let _e217 = light_list_info.list[1u];
    let _e219 = (*row_1);
    let _e223 = light_list_info.list[2u];
    let _e226 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e213 + 0.5f) * _e217), ((_e219 + 0.5f) * _e223)), 0f);
    return _e226;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e221 = g_cluster_offset;
    let _e222 = (*slot_4);
    entry_1 = (_e221 + f32(_e222));
    let _e225 = entry_1;
    row_2 = floor((_e225 / 16f));
    let _e228 = entry_1;
    let _e229 = row_2;
    within_1 = (_e228 - (_e229 * 16f));
    let _e232 = within_1;
    texel_3 = floor((_e232 / 4f));
    let _e237 = light_list_info.cluster_depth[3u];
    let _e238 = row_2;
    let _e240 = texel_3;
    param_93 = _e240;
    param_94 = (_e237 + _e238);
    let _e241 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e241;
    let _e242 = within_1;
    let _e243 = texel_3;
    let _e248 = four_1;
    param_95 = _e248;
    param_96 = i32(((_e242 - (_e243 * 4f)) + 0.5f));
    let _e249 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e249;
}

fn Clustered_u0028_() -> bool {
    let _e213 = light_list_info.cluster_grid[3u];
    return (_e213 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_5: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_32: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_33: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_34: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_35: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_36: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp_1: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e265 = (*index_2);
    if (_e265 < 8i) {
        let _e267 = (*index_2);
        let _e270 = frag_info.light_position[_e267];
        position = _e270;
        let _e271 = (*index_2);
        let _e274 = frag_info.light_color[_e271];
        color_1 = _e274;
        let _e275 = (*index_2);
        let _e278 = frag_info.light_direction[_e275];
        direction = _e278;
        let _e279 = (*index_2);
        let _e282 = frag_info.light_cone[_e279];
        cone = _e282;
    } else {
        let _e283 = (*index_2);
        slot_5 = (_e283 - 8i);
        let _e285 = Clustered_u0028_();
        clustered = _e285;
        let _e286 = clustered;
        if _e286 {
            let _e287 = slot_5;
            param_97 = _e287;
            let _e288 = ClusterRow_u0028_i1_u003b((&param_97));
            local_32 = _e288;
        } else {
            let _e289 = slot_5;
            param_98 = _e289;
            let _e290 = LightListRow_u0028_i1_u003b((&param_98));
            local_32 = _e290;
        }
        let _e291 = local_32;
        listRow = _e291;
        let _e292 = listRow;
        let _e296 = light_list_info.list[2u];
        v_1 = ((_e292 + 0.5f) * _e296);
        let _e300 = light_list_info.list[1u];
        u_1 = _e300;
        let _e301 = u_1;
        let _e303 = v_1;
        let _e305 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e301), _e303), 0f);
        position = _e305;
        let _e306 = u_1;
        let _e308 = v_1;
        let _e310 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e306), _e308), 0f);
        color_1 = _e310;
        let _e311 = u_1;
        let _e313 = v_1;
        let _e315 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e311), _e313), 0f);
        direction = _e315;
        let _e316 = u_1;
        let _e318 = v_1;
        let _e320 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e316), _e318), 0f);
        cone = _e320;
        let _e321 = clustered;
        if _e321 {
            let _e322 = listRow;
            param_99 = _e322;
            let _e323 = InSlots_u0028_f1_u003b((&param_99));
            local_33 = select(1f, 0f, _e323);
        } else {
            let _e325 = slot_5;
            param_100 = _e325;
            let _e326 = LightListScale_u0028_i1_u003b((&param_100));
            local_33 = _e326;
        }
        let _e327 = local_33;
        let _e329 = color_1[3u];
        color_1[3u] = (_e329 * _e327);
    }
    let _e333 = position[3u];
    type_39 = _e333;
    let _e334 = type_39;
    if (_e334 > 15.5f) {
        let _e337 = (*s_5).n;
        light_3.l = _e337;
        let _e340 = (*s_5).n;
        light_3.h = _e340;
        light_3.radiance = vec3<f32>(0f, 0f, 0f);
        light_3.n_dot_l = 0f;
        light_3.n_dot_h = 0f;
        light_3.v_dot_h = 0f;
        let _e346 = light_3;
        return _e346;
    }
    let _e347 = type_39;
    if (_e347 > 2.5f) {
        let _e349 = direction;
        halfWidth_1 = _e349.xyz;
        let _e351 = cone;
        halfHeight_1 = _e351.xyz;
        let _e353 = position;
        let _e355 = v_world_position_1;
        toCentre = (_e353.xyz - _e355);
        let _e357 = toCentre;
        let _e358 = halfWidth_1;
        let _e360 = halfHeight_1;
        corners_1[0i] = ((_e357 - _e358) - _e360);
        let _e363 = toCentre;
        let _e364 = halfWidth_1;
        let _e366 = halfHeight_1;
        corners_1[1i] = ((_e363 + _e364) - _e366);
        let _e369 = toCentre;
        let _e370 = halfWidth_1;
        let _e372 = halfHeight_1;
        corners_1[2i] = ((_e369 + _e370) + _e372);
        let _e375 = toCentre;
        let _e376 = halfWidth_1;
        let _e378 = halfHeight_1;
        corners_1[3i] = ((_e375 - _e376) + _e378);
        let _e381 = toCentre;
        let _e382 = halfWidth_1;
        let _e383 = halfHeight_1;
        behind = (dot(_e381, cross(_e382, _e383)) >= 0f);
        let _e387 = behind;
        if _e387 {
            local_34 = 0f;
        } else {
            let _e388 = corners_1;
            param_101 = _e388;
            let _e390 = (*s_5).n;
            param_102 = _e390;
            let _e391 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_34 = _e391;
        }
        let _e392 = local_34;
        formFactor = _e392;
        let _e393 = halfWidth_1;
        let _e394 = halfHeight_1;
        area = (length(cross(_e393, _e394)) * 4f);
        let _e398 = area;
        if (_e398 > 0.000000001f) {
            let _e400 = area;
            local_35 = (1f / _e400);
        } else {
            local_35 = 0f;
        }
        let _e402 = local_35;
        radiance = _e402;
        let _e403 = toCentre;
        distance_2 = length(_e403);
        let _e406 = direction[3u];
        if (_e406 > 0f) {
            let _e408 = distance_2;
            let _e410 = direction[3u];
            ratio_1 = (_e408 / _e410);
            let _e412 = ratio_1;
            let _e413 = ratio_1;
            let _e415 = ratio_1;
            let _e417 = ratio_1;
            window_1 = clamp((1f - (((_e412 * _e413) * _e415) * _e417)), 0f, 1f);
            let _e421 = window_1;
            let _e422 = window_1;
            let _e424 = radiance;
            radiance = (_e424 * (_e421 * _e422));
        }
        let _e427 = (*s_5).v;
        let _e430 = (*s_5).n;
        mirror_1 = reflect(-(_e427), _e430);
        let _e432 = position;
        param_103 = _e432.xyz;
        let _e434 = halfWidth_1;
        param_104 = _e434;
        let _e435 = halfHeight_1;
        param_105 = _e435;
        let _e436 = v_world_position_1;
        param_106 = _e436;
        let _e437 = mirror_1;
        param_107 = _e437;
        let _e438 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e438;
        let _e439 = representative;
        let _e440 = v_world_position_1;
        toPoint = (_e439 - _e440);
        let _e442 = toPoint;
        pointDistance = length(_e442);
        let _e444 = pointDistance;
        if (_e444 > 0.000001f) {
            let _e446 = toPoint;
            let _e447 = pointDistance;
            local_36 = (_e446 / vec3(_e447));
        } else {
            let _e451 = (*s_5).n;
            local_36 = _e451;
        }
        let _e452 = local_36;
        light_3.l = _e452;
        let _e455 = light_3.l;
        let _e457 = (*s_5).v;
        light_3.h = normalize((_e455 + _e457));
        let _e461 = formFactor;
        light_3.n_dot_l = _e461;
        let _e464 = (*s_5).n;
        let _e466 = light_3.h;
        light_3.n_dot_h = max(dot(_e464, _e466), 0f);
        let _e471 = (*s_5).v;
        let _e473 = light_3.h;
        light_3.v_dot_h = max(dot(_e471, _e473), 0f);
        let _e477 = color_1;
        let _e480 = color_1[3u];
        let _e482 = radiance;
        light_3.radiance = ((_e477.xyz * _e480) * _e482);
        let _e485 = light_3;
        return _e485;
    }
    let _e486 = direction;
    aim = normalize(_e486.xyz);
    attenuation_1 = 1f;
    let _e489 = type_39;
    if (_e489 < 0.5f) {
        let _e491 = aim;
        light_3.l = -(_e491);
    } else {
        let _e494 = position;
        let _e496 = v_world_position_1;
        toLight_1 = (_e494.xyz - _e496);
        let _e498 = toLight_1;
        distance_3 = length(_e498);
        let _e500 = distance_3;
        if (_e500 < 0.000001f) {
            let _e503 = (*s_5).n;
            light_3.l = _e503;
            let _e506 = (*s_5).n;
            light_3.h = _e506;
            light_3.radiance = vec3<f32>(0f, 0f, 0f);
            light_3.n_dot_l = 0f;
            light_3.n_dot_h = 0f;
            light_3.v_dot_h = 0f;
            let _e512 = light_3;
            return _e512;
        }
        let _e513 = toLight_1;
        let _e514 = distance_3;
        light_3.l = (_e513 / vec3(_e514));
        let _e518 = distance_3;
        param_108 = _e518;
        let _e520 = direction[3u];
        param_109 = _e520;
        let _e521 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e521;
        let _e522 = type_39;
        if (_e522 > 1.5f) {
            let _e524 = aim;
            let _e526 = light_3.l;
            cosAngle = dot(_e524, -(_e526));
            let _e529 = cosAngle;
            let _e531 = cone[1u];
            let _e534 = cone[0u];
            let _e536 = cone[1u];
            ramp_1 = clamp(((_e529 - _e531) / (_e534 - _e536)), 0f, 1f);
            let _e540 = ramp_1;
            let _e541 = ramp_1;
            let _e543 = attenuation_1;
            attenuation_1 = (_e543 * (_e540 * _e541));
        }
    }
    let _e546 = light_3.l;
    let _e548 = (*s_5).v;
    light_3.h = normalize((_e546 + _e548));
    let _e553 = (*s_5).n;
    let _e555 = light_3.l;
    light_3.n_dot_l = max(dot(_e553, _e555), 0f);
    let _e560 = (*s_5).n;
    let _e562 = light_3.h;
    light_3.n_dot_h = max(dot(_e560, _e562), 0f);
    let _e567 = (*s_5).v;
    let _e569 = light_3.h;
    light_3.v_dot_h = max(dot(_e567, _e569), 0f);
    let _e573 = color_1;
    let _e576 = color_1[3u];
    let _e578 = attenuation_1;
    light_3.radiance = ((_e573.xyz * _e576) * _e578);
    let _e581 = light_3;
    return _e581;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_37: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e226 = light_list_info.cluster_view_projection;
    let _e227 = (*world_3);
    clip_1 = (_e226 * vec4<f32>(_e227.x, _e227.y, _e227.z, 1f));
    let _e233 = clip_1;
    let _e236 = clip_1[3u];
    ndc_1 = (_e233.xy / vec2(max(_e236, 0.000001f)));
    let _e241 = light_list_info.cluster_grid;
    grid = _e241.xyz;
    let _e245 = light_list_info.cluster_depth[0u];
    near_1 = _e245;
    let _e247 = ndc_1[0u];
    let _e251 = grid[0u];
    let _e255 = grid[0u];
    tx = clamp(floor((((_e247 * 0.5f) + 0.5f) * _e251)), 0f, (_e255 - 1f));
    let _e259 = ndc_1[1u];
    let _e263 = grid[1u];
    let _e267 = grid[1u];
    ty = clamp(floor((((_e259 * 0.5f) + 0.5f) * _e263)), 0f, (_e267 - 1f));
    let _e271 = clip_1[3u];
    let _e272 = near_1;
    if (_e271 <= _e272) {
        local_37 = 0f;
    } else {
        let _e275 = clip_1[3u];
        let _e276 = near_1;
        let _e281 = light_list_info.cluster_depth[1u];
        let _e285 = grid[2u];
        local_37 = clamp(floor((log((_e275 / _e276)) * _e281)), 0f, (_e285 - 1f));
    }
    let _e288 = local_37;
    tz = _e288;
    let _e289 = tx;
    let _e290 = ty;
    let _e292 = grid[0u];
    let _e295 = tz;
    let _e297 = grid[0u];
    let _e300 = grid[1u];
    cell_1 = ((_e289 + (_e290 * _e292)) + ((_e295 * _e297) * _e300));
    let _e303 = cell_1;
    row_3 = floor((_e303 / 4f));
    let _e306 = cell_1;
    let _e307 = row_3;
    let _e312 = light_list_info.cluster_depth[2u];
    let _e313 = row_3;
    param_110 = (_e306 - (_e307 * 4f));
    param_111 = (_e312 + _e313);
    let _e315 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e315;
    let _e317 = header[0u];
    g_cluster_offset = _e317;
    let _e319 = header[1u];
    g_cluster_count = _e319;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e215 = light_list_info.list[0u];
    tail = _e215;
    let _e216 = Clustered_u0028_();
    if _e216 {
        let _e217 = v_world_position_1;
        param_112 = _e217;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e218 = g_cluster_count;
        tail = _e218;
    }
    let _e221 = frag_info.frame_params[1u];
    let _e225 = tail;
    return (clamp(i32((_e221 + 0.5f)), 0i, 8i) + clamp(i32((_e225 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_38: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e229 = LightCount_u0028_();
    count_1 = _e229;
    i_8 = 0i;
    loop {
        let _e230 = i_8;
        if (_e230 < 32i) {
            let _e232 = i_8;
            let _e233 = count_1;
            if (_e232 >= _e233) {
                break;
            }
            let _e235 = i_8;
            param_113 = _e235;
            let _e236 = (*s_6);
            param_114 = _e236;
            let _e237 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_113), (&param_114));
            light_4 = _e237;
            let _e239 = light_4.n_dot_l;
            if (_e239 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e241 = i_8;
            param_115 = _e241;
            let _e242 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e242 {
                let _e243 = (*s_6);
                param_116 = _e243;
                let _e244 = light_4;
                param_117 = _e244;
                let _e245 = i_8;
                param_118 = _e245;
                let _e246 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e247 = v_world_position_1;
                param_119 = _e247;
                let _e249 = (*s_6).n;
                param_120 = _e249;
                let _e250 = i_8;
                param_121 = _e250;
                let _e251 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_38 = (_e246 * _e251);
            } else {
                local_38 = 1f;
            }
            let _e253 = local_38;
            visibility = _e253;
            let _e254 = visibility;
            if (_e254 <= 0f) {
                continue;
            }
            let _e256 = (*s_6);
            param_122 = _e256;
            let _e257 = light_4;
            param_123 = _e257;
            let _e258 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e260 = light_4.radiance;
            let _e263 = light_4.n_dot_l;
            let _e265 = visibility;
            let _e267 = light_transmittance;
            let _e269 = total_1;
            total_1 = (_e269 + ((((_e258 * _e260) * _e263) * _e265) * _e267));
            continue;
        } else {
            break;
        }
        continuing {
            let _e271 = i_8;
            i_8 = (_e271 + 1i);
        }
    }
    let _e273 = total_1;
    return _e273;
}

fn IndirectOcclusion_u0028_struct_u002d_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>) -> f32 {
    var target_: f32;
    var local_39: f32;
    var local_40: f32;

    let _e215 = OcclusionTarget_u0028_();
    target_ = _e215;
    let _e216 = target_;
    let _e218 = target_;
    if ((_e216 > 0.5f) && (_e218 < 1.5f)) {
        local_39 = 1f;
    } else {
        let _e222 = (*s_7).occlusion;
        local_39 = _e222;
    }
    let _e223 = local_39;
    local_40 = _e223;
    let _e224 = local_40;
    return _e224;
}

fn SampleLightmap_u0028_() -> vec3<f32> {
    var texel_4: vec4<f32>;

    let _e212 = v_lightmap_uv_1;
    let _e213 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e212);
    texel_4 = _e213;
    let _e214 = texel_4;
    let _e217 = texel_4[3u];
    return ((_e214.xyz * _e217) * 8f);
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e213 = frag_info.target_origin[1u];
    return _e213;
}

fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
    var orm: vec3<f32>;

    let _e213 = v_texcoord_1;
    let _e214 = MaterialLodBias_u0028_();
    let _e215 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e213, _e214);
    orm = _e215.xyz;
    let _e218 = (*s_8).metallic;
    let _e220 = orm[2u];
    (*s_8).metallic = clamp((_e218 * _e220), 0f, 1f);
    let _e225 = (*s_8).roughness;
    let _e227 = orm[1u];
    (*s_8).roughness = clamp((_e225 * _e227), 0.02f, 1f);
    return;
}

fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
    var emissive: vec3<f32>;
    var param_124: vec3<f32>;

    let _e214 = v_texcoord_1;
    let _e215 = MaterialLodBias_u0028_();
    let _e216 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e214, _e215);
    param_124 = _e216.xyz;
    let _e218 = SrgbToLinear_u0028_vf3_u003b((&param_124));
    emissive = _e218;
    let _e219 = emissive;
    let _e221 = frag_info.emissive;
    let _e226 = frag_info.material2_[3u];
    (*s_9).emissive = ((_e219 * _e221.xyz) * _e226);
    return;
}

fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
    var occlusion: f32;
    var strength_2: f32;

    let _e214 = v_texcoord_1;
    let _e215 = MaterialLodBias_u0028_();
    let _e216 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e214, _e215);
    occlusion = _e216.x;
    let _e220 = frag_info.material2_[2u];
    let _e221 = OcclusionTarget_u0028_();
    strength_2 = (_e220 - (2f * _e221));
    let _e224 = occlusion;
    let _e225 = strength_2;
    (*s_10).occlusion = mix(1f, _e224, clamp(_e225, 0f, 1f));
    return;
}

fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
    var sampledTexel: vec4<f32>;
    var t_2: vec3<f32>;
    var b_3: vec3<f32>;
    var sampled: vec3<f32>;

    let _e216 = v_texcoord_1;
    let _e217 = MaterialLodBias_u0028_();
    let _e218 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e216, _e217);
    sampledTexel = _e218;
    let _e219 = v_tangent_1;
    t_2 = _e219.xyz;
    let _e221 = t_2;
    let _e223 = (*s_11).n;
    let _e225 = (*s_11).n;
    let _e226 = t_2;
    t_2 = (_e221 - (_e223 * dot(_e225, _e226)));
    let _e230 = t_2;
    let _e231 = t_2;
    if (dot(_e230, _e231) < 0.000000000001f) {
        return;
    }
    let _e234 = t_2;
    t_2 = normalize(_e234);
    let _e237 = (*s_11).n;
    let _e238 = t_2;
    let _e241 = v_tangent_1[3u];
    b_3 = (cross(_e237, _e238) * _e241);
    let _e243 = gl_FrontFacing_1;
    if !(_e243) {
        let _e245 = t_2;
        t_2 = -(_e245);
    }
    let _e247 = sampledTexel;
    sampled = ((_e247.xyz * 2f) - vec3(1f));
    let _e254 = frag_info.emissive[3u];
    if (_e254 > 0.5f) {
        let _e256 = sampled;
        let _e258 = sampled;
        sampled[2u] = sqrt(max((1f - dot(_e256.xy, _e258.xy)), 0f));
    }
    let _e267 = frag_info.material2_[1u];
    let _e268 = sampled;
    let _e270 = (_e268.xy * _e267);
    sampled[0u] = _e270.x;
    sampled[1u] = _e270.y;
    let _e275 = t_2;
    let _e277 = sampled[0u];
    let _e279 = b_3;
    let _e281 = sampled[1u];
    let _e285 = (*s_11).n;
    let _e287 = sampled[2u];
    (*s_11).n = normalize((((_e275 * _e277) + (_e279 * _e281)) + (_e285 * _e287)));
    let _e293 = (*s_11).n;
    let _e295 = (*s_11).v;
    (*s_11).n_dot_v = max(dot(_e293, _e295), 0.0001f);
    return;
}

fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e212 = (*texel_5);
    let _e216 = irradiance_info.atlas;
    let _e219 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e212 + vec2(0.5f)) * _e216.xy), 0f);
    return _e219;
}

fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
    var at_1: vec2<f32>;
    var low: vec2<f32>;
    var f: vec2<f32>;
    var a_4: vec4<f32>;
    var param_125: vec2<f32>;
    var b_4: vec4<f32>;
    var param_126: vec2<f32>;
    var c_1: vec4<f32>;
    var param_127: vec2<f32>;
    var d_4: vec4<f32>;
    var param_128: vec2<f32>;

    let _e225 = (*uv_6);
    let _e226 = (*interior);
    at_1 = ((vec2(1f) + (_e225 * _e226)) - vec2(0.5f));
    let _e232 = at_1;
    low = floor(_e232);
    let _e234 = at_1;
    let _e235 = low;
    f = (_e234 - _e235);
    let _e237 = (*corner);
    let _e238 = low;
    param_125 = (_e237 + _e238);
    let _e240 = AtlasTexel_u0028_vf2_u003b((&param_125));
    a_4 = _e240;
    let _e241 = (*corner);
    let _e242 = low;
    param_126 = ((_e241 + _e242) + vec2<f32>(1f, 0f));
    let _e245 = AtlasTexel_u0028_vf2_u003b((&param_126));
    b_4 = _e245;
    let _e246 = (*corner);
    let _e247 = low;
    param_127 = ((_e246 + _e247) + vec2<f32>(0f, 1f));
    let _e250 = AtlasTexel_u0028_vf2_u003b((&param_127));
    c_1 = _e250;
    let _e251 = (*corner);
    let _e252 = low;
    param_128 = ((_e251 + _e252) + vec2<f32>(1f, 1f));
    let _e255 = AtlasTexel_u0028_vf2_u003b((&param_128));
    d_4 = _e255;
    let _e256 = a_4;
    let _e257 = b_4;
    let _e259 = f[0u];
    let _e262 = c_1;
    let _e263 = d_4;
    let _e265 = f[0u];
    let _e269 = f[1u];
    return mix(mix(_e256, _e257, vec4(_e259)), mix(_e262, _e263, vec4(_e265)), vec4(_e269));
}

fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var sum_1: f32;
    var n_5: vec3<f32>;
    var xy: vec2<f32>;

    let _e216 = (*direction_1)[0u];
    let _e219 = (*direction_1)[1u];
    let _e223 = (*direction_1)[2u];
    sum_1 = ((abs(_e216) + abs(_e219)) + abs(_e223));
    let _e226 = sum_1;
    if (_e226 <= 0f) {
        return vec2<f32>(0.5f, 0.5f);
    }
    let _e228 = (*direction_1);
    let _e229 = sum_1;
    n_5 = (_e228 / vec3(_e229));
    let _e232 = n_5;
    xy = _e232.xy;
    let _e235 = n_5[2u];
    if (_e235 < 0f) {
        let _e238 = n_5[1u];
        let _e242 = n_5[0u];
        let _e247 = n_5[0u];
        let _e251 = n_5[1u];
        xy = vec2<f32>(((1f - abs(_e238)) * select(-1f, 1f, (_e242 >= 0f))), ((1f - abs(_e247)) * select(-1f, 1f, (_e251 >= 0f))));
    }
    let _e256 = xy;
    return ((_e256 * 0.5f) + vec2(0.5f));
}

fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var spacing: vec3<f32>;
    var counts: vec3<f32>;
    var irradianceTile: f32;
    var depthTile: f32;
    var columns: f32;
    var momentsTop: f32;
    var unit: vec3<f32>;
    var biased: vec3<f32>;
    var grid_1: vec3<f32>;
    var base: vec3<f32>;
    var f_1: vec3<f32>;
    var total_2: vec3<f32>;
    var weights: f32;
    var corner_1: i32;
    var offset_3: vec3<f32>;
    var cell_2: vec3<f32>;
    var probe: f32;
    var tile_4: vec2<f32>;
    var irradianceCorner: vec2<f32>;
    var momentCorner: vec2<f32>;
    var param_129: vec2<f32>;
    var trilinear: vec3<f32>;
    var weight_3: f32;
    var probePosition: vec3<f32>;
    var toProbe: vec3<f32>;
    var distance_4: f32;
    var direction_2: vec3<f32>;
    var facing: f32;
    var probeWeight: f32;
    var moments_3: vec2<f32>;
    var param_130: vec3<f32>;
    var param_131: vec2<f32>;
    var param_132: f32;
    var param_133: vec2<f32>;
    var chebyshev: f32;
    var variance_1: f32;
    var difference: f32;
    var param_134: vec3<f32>;
    var param_135: vec2<f32>;
    var param_136: f32;
    var param_137: vec2<f32>;
    var local_41: vec3<f32>;

    let _e258 = irradiance_info.origin;
    origin_2 = _e258.xyz;
    let _e261 = irradiance_info.spacing;
    spacing = _e261.xyz;
    let _e264 = irradiance_info.counts;
    counts = _e264.xyz;
    let _e268 = irradiance_info.tiles[0u];
    irradianceTile = _e268;
    let _e271 = irradiance_info.tiles[1u];
    depthTile = _e271;
    let _e274 = irradiance_info.tiles[2u];
    columns = _e274;
    let _e277 = irradiance_info.tiles[3u];
    momentsTop = _e277;
    let _e278 = (*normal_1);
    unit = normalize(_e278);
    let _e280 = (*world_4);
    let _e281 = unit;
    let _e284 = irradiance_info.spacing[3u];
    let _e287 = (*view_1);
    let _e290 = irradiance_info.counts[3u];
    biased = ((_e280 + (_e281 * _e284)) + (_e287 * _e290));
    let _e293 = biased;
    let _e294 = origin_2;
    let _e296 = spacing;
    grid_1 = ((_e293 - _e294) / _e296);
    let _e298 = grid_1;
    let _e300 = counts;
    base = clamp(floor(_e298), vec3<f32>(0f, 0f, 0f), (_e300 - vec3(2f)));
    let _e304 = grid_1;
    let _e305 = base;
    f_1 = clamp((_e304 - _e305), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    total_2 = vec3<f32>(0f, 0f, 0f);
    weights = 0f;
    corner_1 = 0i;
    loop {
        let _e308 = corner_1;
        if (_e308 < 8i) {
            let _e310 = corner_1;
            let _e313 = corner_1;
            let _e318 = corner_1;
            offset_3 = vec3<f32>(f32((_e310 & 1i)), f32(((_e313 >> bitcast<u32>(1i)) & 1i)), f32(((_e318 >> bitcast<u32>(2i)) & 1i)));
            let _e324 = base;
            let _e325 = offset_3;
            cell_2 = (_e324 + _e325);
            let _e328 = cell_2[2u];
            let _e330 = counts[1u];
            let _e333 = cell_2[1u];
            let _e336 = counts[0u];
            let _e339 = cell_2[0u];
            probe = ((((_e328 * _e330) + _e333) * _e336) + _e339);
            let _e341 = probe;
            let _e342 = columns;
            let _e347 = probe;
            let _e348 = columns;
            tile_4 = vec2<f32>((_e341 - (floor((_e341 / _e342)) * _e342)), floor((_e347 / _e348)));
            let _e352 = tile_4;
            let _e353 = irradianceTile;
            irradianceCorner = (_e352 * (_e353 + 2f));
            let _e357 = tile_4[0u];
            let _e358 = depthTile;
            let _e361 = momentsTop;
            let _e363 = tile_4[1u];
            let _e364 = depthTile;
            momentCorner = vec2<f32>((_e357 * (_e358 + 2f)), (_e361 + (_e363 * (_e364 + 2f))));
            let _e369 = irradianceCorner;
            param_129 = (_e369 + vec2(1f));
            let _e372 = AtlasTexel_u0028_vf2_u003b((&param_129));
            if (_e372.w < 0.5f) {
                continue;
            }
            let _e375 = f_1;
            let _e377 = f_1;
            let _e378 = offset_3;
            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e375), _e377, _e378);
            let _e381 = trilinear[0u];
            let _e383 = trilinear[1u];
            let _e386 = trilinear[2u];
            weight_3 = max(((_e381 * _e383) * _e386), 0.001f);
            let _e389 = origin_2;
            let _e390 = spacing;
            let _e391 = cell_2;
            probePosition = (_e389 + (_e390 * _e391));
            let _e394 = probePosition;
            let _e395 = biased;
            toProbe = (_e394 - _e395);
            let _e397 = toProbe;
            distance_4 = length(_e397);
            let _e399 = distance_4;
            if (_e399 > 0.000001f) {
                let _e401 = toProbe;
                let _e402 = distance_4;
                direction_2 = (_e401 / vec3(_e402));
                let _e405 = unit;
                let _e406 = probePosition;
                let _e407 = (*world_4);
                facing = ((dot(_e405, normalize((_e406 - _e407))) * 0.5f) + 0.5f);
                let _e413 = facing;
                let _e414 = facing;
                probeWeight = ((_e413 * _e414) + 0.2f);
                let _e417 = direction_2;
                param_130 = -(_e417);
                let _e419 = ProbeOctahedral_u0028_vf3_u003b((&param_130));
                let _e420 = momentCorner;
                param_131 = _e420;
                let _e421 = depthTile;
                param_132 = _e421;
                param_133 = _e419;
                let _e422 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_131), (&param_132), (&param_133));
                moments_3 = _e422.xy;
                chebyshev = 1f;
                let _e424 = distance_4;
                let _e426 = moments_3[0u];
                if (_e424 > _e426) {
                    let _e429 = moments_3[1u];
                    let _e431 = moments_3[0u];
                    let _e433 = moments_3[0u];
                    variance_1 = max((_e429 - (_e431 * _e433)), 0.000001f);
                    let _e437 = distance_4;
                    let _e439 = moments_3[0u];
                    difference = (_e437 - _e439);
                    let _e441 = variance_1;
                    let _e442 = variance_1;
                    let _e443 = difference;
                    let _e444 = difference;
                    chebyshev = (_e441 / (_e442 + (_e443 * _e444)));
                    let _e448 = chebyshev;
                    let _e449 = chebyshev;
                    let _e451 = chebyshev;
                    chebyshev = ((_e448 * _e449) * _e451);
                }
                let _e453 = probeWeight;
                let _e454 = chebyshev;
                probeWeight = max((_e453 * max(_e454, 0.05f)), 0.000001f);
                let _e458 = probeWeight;
                if (_e458 < 0.2f) {
                    let _e460 = probeWeight;
                    let _e461 = probeWeight;
                    let _e464 = probeWeight;
                    probeWeight = (_e464 * ((_e460 * _e461) * 25f));
                }
                let _e466 = probeWeight;
                let _e467 = weight_3;
                weight_3 = (_e467 * _e466);
            }
            let _e469 = unit;
            param_134 = _e469;
            let _e470 = ProbeOctahedral_u0028_vf3_u003b((&param_134));
            let _e471 = irradianceCorner;
            param_135 = _e471;
            let _e472 = irradianceTile;
            param_136 = _e472;
            param_137 = _e470;
            let _e473 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_135), (&param_136), (&param_137));
            let _e475 = weight_3;
            let _e477 = total_2;
            total_2 = (_e477 + (_e473.xyz * _e475));
            let _e479 = weight_3;
            let _e480 = weights;
            weights = (_e480 + _e479);
            continue;
        } else {
            break;
        }
        continuing {
            let _e482 = corner_1;
            corner_1 = (_e482 + 1i);
        }
    }
    let _e484 = weights;
    if (_e484 > 0f) {
        let _e486 = total_2;
        let _e487 = weights;
        local_41 = (_e486 / vec3(_e487));
    } else {
        local_41 = vec3<f32>(0f, 0f, 0f);
    }
    let _e490 = local_41;
    return _e490;
}

fn IrradianceEnabled_u0028_() -> bool {
    let _e213 = irradiance_info.origin[3u];
    return (_e213 > 0.5f);
}

fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var param_140: vec3<f32>;
    var param_141: Surface;
    var param_142: Surface;
    var param_143: Surface;

    let _e218 = IrradianceEnabled_u0028_();
    if _e218 {
        let _e219 = v_world_position_1;
        param_138 = _e219;
        let _e221 = (*s_12).n;
        param_139 = _e221;
        let _e223 = (*s_12).v;
        param_140 = _e223;
        let _e224 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_138), (&param_139), (&param_140));
        let _e227 = frag_info.material[2u];
        (*s_12).ambient = (_e224 * _e227);
    }
    let _e230 = (*s_12);
    param_141 = _e230;
    ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_141));
    let _e231 = param_141;
    (*s_12) = _e231;
    let _e232 = (*s_12);
    param_142 = _e232;
    ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_142));
    let _e233 = param_142;
    (*s_12) = _e233;
    let _e234 = (*s_12);
    param_143 = _e234;
    ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_143));
    let _e235 = param_143;
    (*s_12) = _e235;
    return;
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_42: vec3<f32>;

    let _e212 = Orthographic_u0028_();
    if _e212 {
        let _e214 = fog_info.forward;
        local_42 = -(_e214.xyz);
    } else {
        let _e218 = fog_info.eye;
        let _e220 = v_world_position_1;
        local_42 = normalize((_e218.xyz - _e220));
    }
    let _e223 = local_42;
    return _e223;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_6: vec4<f32>;
    var s_13: Surface;
    var param_144: vec3<f32>;
    var param_145: vec3<f32>;
    var cutoff: f32;
    var edge: f32;

    let _e217 = v_texcoord_1;
    let _e218 = MaterialLodBias_u0028_();
    let _e219 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e217, _e218);
    texel_6 = _e219;
    let _e220 = texel_6;
    param_144 = _e220.xyz;
    let _e222 = SrgbToLinear_u0028_vf3_u003b((&param_144));
    let _e224 = frag_info.base_color;
    param_145 = _e224.xyz;
    let _e226 = SrgbToLinear_u0028_vf3_u003b((&param_145));
    let _e228 = v_color_1;
    s_13.albedo = ((_e222 * _e226) * _e228.xyz);
    let _e233 = texel_6[3u];
    let _e236 = frag_info.base_color[3u];
    let _e239 = v_color_1[3u];
    s_13.alpha = ((_e233 * _e236) * _e239);
    let _e243 = s_13.albedo;
    g_albedo = _e243;
    let _e246 = frag_info.material2_[0u];
    cutoff = _e246;
    let _e247 = cutoff;
    if (_e247 > 1f) {
        let _e249 = cutoff;
        edge = (_e249 - 1f);
        let _e252 = s_13.alpha;
        let _e253 = edge;
        let _e256 = s_13.alpha;
        let _e257 = fwidth(_e256);
        s_13.alpha = clamp((((_e252 - _e253) / max(_e257, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e263 = cutoff;
        if (_e263 >= 0f) {
            s_13.alpha = 1f;
        }
    }
    let _e266 = cutoff;
    let _e268 = cutoff;
    g_premultiply = ((_e266 < 0f) && (_e268 > -0.75f));
    let _e271 = v_normal_1;
    s_13.n = normalize(_e271);
    let _e274 = gl_FrontFacing_1;
    if !(_e274) {
        let _e277 = s_13.n;
        s_13.n = -(_e277);
    }
    let _e280 = TowardsEye_u0028_();
    s_13.v = _e280;
    let _e283 = s_13.n;
    let _e285 = s_13.v;
    s_13.n_dot_v = max(dot(_e283, _e285), 0.0001f);
    let _e291 = frag_info.material[0u];
    s_13.metallic = clamp(_e291, 0f, 1f);
    let _e296 = frag_info.material[1u];
    s_13.roughness = clamp(_e296, 0.02f, 1f);
    let _e300 = frag_info.ambient_ground;
    let _e303 = frag_info.ambient_sky;
    let _e307 = s_13.n[1u];
    let _e314 = frag_info.material[2u];
    s_13.ambient = (mix(_e300.xyz, _e303.xyz, vec3(((_e307 * 0.5f) + 0.5f))) * _e314);
    let _e319 = frag_info.frame_params[0u];
    s_13.exposure = max(_e319, 0f);
    s_13.occlusion = 1f;
    s_13.emissive = vec3<f32>(0f, 0f, 0f);
    let _e324 = s_13;
    return _e324;
}

fn main_1() {
    var s_14: Surface;
    var param_146: Surface;
    var param_147: Surface;
    var rim: f32;
    var ambient: vec3<f32>;
    var param_148: Surface;
    var lit_3: vec3<f32>;
    var param_149: Surface;
    var param_150: Surface;
    var param_151: Surface;
    var param_152: vec3<f32>;
    var param_153: vec3<f32>;
    var param_154: f32;
    var param_155: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e225 = ReadSurface_u0028_();
    s_14 = _e225;
    let _e226 = s_14;
    param_146 = _e226;
    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((&param_146));
    let _e227 = param_146;
    s_14 = _e227;
    let _e228 = s_14;
    param_147 = _e228;
    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((&param_147));
    let _e229 = param_147;
    s_14 = _e229;
    let _e231 = s_14.n_dot_v;
    let _e236 = frag_info.material[3u];
    rim = (pow((1f - _e231), 3f) * _e236);
    let _e239 = s_14.albedo;
    let _e241 = s_14.ambient;
    let _e242 = SampleLightmap_u0028_();
    let _e245 = s_14;
    param_148 = _e245;
    let _e246 = IndirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_148));
    ambient = ((_e239 * (_e241 + _e242)) * _e246);
    let _e248 = s_14;
    param_149 = _e248;
    let _e249 = 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((&param_149));
    let _e250 = s_14;
    param_150 = _e250;
    let _e251 = DirectOcclusion_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_150));
    let _e253 = ambient;
    let _e255 = rim;
    let _e260 = s_14.emissive;
    lit_3 = ((((_e249 * _e251) + _e253) + vec3((_e255 * 0.35f))) + _e260);
    let _e262 = s_14;
    param_151 = _e262;
    let _e263 = lit_3;
    param_152 = _e263;
    let _e264 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_151), (&param_152));
    if _e264 {
        return;
    }
    let _e265 = lit_3;
    param_153 = _e265;
    let _e267 = s_14.alpha;
    param_154 = _e267;
    let _e269 = s_14.roughness;
    param_155 = _e269;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_153), (&param_154), (&param_155));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'IrradianceInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'spacing',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'counts',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 4,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'emissive_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'irradiance_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lightmap_texture',
          group: 1,
          textureBinding: 13,
          samplerBinding: 14,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'metallic_roughness_texture',
          group: 1,
          textureBinding: 15,
          samplerBinding: 16,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 17,
          samplerBinding: 18,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'occlusion_texture',
          group: 1,
          textureBinding: 19,
          samplerBinding: 20,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 21,
          samplerBinding: 22,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 23,
          samplerBinding: 24,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 25,
          samplerBinding: 26,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'DepthPredraw': WebGpuStage(
      wgsl: r'''
struct PredrawInfo {
    mask: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> predraw_info: PredrawInfo;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn FadePattern_u0028_() -> f32 {
    let _e38 = gl_FragCoord_1;
    return fract((52.982918f * fract(dot(_e38.xy, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin: vec3<f32>;
    var cell: vec3<f32>;
    var p3_: vec3<f32>;

    let _e44 = (*cutoff);
    key = (-2f - _e44);
    let _e46 = key;
    let _e49 = key;
    let _e51 = floor((_e49 / 128f));
    let _e56 = key;
    origin = vec3<f32>(floor((_e46 / 16384f)), (_e51 - (floor((_e51 / 128f)) * 128f)), (_e56 - (floor((_e56 / 128f)) * 128f)));
    let _e62 = (*scenePosition);
    let _e65 = origin;
    let _e66 = (floor((_e62 * 16f)) + _e65);
    let _e67 = vec3(128f);
    cell = (_e66 - (floor((_e66 / _e67)) * _e67));
    let _e72 = cell;
    p3_ = fract((_e72 * 0.1031f));
    let _e75 = p3_;
    let _e76 = p3_;
    let _e81 = p3_;
    p3_ = (_e81 + vec3(dot(_e75, (_e76.zyx + vec3(31.32f)))));
    let _e85 = p3_[0u];
    let _e87 = p3_[1u];
    let _e90 = p3_[2u];
    return fract(((_e85 + _e87) * _e90));
}

fn main_1() {
    var cutoff_1: f32;
    var alpha: f32;
    var alpha_1: f32;
    var param: vec3<f32>;
    var param_1: f32;
    var share: f32;
    var pattern: f32;
    var kept: bool;
    var local: bool;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e49 = predraw_info.mask[0u];
    cutoff_1 = _e49;
    let _e50 = cutoff_1;
    let _e52 = cutoff_1;
    if ((_e50 >= 0f) && (_e52 <= 1f)) {
        let _e55 = v_texcoord_1;
        let _e58 = predraw_info.mask[3u];
        let _e59 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e55, _e58);
        let _e63 = predraw_info.mask[1u];
        let _e66 = v_color_1[3u];
        alpha = ((_e59.w * _e63) * _e66);
        let _e68 = alpha;
        let _e69 = cutoff_1;
        if (_e68 < _e69) {
            discard;
        }
    } else {
        let _e71 = cutoff_1;
        if (_e71 < -1.5f) {
            let _e73 = v_texcoord_1;
            let _e76 = predraw_info.mask[3u];
            let _e77 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e73, _e76);
            let _e81 = predraw_info.mask[1u];
            let _e84 = v_color_1[3u];
            alpha_1 = ((_e77.w * _e81) * _e84);
            let _e86 = alpha_1;
            let _e87 = v_world_position_1;
            param = _e87;
            let _e88 = cutoff_1;
            param_1 = _e88;
            let _e89 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param), (&param_1));
            if (_e86 < _e89) {
                discard;
            }
        }
    }
    let _e93 = predraw_info.mask[2u];
    share = _e93;
    let _e94 = share;
    if (_e94 < 1f) {
        let _e96 = FadePattern_u0028_();
        pattern = _e96;
        let _e97 = share;
        if (_e97 >= 0f) {
            let _e99 = pattern;
            let _e100 = share;
            local = (_e99 < _e100);
        } else {
            let _e102 = pattern;
            let _e103 = share;
            local = (_e102 >= (1f + _e103));
        }
        let _e106 = local;
        kept = _e106;
        let _e107 = kept;
        if !(_e107) {
            discard;
        }
    }
    frag_color = vec4<f32>(0f, 0f, 0f, 0f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'PredrawInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Normals': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e45 = (*n)[0u];
    let _e48 = (*n)[1u];
    let _e52 = (*n)[2u];
    let _e55 = (*n);
    (*n) = (_e55 / vec3(((abs(_e45) + abs(_e48)) + abs(_e52))));
    let _e58 = (*n);
    e = _e58.xy;
    let _e61 = (*n)[2u];
    if (_e61 < 0f) {
        let _e63 = (*n);
        let _e69 = (*n)[0u];
        let _e73 = (*n)[1u];
        e = ((vec2(1f) - abs(_e63.yx)) * vec2<f32>(select(-1f, 1f, (_e69 >= 0f)), select(-1f, 1f, (_e73 >= 0f))));
    }
    let _e78 = e;
    return ((_e78 * 0.5f) + vec2(0.5f));
}

fn ViewDepth_u0028_() -> f32 {
    let _e42 = v_world_position_1;
    let _e44 = fog_info.eye;
    let _e48 = fog_info.forward;
    return dot((_e42 - _e44.xyz), _e48.xyz);
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e43 = (*linear);
    let _e45 = (*linear);
    let _e49 = (*linear);
    return mix((_e43 * 12.92f), ((pow(_e45, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e49));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param: vec3<f32>;
    var geometric: vec3<f32>;
    var param_1: vec3<f32>;

    let _e46 = g_albedo;
    param = clamp(_e46, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e48 = LinearToSrgb_u0028_vf3_u003b((&param));
    frag_albedo = vec4<f32>(_e48.x, _e48.y, _e48.z, 1f);
    let _e53 = g_debug_surface_on;
    if _e53 {
        let _e54 = g_debug_surface;
        let _e55 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e54.x, _e54.y, _e54.z, _e55);
        return;
    }
    let _e60 = v_normal_1;
    geometric = normalize(_e60);
    let _e62 = gl_FrontFacing_1;
    if !(_e62) {
        let _e64 = geometric;
        geometric = -(_e64);
    }
    let _e66 = geometric;
    param_1 = _e66;
    let _e67 = EncodeOctahedral_u0028_vf3_u003b((&param_1));
    let _e68 = (*roughness);
    let _e70 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e67.x, _e67.y, clamp(_e68, 0f, 1f), _e70);
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e43 = (*srgb);
    let _e46 = (*srgb);
    let _e51 = (*srgb);
    return mix((_e43 / vec3(12.92f)), pow(((_e46 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e51));
}

fn WriteDisplayColor_u0028_vf3_u003b_f1_u003b(displayColor: ptr<function, vec3<f32>>, alpha: ptr<function, f32>) {
    var param_2: vec3<f32>;
    var param_3: f32;

    let _e46 = (*displayColor);
    param_2 = _e46;
    let _e47 = SrgbToLinear_u0028_vf3_u003b((&param_2));
    let _e48 = (*alpha);
    frag_color = vec4<f32>(_e47.x, _e47.y, _e47.z, _e48);
    param_3 = 1f;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_3));
    return;
}

fn main_1() {
    var n_1: vec3<f32>;
    var param_4: vec3<f32>;
    var param_5: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e45 = v_normal_1;
    n_1 = normalize(_e45);
    let _e47 = n_1;
    param_4 = ((_e47 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
    param_5 = 1f;
    WriteDisplayColor_u0028_vf3_u003b_f1_u003b((&param_4), (&param_5));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    v_texcoord_1 = v_texcoord;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e17 = frag_albedo;
    let _e18 = frag_surface;
    let _e19 = frag_color;
    return FragmentOutput(_e17, _e18, _e19);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'DebugLine': WebGpuStage(
      wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_line_color_1: vec4<f32>;

fn main_1() {
    let _e2 = v_line_color_1;
    frag_color = _e2;
    return;
}

@fragment
fn main(@location(0) v_line_color: vec4<f32>) -> @location(0) vec4<f32> {
    v_line_color_1 = v_line_color;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'BloomThreshold': WebGpuStage(
      wgsl: r'''
struct BloomInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn Luminance_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
    let _e24 = (*color);
    return dot(_e24, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn main_1() {
    var texel: vec2<f32>;
    var s0_: vec3<f32>;
    var s1_: vec3<f32>;
    var s2_: vec3<f32>;
    var s3_: vec3<f32>;
    var w0_: f32;
    var param: vec3<f32>;
    var w1_: f32;
    var param_1: vec3<f32>;
    var w2_: f32;
    var param_2: vec3<f32>;
    var w3_: f32;
    var param_3: vec3<f32>;
    var color_1: vec3<f32>;
    var threshold: f32;
    var knee: f32;
    var brightness: f32;
    var param_4: vec3<f32>;
    var soft: f32;
    var contribution: f32;

    let _e44 = bloom_info.params;
    texel = _e44.xy;
    let _e46 = v_uv_1;
    let _e47 = texel;
    let _e50 = textureSample(source_texture_tex, source_texture_smp, (_e46 + (_e47 * vec2<f32>(-0.5f, -0.5f))));
    s0_ = _e50.xyz;
    let _e52 = v_uv_1;
    let _e53 = texel;
    let _e56 = textureSample(source_texture_tex, source_texture_smp, (_e52 + (_e53 * vec2<f32>(0.5f, -0.5f))));
    s1_ = _e56.xyz;
    let _e58 = v_uv_1;
    let _e59 = texel;
    let _e62 = textureSample(source_texture_tex, source_texture_smp, (_e58 + (_e59 * vec2<f32>(-0.5f, 0.5f))));
    s2_ = _e62.xyz;
    let _e64 = v_uv_1;
    let _e65 = texel;
    let _e68 = textureSample(source_texture_tex, source_texture_smp, (_e64 + (_e65 * vec2<f32>(0.5f, 0.5f))));
    s3_ = _e68.xyz;
    let _e70 = s0_;
    param = _e70;
    let _e71 = Luminance_u0028_vf3_u003b((&param));
    w0_ = (1f / (1f + _e71));
    let _e74 = s1_;
    param_1 = _e74;
    let _e75 = Luminance_u0028_vf3_u003b((&param_1));
    w1_ = (1f / (1f + _e75));
    let _e78 = s2_;
    param_2 = _e78;
    let _e79 = Luminance_u0028_vf3_u003b((&param_2));
    w2_ = (1f / (1f + _e79));
    let _e82 = s3_;
    param_3 = _e82;
    let _e83 = Luminance_u0028_vf3_u003b((&param_3));
    w3_ = (1f / (1f + _e83));
    let _e86 = s0_;
    let _e87 = w0_;
    let _e89 = s1_;
    let _e90 = w1_;
    let _e93 = s2_;
    let _e94 = w2_;
    let _e97 = s3_;
    let _e98 = w3_;
    let _e101 = w0_;
    let _e102 = w1_;
    let _e104 = w2_;
    let _e106 = w3_;
    color_1 = (((((_e86 * _e87) + (_e89 * _e90)) + (_e93 * _e94)) + (_e97 * _e98)) / vec3((((_e101 + _e102) + _e104) + _e106)));
    let _e112 = bloom_info.params[2u];
    threshold = _e112;
    let _e115 = bloom_info.params[3u];
    knee = max(_e115, 0.0001f);
    let _e117 = color_1;
    param_4 = _e117;
    let _e118 = Luminance_u0028_vf3_u003b((&param_4));
    brightness = _e118;
    let _e119 = brightness;
    let _e120 = threshold;
    let _e122 = knee;
    let _e124 = knee;
    soft = clamp(((_e119 - _e120) + _e122), 0f, (2f * _e124));
    let _e127 = soft;
    let _e128 = soft;
    let _e130 = knee;
    soft = ((_e127 * _e128) / (4f * _e130));
    let _e133 = soft;
    let _e134 = brightness;
    let _e135 = threshold;
    let _e138 = brightness;
    contribution = (max(_e133, (_e134 - _e135)) / max(_e138, 0.0001f));
    let _e141 = color_1;
    let _e142 = contribution;
    let _e143 = (_e141 * _e142);
    frag_color = vec4<f32>(_e143.x, _e143.y, _e143.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'BloomInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'BloomDownsample': WebGpuStage(
      wgsl: r'''
struct BloomInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var t: vec2<f32>;
    var a: vec3<f32>;
    var b: vec3<f32>;
    var c: vec3<f32>;
    var d: vec3<f32>;
    var e: vec3<f32>;
    var f: vec3<f32>;
    var g: vec3<f32>;
    var h: vec3<f32>;
    var i: vec3<f32>;
    var j: vec3<f32>;
    var k: vec3<f32>;
    var l: vec3<f32>;
    var m: vec3<f32>;
    var result: vec3<f32>;

    let _e42 = bloom_info.params;
    t = _e42.xy;
    let _e44 = v_uv_1;
    let _e45 = t;
    let _e48 = textureSample(source_texture_tex, source_texture_smp, (_e44 + (vec2<f32>(-2f, 2f) * _e45)));
    a = _e48.xyz;
    let _e50 = v_uv_1;
    let _e51 = t;
    let _e54 = textureSample(source_texture_tex, source_texture_smp, (_e50 + (vec2<f32>(0f, 2f) * _e51)));
    b = _e54.xyz;
    let _e56 = v_uv_1;
    let _e57 = t;
    let _e60 = textureSample(source_texture_tex, source_texture_smp, (_e56 + (vec2<f32>(2f, 2f) * _e57)));
    c = _e60.xyz;
    let _e62 = v_uv_1;
    let _e63 = t;
    let _e66 = textureSample(source_texture_tex, source_texture_smp, (_e62 + (vec2<f32>(-2f, 0f) * _e63)));
    d = _e66.xyz;
    let _e68 = v_uv_1;
    let _e69 = textureSample(source_texture_tex, source_texture_smp, _e68);
    e = _e69.xyz;
    let _e71 = v_uv_1;
    let _e72 = t;
    let _e75 = textureSample(source_texture_tex, source_texture_smp, (_e71 + (vec2<f32>(2f, 0f) * _e72)));
    f = _e75.xyz;
    let _e77 = v_uv_1;
    let _e78 = t;
    let _e81 = textureSample(source_texture_tex, source_texture_smp, (_e77 + (vec2<f32>(-2f, -2f) * _e78)));
    g = _e81.xyz;
    let _e83 = v_uv_1;
    let _e84 = t;
    let _e87 = textureSample(source_texture_tex, source_texture_smp, (_e83 + (vec2<f32>(0f, -2f) * _e84)));
    h = _e87.xyz;
    let _e89 = v_uv_1;
    let _e90 = t;
    let _e93 = textureSample(source_texture_tex, source_texture_smp, (_e89 + (vec2<f32>(2f, -2f) * _e90)));
    i = _e93.xyz;
    let _e95 = v_uv_1;
    let _e96 = t;
    let _e99 = textureSample(source_texture_tex, source_texture_smp, (_e95 + (vec2<f32>(-1f, 1f) * _e96)));
    j = _e99.xyz;
    let _e101 = v_uv_1;
    let _e102 = t;
    let _e105 = textureSample(source_texture_tex, source_texture_smp, (_e101 + (vec2<f32>(1f, 1f) * _e102)));
    k = _e105.xyz;
    let _e107 = v_uv_1;
    let _e108 = t;
    let _e111 = textureSample(source_texture_tex, source_texture_smp, (_e107 + (vec2<f32>(-1f, -1f) * _e108)));
    l = _e111.xyz;
    let _e113 = v_uv_1;
    let _e114 = t;
    let _e117 = textureSample(source_texture_tex, source_texture_smp, (_e113 + (vec2<f32>(1f, -1f) * _e114)));
    m = _e117.xyz;
    let _e119 = j;
    let _e120 = k;
    let _e122 = l;
    let _e124 = m;
    result = (((((_e119 + _e120) + _e122) + _e124) * 0.5f) * 0.25f);
    let _e128 = a;
    let _e129 = b;
    let _e131 = d;
    let _e133 = e;
    let _e137 = result;
    result = (_e137 + (((((_e128 + _e129) + _e131) + _e133) * 0.125f) * 0.25f));
    let _e139 = b;
    let _e140 = c;
    let _e142 = e;
    let _e144 = f;
    let _e148 = result;
    result = (_e148 + (((((_e139 + _e140) + _e142) + _e144) * 0.125f) * 0.25f));
    let _e150 = d;
    let _e151 = e;
    let _e153 = g;
    let _e155 = h;
    let _e159 = result;
    result = (_e159 + (((((_e150 + _e151) + _e153) + _e155) * 0.125f) * 0.25f));
    let _e161 = e;
    let _e162 = f;
    let _e164 = h;
    let _e166 = i;
    let _e170 = result;
    result = (_e170 + (((((_e161 + _e162) + _e164) + _e166) * 0.125f) * 0.25f));
    let _e172 = result;
    frag_color = vec4<f32>(_e172.x, _e172.y, _e172.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'BloomInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'BloomUpsample': WebGpuStage(
      wgsl: r'''
struct BloomInfo {
    params: vec4<f32>,
    tint: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> bloom_info: BloomInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var t: vec2<f32>;
    var a: vec3<f32>;
    var b: vec3<f32>;
    var c: vec3<f32>;
    var d: vec3<f32>;
    var e: vec3<f32>;
    var f: vec3<f32>;
    var g: vec3<f32>;
    var h: vec3<f32>;
    var i: vec3<f32>;
    var result: vec3<f32>;

    let _e34 = bloom_info.params;
    let _e38 = bloom_info.params[2u];
    t = (_e34.xy * max(_e38, 0f));
    let _e41 = v_uv_1;
    let _e42 = t;
    let _e45 = textureSample(source_texture_tex, source_texture_smp, (_e41 + (vec2<f32>(-1f, 1f) * _e42)));
    a = _e45.xyz;
    let _e47 = v_uv_1;
    let _e48 = t;
    let _e51 = textureSample(source_texture_tex, source_texture_smp, (_e47 + (vec2<f32>(0f, 1f) * _e48)));
    b = _e51.xyz;
    let _e53 = v_uv_1;
    let _e54 = t;
    let _e57 = textureSample(source_texture_tex, source_texture_smp, (_e53 + (vec2<f32>(1f, 1f) * _e54)));
    c = _e57.xyz;
    let _e59 = v_uv_1;
    let _e60 = t;
    let _e63 = textureSample(source_texture_tex, source_texture_smp, (_e59 + (vec2<f32>(-1f, 0f) * _e60)));
    d = _e63.xyz;
    let _e65 = v_uv_1;
    let _e66 = textureSample(source_texture_tex, source_texture_smp, _e65);
    e = _e66.xyz;
    let _e68 = v_uv_1;
    let _e69 = t;
    let _e72 = textureSample(source_texture_tex, source_texture_smp, (_e68 + (vec2<f32>(1f, 0f) * _e69)));
    f = _e72.xyz;
    let _e74 = v_uv_1;
    let _e75 = t;
    let _e78 = textureSample(source_texture_tex, source_texture_smp, (_e74 + (vec2<f32>(-1f, -1f) * _e75)));
    g = _e78.xyz;
    let _e80 = v_uv_1;
    let _e81 = t;
    let _e84 = textureSample(source_texture_tex, source_texture_smp, (_e80 + (vec2<f32>(0f, -1f) * _e81)));
    h = _e84.xyz;
    let _e86 = v_uv_1;
    let _e87 = t;
    let _e90 = textureSample(source_texture_tex, source_texture_smp, (_e86 + (vec2<f32>(1f, -1f) * _e87)));
    i = _e90.xyz;
    let _e92 = e;
    let _e94 = b;
    let _e95 = d;
    let _e97 = f;
    let _e99 = h;
    let _e103 = a;
    let _e104 = c;
    let _e106 = g;
    let _e108 = i;
    result = (((_e92 * 4f) + ((((_e94 + _e95) + _e97) + _e99) * 2f)) + (((_e103 + _e104) + _e106) + _e108));
    let _e111 = result;
    result = (_e111 * 0.0625f);
    let _e114 = bloom_info.tint;
    let _e116 = result;
    result = (_e116 * _e114.xyz);
    let _e118 = result;
    frag_color = vec4<f32>(_e118.x, _e118.y, _e118.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'BloomInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'tint', offsetInBytes: 16, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Composite': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct CompositeInfo {
    params: vec4<f32>,
    ao_texel: vec4<f32>,
    look: vec4<f32>,
    look_more: vec4<f32>,
    output_encode: vec4<f32>,
    lift: vec4<f32>,
    gamma: vec4<f32>,
    gain: vec4<f32>,
    contact: vec4<f32>,
    lens: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(0)
var<uniform> composite_info: CompositeInfo;
@group(1) @binding(12)
var lut_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var lut_texture_smp: sampler;
@group(1) @binding(8)
var display_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var display_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(14)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var scene_texture_smp: sampler;
@group(1) @binding(4)
var bloom_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var bloom_texture_smp: sampler;
@group(1) @binding(2)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var ao_texture_smp: sampler;
@group(1) @binding(6)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var contact_shadow_texture_smp: sampler;
@group(1) @binding(10)
var local_exposure_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var local_exposure_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e151 = (*at)[0u];
    x = i32((_e151 - (floor((_e151 / 4f)) * 4f)));
    let _e158 = (*at)[1u];
    y = i32((_e158 - (floor((_e158 / 4f)) * 4f)));
    let _e164 = y;
    let _e166 = x;
    index = ((_e164 * 4i) + _e166);
    value = 0f;
    let _e168 = index;
    if (_e168 == 0i) {
        value = 0f;
    } else {
        let _e170 = index;
        if (_e170 == 1i) {
            value = 8f;
        } else {
            let _e172 = index;
            if (_e172 == 2i) {
                value = 2f;
            } else {
                let _e174 = index;
                if (_e174 == 3i) {
                    value = 10f;
                } else {
                    let _e176 = index;
                    if (_e176 == 4i) {
                        value = 12f;
                    } else {
                        let _e178 = index;
                        if (_e178 == 5i) {
                            value = 4f;
                        } else {
                            let _e180 = index;
                            if (_e180 == 6i) {
                                value = 14f;
                            } else {
                                let _e182 = index;
                                if (_e182 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e184 = index;
                                    if (_e184 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e186 = index;
                                        if (_e186 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e188 = index;
                                            if (_e188 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e190 = index;
                                                if (_e190 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e192 = index;
                                                    if (_e192 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e194 = index;
                                                        if (_e194 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e196 = index;
                                                            if (_e196 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e198 = value;
    return ((_e198 / 16f) - 0.5f);
}

fn Hash_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
    let _e146 = (*at_1);
    return fract((sin(dot(_e146, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e147 = (*rows);
    if (_e147 > 0f) {
        let _e150 = gl_FragCoord_1[0u];
        let _e151 = (*rows);
        let _e153 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e150, (_e151 - _e153));
    } else {
        let _e156 = gl_FragCoord_1;
        local = _e156.xy;
    }
    let _e158 = local;
    return _e158;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param: f32;

    let _e148 = frag_coord_info.origin[0u];
    param = _e148;
    let _e149 = FragCoordFromTop_u0028_f1_u003b((&param));
    return _e149;
}

fn SrgbToLinear_u0028_vf3_u003b(encoded: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e146 = (*encoded);
    let _e149 = (*encoded);
    let _e155 = (*encoded);
    return mix((_e146 / vec3(12.92f)), pow(((max(_e149, vec3<f32>(0f, 0f, 0f)) + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e155));
}

fn SampleLut_u0028_vf3_u003b_f1_u003b(color: ptr<function, vec3<f32>>, size: ptr<function, f32>) -> vec3<f32> {
    var c: vec3<f32>;
    var sliceWidth: f32;
    var texel: f32;
    var innerWidth: f32;
    var u: f32;
    var v: f32;
    var slice: f32;
    var lower: f32;
    var upper: f32;
    var a: vec3<f32>;
    var b: vec3<f32>;

    let _e158 = (*color);
    c = clamp(_e158, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e160 = (*size);
    sliceWidth = (1f / _e160);
    let _e162 = (*size);
    let _e163 = (*size);
    texel = (1f / (_e162 * _e163));
    let _e166 = texel;
    let _e167 = (*size);
    innerWidth = (_e166 * (_e167 - 1f));
    let _e170 = texel;
    let _e173 = c[0u];
    let _e174 = innerWidth;
    u = ((_e170 * 0.5f) + (_e173 * _e174));
    let _e177 = (*size);
    let _e180 = c[1u];
    let _e181 = (*size);
    let _e183 = (*size);
    v = ((0.5f / _e177) + (_e180 * ((_e181 - 1f) / _e183)));
    let _e188 = c[2u];
    let _e189 = (*size);
    slice = (_e188 * (_e189 - 1f));
    let _e192 = slice;
    lower = floor(_e192);
    let _e194 = lower;
    let _e196 = (*size);
    upper = min((_e194 + 1f), (_e196 - 1f));
    let _e199 = lower;
    let _e200 = sliceWidth;
    let _e202 = u;
    let _e204 = v;
    let _e206 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e199 * _e200) + _e202), _e204));
    a = _e206.xyz;
    let _e208 = upper;
    let _e209 = sliceWidth;
    let _e211 = u;
    let _e213 = v;
    let _e215 = textureSample(lut_texture_tex, lut_texture_smp, vec2<f32>(((_e208 * _e209) + _e211), _e213));
    b = _e215.xyz;
    let _e217 = a;
    let _e218 = b;
    let _e219 = slice;
    let _e220 = lower;
    return mix(_e217, _e218, vec3((_e219 - _e220)));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e146 = (*linear);
    let _e148 = (*linear);
    let _e153 = (*linear);
    return mix((_e146 * 12.92f), ((pow(max(_e148, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e153));
}

fn Luma_u0028_vf3_u003b(color_1: ptr<function, vec3<f32>>) -> f32 {
    let _e146 = (*color_1);
    return dot(_e146, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn AgxSigmoid_u0028_vf3_u003b(color_2: ptr<function, vec3<f32>>) -> vec3<f32> {
    var v_1: vec3<f32>;
    var v2_: vec3<f32>;
    var v4_: vec3<f32>;

    let _e149 = (*color_2);
    v_1 = clamp(log2(max(_e149, vec3<f32>(0.0000000001f, 0.0000000001f, 0.0000000001f))), vec3<f32>(-12.47393f, -12.47393f, -12.47393f), vec3<f32>(4.026069f, 4.026069f, 4.026069f));
    let _e153 = v_1;
    v_1 = ((_e153 - vec3<f32>(-12.47393f, -12.47393f, -12.47393f)) / vec3(16.499998f));
    let _e157 = v_1;
    let _e158 = v_1;
    v2_ = (_e157 * _e158);
    let _e160 = v2_;
    let _e161 = v2_;
    v4_ = (_e160 * _e161);
    let _e163 = v4_;
    let _e165 = v2_;
    let _e167 = v4_;
    let _e169 = v_1;
    let _e172 = v4_;
    let _e175 = v2_;
    let _e177 = v_1;
    let _e180 = v2_;
    let _e183 = v_1;
    v_1 = ((((((((_e163 * 15.5f) * _e165) - ((_e167 * 40.14f) * _e169)) + (_e172 * 31.96f)) - ((_e175 * 6.868f) * _e177)) + (_e180 * 0.4298f)) + (_e183 * 0.1191f)) - vec3(0.00232f));
    let _e188 = v_1;
    return clamp(_e188, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}

fn TonemapAgx_u0028_vf3_u003b(color_3: ptr<function, vec3<f32>>) -> vec3<f32> {
    var v_2: vec3<f32>;
    var param_1: vec3<f32>;

    let _e148 = (*color_3);
    param_1 = (mat3x3<f32>(vec3<f32>(0.84247905f, 0.042328242f, 0.042375654f), vec3<f32>(0.0784336f, 0.87846863f, 0.0784336f), vec3<f32>(0.079223745f, 0.07916613f, 0.879143f)) * max(_e148, vec3<f32>(0f, 0f, 0f)));
    let _e151 = AgxSigmoid_u0028_vf3_u003b((&param_1));
    v_2 = _e151;
    let _e152 = v_2;
    v_2 = (mat3x3<f32>(vec3<f32>(1.196879f, -0.052896854f, -0.052971635f), vec3<f32>(-0.09802088f, 1.1519032f, -0.09804345f), vec3<f32>(-0.09902974f, -0.098961174f, 1.1510737f)) * _e152);
    let _e154 = v_2;
    return clamp(pow(max(_e154, vec3<f32>(0f, 0f, 0f)), vec3<f32>(2.2f, 2.2f, 2.2f)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}

fn TonemapAgxFull_u0028_vf3_u003b(color_4: ptr<function, vec3<f32>>) -> vec3<f32> {
    var param_2: vec3<f32>;

    let _e147 = (*color_4);
    param_2 = _e147;
    let _e148 = TonemapAgx_u0028_vf3_u003b((&param_2));
    return _e148;
}

fn TonemapReinhard_u0028_vf3_u003b(color_5: ptr<function, vec3<f32>>) -> vec3<f32> {
    var numerator: vec3<f32>;

    let _e147 = (*color_5);
    let _e148 = (*color_5);
    numerator = (_e147 * (vec3<f32>(1f, 1f, 1f) + (_e148 / vec3<f32>(16f, 16f, 16f))));
    let _e152 = numerator;
    let _e153 = (*color_5);
    return clamp((_e152 / (vec3<f32>(1f, 1f, 1f) + _e153)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}

fn TonemapAces_u0028_vf3_u003b(color_6: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e146 = (*color_6);
    let _e147 = (*color_6);
    let _e152 = (*color_6);
    let _e153 = (*color_6);
    return clamp(((_e146 * ((_e147 * 2.51f) + vec3(0.03f))) / ((_e152 * ((_e153 * 2.43f) + vec3(0.59f))) + vec3(0.14f))), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
}

fn TonemapNeutral_u0028_vf3_u003b(color_7: ptr<function, vec3<f32>>) -> vec3<f32> {
    var minChannel: f32;
    var offset: f32;
    var local_1: f32;
    var peak: f32;
    var newPeak: f32;
    var desaturate: f32;

    let _e153 = (*color_7)[0u];
    let _e155 = (*color_7)[1u];
    let _e157 = (*color_7)[2u];
    minChannel = min(_e153, min(_e155, _e157));
    let _e160 = minChannel;
    if (_e160 < 0.08f) {
        let _e162 = minChannel;
        let _e163 = minChannel;
        let _e165 = minChannel;
        local_1 = (_e162 - ((6.25f * _e163) * _e165));
    } else {
        local_1 = 0.04f;
    }
    let _e168 = local_1;
    offset = _e168;
    let _e169 = offset;
    let _e170 = (*color_7);
    (*color_7) = (_e170 - vec3(_e169));
    let _e174 = (*color_7)[0u];
    let _e176 = (*color_7)[1u];
    let _e178 = (*color_7)[2u];
    peak = max(_e174, max(_e176, _e178));
    let _e181 = peak;
    if (_e181 < 0.76f) {
        let _e183 = (*color_7);
        return _e183;
    }
    let _e184 = peak;
    newPeak = (1f - (0.0576f / ((_e184 + 0.24f) - 0.76f)));
    let _e189 = newPeak;
    let _e190 = peak;
    let _e192 = (*color_7);
    (*color_7) = (_e192 * (_e189 / _e190));
    let _e194 = peak;
    let _e195 = newPeak;
    desaturate = (1f - (1f / ((0.15f * (_e194 - _e195)) + 1f)));
    let _e201 = (*color_7);
    let _e202 = newPeak;
    let _e204 = desaturate;
    return mix(_e201, vec3(_e202), vec3(_e204));
}

fn SampleDisplay_u0028_vf3_u003b(color_8: ptr<function, vec3<f32>>) -> vec3<f32> {
    var size_1: f32;
    var c_1: vec3<f32>;
    var sliceWidth_1: f32;
    var texel_1: f32;
    var innerWidth_1: f32;
    var u_1: f32;
    var v_3: f32;
    var slice_1: f32;
    var lower_1: f32;
    var upper_1: f32;
    var a_1: vec3<f32>;
    var b_1: vec3<f32>;

    let _e160 = composite_info.contact[1u];
    size_1 = max(_e160, 2f);
    let _e162 = (*color_8);
    c_1 = clamp(((log2((max(_e162, vec3<f32>(0.0000000001f, 0.0000000001f, 0.0000000001f)) / vec3(0.18f))) + vec3(10f)) / vec3(20f)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e172 = size_1;
    sliceWidth_1 = (1f / _e172);
    let _e174 = size_1;
    let _e175 = size_1;
    texel_1 = (1f / (_e174 * _e175));
    let _e178 = texel_1;
    let _e179 = size_1;
    innerWidth_1 = (_e178 * (_e179 - 1f));
    let _e182 = texel_1;
    let _e185 = c_1[0u];
    let _e186 = innerWidth_1;
    u_1 = ((_e182 * 0.5f) + (_e185 * _e186));
    let _e189 = size_1;
    let _e192 = c_1[1u];
    let _e193 = size_1;
    let _e195 = size_1;
    v_3 = ((0.5f / _e189) + (_e192 * ((_e193 - 1f) / _e195)));
    let _e200 = c_1[2u];
    let _e201 = size_1;
    slice_1 = (_e200 * (_e201 - 1f));
    let _e204 = slice_1;
    lower_1 = floor(_e204);
    let _e206 = lower_1;
    let _e208 = size_1;
    upper_1 = min((_e206 + 1f), (_e208 - 1f));
    let _e211 = lower_1;
    let _e212 = sliceWidth_1;
    let _e214 = u_1;
    let _e216 = v_3;
    let _e218 = textureSample(display_texture_tex, display_texture_smp, vec2<f32>(((_e211 * _e212) + _e214), _e216));
    a_1 = _e218.xyz;
    let _e220 = upper_1;
    let _e221 = sliceWidth_1;
    let _e223 = u_1;
    let _e225 = v_3;
    let _e227 = textureSample(display_texture_tex, display_texture_smp, vec2<f32>(((_e220 * _e221) + _e223), _e225));
    b_1 = _e227.xyz;
    let _e229 = a_1;
    let _e230 = b_1;
    let _e231 = slice_1;
    let _e232 = lower_1;
    return mix(_e229, _e230, vec3((_e231 - _e232)));
}

fn TonemapBy_u0028_vf3_u003b_i1_u003b(color_9: ptr<function, vec3<f32>>, curve: ptr<function, i32>) -> vec3<f32> {
    var param_3: vec3<f32>;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;

    let _e153 = (*curve);
    if (_e153 == 6i) {
        let _e155 = (*color_9);
        param_3 = _e155;
        let _e156 = SampleDisplay_u0028_vf3_u003b((&param_3));
        return _e156;
    }
    let _e157 = (*curve);
    if (_e157 == 1i) {
        let _e159 = (*color_9);
        param_4 = _e159;
        let _e160 = TonemapNeutral_u0028_vf3_u003b((&param_4));
        return _e160;
    }
    let _e161 = (*curve);
    if (_e161 == 2i) {
        let _e163 = (*color_9);
        param_5 = _e163;
        let _e164 = TonemapAces_u0028_vf3_u003b((&param_5));
        return _e164;
    }
    let _e165 = (*curve);
    if (_e165 == 3i) {
        let _e167 = (*color_9);
        param_6 = _e167;
        let _e168 = TonemapAgx_u0028_vf3_u003b((&param_6));
        return _e168;
    }
    let _e169 = (*curve);
    if (_e169 == 4i) {
        let _e171 = (*color_9);
        param_7 = _e171;
        let _e172 = TonemapReinhard_u0028_vf3_u003b((&param_7));
        return _e172;
    }
    let _e173 = (*curve);
    if (_e173 == 5i) {
        let _e175 = (*color_9);
        param_8 = _e175;
        let _e176 = TonemapAgxFull_u0028_vf3_u003b((&param_8));
        return _e176;
    }
    let _e177 = (*color_9);
    return _e177;
}

fn Distort_u0028_vf2_u003b_f1_u003b(at_2: ptr<function, vec2<f32>>, k: ptr<function, f32>) -> vec2<f32> {
    var aspect: f32;
    var fromCentre: vec2<f32>;
    var onFrame: vec2<f32>;
    var r2_: f32;
    var border: f32;
    var local_2: f32;

    let _e155 = composite_info.look_more[3u];
    aspect = max(_e155, 0.0001f);
    let _e157 = (*at_2);
    fromCentre = (_e157 - vec2<f32>(0.5f, 0.5f));
    let _e159 = fromCentre;
    let _e160 = aspect;
    onFrame = (_e159 * vec2<f32>(_e160, 1f));
    let _e163 = onFrame;
    let _e164 = onFrame;
    r2_ = dot(_e163, _e164);
    let _e166 = (*k);
    if (_e166 > 0f) {
        let _e168 = aspect;
        let _e169 = aspect;
        local_2 = (0.25f * ((_e168 * _e169) + 1f));
    } else {
        let _e173 = aspect;
        let _e174 = aspect;
        local_2 = (0.25f * min((_e173 * _e174), 1f));
    }
    let _e178 = local_2;
    border = _e178;
    let _e179 = fromCentre;
    let _e180 = (*k);
    let _e181 = r2_;
    let _e185 = (*k);
    let _e186 = border;
    return (vec2<f32>(0.5f, 0.5f) + ((_e179 * (1f + (_e180 * _e181))) / vec2((1f + (_e185 * _e186)))));
}

fn main_1() {
    var distortion: f32;
    var uv: vec2<f32>;
    var local_3: vec2<f32>;
    var param_9: vec2<f32>;
    var param_10: f32;
    var dispersion: f32;
    var fromCentre_1: vec2<f32>;
    var step_uv: vec2<f32>;
    var scene: vec4<f32>;
    var bloom: vec3<f32>;
    var half_texel: vec2<f32>;
    var occlusion: vec4<f32>;
    var ao: f32;
    var contact: f32;
    var localStops: f32;
    var exposed: vec3<f32>;
    var color_10: vec3<f32>;
    var param_11: vec3<f32>;
    var param_12: i32;
    var contrast: f32;
    var saturation: f32;
    var temperature: f32;
    var param_13: vec3<f32>;
    var lift: vec3<f32>;
    var gammaCurve: vec3<f32>;
    var gain: vec3<f32>;
    var balance: f32;
    var tint: f32;
    var lutStrength: f32;
    var encodedIn: vec3<f32>;
    var param_14: vec3<f32>;
    var graded: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: f32;
    var param_17: vec3<f32>;
    var vignette: f32;
    var fromCentre_2: vec2<f32>;
    var aspect_1: f32;
    var radius: f32;
    var encoded_1: vec3<f32>;
    var param_18: vec3<f32>;
    var grain: f32;
    var param_19: vec2<f32>;
    var dither: f32;
    var param_20: vec2<f32>;
    var sides: f32;
    var right_of_wipe: bool;
    var shows_channel: bool;
    var raw: vec4<f32>;
    var param_21: vec3<f32>;
    var phi_1289_: bool;
    var phi_1300_: bool;

    let _e197 = composite_info.lens[0u];
    distortion = _e197;
    let _e198 = distortion;
    if (_e198 != 0f) {
        let _e200 = v_uv_1;
        param_9 = _e200;
        let _e201 = distortion;
        param_10 = _e201;
        let _e202 = Distort_u0028_vf2_u003b_f1_u003b((&param_9), (&param_10));
        local_3 = _e202;
    } else {
        let _e203 = v_uv_1;
        local_3 = _e203;
    }
    let _e204 = local_3;
    uv = _e204;
    let _e207 = composite_info.look[3u];
    dispersion = _e207;
    let _e208 = dispersion;
    if (_e208 > 0f) {
        let _e210 = uv;
        fromCentre_1 = (_e210 - vec2<f32>(0.5f, 0.5f));
        let _e212 = fromCentre_1;
        let _e213 = dispersion;
        step_uv = (_e212 * _e213);
        let _e215 = uv;
        let _e216 = textureSample(scene_texture_tex, scene_texture_smp, _e215);
        scene = _e216;
        let _e217 = uv;
        let _e218 = step_uv;
        let _e220 = textureSample(scene_texture_tex, scene_texture_smp, (_e217 + _e218));
        scene[0u] = _e220.x;
        let _e223 = uv;
        let _e224 = step_uv;
        let _e226 = textureSample(scene_texture_tex, scene_texture_smp, (_e223 - _e224));
        scene[2u] = _e226.z;
    } else {
        let _e229 = uv;
        let _e230 = textureSample(scene_texture_tex, scene_texture_smp, _e229);
        scene = _e230;
    }
    let _e233 = composite_info.lens[3u];
    if (_e233 > 0.5f) {
        let _e235 = scene;
        let _e236 = _e235.xxx;
        scene = vec4<f32>(_e236.x, _e236.y, _e236.z, 1f);
    }
    let _e241 = uv;
    let _e242 = textureSample(bloom_texture_tex, bloom_texture_smp, _e241);
    bloom = _e242.xyz;
    let _e245 = composite_info.ao_texel;
    half_texel = (_e245.xy * 0.5f);
    let _e248 = uv;
    let _e250 = half_texel[0u];
    let _e252 = half_texel[1u];
    let _e255 = textureSample(ao_texture_tex, ao_texture_smp, (_e248 + vec2<f32>(_e250, _e252)));
    let _e256 = uv;
    let _e258 = half_texel[0u];
    let _e261 = half_texel[1u];
    let _e264 = textureSample(ao_texture_tex, ao_texture_smp, (_e256 + vec2<f32>(-(_e258), _e261)));
    let _e266 = uv;
    let _e268 = half_texel[0u];
    let _e270 = half_texel[1u];
    let _e274 = textureSample(ao_texture_tex, ao_texture_smp, (_e266 + vec2<f32>(_e268, -(_e270))));
    let _e276 = uv;
    let _e278 = half_texel[0u];
    let _e281 = half_texel[1u];
    let _e285 = textureSample(ao_texture_tex, ao_texture_smp, (_e276 + vec2<f32>(-(_e278), -(_e281))));
    occlusion = ((((_e255 + _e264) + _e274) + _e285) * 0.25f);
    let _e289 = occlusion[3u];
    ao = _e289;
    let _e290 = ao;
    let _e293 = composite_info.params[3u];
    ao = mix(1f, _e290, clamp(_e293, 0f, 1f));
    let _e296 = uv;
    let _e297 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e296);
    contact = _e297.x;
    let _e299 = contact;
    let _e302 = composite_info.contact[0u];
    let _e305 = ao;
    ao = (_e305 * mix(1f, _e299, clamp(_e302, 0f, 1f)));
    let _e307 = uv;
    let _e308 = textureSample(local_exposure_texture_tex, local_exposure_texture_smp, _e307);
    localStops = _e308.x;
    let _e310 = scene;
    let _e312 = localStops;
    let _e315 = composite_info.contact[3u];
    exposed = (_e310.xyz * exp2((_e312 * _e315)));
    let _e319 = exposed;
    let _e320 = ao;
    let _e322 = bloom;
    let _e325 = composite_info.params[1u];
    color_10 = ((_e319 * _e320) + (_e322 * _e325));
    let _e328 = occlusion;
    let _e332 = composite_info.contact[2u];
    let _e336 = composite_info.params[3u];
    let _e339 = color_10;
    color_10 = (_e339 + ((_e328.xyz * _e332) * clamp(_e336, 0f, 1f)));
    let _e343 = composite_info.params[0u];
    let _e345 = color_10;
    color_10 = (_e345 * max(_e343, 0f));
    let _e349 = composite_info.params[2u];
    let _e352 = color_10;
    param_11 = _e352;
    param_12 = i32((_e349 + 0.5f));
    let _e353 = TonemapBy_u0028_vf3_u003b_i1_u003b((&param_11), (&param_12));
    color_10 = _e353;
    let _e356 = composite_info.look[0u];
    contrast = _e356;
    let _e359 = composite_info.look[1u];
    saturation = _e359;
    let _e362 = composite_info.look[2u];
    temperature = _e362;
    let _e363 = contrast;
    if (_e363 != 1f) {
        let _e365 = color_10;
        let _e369 = contrast;
        color_10 = (vec3<f32>(0.18f, 0.18f, 0.18f) * pow((max(_e365, vec3<f32>(0f, 0f, 0f)) / vec3(0.18f)), vec3(_e369)));
    }
    let _e373 = color_10;
    param_13 = _e373;
    let _e374 = Luma_u0028_vf3_u003b((&param_13));
    let _e376 = color_10;
    let _e377 = saturation;
    color_10 = mix(vec3(_e374), _e376, vec3(_e377));
    let _e380 = temperature;
    let _e383 = temperature;
    let _e387 = color_10;
    color_10 = (_e387 * vec3<f32>((1f + (_e380 * 0.1f)), 1f, (1f - (_e383 * 0.1f))));
    let _e390 = composite_info.lift;
    lift = _e390.xyz;
    let _e393 = composite_info.gamma;
    gammaCurve = _e393.xyz;
    let _e396 = composite_info.gain;
    gain = _e396.xyz;
    let _e398 = color_10;
    let _e399 = lift;
    let _e402 = lift;
    color_10 = ((_e398 * (vec3<f32>(1f, 1f, 1f) - _e399)) + _e402);
    let _e404 = color_10;
    color_10 = max(_e404, vec3<f32>(0f, 0f, 0f));
    let _e406 = gammaCurve;
    if any((_e406 != vec3<f32>(1f, 1f, 1f))) {
        let _e409 = color_10;
        let _e410 = gammaCurve;
        color_10 = pow(_e409, (vec3<f32>(1f, 1f, 1f) / _e410));
    }
    let _e413 = gain;
    let _e414 = color_10;
    color_10 = (_e414 * _e413);
    let _e418 = composite_info.output_encode[1u];
    balance = _e418;
    let _e421 = composite_info.output_encode[2u];
    tint = _e421;
    let _e422 = balance;
    let _e424 = tint;
    if ((_e422 != 0f) || (_e424 != 0f)) {
        let _e427 = balance;
        let _e430 = tint;
        let _e433 = balance;
        let _e437 = color_10;
        color_10 = (_e437 * vec3<f32>((1f + (_e427 * 0.2f)), (1f + (_e430 * 0.15f)), (1f - (_e433 * 0.2f))));
        let _e439 = tint;
        let _e442 = color_10[0u];
        color_10[0u] = (_e442 - (_e439 * 0.075f));
        let _e445 = tint;
        let _e448 = color_10[2u];
        color_10[2u] = (_e448 - (_e445 * 0.075f));
    }
    let _e453 = composite_info.ao_texel[2u];
    lutStrength = _e453;
    let _e454 = lutStrength;
    if (_e454 > 0f) {
        let _e456 = color_10;
        param_14 = clamp(_e456, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e458 = LinearToSrgb_u0028_vf3_u003b((&param_14));
        encodedIn = _e458;
        let _e461 = composite_info.ao_texel[3u];
        let _e463 = encodedIn;
        param_15 = _e463;
        param_16 = max(_e461, 2f);
        let _e464 = SampleLut_u0028_vf3_u003b_f1_u003b((&param_15), (&param_16));
        param_17 = _e464;
        let _e465 = SrgbToLinear_u0028_vf3_u003b((&param_17));
        graded = _e465;
        let _e466 = color_10;
        let _e467 = graded;
        let _e468 = lutStrength;
        color_10 = mix(_e466, _e467, vec3(clamp(_e468, 0f, 1f)));
    }
    let _e474 = composite_info.look_more[0u];
    vignette = _e474;
    let _e475 = vignette;
    if (_e475 > 0f) {
        let _e477 = v_uv_1;
        fromCentre_2 = (_e477 - vec2<f32>(0.5f, 0.5f));
        let _e481 = composite_info.look_more[3u];
        aspect_1 = max(_e481, 0.0001f);
        let _e483 = aspect_1;
        let _e486 = composite_info.look_more[1u];
        let _e489 = fromCentre_2[0u];
        fromCentre_2[0u] = (_e489 * mix(1f, _e483, _e486));
        let _e492 = fromCentre_2;
        radius = (length(_e492) * 1.4142135f);
        let _e495 = vignette;
        let _e497 = radius;
        let _e500 = color_10;
        color_10 = (_e500 * mix(1f, (1f - _e495), clamp(_e497, 0f, 1f)));
    }
    let _e502 = color_10;
    param_18 = max(_e502, vec3<f32>(0f, 0f, 0f));
    let _e504 = LinearToSrgb_u0028_vf3_u003b((&param_18));
    encoded_1 = _e504;
    let _e507 = composite_info.look_more[2u];
    grain = _e507;
    let _e508 = grain;
    if (_e508 > 0f) {
        let _e510 = TargetFragCoord_u0028_();
        param_19 = _e510;
        let _e511 = Hash_u0028_vf2_u003b((&param_19));
        let _e513 = grain;
        let _e516 = encoded_1;
        encoded_1 = (_e516 + vec3(((_e511 - 0.5f) * _e513)));
    }
    let _e520 = composite_info.output_encode[0u];
    dither = _e520;
    let _e521 = dither;
    if (_e521 > 0f) {
        let _e523 = TargetFragCoord_u0028_();
        param_20 = _e523;
        let _e524 = BayerCell_u0028_vf2_u003b((&param_20));
        let _e526 = dither;
        let _e529 = encoded_1;
        encoded_1 = (_e529 + vec3(((_e524 + 0.03125f) * _e526)));
    }
    let _e531 = encoded_1;
    let _e533 = scene[3u];
    frag_color = vec4<f32>(_e531.x, _e531.y, _e531.z, _e533);
    let _e540 = composite_info.lens[1u];
    sides = _e540;
    let _e542 = v_uv_1[0u];
    let _e545 = composite_info.lens[2u];
    right_of_wipe = (_e542 >= _e545);
    let _e547 = sides;
    let _e548 = (_e547 > 2.5f);
    phi_1289_ = _e548;
    if !(_e548) {
        let _e550 = sides;
        let _e552 = sides;
        let _e555 = right_of_wipe;
        phi_1289_ = (((_e550 > 1.5f) && (_e552 < 2.5f)) && !(_e555));
    }
    let _e559 = phi_1289_;
    phi_1300_ = _e559;
    if !(_e559) {
        let _e561 = sides;
        let _e563 = sides;
        let _e566 = right_of_wipe;
        phi_1300_ = (((_e561 > 0.5f) && (_e563 < 1.5f)) && _e566);
    }
    let _e569 = phi_1300_;
    shows_channel = _e569;
    let _e570 = shows_channel;
    if _e570 {
        let _e571 = v_uv_1;
        let _e572 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e571, 0f);
        raw = _e572;
        let _e573 = raw;
        param_21 = clamp(_e573.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e576 = LinearToSrgb_u0028_vf3_u003b((&param_21));
        let _e578 = raw[3u];
        frag_color = vec4<f32>(_e576.x, _e576.y, _e576.z, _e578);
    }
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'CompositeInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 160,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ao_texel',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'look', offsetInBytes: 32, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'look_more',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'output_encode',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'lift', offsetInBytes: 80, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'gamma',
              offsetInBytes: 96,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'gain',
              offsetInBytes: 112,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'contact',
              offsetInBytes: 128,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'lens',
              offsetInBytes: 144,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'ao_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'bloom_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'contact_shadow_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'display_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'local_exposure_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'lut_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Easu': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct EasuInfo {
    source: vec4<f32>,
    params: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(2)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var source_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> easu_info: EasuInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn Hash_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    let _e42 = (*at);
    return fract((sin(dot(_e42, vec2<f32>(12.9898f, 78.233f))) * 43758.547f));
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e43 = (*rows);
    if (_e43 > 0f) {
        let _e46 = gl_FragCoord_1[0u];
        let _e47 = (*rows);
        let _e49 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e46, (_e47 - _e49));
    } else {
        let _e52 = gl_FragCoord_1;
        local = _e52.xy;
    }
    let _e54 = local;
    return _e54;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param: f32;

    let _e44 = frag_coord_info.origin[0u];
    param = _e44;
    let _e45 = FragCoordFromTop_u0028_f1_u003b((&param));
    return _e45;
}

fn TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(off: ptr<function, vec2<f32>>, dir: ptr<function, vec2<f32>>, len2_: ptr<function, vec2<f32>>, lob: ptr<function, f32>, clp: ptr<function, f32>) -> f32 {
    var v: vec2<f32>;
    var d2_: f32;
    var wB: f32;
    var wA: f32;

    let _e51 = (*off)[0u];
    let _e53 = (*dir)[0u];
    let _e56 = (*off)[1u];
    let _e58 = (*dir)[1u];
    let _e62 = (*off)[0u];
    let _e64 = (*dir)[1u];
    let _e68 = (*off)[1u];
    let _e70 = (*dir)[0u];
    v = vec2<f32>(((_e51 * _e53) + (_e56 * _e58)), ((_e62 * -(_e64)) + (_e68 * _e70)));
    let _e74 = (*len2_);
    let _e75 = v;
    v = (_e75 * _e74);
    let _e77 = v;
    let _e78 = v;
    let _e80 = (*clp);
    d2_ = min(dot(_e77, _e78), _e80);
    let _e82 = d2_;
    wB = ((0.4f * _e82) - 1f);
    let _e85 = (*lob);
    let _e86 = d2_;
    wA = ((_e85 * _e86) - 1f);
    let _e89 = wB;
    let _e90 = wB;
    wB = (_e90 * _e89);
    let _e92 = wA;
    let _e93 = wA;
    wA = (_e93 * _e92);
    let _e95 = wB;
    wB = ((1.5625f * _e95) - 0.5625f);
    let _e98 = wB;
    let _e99 = wA;
    return (_e98 * _e99);
}

fn EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(dir_1: ptr<function, vec2<f32>>, len: ptr<function, f32>, w: ptr<function, f32>, a: ptr<function, f32>, b: ptr<function, f32>, c: ptr<function, f32>, d: ptr<function, f32>, e: ptr<function, f32>) {
    var lenX: f32;
    var dirX: f32;
    var stretchX: f32;
    var lenY: f32;
    var dirY: f32;
    var stretchY: f32;

    let _e55 = (*d);
    let _e56 = (*c);
    let _e59 = (*c);
    let _e60 = (*b);
    lenX = max(abs((_e55 - _e56)), abs((_e59 - _e60)));
    let _e64 = (*d);
    let _e65 = (*b);
    dirX = (_e64 - _e65);
    let _e67 = dirX;
    let _e69 = lenX;
    stretchX = clamp((abs(_e67) / max(_e69, 0.000001f)), 0f, 1f);
    let _e73 = (*e);
    let _e74 = (*c);
    let _e77 = (*c);
    let _e78 = (*a);
    lenY = max(abs((_e73 - _e74)), abs((_e77 - _e78)));
    let _e82 = (*e);
    let _e83 = (*a);
    dirY = (_e82 - _e83);
    let _e85 = dirY;
    let _e87 = lenY;
    stretchY = clamp((abs(_e85) / max(_e87, 0.000001f)), 0f, 1f);
    let _e91 = dirX;
    let _e92 = dirY;
    let _e94 = (*w);
    let _e96 = (*dir_1);
    (*dir_1) = (_e96 + (vec2<f32>(_e91, _e92) * _e94));
    let _e98 = stretchX;
    let _e99 = stretchX;
    let _e101 = stretchY;
    let _e102 = stretchY;
    let _e105 = (*w);
    let _e107 = (*len);
    (*len) = (_e107 + (((_e98 * _e99) + (_e101 * _e102)) * _e105));
    return;
}

fn EasuLuma_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> f32 {
    let _e43 = (*c_1)[1u];
    let _e45 = (*c_1)[0u];
    let _e47 = (*c_1)[2u];
    return (_e43 + (0.5f * (_e45 + _e47)));
}

fn Tap_u0028_vf2_u003b(pixel: ptr<function, vec2<f32>>) -> vec3<f32> {
    let _e42 = (*pixel);
    let _e46 = easu_info.source;
    let _e49 = textureSampleLevel(source_texture_tex, source_texture_smp, ((_e42 + vec2(0.5f)) * _e46.zw), 0f);
    return _e49.xyz;
}

fn main_1() {
    var pp: vec2<f32>;
    var fp: vec2<f32>;
    var b_1: vec3<f32>;
    var param_1: vec2<f32>;
    var c_2: vec3<f32>;
    var param_2: vec2<f32>;
    var e_1: vec3<f32>;
    var param_3: vec2<f32>;
    var f: vec3<f32>;
    var param_4: vec2<f32>;
    var g: vec3<f32>;
    var param_5: vec2<f32>;
    var h: vec3<f32>;
    var param_6: vec2<f32>;
    var i: vec3<f32>;
    var param_7: vec2<f32>;
    var j: vec3<f32>;
    var param_8: vec2<f32>;
    var k: vec3<f32>;
    var param_9: vec2<f32>;
    var l: vec3<f32>;
    var param_10: vec2<f32>;
    var n: vec3<f32>;
    var param_11: vec2<f32>;
    var o: vec3<f32>;
    var param_12: vec2<f32>;
    var bL: f32;
    var param_13: vec3<f32>;
    var cL: f32;
    var param_14: vec3<f32>;
    var eL: f32;
    var param_15: vec3<f32>;
    var fL: f32;
    var param_16: vec3<f32>;
    var gL: f32;
    var param_17: vec3<f32>;
    var hL: f32;
    var param_18: vec3<f32>;
    var iL: f32;
    var param_19: vec3<f32>;
    var jL: f32;
    var param_20: vec3<f32>;
    var kL: f32;
    var param_21: vec3<f32>;
    var lL: f32;
    var param_22: vec3<f32>;
    var nL: f32;
    var param_23: vec3<f32>;
    var oL: f32;
    var param_24: vec3<f32>;
    var dir_2: vec2<f32>;
    var len_1: f32;
    var param_25: vec2<f32>;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var param_31: f32;
    var param_32: f32;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: f32;
    var param_41: vec2<f32>;
    var param_42: f32;
    var param_43: f32;
    var param_44: f32;
    var param_45: f32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: f32;
    var param_51: f32;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;
    var param_55: f32;
    var param_56: f32;
    var dirR: f32;
    var featureless: bool;
    var local_1: vec2<f32>;
    var stretch: f32;
    var len2_1: vec2<f32>;
    var lob_1: f32;
    var clp_1: f32;
    var sum: vec3<f32>;
    var weight: f32;
    var w_1: f32;
    var param_57: vec2<f32>;
    var param_58: vec2<f32>;
    var param_59: vec2<f32>;
    var param_60: f32;
    var param_61: f32;
    var param_62: vec2<f32>;
    var param_63: vec2<f32>;
    var param_64: vec2<f32>;
    var param_65: f32;
    var param_66: f32;
    var param_67: vec2<f32>;
    var param_68: vec2<f32>;
    var param_69: vec2<f32>;
    var param_70: f32;
    var param_71: f32;
    var param_72: vec2<f32>;
    var param_73: vec2<f32>;
    var param_74: vec2<f32>;
    var param_75: f32;
    var param_76: f32;
    var param_77: vec2<f32>;
    var param_78: vec2<f32>;
    var param_79: vec2<f32>;
    var param_80: f32;
    var param_81: f32;
    var param_82: vec2<f32>;
    var param_83: vec2<f32>;
    var param_84: vec2<f32>;
    var param_85: f32;
    var param_86: f32;
    var param_87: vec2<f32>;
    var param_88: vec2<f32>;
    var param_89: vec2<f32>;
    var param_90: f32;
    var param_91: f32;
    var param_92: vec2<f32>;
    var param_93: vec2<f32>;
    var param_94: vec2<f32>;
    var param_95: f32;
    var param_96: f32;
    var param_97: vec2<f32>;
    var param_98: vec2<f32>;
    var param_99: vec2<f32>;
    var param_100: f32;
    var param_101: f32;
    var param_102: vec2<f32>;
    var param_103: vec2<f32>;
    var param_104: vec2<f32>;
    var param_105: f32;
    var param_106: f32;
    var param_107: vec2<f32>;
    var param_108: vec2<f32>;
    var param_109: vec2<f32>;
    var param_110: f32;
    var param_111: f32;
    var param_112: vec2<f32>;
    var param_113: vec2<f32>;
    var param_114: vec2<f32>;
    var param_115: f32;
    var param_116: f32;
    var lo: vec3<f32>;
    var hi: vec3<f32>;
    var color: vec3<f32>;
    var grain: f32;
    var param_117: vec2<f32>;

    let _e200 = v_uv_1;
    let _e202 = easu_info.source;
    pp = ((_e200 * _e202.xy) - vec2(0.5f));
    let _e207 = pp;
    fp = floor(_e207);
    let _e209 = fp;
    let _e210 = pp;
    pp = (_e210 - _e209);
    let _e212 = fp;
    param_1 = (_e212 + vec2<f32>(0f, -1f));
    let _e214 = Tap_u0028_vf2_u003b((&param_1));
    b_1 = _e214;
    let _e215 = fp;
    param_2 = (_e215 + vec2<f32>(1f, -1f));
    let _e217 = Tap_u0028_vf2_u003b((&param_2));
    c_2 = _e217;
    let _e218 = fp;
    param_3 = (_e218 + vec2<f32>(-1f, 0f));
    let _e220 = Tap_u0028_vf2_u003b((&param_3));
    e_1 = _e220;
    let _e221 = fp;
    param_4 = _e221;
    let _e222 = Tap_u0028_vf2_u003b((&param_4));
    f = _e222;
    let _e223 = fp;
    param_5 = (_e223 + vec2<f32>(1f, 0f));
    let _e225 = Tap_u0028_vf2_u003b((&param_5));
    g = _e225;
    let _e226 = fp;
    param_6 = (_e226 + vec2<f32>(2f, 0f));
    let _e228 = Tap_u0028_vf2_u003b((&param_6));
    h = _e228;
    let _e229 = fp;
    param_7 = (_e229 + vec2<f32>(-1f, 1f));
    let _e231 = Tap_u0028_vf2_u003b((&param_7));
    i = _e231;
    let _e232 = fp;
    param_8 = (_e232 + vec2<f32>(0f, 1f));
    let _e234 = Tap_u0028_vf2_u003b((&param_8));
    j = _e234;
    let _e235 = fp;
    param_9 = (_e235 + vec2<f32>(1f, 1f));
    let _e237 = Tap_u0028_vf2_u003b((&param_9));
    k = _e237;
    let _e238 = fp;
    param_10 = (_e238 + vec2<f32>(2f, 1f));
    let _e240 = Tap_u0028_vf2_u003b((&param_10));
    l = _e240;
    let _e241 = fp;
    param_11 = (_e241 + vec2<f32>(0f, 2f));
    let _e243 = Tap_u0028_vf2_u003b((&param_11));
    n = _e243;
    let _e244 = fp;
    param_12 = (_e244 + vec2<f32>(1f, 2f));
    let _e246 = Tap_u0028_vf2_u003b((&param_12));
    o = _e246;
    let _e247 = b_1;
    param_13 = _e247;
    let _e248 = EasuLuma_u0028_vf3_u003b((&param_13));
    bL = _e248;
    let _e249 = c_2;
    param_14 = _e249;
    let _e250 = EasuLuma_u0028_vf3_u003b((&param_14));
    cL = _e250;
    let _e251 = e_1;
    param_15 = _e251;
    let _e252 = EasuLuma_u0028_vf3_u003b((&param_15));
    eL = _e252;
    let _e253 = f;
    param_16 = _e253;
    let _e254 = EasuLuma_u0028_vf3_u003b((&param_16));
    fL = _e254;
    let _e255 = g;
    param_17 = _e255;
    let _e256 = EasuLuma_u0028_vf3_u003b((&param_17));
    gL = _e256;
    let _e257 = h;
    param_18 = _e257;
    let _e258 = EasuLuma_u0028_vf3_u003b((&param_18));
    hL = _e258;
    let _e259 = i;
    param_19 = _e259;
    let _e260 = EasuLuma_u0028_vf3_u003b((&param_19));
    iL = _e260;
    let _e261 = j;
    param_20 = _e261;
    let _e262 = EasuLuma_u0028_vf3_u003b((&param_20));
    jL = _e262;
    let _e263 = k;
    param_21 = _e263;
    let _e264 = EasuLuma_u0028_vf3_u003b((&param_21));
    kL = _e264;
    let _e265 = l;
    param_22 = _e265;
    let _e266 = EasuLuma_u0028_vf3_u003b((&param_22));
    lL = _e266;
    let _e267 = n;
    param_23 = _e267;
    let _e268 = EasuLuma_u0028_vf3_u003b((&param_23));
    nL = _e268;
    let _e269 = o;
    param_24 = _e269;
    let _e270 = EasuLuma_u0028_vf3_u003b((&param_24));
    oL = _e270;
    dir_2 = vec2<f32>(0f, 0f);
    len_1 = 0f;
    let _e272 = pp[0u];
    let _e275 = pp[1u];
    let _e278 = dir_2;
    param_25 = _e278;
    let _e279 = len_1;
    param_26 = _e279;
    param_27 = ((1f - _e272) * (1f - _e275));
    let _e280 = bL;
    param_28 = _e280;
    let _e281 = eL;
    param_29 = _e281;
    let _e282 = fL;
    param_30 = _e282;
    let _e283 = gL;
    param_31 = _e283;
    let _e284 = jL;
    param_32 = _e284;
    EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30), (&param_31), (&param_32));
    let _e285 = param_25;
    dir_2 = _e285;
    let _e286 = param_26;
    len_1 = _e286;
    let _e288 = pp[0u];
    let _e290 = pp[1u];
    let _e293 = dir_2;
    param_33 = _e293;
    let _e294 = len_1;
    param_34 = _e294;
    param_35 = (_e288 * (1f - _e290));
    let _e295 = cL;
    param_36 = _e295;
    let _e296 = fL;
    param_37 = _e296;
    let _e297 = gL;
    param_38 = _e297;
    let _e298 = hL;
    param_39 = _e298;
    let _e299 = kL;
    param_40 = _e299;
    EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39), (&param_40));
    let _e300 = param_33;
    dir_2 = _e300;
    let _e301 = param_34;
    len_1 = _e301;
    let _e303 = pp[0u];
    let _e306 = pp[1u];
    let _e308 = dir_2;
    param_41 = _e308;
    let _e309 = len_1;
    param_42 = _e309;
    param_43 = ((1f - _e303) * _e306);
    let _e310 = fL;
    param_44 = _e310;
    let _e311 = iL;
    param_45 = _e311;
    let _e312 = jL;
    param_46 = _e312;
    let _e313 = kL;
    param_47 = _e313;
    let _e314 = nL;
    param_48 = _e314;
    EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_41), (&param_42), (&param_43), (&param_44), (&param_45), (&param_46), (&param_47), (&param_48));
    let _e315 = param_41;
    dir_2 = _e315;
    let _e316 = param_42;
    len_1 = _e316;
    let _e318 = pp[0u];
    let _e320 = pp[1u];
    let _e322 = dir_2;
    param_49 = _e322;
    let _e323 = len_1;
    param_50 = _e323;
    param_51 = (_e318 * _e320);
    let _e324 = gL;
    param_52 = _e324;
    let _e325 = jL;
    param_53 = _e325;
    let _e326 = kL;
    param_54 = _e326;
    let _e327 = lL;
    param_55 = _e327;
    let _e328 = oL;
    param_56 = _e328;
    EdgeAt_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53), (&param_54), (&param_55), (&param_56));
    let _e329 = param_49;
    dir_2 = _e329;
    let _e330 = param_50;
    len_1 = _e330;
    let _e331 = dir_2;
    let _e332 = dir_2;
    dirR = dot(_e331, _e332);
    let _e334 = dirR;
    featureless = (_e334 < 0.000030517578f);
    let _e336 = featureless;
    if _e336 {
        local_1 = vec2<f32>(1f, 0f);
    } else {
        let _e337 = dir_2;
        let _e338 = dirR;
        local_1 = (_e337 * inverseSqrt(max(_e338, 0.000000000001f)));
    }
    let _e342 = local_1;
    dir_2 = _e342;
    let _e343 = len_1;
    len_1 = (_e343 * 0.5f);
    let _e345 = len_1;
    let _e346 = len_1;
    len_1 = (_e346 * _e345);
    let _e348 = dir_2;
    let _e349 = dir_2;
    let _e352 = dir_2[0u];
    let _e355 = dir_2[1u];
    stretch = (dot(_e348, _e349) / max(abs(_e352), abs(_e355)));
    let _e359 = stretch;
    let _e361 = len_1;
    let _e364 = len_1;
    len2_1 = vec2<f32>((1f + ((_e359 - 1f) * _e361)), (1f - (0.5f * _e364)));
    let _e368 = len_1;
    lob_1 = (0.5f - (0.29f * _e368));
    let _e371 = lob_1;
    clp_1 = (1f / _e371);
    sum = vec3<f32>(0f, 0f, 0f);
    weight = 0f;
    let _e373 = pp;
    param_57 = (vec2<f32>(0f, -1f) - _e373);
    let _e375 = dir_2;
    param_58 = _e375;
    let _e376 = len2_1;
    param_59 = _e376;
    let _e377 = lob_1;
    param_60 = _e377;
    let _e378 = clp_1;
    param_61 = _e378;
    let _e379 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60), (&param_61));
    w_1 = _e379;
    let _e380 = b_1;
    let _e381 = w_1;
    let _e383 = sum;
    sum = (_e383 + (_e380 * _e381));
    let _e385 = w_1;
    let _e386 = weight;
    weight = (_e386 + _e385);
    let _e388 = pp;
    param_62 = (vec2<f32>(1f, -1f) - _e388);
    let _e390 = dir_2;
    param_63 = _e390;
    let _e391 = len2_1;
    param_64 = _e391;
    let _e392 = lob_1;
    param_65 = _e392;
    let _e393 = clp_1;
    param_66 = _e393;
    let _e394 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_62), (&param_63), (&param_64), (&param_65), (&param_66));
    w_1 = _e394;
    let _e395 = c_2;
    let _e396 = w_1;
    let _e398 = sum;
    sum = (_e398 + (_e395 * _e396));
    let _e400 = w_1;
    let _e401 = weight;
    weight = (_e401 + _e400);
    let _e403 = pp;
    param_67 = (vec2<f32>(-1f, 1f) - _e403);
    let _e405 = dir_2;
    param_68 = _e405;
    let _e406 = len2_1;
    param_69 = _e406;
    let _e407 = lob_1;
    param_70 = _e407;
    let _e408 = clp_1;
    param_71 = _e408;
    let _e409 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_67), (&param_68), (&param_69), (&param_70), (&param_71));
    w_1 = _e409;
    let _e410 = i;
    let _e411 = w_1;
    let _e413 = sum;
    sum = (_e413 + (_e410 * _e411));
    let _e415 = w_1;
    let _e416 = weight;
    weight = (_e416 + _e415);
    let _e418 = pp;
    param_72 = (vec2<f32>(0f, 1f) - _e418);
    let _e420 = dir_2;
    param_73 = _e420;
    let _e421 = len2_1;
    param_74 = _e421;
    let _e422 = lob_1;
    param_75 = _e422;
    let _e423 = clp_1;
    param_76 = _e423;
    let _e424 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_72), (&param_73), (&param_74), (&param_75), (&param_76));
    w_1 = _e424;
    let _e425 = j;
    let _e426 = w_1;
    let _e428 = sum;
    sum = (_e428 + (_e425 * _e426));
    let _e430 = w_1;
    let _e431 = weight;
    weight = (_e431 + _e430);
    let _e433 = pp;
    param_77 = (vec2<f32>(0f, 0f) - _e433);
    let _e435 = dir_2;
    param_78 = _e435;
    let _e436 = len2_1;
    param_79 = _e436;
    let _e437 = lob_1;
    param_80 = _e437;
    let _e438 = clp_1;
    param_81 = _e438;
    let _e439 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_77), (&param_78), (&param_79), (&param_80), (&param_81));
    w_1 = _e439;
    let _e440 = f;
    let _e441 = w_1;
    let _e443 = sum;
    sum = (_e443 + (_e440 * _e441));
    let _e445 = w_1;
    let _e446 = weight;
    weight = (_e446 + _e445);
    let _e448 = pp;
    param_82 = (vec2<f32>(-1f, 0f) - _e448);
    let _e450 = dir_2;
    param_83 = _e450;
    let _e451 = len2_1;
    param_84 = _e451;
    let _e452 = lob_1;
    param_85 = _e452;
    let _e453 = clp_1;
    param_86 = _e453;
    let _e454 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_82), (&param_83), (&param_84), (&param_85), (&param_86));
    w_1 = _e454;
    let _e455 = e_1;
    let _e456 = w_1;
    let _e458 = sum;
    sum = (_e458 + (_e455 * _e456));
    let _e460 = w_1;
    let _e461 = weight;
    weight = (_e461 + _e460);
    let _e463 = pp;
    param_87 = (vec2<f32>(1f, 1f) - _e463);
    let _e465 = dir_2;
    param_88 = _e465;
    let _e466 = len2_1;
    param_89 = _e466;
    let _e467 = lob_1;
    param_90 = _e467;
    let _e468 = clp_1;
    param_91 = _e468;
    let _e469 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_87), (&param_88), (&param_89), (&param_90), (&param_91));
    w_1 = _e469;
    let _e470 = k;
    let _e471 = w_1;
    let _e473 = sum;
    sum = (_e473 + (_e470 * _e471));
    let _e475 = w_1;
    let _e476 = weight;
    weight = (_e476 + _e475);
    let _e478 = pp;
    param_92 = (vec2<f32>(2f, 1f) - _e478);
    let _e480 = dir_2;
    param_93 = _e480;
    let _e481 = len2_1;
    param_94 = _e481;
    let _e482 = lob_1;
    param_95 = _e482;
    let _e483 = clp_1;
    param_96 = _e483;
    let _e484 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_92), (&param_93), (&param_94), (&param_95), (&param_96));
    w_1 = _e484;
    let _e485 = l;
    let _e486 = w_1;
    let _e488 = sum;
    sum = (_e488 + (_e485 * _e486));
    let _e490 = w_1;
    let _e491 = weight;
    weight = (_e491 + _e490);
    let _e493 = pp;
    param_97 = (vec2<f32>(2f, 0f) - _e493);
    let _e495 = dir_2;
    param_98 = _e495;
    let _e496 = len2_1;
    param_99 = _e496;
    let _e497 = lob_1;
    param_100 = _e497;
    let _e498 = clp_1;
    param_101 = _e498;
    let _e499 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_97), (&param_98), (&param_99), (&param_100), (&param_101));
    w_1 = _e499;
    let _e500 = h;
    let _e501 = w_1;
    let _e503 = sum;
    sum = (_e503 + (_e500 * _e501));
    let _e505 = w_1;
    let _e506 = weight;
    weight = (_e506 + _e505);
    let _e508 = pp;
    param_102 = (vec2<f32>(1f, 0f) - _e508);
    let _e510 = dir_2;
    param_103 = _e510;
    let _e511 = len2_1;
    param_104 = _e511;
    let _e512 = lob_1;
    param_105 = _e512;
    let _e513 = clp_1;
    param_106 = _e513;
    let _e514 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_102), (&param_103), (&param_104), (&param_105), (&param_106));
    w_1 = _e514;
    let _e515 = g;
    let _e516 = w_1;
    let _e518 = sum;
    sum = (_e518 + (_e515 * _e516));
    let _e520 = w_1;
    let _e521 = weight;
    weight = (_e521 + _e520);
    let _e523 = pp;
    param_107 = (vec2<f32>(1f, 2f) - _e523);
    let _e525 = dir_2;
    param_108 = _e525;
    let _e526 = len2_1;
    param_109 = _e526;
    let _e527 = lob_1;
    param_110 = _e527;
    let _e528 = clp_1;
    param_111 = _e528;
    let _e529 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_107), (&param_108), (&param_109), (&param_110), (&param_111));
    w_1 = _e529;
    let _e530 = o;
    let _e531 = w_1;
    let _e533 = sum;
    sum = (_e533 + (_e530 * _e531));
    let _e535 = w_1;
    let _e536 = weight;
    weight = (_e536 + _e535);
    let _e538 = pp;
    param_112 = (vec2<f32>(0f, 2f) - _e538);
    let _e540 = dir_2;
    param_113 = _e540;
    let _e541 = len2_1;
    param_114 = _e541;
    let _e542 = lob_1;
    param_115 = _e542;
    let _e543 = clp_1;
    param_116 = _e543;
    let _e544 = TapWeight_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_112), (&param_113), (&param_114), (&param_115), (&param_116));
    w_1 = _e544;
    let _e545 = n;
    let _e546 = w_1;
    let _e548 = sum;
    sum = (_e548 + (_e545 * _e546));
    let _e550 = w_1;
    let _e551 = weight;
    weight = (_e551 + _e550);
    let _e553 = f;
    let _e554 = g;
    let _e556 = j;
    let _e557 = k;
    lo = min(min(_e553, _e554), min(_e556, _e557));
    let _e560 = f;
    let _e561 = g;
    let _e563 = j;
    let _e564 = k;
    hi = max(max(_e560, _e561), max(_e563, _e564));
    let _e567 = sum;
    let _e568 = weight;
    let _e572 = lo;
    let _e573 = hi;
    color = clamp((_e567 / vec3(max(_e568, 0.000001f))), _e572, _e573);
    let _e577 = easu_info.params[0u];
    grain = _e577;
    let _e578 = TargetFragCoord_u0028_();
    param_117 = _e578;
    let _e579 = Hash_u0028_vf2_u003b((&param_117));
    let _e581 = grain;
    let _e584 = color;
    color = (_e584 + vec3(((_e579 - 0.5f) * _e581)));
    let _e586 = color;
    frag_color = vec4<f32>(_e586.x, _e586.y, _e586.z, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'EasuInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'source',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LocalExposure': WebGpuStage(
      wgsl: r'''
struct LocalExposureInfo {
    stops: vec4<f32>,
    camera: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> local_exposure_info: LocalExposureInfo;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn WellExposed_u0028_f1_u003b(y: ptr<function, f32>) -> f32 {
    var display: f32;
    var off: f32;

    let _e24 = (*y);
    let _e25 = (*y);
    display = pow((_e24 / (1f + _e25)), 0.45454547f);
    let _e29 = display;
    off = (_e29 - 0.5f);
    let _e31 = off;
    let _e33 = off;
    return exp(((-(_e31) * _e33) / 0.08f));
}

fn Luma_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {
    let _e22 = (*c);
    return dot(_e22, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn main_1() {
    var t: vec2<f32>;
    var y_1: f32;
    var param: vec3<f32>;
    var param_1: vec3<f32>;
    var param_2: vec3<f32>;
    var param_3: vec3<f32>;
    var shadow: f32;
    var highlight: f32;
    var param_4: f32;
    var param_5: f32;
    var param_6: f32;

    let _e33 = local_exposure_info.stops;
    t = (_e33.zw * 2f);
    let _e36 = v_uv_1;
    let _e38 = t[0u];
    let _e41 = t[1u];
    let _e45 = textureSample(scene_texture_tex, scene_texture_smp, (_e36 + vec2<f32>(-(_e38), -(_e41))));
    param = _e45.xyz;
    let _e47 = Luma_u0028_vf3_u003b((&param));
    let _e48 = v_uv_1;
    let _e50 = t[0u];
    let _e52 = t[1u];
    let _e56 = textureSample(scene_texture_tex, scene_texture_smp, (_e48 + vec2<f32>(_e50, -(_e52))));
    param_1 = _e56.xyz;
    let _e58 = Luma_u0028_vf3_u003b((&param_1));
    let _e60 = v_uv_1;
    let _e62 = t[0u];
    let _e65 = t[1u];
    let _e68 = textureSample(scene_texture_tex, scene_texture_smp, (_e60 + vec2<f32>(-(_e62), _e65)));
    param_2 = _e68.xyz;
    let _e70 = Luma_u0028_vf3_u003b((&param_2));
    let _e72 = v_uv_1;
    let _e74 = t[0u];
    let _e76 = t[1u];
    let _e79 = textureSample(scene_texture_tex, scene_texture_smp, (_e72 + vec2<f32>(_e74, _e76)));
    param_3 = _e79.xyz;
    let _e81 = Luma_u0028_vf3_u003b((&param_3));
    y_1 = (0.25f * (((_e47 + _e58) + _e70) + _e81));
    let _e84 = y_1;
    let _e88 = local_exposure_info.camera[0u];
    y_1 = (max(_e84, 0f) * max(_e88, 0f));
    let _e93 = local_exposure_info.stops[0u];
    shadow = exp2(_e93);
    let _e97 = local_exposure_info.stops[1u];
    highlight = exp2(-(_e97));
    let _e100 = y_1;
    let _e101 = shadow;
    param_4 = (_e100 * _e101);
    let _e103 = WellExposed_u0028_f1_u003b((&param_4));
    let _e105 = y_1;
    param_5 = _e105;
    let _e106 = WellExposed_u0028_f1_u003b((&param_5));
    let _e108 = y_1;
    let _e109 = highlight;
    param_6 = (_e108 * _e109);
    let _e111 = WellExposed_u0028_f1_u003b((&param_6));
    frag_color = vec4<f32>((_e103 + 0.0001f), (_e106 + 0.0001f), (_e111 + 0.0001f), 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'LocalExposureInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'stops', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LocalExposureBlur': WebGpuStage(
      wgsl: r'''
struct LocalExposureBlurInfo {
    step: vec4<f32>,
    stops: vec4<f32>,
}

@group(1) @binding(1)
var weight_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var weight_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> blur_info: LocalExposureBlurInfo;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var sum: vec3<f32>;
    var total: f32;
    var i: i32;
    var w: f32;
    var weights: vec3<f32>;
    var stops: f32;
    var local: vec4<f32>;

    sum = vec3<f32>(0f, 0f, 0f);
    total = 0f;
    i = -6i;
    loop {
        let _e25 = i;
        if (_e25 <= 6i) {
            let _e27 = i;
            let _e28 = i;
            w = exp((-(f32((_e27 * _e28))) / 18f));
            let _e34 = v_uv_1;
            let _e36 = blur_info.step;
            let _e38 = i;
            let _e42 = textureSample(weight_texture_tex, weight_texture_smp, (_e34 + (_e36.xy * f32(_e38))));
            let _e44 = w;
            let _e46 = sum;
            sum = (_e46 + (_e42.xyz * _e44));
            let _e48 = w;
            let _e49 = total;
            total = (_e49 + _e48);
            continue;
        } else {
            break;
        }
        continuing {
            let _e51 = i;
            i = (_e51 + 1i);
        }
    }
    let _e53 = sum;
    let _e54 = total;
    weights = (_e53 / vec3(_e54));
    let _e58 = weights[0u];
    let _e61 = blur_info.stops[0u];
    let _e64 = weights[2u];
    let _e67 = blur_info.stops[1u];
    let _e71 = weights[0u];
    let _e73 = weights[1u];
    let _e76 = weights[2u];
    stops = (((_e58 * _e61) - (_e64 * _e67)) / max(((_e71 + _e73) + _e76), 0.000001f));
    let _e82 = blur_info.step[2u];
    if (_e82 > 0.5f) {
        let _e84 = stops;
        local = vec4<f32>(_e84, _e84, _e84, 1f);
    } else {
        let _e86 = weights;
        local = vec4<f32>(_e86.x, _e86.y, _e86.z, 1f);
    }
    let _e91 = local;
    frag_color = _e91;
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'LocalExposureBlurInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'step', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'stops',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'weight_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Fxaa': WebGpuStage(
      wgsl: r'''
struct FxaaInfo {
    params: vec4<f32>,
    sharpen: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> fxaa_info: FxaaInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn SearchStep_u0028_i1_u003b(i: ptr<function, i32>) -> f32 {
    var local: f32;
    var local_1: f32;

    let _e37 = (*i);
    if (_e37 == 1i) {
        local = 1.5f;
    } else {
        let _e39 = (*i);
        if (_e39 == 2i) {
            local_1 = 2f;
        } else {
            let _e41 = (*i);
            local_1 = select(12f, 4f, (_e41 == 3i));
        }
        let _e44 = local_1;
        local = _e44;
    }
    let _e45 = local;
    return _e45;
}

fn MinChannel_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> f32 {
    let _e36 = (*v)[0u];
    let _e38 = (*v)[1u];
    let _e40 = (*v)[2u];
    return min(_e36, min(_e38, _e40));
}

fn MaxChannel_u0028_vf3_u003b(v_1: ptr<function, vec3<f32>>) -> f32 {
    let _e36 = (*v_1)[0u];
    let _e38 = (*v_1)[1u];
    let _e40 = (*v_1)[2u];
    return max(_e36, max(_e38, _e40));
}

fn SharpenRobust_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_f1_u003b(centre: ptr<function, vec3<f32>>, n: ptr<function, vec3<f32>>, s: ptr<function, vec3<f32>>, w: ptr<function, vec3<f32>>, e: ptr<function, vec3<f32>>, amount: ptr<function, f32>) -> vec3<f32> {
    var lowest: vec3<f32>;
    var highest: vec3<f32>;
    var hitMin: vec3<f32>;
    var hitMax: vec3<f32>;
    var lobeRgb: vec3<f32>;
    var lobe: f32;
    var param: vec3<f32>;

    let _e47 = (*n);
    let _e48 = (*s);
    let _e50 = (*w);
    let _e51 = (*e);
    lowest = min(min(_e47, _e48), min(_e50, _e51));
    let _e54 = (*n);
    let _e55 = (*s);
    let _e57 = (*w);
    let _e58 = (*e);
    highest = max(max(_e54, _e55), max(_e57, _e58));
    let _e61 = lowest;
    let _e62 = highest;
    hitMin = (_e61 / max((_e62 * 4f), vec3<f32>(0.00001f, 0.00001f, 0.00001f)));
    let _e66 = highest;
    let _e68 = lowest;
    hitMax = ((vec3<f32>(1f, 1f, 1f) - _e66) / min(((_e68 * 4f) - vec3(4f)), vec3<f32>(-0.00001f, -0.00001f, -0.00001f)));
    let _e74 = hitMin;
    let _e76 = hitMax;
    lobeRgb = max(-(_e74), _e76);
    let _e78 = lobeRgb;
    param = _e78;
    let _e79 = MaxChannel_u0028_vf3_u003b((&param));
    let _e82 = (*amount);
    lobe = (max(-0.1875f, min(_e79, 0f)) * _e82);
    let _e84 = lobe;
    let _e85 = (*n);
    let _e86 = (*s);
    let _e88 = (*w);
    let _e90 = (*e);
    let _e93 = (*centre);
    let _e95 = lobe;
    return ((((((_e85 + _e86) + _e88) + _e90) * _e84) + _e93) / vec3(((4f * _e95) + 1f)));
}

fn Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre_1: ptr<function, vec3<f32>>, n_1: ptr<function, vec3<f32>>, s_1: ptr<function, vec3<f32>>, w_1: ptr<function, vec3<f32>>, e_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var strength: f32;
    var param_1: vec3<f32>;
    var param_2: vec3<f32>;
    var param_3: vec3<f32>;
    var param_4: vec3<f32>;
    var param_5: vec3<f32>;
    var param_6: f32;
    var lowest_1: vec3<f32>;
    var highest_1: vec3<f32>;
    var room: vec3<f32>;
    var amount_1: f32;
    var param_7: vec3<f32>;
    var average: vec3<f32>;

    let _e54 = fxaa_info.sharpen[0u];
    strength = _e54;
    let _e55 = strength;
    if (_e55 <= 0f) {
        let _e57 = (*centre_1);
        return _e57;
    }
    let _e60 = fxaa_info.sharpen[1u];
    if (_e60 > 0.5f) {
        let _e62 = (*centre_1);
        param_1 = _e62;
        let _e63 = (*n_1);
        param_2 = _e63;
        let _e64 = (*s_1);
        param_3 = _e64;
        let _e65 = (*w_1);
        param_4 = _e65;
        let _e66 = (*e_1);
        param_5 = _e66;
        let _e67 = strength;
        param_6 = _e67;
        let _e68 = SharpenRobust_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_f1_u003b((&param_1), (&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
        return _e68;
    }
    let _e69 = (*centre_1);
    let _e70 = (*n_1);
    let _e71 = (*s_1);
    let _e73 = (*w_1);
    let _e74 = (*e_1);
    lowest_1 = min(_e69, min(min(_e70, _e71), min(_e73, _e74)));
    let _e78 = (*centre_1);
    let _e79 = (*n_1);
    let _e80 = (*s_1);
    let _e82 = (*w_1);
    let _e83 = (*e_1);
    highest_1 = max(_e78, max(max(_e79, _e80), max(_e82, _e83)));
    let _e87 = lowest_1;
    let _e88 = highest_1;
    let _e91 = highest_1;
    room = (min(_e87, (vec3<f32>(1f, 1f, 1f) - _e88)) / max(_e91, vec3<f32>(0.00001f, 0.00001f, 0.00001f)));
    let _e94 = room;
    param_7 = _e94;
    let _e95 = MinChannel_u0028_vf3_u003b((&param_7));
    amount_1 = clamp(sqrt(clamp(_e95, 0f, 1f)), 0f, 1f);
    let _e99 = (*n_1);
    let _e100 = (*s_1);
    let _e102 = (*w_1);
    let _e104 = (*e_1);
    average = ((((_e99 + _e100) + _e102) + _e104) * 0.25f);
    let _e107 = (*centre_1);
    let _e108 = (*centre_1);
    let _e109 = average;
    let _e111 = amount_1;
    let _e113 = strength;
    return (_e107 + (((_e108 - _e109) * _e111) * _e113));
}

fn Weight_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
    let _e35 = (*color);
    return dot(_e35, vec3<f32>(0.299f, 0.587f, 0.114f));
}

fn main_1() {
    var texel: vec2<f32>;
    var middle: vec3<f32>;
    var mid: f32;
    var param_8: vec3<f32>;
    var northRgb: vec3<f32>;
    var southRgb: vec3<f32>;
    var westRgb: vec3<f32>;
    var eastRgb: vec3<f32>;
    var north: f32;
    var param_9: vec3<f32>;
    var south: f32;
    var param_10: vec3<f32>;
    var west: f32;
    var param_11: vec3<f32>;
    var east: f32;
    var param_12: vec3<f32>;
    var lowest_2: f32;
    var highest_2: f32;
    var contrast: f32;
    var param_13: vec3<f32>;
    var param_14: vec3<f32>;
    var param_15: vec3<f32>;
    var param_16: vec3<f32>;
    var param_17: vec3<f32>;
    var northWest: f32;
    var param_18: vec3<f32>;
    var southEast: f32;
    var param_19: vec3<f32>;
    var northEast: f32;
    var param_20: vec3<f32>;
    var southWest: f32;
    var param_21: vec3<f32>;
    var edgeHorizontal: f32;
    var edgeVertical: f32;
    var horizontalSpan: bool;
    var lowPass: f32;
    var subpixC: f32;
    var subpixF: f32;
    var subpixH: f32;
    var lumaN: f32;
    var lumaS: f32;
    var gradientN: f32;
    var gradientS: f32;
    var pairN: bool;
    var gradient: f32;
    var lengthSign: f32;
    var local_2: f32;
    var pairAverage: f32;
    var local_3: f32;
    var along: vec2<f32>;
    var local_4: vec2<f32>;
    var start: vec2<f32>;
    var local_5: vec2<f32>;
    var gradientScaled: f32;
    var posN: vec2<f32>;
    var posP: vec2<f32>;
    var endN: f32;
    var param_22: vec3<f32>;
    var endP: f32;
    var param_23: vec3<f32>;
    var doneN: bool;
    var doneP: bool;
    var i_1: i32;
    var stride: f32;
    var param_24: i32;
    var param_25: vec3<f32>;
    var param_26: vec3<f32>;
    var distanceN: f32;
    var local_6: f32;
    var distanceP: f32;
    var local_7: f32;
    var middleBelow: bool;
    var nearerN: bool;
    var goodSpan: bool;
    var local_8: bool;
    var nearest: f32;
    var pixelOffset: f32;
    var offset: f32;
    var at: vec2<f32>;
    var local_9: vec2<f32>;
    var smoothed: vec3<f32>;
    var param_27: vec3<f32>;
    var param_28: vec3<f32>;
    var param_29: vec3<f32>;
    var param_30: vec3<f32>;
    var param_31: vec3<f32>;

    let _e121 = fxaa_info.params;
    texel = _e121.xy;
    let _e123 = v_uv_1;
    let _e124 = textureSampleLevel(source_texture_tex, source_texture_smp, _e123, 0f);
    middle = _e124.xyz;
    let _e126 = middle;
    param_8 = _e126;
    let _e127 = Weight_u0028_vf3_u003b((&param_8));
    mid = _e127;
    let _e128 = v_uv_1;
    let _e130 = texel[1u];
    let _e134 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e128 + vec2<f32>(0f, -(_e130))), 0f);
    northRgb = _e134.xyz;
    let _e136 = v_uv_1;
    let _e138 = texel[1u];
    let _e141 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e136 + vec2<f32>(0f, _e138)), 0f);
    southRgb = _e141.xyz;
    let _e143 = v_uv_1;
    let _e145 = texel[0u];
    let _e149 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e143 + vec2<f32>(-(_e145), 0f)), 0f);
    westRgb = _e149.xyz;
    let _e151 = v_uv_1;
    let _e153 = texel[0u];
    let _e156 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e151 + vec2<f32>(_e153, 0f)), 0f);
    eastRgb = _e156.xyz;
    let _e158 = northRgb;
    param_9 = _e158;
    let _e159 = Weight_u0028_vf3_u003b((&param_9));
    north = _e159;
    let _e160 = southRgb;
    param_10 = _e160;
    let _e161 = Weight_u0028_vf3_u003b((&param_10));
    south = _e161;
    let _e162 = westRgb;
    param_11 = _e162;
    let _e163 = Weight_u0028_vf3_u003b((&param_11));
    west = _e163;
    let _e164 = eastRgb;
    param_12 = _e164;
    let _e165 = Weight_u0028_vf3_u003b((&param_12));
    east = _e165;
    let _e166 = mid;
    let _e167 = north;
    let _e168 = south;
    let _e170 = west;
    let _e171 = east;
    lowest_2 = min(_e166, min(min(_e167, _e168), min(_e170, _e171)));
    let _e175 = mid;
    let _e176 = north;
    let _e177 = south;
    let _e179 = west;
    let _e180 = east;
    highest_2 = max(_e175, max(max(_e176, _e177), max(_e179, _e180)));
    let _e184 = highest_2;
    let _e185 = lowest_2;
    contrast = (_e184 - _e185);
    let _e187 = contrast;
    let _e188 = highest_2;
    let _e191 = fxaa_info.params[2u];
    if (_e187 < max(0.0312f, (_e188 * _e191))) {
        let _e195 = middle;
        param_13 = _e195;
        let _e196 = northRgb;
        param_14 = _e196;
        let _e197 = southRgb;
        param_15 = _e197;
        let _e198 = westRgb;
        param_16 = _e198;
        let _e199 = eastRgb;
        param_17 = _e199;
        let _e200 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_13), (&param_14), (&param_15), (&param_16), (&param_17));
        frag_color = vec4<f32>(_e200.x, _e200.y, _e200.z, 1f);
        return;
    }
    let _e205 = v_uv_1;
    let _e206 = texel;
    let _e208 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e205 - _e206), 0f);
    param_18 = _e208.xyz;
    let _e210 = Weight_u0028_vf3_u003b((&param_18));
    northWest = _e210;
    let _e211 = v_uv_1;
    let _e212 = texel;
    let _e214 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e211 + _e212), 0f);
    param_19 = _e214.xyz;
    let _e216 = Weight_u0028_vf3_u003b((&param_19));
    southEast = _e216;
    let _e217 = v_uv_1;
    let _e219 = texel[0u];
    let _e221 = texel[1u];
    let _e225 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e217 + vec2<f32>(_e219, -(_e221))), 0f);
    param_20 = _e225.xyz;
    let _e227 = Weight_u0028_vf3_u003b((&param_20));
    northEast = _e227;
    let _e228 = v_uv_1;
    let _e230 = texel[0u];
    let _e233 = texel[1u];
    let _e236 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e228 + vec2<f32>(-(_e230), _e233)), 0f);
    param_21 = _e236.xyz;
    let _e238 = Weight_u0028_vf3_u003b((&param_21));
    southWest = _e238;
    let _e239 = northWest;
    let _e240 = southWest;
    let _e242 = west;
    let _e246 = north;
    let _e247 = south;
    let _e249 = mid;
    let _e255 = northEast;
    let _e256 = southEast;
    let _e258 = east;
    edgeHorizontal = ((abs(((_e239 + _e240) - (2f * _e242))) + (2f * abs(((_e246 + _e247) - (2f * _e249))))) + abs(((_e255 + _e256) - (2f * _e258))));
    let _e263 = northWest;
    let _e264 = northEast;
    let _e266 = north;
    let _e270 = west;
    let _e271 = east;
    let _e273 = mid;
    let _e279 = southWest;
    let _e280 = southEast;
    let _e282 = south;
    edgeVertical = ((abs(((_e263 + _e264) - (2f * _e266))) + (2f * abs(((_e270 + _e271) - (2f * _e273))))) + abs(((_e279 + _e280) - (2f * _e282))));
    let _e287 = edgeHorizontal;
    let _e288 = edgeVertical;
    horizontalSpan = (_e287 >= _e288);
    let _e290 = north;
    let _e291 = south;
    let _e293 = west;
    let _e295 = east;
    let _e298 = northWest;
    let _e300 = northEast;
    let _e302 = southWest;
    let _e304 = southEast;
    lowPass = ((((((2f * (((_e290 + _e291) + _e293) + _e295)) + _e298) + _e300) + _e302) + _e304) / 12f);
    let _e307 = lowPass;
    let _e308 = mid;
    let _e311 = contrast;
    subpixC = clamp((abs((_e307 - _e308)) / _e311), 0f, 1f);
    let _e314 = subpixC;
    let _e317 = subpixC;
    let _e319 = subpixC;
    subpixF = (((3f - (2f * _e314)) * _e317) * _e319);
    let _e321 = subpixF;
    let _e322 = subpixF;
    let _e326 = fxaa_info.params[3u];
    subpixH = ((_e321 * _e322) * _e326);
    let _e328 = horizontalSpan;
    let _e329 = north;
    let _e330 = west;
    lumaN = select(_e330, _e329, _e328);
    let _e332 = horizontalSpan;
    let _e333 = south;
    let _e334 = east;
    lumaS = select(_e334, _e333, _e332);
    let _e336 = lumaN;
    let _e337 = mid;
    gradientN = (_e336 - _e337);
    let _e339 = lumaS;
    let _e340 = mid;
    gradientS = (_e339 - _e340);
    let _e342 = gradientN;
    let _e344 = gradientS;
    pairN = (abs(_e342) >= abs(_e344));
    let _e347 = gradientN;
    let _e349 = gradientS;
    gradient = max(abs(_e347), abs(_e349));
    let _e352 = horizontalSpan;
    if _e352 {
        let _e354 = texel[1u];
        local_2 = _e354;
    } else {
        let _e356 = texel[0u];
        local_2 = _e356;
    }
    let _e357 = local_2;
    lengthSign = _e357;
    let _e358 = pairN;
    if _e358 {
        let _e359 = lengthSign;
        lengthSign = -(_e359);
    }
    let _e361 = pairN;
    if _e361 {
        let _e362 = lumaN;
        let _e363 = mid;
        local_3 = (_e362 + _e363);
    } else {
        let _e365 = lumaS;
        let _e366 = mid;
        local_3 = (_e365 + _e366);
    }
    let _e368 = local_3;
    pairAverage = (0.5f * _e368);
    let _e370 = horizontalSpan;
    if _e370 {
        let _e372 = texel[0u];
        local_4 = vec2<f32>(_e372, 0f);
    } else {
        let _e375 = texel[1u];
        local_4 = vec2<f32>(0f, _e375);
    }
    let _e377 = local_4;
    along = _e377;
    let _e378 = v_uv_1;
    let _e379 = horizontalSpan;
    if _e379 {
        let _e380 = lengthSign;
        local_5 = vec2<f32>(0f, (_e380 * 0.5f));
    } else {
        let _e383 = lengthSign;
        local_5 = vec2<f32>((_e383 * 0.5f), 0f);
    }
    let _e386 = local_5;
    start = (_e378 + _e386);
    let _e388 = gradient;
    gradientScaled = (_e388 * 0.25f);
    let _e390 = start;
    let _e391 = along;
    posN = (_e390 - _e391);
    let _e393 = start;
    let _e394 = along;
    posP = (_e393 + _e394);
    let _e396 = posN;
    let _e397 = textureSampleLevel(source_texture_tex, source_texture_smp, _e396, 0f);
    param_22 = _e397.xyz;
    let _e399 = Weight_u0028_vf3_u003b((&param_22));
    let _e400 = pairAverage;
    endN = (_e399 - _e400);
    let _e402 = posP;
    let _e403 = textureSampleLevel(source_texture_tex, source_texture_smp, _e402, 0f);
    param_23 = _e403.xyz;
    let _e405 = Weight_u0028_vf3_u003b((&param_23));
    let _e406 = pairAverage;
    endP = (_e405 - _e406);
    let _e408 = endN;
    let _e410 = gradientScaled;
    doneN = (abs(_e408) >= _e410);
    let _e412 = endP;
    let _e414 = gradientScaled;
    doneP = (abs(_e412) >= _e414);
    i_1 = 1i;
    loop {
        let _e416 = i_1;
        if (_e416 < 5i) {
            let _e418 = doneN;
            let _e419 = doneP;
            if (_e418 && _e419) {
                break;
            }
            let _e421 = i_1;
            param_24 = _e421;
            let _e422 = SearchStep_u0028_i1_u003b((&param_24));
            stride = _e422;
            let _e423 = doneN;
            if !(_e423) {
                let _e425 = along;
                let _e426 = stride;
                let _e428 = posN;
                posN = (_e428 - (_e425 * _e426));
                let _e430 = posN;
                let _e431 = textureSampleLevel(source_texture_tex, source_texture_smp, _e430, 0f);
                param_25 = _e431.xyz;
                let _e433 = Weight_u0028_vf3_u003b((&param_25));
                let _e434 = pairAverage;
                endN = (_e433 - _e434);
                let _e436 = endN;
                let _e438 = gradientScaled;
                doneN = (abs(_e436) >= _e438);
            }
            let _e440 = doneP;
            if !(_e440) {
                let _e442 = along;
                let _e443 = stride;
                let _e445 = posP;
                posP = (_e445 + (_e442 * _e443));
                let _e447 = posP;
                let _e448 = textureSampleLevel(source_texture_tex, source_texture_smp, _e447, 0f);
                param_26 = _e448.xyz;
                let _e450 = Weight_u0028_vf3_u003b((&param_26));
                let _e451 = pairAverage;
                endP = (_e450 - _e451);
                let _e453 = endP;
                let _e455 = gradientScaled;
                doneP = (abs(_e453) >= _e455);
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e457 = i_1;
            i_1 = (_e457 + 1i);
        }
    }
    let _e459 = horizontalSpan;
    if _e459 {
        let _e461 = v_uv_1[0u];
        let _e463 = posN[0u];
        local_6 = (_e461 - _e463);
    } else {
        let _e466 = v_uv_1[1u];
        let _e468 = posN[1u];
        local_6 = (_e466 - _e468);
    }
    let _e470 = local_6;
    distanceN = _e470;
    let _e471 = horizontalSpan;
    if _e471 {
        let _e473 = posP[0u];
        let _e475 = v_uv_1[0u];
        local_7 = (_e473 - _e475);
    } else {
        let _e478 = posP[1u];
        let _e480 = v_uv_1[1u];
        local_7 = (_e478 - _e480);
    }
    let _e482 = local_7;
    distanceP = _e482;
    let _e483 = mid;
    let _e484 = pairAverage;
    middleBelow = ((_e483 - _e484) < 0f);
    let _e487 = distanceN;
    let _e488 = distanceP;
    nearerN = (_e487 < _e488);
    let _e490 = nearerN;
    if _e490 {
        let _e491 = endN;
        let _e493 = middleBelow;
        local_8 = ((_e491 < 0f) != _e493);
    } else {
        let _e495 = endP;
        let _e497 = middleBelow;
        local_8 = ((_e495 < 0f) != _e497);
    }
    let _e499 = local_8;
    goodSpan = _e499;
    let _e500 = distanceN;
    let _e501 = distanceP;
    nearest = min(_e500, _e501);
    let _e503 = nearest;
    let _e504 = distanceN;
    let _e505 = distanceP;
    pixelOffset = (0.5f - (_e503 / (_e504 + _e505)));
    let _e509 = goodSpan;
    let _e510 = pixelOffset;
    let _e512 = subpixH;
    offset = max(select(0f, _e510, _e509), _e512);
    let _e514 = v_uv_1;
    let _e515 = horizontalSpan;
    if _e515 {
        let _e516 = offset;
        let _e517 = lengthSign;
        local_9 = vec2<f32>(0f, (_e516 * _e517));
    } else {
        let _e520 = offset;
        let _e521 = lengthSign;
        local_9 = vec2<f32>((_e520 * _e521), 0f);
    }
    let _e524 = local_9;
    at = (_e514 + _e524);
    let _e526 = at;
    let _e527 = textureSampleLevel(source_texture_tex, source_texture_smp, _e526, 0f);
    smoothed = _e527.xyz;
    let _e529 = smoothed;
    param_27 = _e529;
    let _e530 = northRgb;
    param_28 = _e530;
    let _e531 = southRgb;
    param_29 = _e531;
    let _e532 = westRgb;
    param_30 = _e532;
    let _e533 = eastRgb;
    param_31 = _e533;
    let _e534 = Sharpen_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_27), (&param_28), (&param_29), (&param_30), (&param_31));
    frag_color = vec4<f32>(_e534.x, _e534.y, _e534.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FxaaInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'sharpen',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'SmaaEdges': WebGpuStage(
      wgsl: r'''
struct SmaaInfo {
    params: vec4<f32>,
}

@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> smaa_info: SmaaInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn Luma_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    var c: vec3<f32>;

    let _e19 = (*at);
    let _e20 = textureSampleLevel(source_texture_tex, source_texture_smp, _e19, 0f);
    c = _e20.xyz;
    let _e22 = c;
    return dot(_e22, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn main_1() {
    var texel: vec2<f32>;
    var middle: f32;
    var param: vec2<f32>;
    var left: f32;
    var param_1: vec2<f32>;
    var top: f32;
    var param_2: vec2<f32>;
    var delta: vec2<f32>;
    var edges: vec2<f32>;
    var right: f32;
    var param_3: vec2<f32>;
    var bottom: f32;
    var param_4: vec2<f32>;
    var leftLeft: f32;
    var param_5: vec2<f32>;
    var topTop: f32;
    var param_6: vec2<f32>;
    var largest: f32;

    let _e36 = smaa_info.params;
    texel = _e36.xy;
    let _e38 = v_uv_1;
    param = _e38;
    let _e39 = Luma_u0028_vf2_u003b((&param));
    middle = _e39;
    let _e40 = v_uv_1;
    let _e42 = texel[0u];
    param_1 = (_e40 + vec2<f32>(-(_e42), 0f));
    let _e46 = Luma_u0028_vf2_u003b((&param_1));
    left = _e46;
    let _e47 = v_uv_1;
    let _e49 = texel[1u];
    param_2 = (_e47 + vec2<f32>(0f, -(_e49)));
    let _e53 = Luma_u0028_vf2_u003b((&param_2));
    top = _e53;
    let _e54 = middle;
    let _e55 = left;
    let _e57 = middle;
    let _e58 = top;
    delta = abs(vec2<f32>((_e54 - _e55), (_e57 - _e58)));
    let _e64 = smaa_info.params[2u];
    let _e66 = delta;
    edges = step(vec2(_e64), _e66);
    let _e69 = edges[0u];
    let _e71 = edges[1u];
    if ((_e69 + _e71) == 0f) {
        frag_color = vec4<f32>(0f, 0f, 0f, 0f);
        return;
    }
    let _e74 = middle;
    let _e75 = v_uv_1;
    let _e77 = texel[0u];
    param_3 = (_e75 + vec2<f32>(_e77, 0f));
    let _e80 = Luma_u0028_vf2_u003b((&param_3));
    right = abs((_e74 - _e80));
    let _e83 = middle;
    let _e84 = v_uv_1;
    let _e86 = texel[1u];
    param_4 = (_e84 + vec2<f32>(0f, _e86));
    let _e89 = Luma_u0028_vf2_u003b((&param_4));
    bottom = abs((_e83 - _e89));
    let _e92 = left;
    let _e93 = v_uv_1;
    let _e95 = texel[0u];
    param_5 = (_e93 + vec2<f32>((-2f * _e95), 0f));
    let _e99 = Luma_u0028_vf2_u003b((&param_5));
    leftLeft = abs((_e92 - _e99));
    let _e102 = top;
    let _e103 = v_uv_1;
    let _e105 = texel[1u];
    param_6 = (_e103 + vec2<f32>(0f, (-2f * _e105)));
    let _e109 = Luma_u0028_vf2_u003b((&param_6));
    topTop = abs((_e102 - _e109));
    let _e113 = delta[0u];
    let _e115 = delta[1u];
    let _e117 = right;
    let _e118 = bottom;
    let _e121 = leftLeft;
    let _e122 = topTop;
    largest = max(max(max(_e113, _e115), max(_e117, _e118)), max(_e121, _e122));
    let _e125 = largest;
    let _e129 = smaa_info.params[3u];
    let _e130 = delta;
    let _e133 = edges;
    edges = (_e133 * step(vec2(_e125), (_e130 * _e129)));
    let _e135 = edges;
    frag_color = vec4<f32>(_e135.x, _e135.y, 0f, 0f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'SmaaInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'SmaaWeights': WebGpuStage(
      wgsl: r'''
struct SmaaInfo {
    params: vec4<f32>,
}

@group(1) @binding(3)
var edges_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var edges_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> smaa_info: SmaaInfo;
@group(1) @binding(1)
var area_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var area_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn Area_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b(first: ptr<function, f32>, last: ptr<function, f32>, codeFirst: ptr<function, f32>, codeLast: ptr<function, f32>) -> vec2<f32> {
    var at: vec2<f32>;

    let _e28 = (*codeFirst);
    let _e29 = (*codeLast);
    let _e32 = (*first);
    let _e33 = (*last);
    at = ((((vec2<f32>(_e28, _e29) * 16f) + sqrt(vec2<f32>(_e32, _e33))) + vec2(0.5f)) / vec2(80f));
    let _e41 = at;
    let _e42 = textureSampleLevel(area_texture_tex, area_texture_smp, _e41, 0f);
    return _e42.xy;
}

fn Edges_u0028_vf2_u003b(offset: ptr<function, vec2<f32>>) -> vec4<f32> {
    let _e24 = v_uv_1;
    let _e25 = (*offset);
    let _e27 = smaa_info.params;
    let _e31 = textureSampleLevel(edges_texture_tex, edges_texture_smp, (_e24 + (_e25 * _e27.xy)), 0f);
    return _e31;
}

fn main_1() {
    var here: vec4<f32>;
    var param: vec2<f32>;
    var weights: vec4<f32>;
    var first_1: i32;
    var i: i32;
    var param_1: vec2<f32>;
    var param_2: vec2<f32>;
    var last_1: i32;
    var i_1: i32;
    var next: vec4<f32>;
    var param_3: vec2<f32>;
    var f: f32;
    var l: f32;
    var codeFirst_1: f32;
    var local: f32;
    var param_4: vec2<f32>;
    var param_5: vec2<f32>;
    var codeLast_1: f32;
    var local_1: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: f32;
    var param_9: f32;
    var param_10: f32;
    var param_11: f32;
    var first_2: i32;
    var i_2: i32;
    var param_12: vec2<f32>;
    var param_13: vec2<f32>;
    var last_2: i32;
    var i_3: i32;
    var next_1: vec4<f32>;
    var param_14: vec2<f32>;
    var f_1: f32;
    var l_1: f32;
    var codeFirst_2: f32;
    var local_2: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var codeLast_2: f32;
    var local_3: f32;
    var param_17: vec2<f32>;
    var param_18: vec2<f32>;
    var param_19: f32;
    var param_20: f32;
    var param_21: f32;
    var param_22: f32;
    var phi_126_: bool;
    var phi_159_: bool;
    var phi_265_: bool;
    var phi_297_: bool;

    param = vec2<f32>(0f, 0f);
    let _e70 = Edges_u0028_vf2_u003b((&param));
    here = _e70;
    weights = vec4<f32>(0f, 0f, 0f, 0f);
    let _e72 = here[1u];
    if (_e72 > 0.5f) {
        first_1 = 32i;
        i = 0i;
        loop {
            let _e74 = i;
            if (_e74 < 32i) {
                let _e76 = i;
                param_1 = vec2<f32>(-(f32(_e76)), 0f);
                let _e80 = Edges_u0028_vf2_u003b((&param_1));
                let _e82 = (_e80.x > 0.5f);
                phi_126_ = _e82;
                if !(_e82) {
                    let _e84 = i;
                    param_2 = vec2<f32>((-(f32(_e84)) - 1f), 0f);
                    let _e89 = Edges_u0028_vf2_u003b((&param_2));
                    phi_126_ = (_e89.y < 0.5f);
                }
                let _e93 = phi_126_;
                if _e93 {
                    let _e94 = i;
                    first_1 = _e94;
                    break;
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e95 = i;
                i = (_e95 + 1i);
            }
        }
        last_1 = 32i;
        i_1 = 0i;
        loop {
            let _e97 = i_1;
            if (_e97 < 32i) {
                let _e99 = i_1;
                param_3 = vec2<f32>((f32(_e99) + 1f), 0f);
                let _e103 = Edges_u0028_vf2_u003b((&param_3));
                next = _e103;
                let _e105 = next[0u];
                let _e106 = (_e105 > 0.5f);
                phi_159_ = _e106;
                if !(_e106) {
                    let _e109 = next[1u];
                    phi_159_ = (_e109 < 0.5f);
                }
                let _e112 = phi_159_;
                if _e112 {
                    let _e113 = i_1;
                    last_1 = _e113;
                    break;
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e114 = i_1;
                i_1 = (_e114 + 1i);
            }
        }
        let _e116 = first_1;
        f = f32(_e116);
        let _e118 = last_1;
        l = f32(_e118);
        let _e120 = first_1;
        if (_e120 == 32i) {
            local = 0f;
        } else {
            let _e122 = f;
            param_4 = vec2<f32>(-(_e122), 0f);
            let _e125 = Edges_u0028_vf2_u003b((&param_4));
            let _e128 = f;
            param_5 = vec2<f32>(-(_e128), -1f);
            let _e131 = Edges_u0028_vf2_u003b((&param_5));
            local = ((3f * _e125.x) + _e131.x);
        }
        let _e134 = local;
        codeFirst_1 = _e134;
        let _e135 = last_1;
        if (_e135 == 32i) {
            local_1 = 0f;
        } else {
            let _e137 = l;
            param_6 = vec2<f32>((_e137 + 1f), 0f);
            let _e140 = Edges_u0028_vf2_u003b((&param_6));
            let _e143 = l;
            param_7 = vec2<f32>((_e143 + 1f), -1f);
            let _e146 = Edges_u0028_vf2_u003b((&param_7));
            local_1 = ((3f * _e140.x) + _e146.x);
        }
        let _e149 = local_1;
        codeLast_1 = _e149;
        let _e150 = f;
        param_8 = _e150;
        let _e151 = l;
        param_9 = _e151;
        let _e152 = codeFirst_1;
        param_10 = _e152;
        let _e153 = codeLast_1;
        param_11 = _e153;
        let _e154 = Area_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_8), (&param_9), (&param_10), (&param_11));
        weights[0u] = _e154.x;
        weights[1u] = _e154.y;
    }
    let _e160 = here[0u];
    if (_e160 > 0.5f) {
        first_2 = 32i;
        i_2 = 0i;
        loop {
            let _e162 = i_2;
            if (_e162 < 32i) {
                let _e164 = i_2;
                param_12 = vec2<f32>(0f, -(f32(_e164)));
                let _e168 = Edges_u0028_vf2_u003b((&param_12));
                let _e170 = (_e168.y > 0.5f);
                phi_265_ = _e170;
                if !(_e170) {
                    let _e172 = i_2;
                    param_13 = vec2<f32>(0f, (-(f32(_e172)) - 1f));
                    let _e177 = Edges_u0028_vf2_u003b((&param_13));
                    phi_265_ = (_e177.x < 0.5f);
                }
                let _e181 = phi_265_;
                if _e181 {
                    let _e182 = i_2;
                    first_2 = _e182;
                    break;
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e183 = i_2;
                i_2 = (_e183 + 1i);
            }
        }
        last_2 = 32i;
        i_3 = 0i;
        loop {
            let _e185 = i_3;
            if (_e185 < 32i) {
                let _e187 = i_3;
                param_14 = vec2<f32>(0f, (f32(_e187) + 1f));
                let _e191 = Edges_u0028_vf2_u003b((&param_14));
                next_1 = _e191;
                let _e193 = next_1[1u];
                let _e194 = (_e193 > 0.5f);
                phi_297_ = _e194;
                if !(_e194) {
                    let _e197 = next_1[0u];
                    phi_297_ = (_e197 < 0.5f);
                }
                let _e200 = phi_297_;
                if _e200 {
                    let _e201 = i_3;
                    last_2 = _e201;
                    break;
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e202 = i_3;
                i_3 = (_e202 + 1i);
            }
        }
        let _e204 = first_2;
        f_1 = f32(_e204);
        let _e206 = last_2;
        l_1 = f32(_e206);
        let _e208 = first_2;
        if (_e208 == 32i) {
            local_2 = 0f;
        } else {
            let _e210 = f_1;
            param_15 = vec2<f32>(0f, -(_e210));
            let _e213 = Edges_u0028_vf2_u003b((&param_15));
            let _e216 = f_1;
            param_16 = vec2<f32>(-1f, -(_e216));
            let _e219 = Edges_u0028_vf2_u003b((&param_16));
            local_2 = ((3f * _e213.y) + _e219.y);
        }
        let _e222 = local_2;
        codeFirst_2 = _e222;
        let _e223 = last_2;
        if (_e223 == 32i) {
            local_3 = 0f;
        } else {
            let _e225 = l_1;
            param_17 = vec2<f32>(0f, (_e225 + 1f));
            let _e228 = Edges_u0028_vf2_u003b((&param_17));
            let _e231 = l_1;
            param_18 = vec2<f32>(-1f, (_e231 + 1f));
            let _e234 = Edges_u0028_vf2_u003b((&param_18));
            local_3 = ((3f * _e228.y) + _e234.y);
        }
        let _e237 = local_3;
        codeLast_2 = _e237;
        let _e238 = f_1;
        param_19 = _e238;
        let _e239 = l_1;
        param_20 = _e239;
        let _e240 = codeFirst_2;
        param_21 = _e240;
        let _e241 = codeLast_2;
        param_22 = _e241;
        let _e242 = Area_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        weights[2u] = _e242.x;
        weights[3u] = _e242.y;
    }
    let _e247 = weights;
    frag_color = _e247;
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'SmaaInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'area_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'edges_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'SmaaBlend': WebGpuStage(
      wgsl: r'''
struct SmaaInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> smaa_info: SmaaInfo;
@group(1) @binding(1)
var blend_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var blend_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var source_texture_smp: sampler;

fn main_1() {
    var texel: vec2<f32>;
    var right: f32;
    var bottom: f32;
    var mine: vec4<f32>;
    var top: f32;
    var left: f32;
    var across: bool;
    var toward: f32;
    var away: f32;
    var axis: vec2<f32>;
    var local: vec2<f32>;
    var first: vec4<f32>;
    var second: vec4<f32>;
    var total: f32;

    let _e29 = smaa_info.params;
    texel = _e29.xy;
    let _e31 = v_uv_1;
    let _e33 = texel[0u];
    let _e36 = textureSampleLevel(blend_texture_tex, blend_texture_smp, (_e31 + vec2<f32>(_e33, 0f)), 0f);
    right = _e36.w;
    let _e38 = v_uv_1;
    let _e40 = texel[1u];
    let _e43 = textureSampleLevel(blend_texture_tex, blend_texture_smp, (_e38 + vec2<f32>(0f, _e40)), 0f);
    bottom = _e43.y;
    let _e45 = v_uv_1;
    let _e46 = textureSampleLevel(blend_texture_tex, blend_texture_smp, _e45, 0f);
    mine = _e46;
    let _e48 = mine[0u];
    top = _e48;
    let _e50 = mine[2u];
    left = _e50;
    let _e51 = right;
    let _e52 = bottom;
    let _e54 = top;
    let _e56 = left;
    if ((((_e51 + _e52) + _e54) + _e56) < 0.00001f) {
        let _e59 = v_uv_1;
        let _e60 = textureSampleLevel(source_texture_tex, source_texture_smp, _e59, 0f);
        frag_color = _e60;
        return;
    }
    let _e61 = right;
    let _e62 = left;
    let _e64 = bottom;
    let _e65 = top;
    across = (max(_e61, _e62) > max(_e64, _e65));
    let _e68 = across;
    let _e69 = right;
    let _e70 = bottom;
    toward = select(_e70, _e69, _e68);
    let _e72 = across;
    let _e73 = left;
    let _e74 = top;
    away = select(_e74, _e73, _e72);
    let _e76 = across;
    if _e76 {
        let _e78 = texel[0u];
        local = vec2<f32>(_e78, 0f);
    } else {
        let _e81 = texel[1u];
        local = vec2<f32>(0f, _e81);
    }
    let _e83 = local;
    axis = _e83;
    let _e84 = v_uv_1;
    let _e85 = toward;
    let _e86 = axis;
    let _e89 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e84 + (_e86 * _e85)), 0f);
    first = _e89;
    let _e90 = v_uv_1;
    let _e91 = away;
    let _e92 = axis;
    let _e95 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e90 - (_e92 * _e91)), 0f);
    second = _e95;
    let _e96 = toward;
    let _e97 = away;
    total = (_e96 + _e97);
    let _e99 = first;
    let _e100 = toward;
    let _e101 = total;
    let _e104 = second;
    let _e105 = away;
    let _e106 = total;
    frag_color = ((_e99 * (_e100 / _e101)) + (_e104 * (_e105 / _e106)));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'SmaaInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blend_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LensFlare': WebGpuStage(
      wgsl: r'''
struct LensFlareInfo {
    params: vec4<f32>,
    more: vec4<f32>,
}

@group(1) @binding(1)
var bloom_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var bloom_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> lens_flare_info: LensFlareInfo;
var<private> frag_color: vec4<f32>;

fn Falloff_u0028_vf2_u003b_f1_u003b(at: ptr<function, vec2<f32>>, power: ptr<function, f32>) -> f32 {
    var d: f32;

    let _e27 = (*at);
    d = (length((vec2<f32>(0.5f, 0.5f) - _e27)) / 0.70710677f);
    let _e31 = d;
    let _e34 = (*power);
    return pow(max((1f - _e31), 0f), _e34);
}

fn Fringed_u0028_vf2_u003b_vf2_u003b_f1_u003b(at_1: ptr<function, vec2<f32>>, along: ptr<function, vec2<f32>>, spread: ptr<function, f32>) -> vec3<f32> {
    let _e27 = (*at_1);
    let _e28 = (*along);
    let _e29 = (*spread);
    let _e32 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, (_e27 + (_e28 * _e29)), 0f);
    let _e34 = (*at_1);
    let _e35 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, _e34, 0f);
    let _e37 = (*at_1);
    let _e38 = (*along);
    let _e39 = (*spread);
    let _e42 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, (_e37 - (_e38 * _e39)), 0f);
    return vec3<f32>(_e32.x, _e35.y, _e42.z);
}

fn main_1() {
    var glow: vec3<f32>;
    var intensity: f32;
    var flipped: vec2<f32>;
    var towardMiddle: vec2<f32>;
    var reach: f32;
    var along_1: vec2<f32>;
    var local: vec2<f32>;
    var spread_1: f32;
    var flare: vec3<f32>;
    var ghosts: i32;
    var i: i32;
    var at_2: vec2<f32>;
    var param: vec2<f32>;
    var param_1: vec2<f32>;
    var param_2: f32;
    var param_3: vec2<f32>;
    var param_4: f32;
    var aspect: f32;
    var halo: vec2<f32>;
    var haloAt: vec2<f32>;
    var param_5: vec2<f32>;
    var param_6: vec2<f32>;
    var param_7: f32;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e49 = v_uv_1;
    let _e50 = textureSampleLevel(bloom_texture_tex, bloom_texture_smp, _e49, 0f);
    glow = _e50.xyz;
    let _e54 = lens_flare_info.params[0u];
    intensity = _e54;
    let _e55 = v_uv_1;
    flipped = (vec2<f32>(1f, 1f) - _e55);
    let _e57 = flipped;
    let _e61 = lens_flare_info.params[2u];
    towardMiddle = ((vec2<f32>(0.5f, 0.5f) - _e57) * _e61);
    let _e63 = towardMiddle;
    reach = length(_e63);
    let _e65 = reach;
    if (_e65 > 0.000001f) {
        let _e67 = towardMiddle;
        let _e68 = reach;
        local = (_e67 / vec2(_e68));
    } else {
        local = vec2<f32>(0f, 0f);
    }
    let _e71 = local;
    along_1 = _e71;
    let _e74 = lens_flare_info.more[0u];
    spread_1 = _e74;
    flare = vec3<f32>(0f, 0f, 0f);
    let _e77 = lens_flare_info.params[1u];
    ghosts = i32((_e77 + 0.5f));
    i = 0i;
    loop {
        let _e80 = i;
        if (_e80 < 8i) {
            let _e82 = i;
            let _e83 = ghosts;
            if (_e82 >= _e83) {
                break;
            }
            let _e85 = flipped;
            let _e86 = towardMiddle;
            let _e87 = i;
            at_2 = (_e85 + (_e86 * f32(_e87)));
            let _e91 = at_2;
            param = _e91;
            let _e92 = along_1;
            param_1 = _e92;
            let _e93 = spread_1;
            param_2 = _e93;
            let _e94 = Fringed_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param), (&param_1), (&param_2));
            let _e95 = at_2;
            param_3 = _e95;
            param_4 = 10f;
            let _e96 = Falloff_u0028_vf2_u003b_f1_u003b((&param_3), (&param_4));
            let _e98 = flare;
            flare = (_e98 + (_e94 * _e96));
            continue;
        } else {
            break;
        }
        continuing {
            let _e100 = i;
            i = (_e100 + 1i);
        }
    }
    let _e104 = lens_flare_info.more[2u];
    aspect = max(_e104, 0.0001f);
    let _e106 = along_1;
    let _e107 = aspect;
    let _e113 = lens_flare_info.params[3u];
    halo = ((_e106 * vec2<f32>((1f / _e107), 1f)) * _e113);
    let _e115 = flipped;
    let _e116 = halo;
    haloAt = (_e115 + _e116);
    let _e118 = haloAt;
    param_5 = _e118;
    let _e119 = along_1;
    param_6 = _e119;
    let _e120 = spread_1;
    param_7 = _e120;
    let _e121 = Fringed_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    let _e122 = haloAt;
    param_8 = _e122;
    param_9 = 5f;
    let _e123 = Falloff_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));
    let _e127 = lens_flare_info.more[1u];
    let _e129 = flare;
    flare = (_e129 + ((_e121 * _e123) * _e127));
    let _e131 = glow;
    let _e132 = flare;
    let _e133 = intensity;
    let _e135 = (_e131 + (_e132 * _e133));
    frag_color = vec4<f32>(_e135.x, _e135.y, _e135.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'LensFlareInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'more', offsetInBytes: 16, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'bloom_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'MrtProbe': WebGpuStage(
      wgsl: r'''
struct FragmentOutput {
    @location(0) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
}

var<private> out_first: vec4<f32>;
var<private> out_second: vec4<f32>;
var<private> v_uv_1: vec2<f32>;

fn main_1() {
    out_first = vec4<f32>(0.25f, 0.5f, 0.75f, 1f);
    out_second = vec4<f32>(0.75f, 0.5f, 0.25f, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> FragmentOutput {
    v_uv_1 = v_uv;
    main_1();
    let _e4 = out_first;
    let _e5 = out_second;
    return FragmentOutput(_e4, _e5);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'ShadowDepth': WebGpuStage(
      wgsl: r'''
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e20 = gl_FragCoord_1[2u];
    frag_color = vec4<f32>(_e20, 0f, 0f, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_texcoord_1 = v_texcoord;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'Particle': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;

fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var local: f32;

    let _e21 = fog_info.projection[0u];
    if (_e21 > 0.5f) {
        let _e23 = (*world);
        let _e25 = fog_info.eye;
        let _e29 = fog_info.forward;
        local = max(dot((_e23 - _e25.xyz), _e29.xyz), 0f);
    } else {
        let _e33 = (*world);
        let _e35 = fog_info.eye;
        local = distance(_e33, _e35.xyz);
    }
    let _e38 = local;
    return _e38;
}

fn FogTransmittance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;
    var param: vec3<f32>;

    let _e25 = fog_info.fog[3u];
    density = _e25;
    let _e26 = density;
    if (_e26 <= 0f) {
        return 1f;
    }
    let _e30 = fog_info.eye[3u];
    falloff = _e30;
    let _e31 = falloff;
    if (_e31 > 0f) {
        let _e33 = falloff;
        let _e35 = (*world_1)[1u];
        let _e38 = fog_info.eye[1u];
        k = (_e33 * (_e35 - _e38));
        let _e41 = k;
        if (abs(_e41) > 0.001f) {
            let _e44 = k;
            let _e48 = k;
            local_1 = ((1f - exp(-(_e44))) / _e48);
        } else {
            let _e50 = k;
            local_1 = (1f - (0.5f * _e50));
        }
        let _e53 = local_1;
        let _e54 = density;
        density = (_e54 * _e53);
    }
    let _e56 = density;
    let _e58 = (*world_1);
    param = _e58;
    let _e59 = FogDistance_u0028_vf3_u003b((&param));
    return clamp(exp((-(_e56) * _e59)), 0f, 1f);
}

fn main_1() {
    var centred: vec2<f32>;
    var radius: f32;
    var falloff_1: f32;
    var intensity: f32;
    var fogged: f32;
    var param_1: vec3<f32>;

    let _e23 = v_uv_1;
    centred = ((_e23 * 2f) - vec2(1f));
    let _e27 = centred;
    radius = length(_e27);
    let _e29 = radius;
    falloff_1 = (1f - smoothstep(0f, 1f, _e29));
    let _e32 = falloff_1;
    let _e33 = falloff_1;
    intensity = (_e32 * _e33);
    let _e35 = v_world_position_1;
    param_1 = _e35;
    let _e36 = FogTransmittance_u0028_vf3_u003b((&param_1));
    fogged = _e36;
    let _e37 = v_color_1;
    let _e40 = v_color_1[3u];
    let _e42 = intensity;
    let _e44 = fogged;
    let _e45 = (((_e37.xyz * _e40) * _e42) * _e44);
    frag_color = vec4<f32>(_e45.x, _e45.y, _e45.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    v_world_position_1 = v_world_position;
    v_color_1 = v_color;
    main_1();
    let _e7 = frag_color;
    return _e7;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'ParticleTextured': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
@group(1) @binding(1)
var particle_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var particle_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var local: f32;

    let _e22 = fog_info.projection[0u];
    if (_e22 > 0.5f) {
        let _e24 = (*world);
        let _e26 = fog_info.eye;
        let _e30 = fog_info.forward;
        local = max(dot((_e24 - _e26.xyz), _e30.xyz), 0f);
    } else {
        let _e34 = (*world);
        let _e36 = fog_info.eye;
        local = distance(_e34, _e36.xyz);
    }
    let _e39 = local;
    return _e39;
}

fn FogTransmittance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;
    var param: vec3<f32>;

    let _e26 = fog_info.fog[3u];
    density = _e26;
    let _e27 = density;
    if (_e27 <= 0f) {
        return 1f;
    }
    let _e31 = fog_info.eye[3u];
    falloff = _e31;
    let _e32 = falloff;
    if (_e32 > 0f) {
        let _e34 = falloff;
        let _e36 = (*world_1)[1u];
        let _e39 = fog_info.eye[1u];
        k = (_e34 * (_e36 - _e39));
        let _e42 = k;
        if (abs(_e42) > 0.001f) {
            let _e45 = k;
            let _e49 = k;
            local_1 = ((1f - exp(-(_e45))) / _e49);
        } else {
            let _e51 = k;
            local_1 = (1f - (0.5f * _e51));
        }
        let _e54 = local_1;
        let _e55 = density;
        density = (_e55 * _e54);
    }
    let _e57 = density;
    let _e59 = (*world_1);
    param = _e59;
    let _e60 = FogDistance_u0028_vf3_u003b((&param));
    return clamp(exp((-(_e57) * _e60)), 0f, 1f);
}

fn main_1() {
    var texel: vec4<f32>;
    var fogged: f32;
    var param_1: vec3<f32>;
    var scale: f32;

    let _e22 = v_uv_1;
    let _e23 = textureSample(particle_texture_tex, particle_texture_smp, _e22);
    texel = _e23;
    let _e24 = v_world_position_1;
    param_1 = _e24;
    let _e25 = FogTransmittance_u0028_vf3_u003b((&param_1));
    fogged = _e25;
    let _e27 = v_color_1[3u];
    let _e29 = texel[3u];
    let _e31 = fogged;
    scale = ((_e27 * _e29) * _e31);
    let _e33 = v_color_1;
    let _e35 = texel;
    let _e38 = scale;
    let _e39 = ((_e33.xyz * _e35.xyz) * _e38);
    frag_color = vec4<f32>(_e39.x, _e39.y, _e39.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    v_world_position_1 = v_world_position;
    v_color_1 = v_color;
    main_1();
    let _e7 = frag_color;
    return _e7;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'particle_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ParticleSixWay': WebGpuStage(
      wgsl: r'''
struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct ContributorLightInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    slots: vec4<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct SixWayInfo {
    right: vec4<f32>,
    up: vec4<f32>,
    forward: vec4<f32>,
    emission: vec4<f32>,
    ambient: vec4<f32>,
}

var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(4)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var light_list_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> contributor_light_info: ContributorLightInfo;
@group(1) @binding(1)
var<uniform> fog_info: FogInfo;
@group(1) @binding(3)
var<uniform> six_way_info: SixWayInfo;
@group(1) @binding(8)
var six_way_positive_tex: texture_2d<f32>;
@group(1) @binding(9)
var six_way_positive_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(6)
var six_way_negative_tex: texture_2d<f32>;
@group(1) @binding(7)
var six_way_negative_smp: sampler;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var local: f32;

    let _e50 = fog_info.projection[0u];
    if (_e50 > 0.5f) {
        let _e52 = (*world);
        let _e54 = fog_info.eye;
        let _e58 = fog_info.forward;
        local = max(dot((_e52 - _e54.xyz), _e58.xyz), 0f);
    } else {
        let _e62 = (*world);
        let _e64 = fog_info.eye;
        local = distance(_e62, _e64.xyz);
    }
    let _e67 = local;
    return _e67;
}

fn FogTransmittance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;
    var param: vec3<f32>;

    let _e54 = fog_info.fog[3u];
    density = _e54;
    let _e55 = density;
    if (_e55 <= 0f) {
        return 1f;
    }
    let _e59 = fog_info.eye[3u];
    falloff = _e59;
    let _e60 = falloff;
    if (_e60 > 0f) {
        let _e62 = falloff;
        let _e64 = (*world_1)[1u];
        let _e67 = fog_info.eye[1u];
        k = (_e62 * (_e64 - _e67));
        let _e70 = k;
        if (abs(_e70) > 0.001f) {
            let _e73 = k;
            let _e77 = k;
            local_1 = ((1f - exp(-(_e73))) / _e77);
        } else {
            let _e79 = k;
            local_1 = (1f - (0.5f * _e79));
        }
        let _e82 = local_1;
        let _e83 = density;
        density = (_e83 * _e82);
    }
    let _e85 = density;
    let _e87 = (*world_1);
    param = _e87;
    let _e88 = FogDistance_u0028_vf3_u003b((&param));
    return clamp(exp((-(_e85) * _e88)), 0f, 1f);
}

fn SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b(l: ptr<function, vec3<f32>>, positive: ptr<function, vec3<f32>>, negative: ptr<function, vec3<f32>>) -> f32 {
    var x: f32;
    var y: f32;
    var z: f32;
    var local_2: f32;
    var local_3: f32;
    var local_4: f32;

    let _e55 = (*l);
    let _e57 = six_way_info.right;
    x = dot(_e55, _e57.xyz);
    let _e60 = (*l);
    let _e62 = six_way_info.up;
    y = dot(_e60, _e62.xyz);
    let _e65 = (*l);
    let _e67 = six_way_info.forward;
    z = dot(_e65, _e67.xyz);
    let _e70 = x;
    let _e71 = x;
    let _e73 = x;
    if (_e73 > 0f) {
        let _e76 = (*positive)[0u];
        local_2 = _e76;
    } else {
        let _e78 = (*negative)[0u];
        local_2 = _e78;
    }
    let _e79 = local_2;
    let _e81 = y;
    let _e82 = y;
    let _e84 = y;
    if (_e84 > 0f) {
        let _e87 = (*positive)[1u];
        local_3 = _e87;
    } else {
        let _e89 = (*negative)[1u];
        local_3 = _e89;
    }
    let _e90 = local_3;
    let _e93 = z;
    let _e94 = z;
    let _e96 = z;
    if (_e96 > 0f) {
        let _e99 = (*positive)[2u];
        local_4 = _e99;
    } else {
        let _e101 = (*negative)[2u];
        local_4 = _e101;
    }
    let _e102 = local_4;
    return ((((_e70 * _e71) * _e79) + ((_e81 * _e82) * _e90)) + ((_e93 * _e94) * _e102));
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_5: f32;
    var local_6: f32;
    var local_7: f32;

    let _e52 = (*slot);
    let _e53 = (*slot);
    lane = (_e52 - ((_e53 / 4i) * 4i));
    let _e57 = lane;
    if (_e57 == 0i) {
        let _e60 = (*four)[0u];
        local_5 = _e60;
    } else {
        let _e61 = lane;
        if (_e61 == 1i) {
            let _e64 = (*four)[1u];
            local_6 = _e64;
        } else {
            let _e65 = lane;
            if (_e65 == 2i) {
                let _e68 = (*four)[2u];
                local_7 = _e68;
            } else {
                let _e70 = (*four)[3u];
                local_7 = _e70;
            }
            let _e71 = local_7;
            local_6 = _e71;
        }
        let _e72 = local_6;
        local_5 = _e72;
    }
    let _e73 = local_5;
    return _e73;
}

fn LightListScale_u0028_i1_u003b(slot_1: ptr<function, i32>) -> f32 {
    var param_1: vec4<f32>;
    var param_2: i32;

    let _e49 = (*slot_1);
    let _e53 = light_list_info.scales[(_e49 / 4i)];
    param_1 = _e53;
    let _e54 = (*slot_1);
    param_2 = _e54;
    let _e55 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_1), (&param_2));
    return _e55;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a: vec4<f32>;
    var b: vec4<f32>;

    let _e51 = light_list_info.slot_rows[0i];
    let _e52 = (*row);
    a = abs((_e51 - vec4(_e52)));
    let _e58 = light_list_info.slot_rows[1i];
    let _e59 = (*row);
    b = abs((_e58 - vec4(_e59)));
    let _e64 = a[0u];
    let _e66 = a[1u];
    let _e69 = a[2u];
    let _e71 = a[3u];
    let _e75 = b[0u];
    let _e77 = b[1u];
    let _e80 = b[2u];
    let _e82 = b[3u];
    return (min(min(min(_e64, _e66), min(_e69, _e71)), min(min(_e75, _e77), min(_e80, _e82))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_3: vec4<f32>;
    var param_4: i32;

    let _e49 = (*slot_2);
    let _e53 = light_list_info.indices[(_e49 / 4i)];
    param_3 = _e53;
    let _e54 = (*slot_2);
    param_4 = _e54;
    let _e55 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_3), (&param_4));
    return _e55;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e48 = (*texel);
    let _e52 = light_list_info.list[1u];
    let _e54 = (*row_1);
    let _e58 = light_list_info.list[2u];
    let _e61 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e48 + 0.5f) * _e52), ((_e54 + 0.5f) * _e58)), 0f);
    return _e61;
}

fn ClusterRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var entry: f32;
    var row_2: f32;
    var within: f32;
    var texel_1: f32;
    var four_1: vec4<f32>;
    var param_5: f32;
    var param_6: f32;
    var param_7: vec4<f32>;
    var param_8: i32;

    let _e56 = g_cluster_offset;
    let _e57 = (*slot_3);
    entry = (_e56 + f32(_e57));
    let _e60 = entry;
    row_2 = floor((_e60 / 16f));
    let _e63 = entry;
    let _e64 = row_2;
    within = (_e63 - (_e64 * 16f));
    let _e67 = within;
    texel_1 = floor((_e67 / 4f));
    let _e72 = light_list_info.cluster_depth[3u];
    let _e73 = row_2;
    let _e75 = texel_1;
    param_5 = _e75;
    param_6 = (_e72 + _e73);
    let _e76 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_5), (&param_6));
    four_1 = _e76;
    let _e77 = within;
    let _e78 = texel_1;
    let _e83 = four_1;
    param_7 = _e83;
    param_8 = i32(((_e77 - (_e78 * 4f)) + 0.5f));
    let _e84 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_7), (&param_8));
    return _e84;
}

fn Clustered_u0028_() -> bool {
    let _e48 = light_list_info.cluster_grid[3u];
    return (_e48 > 0.5f);
}

fn ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b(index: ptr<function, i32>, world_2: ptr<function, vec3<f32>>, toLight: ptr<function, vec3<f32>>, radiance: ptr<function, vec3<f32>>) {
    var position: vec4<f32>;
    var color: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_4: i32;
    var clustered: bool;
    var listRow: f32;
    var local_8: f32;
    var param_9: i32;
    var param_10: i32;
    var v: f32;
    var u: f32;
    var local_9: f32;
    var param_11: f32;
    var param_12: i32;
    var type_30: f32;
    var directional: bool;
    var offset: vec3<f32>;
    var distance_: f32;
    var aim: vec3<f32>;
    var degenerate: bool;
    var local_10: vec3<f32>;
    var ratio: f32;
    var local_11: f32;
    var window: f32;
    var falloff_1: f32;
    var spot: bool;
    var linearRamp: f32;
    var local_12: f32;
    var ramp: f32;
    var attenuation: f32;
    var local_13: f32;
    var local_14: f32;
    var local_15: f32;

    let _e84 = (*index);
    if (_e84 < 8i) {
        let _e86 = (*index);
        let _e89 = contributor_light_info.light_position[_e86];
        position = _e89;
        let _e90 = (*index);
        let _e93 = contributor_light_info.light_color[_e90];
        color = _e93;
        let _e94 = (*index);
        let _e97 = contributor_light_info.light_direction[_e94];
        direction = _e97;
        let _e98 = (*index);
        let _e101 = contributor_light_info.light_cone[_e98];
        cone = _e101;
    } else {
        let _e102 = (*index);
        slot_4 = (_e102 - 8i);
        let _e104 = Clustered_u0028_();
        clustered = _e104;
        let _e105 = clustered;
        if _e105 {
            let _e106 = slot_4;
            param_9 = _e106;
            let _e107 = ClusterRow_u0028_i1_u003b((&param_9));
            local_8 = _e107;
        } else {
            let _e108 = slot_4;
            param_10 = _e108;
            let _e109 = LightListRow_u0028_i1_u003b((&param_10));
            local_8 = _e109;
        }
        let _e110 = local_8;
        listRow = _e110;
        let _e111 = listRow;
        let _e115 = light_list_info.list[2u];
        v = ((_e111 + 0.5f) * _e115);
        let _e119 = light_list_info.list[1u];
        u = _e119;
        let _e120 = u;
        let _e122 = v;
        let _e124 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e120), _e122), 0f);
        position = _e124;
        let _e125 = u;
        let _e127 = v;
        let _e129 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e125), _e127), 0f);
        color = _e129;
        let _e130 = u;
        let _e132 = v;
        let _e134 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e130), _e132), 0f);
        direction = _e134;
        let _e135 = u;
        let _e137 = v;
        let _e139 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e135), _e137), 0f);
        cone = _e139;
        let _e140 = clustered;
        if _e140 {
            let _e141 = listRow;
            param_11 = _e141;
            let _e142 = InSlots_u0028_f1_u003b((&param_11));
            local_9 = select(1f, 0f, _e142);
        } else {
            let _e144 = slot_4;
            param_12 = _e144;
            let _e145 = LightListScale_u0028_i1_u003b((&param_12));
            local_9 = _e145;
        }
        let _e146 = local_9;
        let _e148 = color[3u];
        color[3u] = (_e148 * _e146);
    }
    let _e152 = position[3u];
    type_30 = _e152;
    let _e153 = type_30;
    directional = (_e153 < 0.5f);
    let _e155 = position;
    let _e157 = (*world_2);
    offset = (_e155.xyz - _e157);
    let _e159 = offset;
    distance_ = length(_e159);
    let _e161 = direction;
    aim = normalize(_e161.xyz);
    let _e164 = directional;
    let _e166 = distance_;
    degenerate = (!(_e164) && (_e166 < 0.000001f));
    let _e169 = directional;
    if _e169 {
        let _e170 = aim;
        local_10 = -(_e170);
    } else {
        let _e172 = offset;
        let _e173 = distance_;
        local_10 = (_e172 / vec3(max(_e173, 0.000001f)));
    }
    let _e177 = local_10;
    (*toLight) = _e177;
    let _e179 = direction[3u];
    if (_e179 > 0f) {
        let _e181 = distance_;
        let _e183 = direction[3u];
        local_11 = (_e181 / _e183);
    } else {
        local_11 = 0f;
    }
    let _e185 = local_11;
    ratio = _e185;
    let _e186 = ratio;
    let _e187 = ratio;
    let _e189 = ratio;
    let _e191 = ratio;
    window = clamp((1f - (((_e186 * _e187) * _e189) * _e191)), 0f, 1f);
    let _e195 = window;
    let _e196 = window;
    let _e198 = distance_;
    let _e199 = distance_;
    falloff_1 = ((_e195 * _e196) / max((_e198 * _e199), 0.0001f));
    let _e203 = type_30;
    let _e205 = type_30;
    spot = ((_e203 > 1.5f) && (_e205 < 2.5f));
    let _e208 = spot;
    if _e208 {
        let _e209 = aim;
        let _e210 = (*toLight);
        let _e214 = cone[1u];
        let _e217 = cone[0u];
        let _e219 = cone[1u];
        local_12 = clamp(((dot(_e209, -(_e210)) - _e214) / max((_e217 - _e219), 0.0001f)), 0f, 1f);
    } else {
        local_12 = 1f;
    }
    let _e224 = local_12;
    linearRamp = _e224;
    let _e225 = linearRamp;
    let _e226 = linearRamp;
    ramp = (_e225 * _e226);
    let _e228 = type_30;
    if (_e228 > 15.5f) {
        local_13 = 0f;
    } else {
        let _e230 = directional;
        if _e230 {
            local_14 = 1f;
        } else {
            let _e231 = degenerate;
            if _e231 {
                local_15 = 0f;
            } else {
                let _e232 = falloff_1;
                let _e233 = ramp;
                local_15 = (_e232 * _e233);
            }
            let _e235 = local_15;
            local_14 = _e235;
        }
        let _e236 = local_14;
        local_13 = _e236;
    }
    let _e237 = local_13;
    attenuation = _e237;
    let _e238 = color;
    let _e241 = color[3u];
    let _e243 = attenuation;
    (*radiance) = ((_e238.xyz * _e241) * _e243);
    return;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var grid: vec3<f32>;
    var near: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_16: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_13: f32;
    var param_14: f32;

    let _e61 = light_list_info.cluster_view_projection;
    let _e62 = (*world_3);
    clip = (_e61 * vec4<f32>(_e62.x, _e62.y, _e62.z, 1f));
    let _e68 = clip;
    let _e71 = clip[3u];
    ndc = (_e68.xy / vec2(max(_e71, 0.000001f)));
    let _e76 = light_list_info.cluster_grid;
    grid = _e76.xyz;
    let _e80 = light_list_info.cluster_depth[0u];
    near = _e80;
    let _e82 = ndc[0u];
    let _e86 = grid[0u];
    let _e90 = grid[0u];
    tx = clamp(floor((((_e82 * 0.5f) + 0.5f) * _e86)), 0f, (_e90 - 1f));
    let _e94 = ndc[1u];
    let _e98 = grid[1u];
    let _e102 = grid[1u];
    ty = clamp(floor((((_e94 * 0.5f) + 0.5f) * _e98)), 0f, (_e102 - 1f));
    let _e106 = clip[3u];
    let _e107 = near;
    if (_e106 <= _e107) {
        local_16 = 0f;
    } else {
        let _e110 = clip[3u];
        let _e111 = near;
        let _e116 = light_list_info.cluster_depth[1u];
        let _e120 = grid[2u];
        local_16 = clamp(floor((log((_e110 / _e111)) * _e116)), 0f, (_e120 - 1f));
    }
    let _e123 = local_16;
    tz = _e123;
    let _e124 = tx;
    let _e125 = ty;
    let _e127 = grid[0u];
    let _e130 = tz;
    let _e132 = grid[0u];
    let _e135 = grid[1u];
    cell = ((_e124 + (_e125 * _e127)) + ((_e130 * _e132) * _e135));
    let _e138 = cell;
    row_3 = floor((_e138 / 4f));
    let _e141 = cell;
    let _e142 = row_3;
    let _e147 = light_list_info.cluster_depth[2u];
    let _e148 = row_3;
    param_13 = (_e141 - (_e142 * 4f));
    param_14 = (_e147 + _e148);
    let _e150 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_13), (&param_14));
    header = _e150;
    let _e152 = header[0u];
    g_cluster_offset = _e152;
    let _e154 = header[1u];
    g_cluster_count = _e154;
    return;
}

fn ContributorLightCount_u0028_vf3_u003b(world_4: ptr<function, vec3<f32>>) -> i32 {
    var tail: f32;
    var param_15: vec3<f32>;

    let _e51 = light_list_info.list[0u];
    tail = _e51;
    let _e52 = Clustered_u0028_();
    if _e52 {
        let _e53 = (*world_4);
        param_15 = _e53;
        FindCluster_u0028_vf3_u003b((&param_15));
        let _e54 = g_cluster_count;
        tail = _e54;
    }
    let _e57 = contributor_light_info.slots[0u];
    let _e61 = tail;
    return (clamp(i32((_e57 + 0.5f)), 0i, 8i) + clamp(i32((_e61 + 0.5f)), 0i, 24i));
}

fn main_1() {
    var positive_1: vec4<f32>;
    var negative_1: vec4<f32>;
    var lit: vec3<f32>;
    var count: i32;
    var param_16: vec3<f32>;
    var i: i32;
    var l_1: vec3<f32>;
    var radiance_1: vec3<f32>;
    var param_17: i32;
    var param_18: vec3<f32>;
    var param_19: vec3<f32>;
    var param_20: vec3<f32>;
    var param_21: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var mean: f32;
    var color_1: vec3<f32>;
    var fogged: f32;
    var param_24: vec3<f32>;
    var coverage: f32;

    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    let _e66 = v_uv_1;
    let _e67 = textureSample(six_way_positive_tex, six_way_positive_smp, _e66);
    positive_1 = _e67;
    let _e68 = v_uv_1;
    let _e69 = textureSample(six_way_negative_tex, six_way_negative_smp, _e68);
    negative_1 = _e69;
    lit = vec3<f32>(0f, 0f, 0f);
    let _e70 = v_world_position_1;
    param_16 = _e70;
    let _e71 = ContributorLightCount_u0028_vf3_u003b((&param_16));
    count = _e71;
    i = 0i;
    loop {
        let _e72 = i;
        if (_e72 < 32i) {
            let _e74 = i;
            let _e75 = count;
            if (_e74 >= _e75) {
                break;
            }
            let _e77 = i;
            param_17 = _e77;
            let _e78 = v_world_position_1;
            param_18 = _e78;
            ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_17), (&param_18), (&param_19), (&param_20));
            let _e79 = param_19;
            l_1 = _e79;
            let _e80 = param_20;
            radiance_1 = _e80;
            let _e81 = radiance_1;
            let _e82 = l_1;
            param_21 = _e82;
            let _e83 = positive_1;
            param_22 = _e83.xyz;
            let _e85 = negative_1;
            param_23 = _e85.xyz;
            let _e87 = SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_21), (&param_22), (&param_23));
            let _e89 = lit;
            lit = (_e89 + (_e81 * _e87));
            continue;
        } else {
            break;
        }
        continuing {
            let _e91 = i;
            i = (_e91 + 1i);
        }
    }
    let _e94 = positive_1[0u];
    let _e96 = positive_1[1u];
    let _e99 = positive_1[2u];
    let _e102 = negative_1[0u];
    let _e105 = negative_1[1u];
    let _e108 = negative_1[2u];
    mean = ((((((_e94 + _e96) + _e99) + _e102) + _e105) + _e108) / 6f);
    let _e111 = v_color_1;
    let _e113 = lit;
    let _e115 = six_way_info.ambient;
    let _e117 = mean;
    let _e122 = six_way_info.emission;
    let _e125 = negative_1[3u];
    color_1 = ((_e111.xyz * (_e113 + (_e115.xyz * _e117))) + (_e122.xyz * _e125));
    let _e128 = v_world_position_1;
    param_24 = _e128;
    let _e129 = FogTransmittance_u0028_vf3_u003b((&param_24));
    fogged = _e129;
    let _e131 = fog_info.fog;
    let _e133 = color_1;
    let _e134 = fogged;
    color_1 = mix(_e131.xyz, _e133, vec3(_e134));
    let _e138 = v_color_1[3u];
    let _e140 = positive_1[3u];
    coverage = clamp((_e138 * _e140), 0f, 1f);
    let _e143 = color_1;
    let _e144 = coverage;
    let _e145 = (_e143 * _e144);
    let _e146 = coverage;
    frag_color = vec4<f32>(_e145.x, _e145.y, _e145.z, _e146);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    v_world_position_1 = v_world_position;
    v_color_1 = v_color;
    main_1();
    let _e7 = frag_color;
    return _e7;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ContributorLightInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 528,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SixWayInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'right', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'up', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emission',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'six_way_negative',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'six_way_positive',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ParticleSoft': WebGpuStage(
      wgsl: r'''
struct SoftParticleInfo {
    target_: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> soft_particle_info: SoftParticleInfo;
@group(1) @binding(2)
var scene_depth_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var scene_depth_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e24 = (*rows);
    if (_e24 > 0f) {
        let _e27 = gl_FragCoord_1[0u];
        let _e28 = (*rows);
        let _e30 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e27, (_e28 - _e30));
    } else {
        let _e33 = gl_FragCoord_1;
        local = _e33.xy;
    }
    let _e35 = local;
    return _e35;
}

fn SoftParticleFade_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var depth: f32;
    var fade: f32;

    let _e30 = soft_particle_info.target_[2u];
    param = _e30;
    let _e31 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e33 = soft_particle_info.target_;
    uv = (_e31 * _e33.xy);
    let _e36 = uv;
    let _e37 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e36, 0f);
    stored = _e37.w;
    let _e39 = (*world);
    let _e41 = soft_particle_info.eye;
    let _e45 = soft_particle_info.forward;
    depth = dot((_e39 - _e41.xyz), _e45.xyz);
    let _e48 = stored;
    let _e49 = depth;
    let _e53 = soft_particle_info.target_[3u];
    fade = clamp(((_e48 - _e49) * _e53), 0f, 1f);
    let _e56 = stored;
    let _e58 = fade;
    return select(1f, _e58, (_e56 > 0f));
}

fn FogDistance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var local_1: f32;

    let _e26 = fog_info.projection[0u];
    if (_e26 > 0.5f) {
        let _e28 = (*world_1);
        let _e30 = fog_info.eye;
        let _e34 = fog_info.forward;
        local_1 = max(dot((_e28 - _e30.xyz), _e34.xyz), 0f);
    } else {
        let _e38 = (*world_1);
        let _e40 = fog_info.eye;
        local_1 = distance(_e38, _e40.xyz);
    }
    let _e43 = local_1;
    return _e43;
}

fn FogTransmittance_u0028_vf3_u003b(world_2: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;
    var param_1: vec3<f32>;

    let _e30 = fog_info.fog[3u];
    density = _e30;
    let _e31 = density;
    if (_e31 <= 0f) {
        return 1f;
    }
    let _e35 = fog_info.eye[3u];
    falloff = _e35;
    let _e36 = falloff;
    if (_e36 > 0f) {
        let _e38 = falloff;
        let _e40 = (*world_2)[1u];
        let _e43 = fog_info.eye[1u];
        k = (_e38 * (_e40 - _e43));
        let _e46 = k;
        if (abs(_e46) > 0.001f) {
            let _e49 = k;
            let _e53 = k;
            local_2 = ((1f - exp(-(_e49))) / _e53);
        } else {
            let _e55 = k;
            local_2 = (1f - (0.5f * _e55));
        }
        let _e58 = local_2;
        let _e59 = density;
        density = (_e59 * _e58);
    }
    let _e61 = density;
    let _e63 = (*world_2);
    param_1 = _e63;
    let _e64 = FogDistance_u0028_vf3_u003b((&param_1));
    return clamp(exp((-(_e61) * _e64)), 0f, 1f);
}

fn main_1() {
    var centred: vec2<f32>;
    var radius: f32;
    var falloff_1: f32;
    var intensity: f32;
    var fogged: f32;
    var param_2: vec3<f32>;
    var param_3: vec3<f32>;

    let _e29 = v_uv_1;
    centred = ((_e29 * 2f) - vec2(1f));
    let _e33 = centred;
    radius = length(_e33);
    let _e35 = radius;
    falloff_1 = (1f - smoothstep(0f, 1f, _e35));
    let _e38 = falloff_1;
    let _e39 = falloff_1;
    intensity = (_e38 * _e39);
    let _e41 = v_world_position_1;
    param_2 = _e41;
    let _e42 = FogTransmittance_u0028_vf3_u003b((&param_2));
    fogged = _e42;
    let _e43 = v_world_position_1;
    param_3 = _e43;
    let _e44 = SoftParticleFade_u0028_vf3_u003b((&param_3));
    let _e45 = intensity;
    intensity = (_e45 * _e44);
    let _e47 = v_color_1;
    let _e50 = v_color_1[3u];
    let _e52 = intensity;
    let _e54 = fogged;
    let _e55 = (((_e47.xyz * _e50) * _e52) * _e54);
    frag_color = vec4<f32>(_e55.x, _e55.y, _e55.z, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    v_world_position_1 = v_world_position;
    v_color_1 = v_color;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SoftParticleInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'scene_depth_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ParticleTexturedSoft': WebGpuStage(
      wgsl: r'''
struct SoftParticleInfo {
    target_: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> soft_particle_info: SoftParticleInfo;
@group(1) @binding(4)
var scene_depth_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var scene_depth_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
@group(1) @binding(2)
var particle_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var particle_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e25 = (*rows);
    if (_e25 > 0f) {
        let _e28 = gl_FragCoord_1[0u];
        let _e29 = (*rows);
        let _e31 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e28, (_e29 - _e31));
    } else {
        let _e34 = gl_FragCoord_1;
        local = _e34.xy;
    }
    let _e36 = local;
    return _e36;
}

fn SoftParticleFade_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var depth: f32;
    var fade: f32;

    let _e31 = soft_particle_info.target_[2u];
    param = _e31;
    let _e32 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e34 = soft_particle_info.target_;
    uv = (_e32 * _e34.xy);
    let _e37 = uv;
    let _e38 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e37, 0f);
    stored = _e38.w;
    let _e40 = (*world);
    let _e42 = soft_particle_info.eye;
    let _e46 = soft_particle_info.forward;
    depth = dot((_e40 - _e42.xyz), _e46.xyz);
    let _e49 = stored;
    let _e50 = depth;
    let _e54 = soft_particle_info.target_[3u];
    fade = clamp(((_e49 - _e50) * _e54), 0f, 1f);
    let _e57 = stored;
    let _e59 = fade;
    return select(1f, _e59, (_e57 > 0f));
}

fn FogDistance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var local_1: f32;

    let _e27 = fog_info.projection[0u];
    if (_e27 > 0.5f) {
        let _e29 = (*world_1);
        let _e31 = fog_info.eye;
        let _e35 = fog_info.forward;
        local_1 = max(dot((_e29 - _e31.xyz), _e35.xyz), 0f);
    } else {
        let _e39 = (*world_1);
        let _e41 = fog_info.eye;
        local_1 = distance(_e39, _e41.xyz);
    }
    let _e44 = local_1;
    return _e44;
}

fn FogTransmittance_u0028_vf3_u003b(world_2: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;
    var param_1: vec3<f32>;

    let _e31 = fog_info.fog[3u];
    density = _e31;
    let _e32 = density;
    if (_e32 <= 0f) {
        return 1f;
    }
    let _e36 = fog_info.eye[3u];
    falloff = _e36;
    let _e37 = falloff;
    if (_e37 > 0f) {
        let _e39 = falloff;
        let _e41 = (*world_2)[1u];
        let _e44 = fog_info.eye[1u];
        k = (_e39 * (_e41 - _e44));
        let _e47 = k;
        if (abs(_e47) > 0.001f) {
            let _e50 = k;
            let _e54 = k;
            local_2 = ((1f - exp(-(_e50))) / _e54);
        } else {
            let _e56 = k;
            local_2 = (1f - (0.5f * _e56));
        }
        let _e59 = local_2;
        let _e60 = density;
        density = (_e60 * _e59);
    }
    let _e62 = density;
    let _e64 = (*world_2);
    param_1 = _e64;
    let _e65 = FogDistance_u0028_vf3_u003b((&param_1));
    return clamp(exp((-(_e62) * _e65)), 0f, 1f);
}

fn main_1() {
    var texel: vec4<f32>;
    var fogged: f32;
    var param_2: vec3<f32>;
    var scale: f32;
    var param_3: vec3<f32>;

    let _e28 = v_uv_1;
    let _e29 = textureSample(particle_texture_tex, particle_texture_smp, _e28);
    texel = _e29;
    let _e30 = v_world_position_1;
    param_2 = _e30;
    let _e31 = FogTransmittance_u0028_vf3_u003b((&param_2));
    fogged = _e31;
    let _e33 = v_color_1[3u];
    let _e35 = texel[3u];
    let _e37 = fogged;
    scale = ((_e33 * _e35) * _e37);
    let _e39 = v_world_position_1;
    param_3 = _e39;
    let _e40 = SoftParticleFade_u0028_vf3_u003b((&param_3));
    let _e41 = scale;
    scale = (_e41 * _e40);
    let _e43 = v_color_1;
    let _e45 = texel;
    let _e48 = scale;
    let _e49 = ((_e43.xyz * _e45.xyz) * _e48);
    frag_color = vec4<f32>(_e49.x, _e49.y, _e49.z, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    v_world_position_1 = v_world_position;
    v_color_1 = v_color;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SoftParticleInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'particle_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_depth_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ParticleSixWaySoft': WebGpuStage(
      wgsl: r'''
struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct ContributorLightInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    slots: vec4<f32>,
}

struct SoftParticleInfo {
    target_: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct SixWayInfo {
    right: vec4<f32>,
    up: vec4<f32>,
    forward: vec4<f32>,
    emission: vec4<f32>,
    ambient: vec4<f32>,
}

var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(5)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var light_list_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> contributor_light_info: ContributorLightInfo;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(4)
var<uniform> soft_particle_info: SoftParticleInfo;
@group(1) @binding(7)
var scene_depth_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_depth_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> fog_info: FogInfo;
@group(1) @binding(3)
var<uniform> six_way_info: SixWayInfo;
@group(1) @binding(11)
var six_way_positive_tex: texture_2d<f32>;
@group(1) @binding(12)
var six_way_positive_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(9)
var six_way_negative_tex: texture_2d<f32>;
@group(1) @binding(10)
var six_way_negative_smp: sampler;
var<private> v_world_position_1: vec3<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e52 = (*rows);
    if (_e52 > 0f) {
        let _e55 = gl_FragCoord_1[0u];
        let _e56 = (*rows);
        let _e58 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e55, (_e56 - _e58));
    } else {
        let _e61 = gl_FragCoord_1;
        local = _e61.xy;
    }
    let _e63 = local;
    return _e63;
}

fn SoftParticleFade_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var depth: f32;
    var fade: f32;

    let _e58 = soft_particle_info.target_[2u];
    param = _e58;
    let _e59 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e61 = soft_particle_info.target_;
    uv = (_e59 * _e61.xy);
    let _e64 = uv;
    let _e65 = textureSampleLevel(scene_depth_texture_tex, scene_depth_texture_smp, _e64, 0f);
    stored = _e65.w;
    let _e67 = (*world);
    let _e69 = soft_particle_info.eye;
    let _e73 = soft_particle_info.forward;
    depth = dot((_e67 - _e69.xyz), _e73.xyz);
    let _e76 = stored;
    let _e77 = depth;
    let _e81 = soft_particle_info.target_[3u];
    fade = clamp(((_e76 - _e77) * _e81), 0f, 1f);
    let _e84 = stored;
    let _e86 = fade;
    return select(1f, _e86, (_e84 > 0f));
}

fn FogDistance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var local_1: f32;

    let _e54 = fog_info.projection[0u];
    if (_e54 > 0.5f) {
        let _e56 = (*world_1);
        let _e58 = fog_info.eye;
        let _e62 = fog_info.forward;
        local_1 = max(dot((_e56 - _e58.xyz), _e62.xyz), 0f);
    } else {
        let _e66 = (*world_1);
        let _e68 = fog_info.eye;
        local_1 = distance(_e66, _e68.xyz);
    }
    let _e71 = local_1;
    return _e71;
}

fn FogTransmittance_u0028_vf3_u003b(world_2: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;
    var param_1: vec3<f32>;

    let _e58 = fog_info.fog[3u];
    density = _e58;
    let _e59 = density;
    if (_e59 <= 0f) {
        return 1f;
    }
    let _e63 = fog_info.eye[3u];
    falloff = _e63;
    let _e64 = falloff;
    if (_e64 > 0f) {
        let _e66 = falloff;
        let _e68 = (*world_2)[1u];
        let _e71 = fog_info.eye[1u];
        k = (_e66 * (_e68 - _e71));
        let _e74 = k;
        if (abs(_e74) > 0.001f) {
            let _e77 = k;
            let _e81 = k;
            local_2 = ((1f - exp(-(_e77))) / _e81);
        } else {
            let _e83 = k;
            local_2 = (1f - (0.5f * _e83));
        }
        let _e86 = local_2;
        let _e87 = density;
        density = (_e87 * _e86);
    }
    let _e89 = density;
    let _e91 = (*world_2);
    param_1 = _e91;
    let _e92 = FogDistance_u0028_vf3_u003b((&param_1));
    return clamp(exp((-(_e89) * _e92)), 0f, 1f);
}

fn SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b(l: ptr<function, vec3<f32>>, positive: ptr<function, vec3<f32>>, negative: ptr<function, vec3<f32>>) -> f32 {
    var x: f32;
    var y: f32;
    var z: f32;
    var local_3: f32;
    var local_4: f32;
    var local_5: f32;

    let _e59 = (*l);
    let _e61 = six_way_info.right;
    x = dot(_e59, _e61.xyz);
    let _e64 = (*l);
    let _e66 = six_way_info.up;
    y = dot(_e64, _e66.xyz);
    let _e69 = (*l);
    let _e71 = six_way_info.forward;
    z = dot(_e69, _e71.xyz);
    let _e74 = x;
    let _e75 = x;
    let _e77 = x;
    if (_e77 > 0f) {
        let _e80 = (*positive)[0u];
        local_3 = _e80;
    } else {
        let _e82 = (*negative)[0u];
        local_3 = _e82;
    }
    let _e83 = local_3;
    let _e85 = y;
    let _e86 = y;
    let _e88 = y;
    if (_e88 > 0f) {
        let _e91 = (*positive)[1u];
        local_4 = _e91;
    } else {
        let _e93 = (*negative)[1u];
        local_4 = _e93;
    }
    let _e94 = local_4;
    let _e97 = z;
    let _e98 = z;
    let _e100 = z;
    if (_e100 > 0f) {
        let _e103 = (*positive)[2u];
        local_5 = _e103;
    } else {
        let _e105 = (*negative)[2u];
        local_5 = _e105;
    }
    let _e106 = local_5;
    return ((((_e74 * _e75) * _e83) + ((_e85 * _e86) * _e94)) + ((_e97 * _e98) * _e106));
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_6: f32;
    var local_7: f32;
    var local_8: f32;

    let _e56 = (*slot);
    let _e57 = (*slot);
    lane = (_e56 - ((_e57 / 4i) * 4i));
    let _e61 = lane;
    if (_e61 == 0i) {
        let _e64 = (*four)[0u];
        local_6 = _e64;
    } else {
        let _e65 = lane;
        if (_e65 == 1i) {
            let _e68 = (*four)[1u];
            local_7 = _e68;
        } else {
            let _e69 = lane;
            if (_e69 == 2i) {
                let _e72 = (*four)[2u];
                local_8 = _e72;
            } else {
                let _e74 = (*four)[3u];
                local_8 = _e74;
            }
            let _e75 = local_8;
            local_7 = _e75;
        }
        let _e76 = local_7;
        local_6 = _e76;
    }
    let _e77 = local_6;
    return _e77;
}

fn LightListScale_u0028_i1_u003b(slot_1: ptr<function, i32>) -> f32 {
    var param_2: vec4<f32>;
    var param_3: i32;

    let _e53 = (*slot_1);
    let _e57 = light_list_info.scales[(_e53 / 4i)];
    param_2 = _e57;
    let _e58 = (*slot_1);
    param_3 = _e58;
    let _e59 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_2), (&param_3));
    return _e59;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a: vec4<f32>;
    var b: vec4<f32>;

    let _e55 = light_list_info.slot_rows[0i];
    let _e56 = (*row);
    a = abs((_e55 - vec4(_e56)));
    let _e62 = light_list_info.slot_rows[1i];
    let _e63 = (*row);
    b = abs((_e62 - vec4(_e63)));
    let _e68 = a[0u];
    let _e70 = a[1u];
    let _e73 = a[2u];
    let _e75 = a[3u];
    let _e79 = b[0u];
    let _e81 = b[1u];
    let _e84 = b[2u];
    let _e86 = b[3u];
    return (min(min(min(_e68, _e70), min(_e73, _e75)), min(min(_e79, _e81), min(_e84, _e86))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_4: vec4<f32>;
    var param_5: i32;

    let _e53 = (*slot_2);
    let _e57 = light_list_info.indices[(_e53 / 4i)];
    param_4 = _e57;
    let _e58 = (*slot_2);
    param_5 = _e58;
    let _e59 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_4), (&param_5));
    return _e59;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e52 = (*texel);
    let _e56 = light_list_info.list[1u];
    let _e58 = (*row_1);
    let _e62 = light_list_info.list[2u];
    let _e65 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e52 + 0.5f) * _e56), ((_e58 + 0.5f) * _e62)), 0f);
    return _e65;
}

fn ClusterRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var entry: f32;
    var row_2: f32;
    var within: f32;
    var texel_1: f32;
    var four_1: vec4<f32>;
    var param_6: f32;
    var param_7: f32;
    var param_8: vec4<f32>;
    var param_9: i32;

    let _e60 = g_cluster_offset;
    let _e61 = (*slot_3);
    entry = (_e60 + f32(_e61));
    let _e64 = entry;
    row_2 = floor((_e64 / 16f));
    let _e67 = entry;
    let _e68 = row_2;
    within = (_e67 - (_e68 * 16f));
    let _e71 = within;
    texel_1 = floor((_e71 / 4f));
    let _e76 = light_list_info.cluster_depth[3u];
    let _e77 = row_2;
    let _e79 = texel_1;
    param_6 = _e79;
    param_7 = (_e76 + _e77);
    let _e80 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_6), (&param_7));
    four_1 = _e80;
    let _e81 = within;
    let _e82 = texel_1;
    let _e87 = four_1;
    param_8 = _e87;
    param_9 = i32(((_e81 - (_e82 * 4f)) + 0.5f));
    let _e88 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_8), (&param_9));
    return _e88;
}

fn Clustered_u0028_() -> bool {
    let _e52 = light_list_info.cluster_grid[3u];
    return (_e52 > 0.5f);
}

fn ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b(index: ptr<function, i32>, world_3: ptr<function, vec3<f32>>, toLight: ptr<function, vec3<f32>>, radiance: ptr<function, vec3<f32>>) {
    var position: vec4<f32>;
    var color: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_4: i32;
    var clustered: bool;
    var listRow: f32;
    var local_9: f32;
    var param_10: i32;
    var param_11: i32;
    var v: f32;
    var u: f32;
    var local_10: f32;
    var param_12: f32;
    var param_13: i32;
    var type_31: f32;
    var directional: bool;
    var offset: vec3<f32>;
    var distance_: f32;
    var aim: vec3<f32>;
    var degenerate: bool;
    var local_11: vec3<f32>;
    var ratio: f32;
    var local_12: f32;
    var window: f32;
    var falloff_1: f32;
    var spot: bool;
    var linearRamp: f32;
    var local_13: f32;
    var ramp: f32;
    var attenuation: f32;
    var local_14: f32;
    var local_15: f32;
    var local_16: f32;

    let _e88 = (*index);
    if (_e88 < 8i) {
        let _e90 = (*index);
        let _e93 = contributor_light_info.light_position[_e90];
        position = _e93;
        let _e94 = (*index);
        let _e97 = contributor_light_info.light_color[_e94];
        color = _e97;
        let _e98 = (*index);
        let _e101 = contributor_light_info.light_direction[_e98];
        direction = _e101;
        let _e102 = (*index);
        let _e105 = contributor_light_info.light_cone[_e102];
        cone = _e105;
    } else {
        let _e106 = (*index);
        slot_4 = (_e106 - 8i);
        let _e108 = Clustered_u0028_();
        clustered = _e108;
        let _e109 = clustered;
        if _e109 {
            let _e110 = slot_4;
            param_10 = _e110;
            let _e111 = ClusterRow_u0028_i1_u003b((&param_10));
            local_9 = _e111;
        } else {
            let _e112 = slot_4;
            param_11 = _e112;
            let _e113 = LightListRow_u0028_i1_u003b((&param_11));
            local_9 = _e113;
        }
        let _e114 = local_9;
        listRow = _e114;
        let _e115 = listRow;
        let _e119 = light_list_info.list[2u];
        v = ((_e115 + 0.5f) * _e119);
        let _e123 = light_list_info.list[1u];
        u = _e123;
        let _e124 = u;
        let _e126 = v;
        let _e128 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e124), _e126), 0f);
        position = _e128;
        let _e129 = u;
        let _e131 = v;
        let _e133 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e129), _e131), 0f);
        color = _e133;
        let _e134 = u;
        let _e136 = v;
        let _e138 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e134), _e136), 0f);
        direction = _e138;
        let _e139 = u;
        let _e141 = v;
        let _e143 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e139), _e141), 0f);
        cone = _e143;
        let _e144 = clustered;
        if _e144 {
            let _e145 = listRow;
            param_12 = _e145;
            let _e146 = InSlots_u0028_f1_u003b((&param_12));
            local_10 = select(1f, 0f, _e146);
        } else {
            let _e148 = slot_4;
            param_13 = _e148;
            let _e149 = LightListScale_u0028_i1_u003b((&param_13));
            local_10 = _e149;
        }
        let _e150 = local_10;
        let _e152 = color[3u];
        color[3u] = (_e152 * _e150);
    }
    let _e156 = position[3u];
    type_31 = _e156;
    let _e157 = type_31;
    directional = (_e157 < 0.5f);
    let _e159 = position;
    let _e161 = (*world_3);
    offset = (_e159.xyz - _e161);
    let _e163 = offset;
    distance_ = length(_e163);
    let _e165 = direction;
    aim = normalize(_e165.xyz);
    let _e168 = directional;
    let _e170 = distance_;
    degenerate = (!(_e168) && (_e170 < 0.000001f));
    let _e173 = directional;
    if _e173 {
        let _e174 = aim;
        local_11 = -(_e174);
    } else {
        let _e176 = offset;
        let _e177 = distance_;
        local_11 = (_e176 / vec3(max(_e177, 0.000001f)));
    }
    let _e181 = local_11;
    (*toLight) = _e181;
    let _e183 = direction[3u];
    if (_e183 > 0f) {
        let _e185 = distance_;
        let _e187 = direction[3u];
        local_12 = (_e185 / _e187);
    } else {
        local_12 = 0f;
    }
    let _e189 = local_12;
    ratio = _e189;
    let _e190 = ratio;
    let _e191 = ratio;
    let _e193 = ratio;
    let _e195 = ratio;
    window = clamp((1f - (((_e190 * _e191) * _e193) * _e195)), 0f, 1f);
    let _e199 = window;
    let _e200 = window;
    let _e202 = distance_;
    let _e203 = distance_;
    falloff_1 = ((_e199 * _e200) / max((_e202 * _e203), 0.0001f));
    let _e207 = type_31;
    let _e209 = type_31;
    spot = ((_e207 > 1.5f) && (_e209 < 2.5f));
    let _e212 = spot;
    if _e212 {
        let _e213 = aim;
        let _e214 = (*toLight);
        let _e218 = cone[1u];
        let _e221 = cone[0u];
        let _e223 = cone[1u];
        local_13 = clamp(((dot(_e213, -(_e214)) - _e218) / max((_e221 - _e223), 0.0001f)), 0f, 1f);
    } else {
        local_13 = 1f;
    }
    let _e228 = local_13;
    linearRamp = _e228;
    let _e229 = linearRamp;
    let _e230 = linearRamp;
    ramp = (_e229 * _e230);
    let _e232 = type_31;
    if (_e232 > 15.5f) {
        local_14 = 0f;
    } else {
        let _e234 = directional;
        if _e234 {
            local_15 = 1f;
        } else {
            let _e235 = degenerate;
            if _e235 {
                local_16 = 0f;
            } else {
                let _e236 = falloff_1;
                let _e237 = ramp;
                local_16 = (_e236 * _e237);
            }
            let _e239 = local_16;
            local_15 = _e239;
        }
        let _e240 = local_15;
        local_14 = _e240;
    }
    let _e241 = local_14;
    attenuation = _e241;
    let _e242 = color;
    let _e245 = color[3u];
    let _e247 = attenuation;
    (*radiance) = ((_e242.xyz * _e245) * _e247);
    return;
}

fn FindCluster_u0028_vf3_u003b(world_4: ptr<function, vec3<f32>>) {
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var grid: vec3<f32>;
    var near: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_17: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_14: f32;
    var param_15: f32;

    let _e65 = light_list_info.cluster_view_projection;
    let _e66 = (*world_4);
    clip = (_e65 * vec4<f32>(_e66.x, _e66.y, _e66.z, 1f));
    let _e72 = clip;
    let _e75 = clip[3u];
    ndc = (_e72.xy / vec2(max(_e75, 0.000001f)));
    let _e80 = light_list_info.cluster_grid;
    grid = _e80.xyz;
    let _e84 = light_list_info.cluster_depth[0u];
    near = _e84;
    let _e86 = ndc[0u];
    let _e90 = grid[0u];
    let _e94 = grid[0u];
    tx = clamp(floor((((_e86 * 0.5f) + 0.5f) * _e90)), 0f, (_e94 - 1f));
    let _e98 = ndc[1u];
    let _e102 = grid[1u];
    let _e106 = grid[1u];
    ty = clamp(floor((((_e98 * 0.5f) + 0.5f) * _e102)), 0f, (_e106 - 1f));
    let _e110 = clip[3u];
    let _e111 = near;
    if (_e110 <= _e111) {
        local_17 = 0f;
    } else {
        let _e114 = clip[3u];
        let _e115 = near;
        let _e120 = light_list_info.cluster_depth[1u];
        let _e124 = grid[2u];
        local_17 = clamp(floor((log((_e114 / _e115)) * _e120)), 0f, (_e124 - 1f));
    }
    let _e127 = local_17;
    tz = _e127;
    let _e128 = tx;
    let _e129 = ty;
    let _e131 = grid[0u];
    let _e134 = tz;
    let _e136 = grid[0u];
    let _e139 = grid[1u];
    cell = ((_e128 + (_e129 * _e131)) + ((_e134 * _e136) * _e139));
    let _e142 = cell;
    row_3 = floor((_e142 / 4f));
    let _e145 = cell;
    let _e146 = row_3;
    let _e151 = light_list_info.cluster_depth[2u];
    let _e152 = row_3;
    param_14 = (_e145 - (_e146 * 4f));
    param_15 = (_e151 + _e152);
    let _e154 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_14), (&param_15));
    header = _e154;
    let _e156 = header[0u];
    g_cluster_offset = _e156;
    let _e158 = header[1u];
    g_cluster_count = _e158;
    return;
}

fn ContributorLightCount_u0028_vf3_u003b(world_5: ptr<function, vec3<f32>>) -> i32 {
    var tail: f32;
    var param_16: vec3<f32>;

    let _e55 = light_list_info.list[0u];
    tail = _e55;
    let _e56 = Clustered_u0028_();
    if _e56 {
        let _e57 = (*world_5);
        param_16 = _e57;
        FindCluster_u0028_vf3_u003b((&param_16));
        let _e58 = g_cluster_count;
        tail = _e58;
    }
    let _e61 = contributor_light_info.slots[0u];
    let _e65 = tail;
    return (clamp(i32((_e61 + 0.5f)), 0i, 8i) + clamp(i32((_e65 + 0.5f)), 0i, 24i));
}

fn main_1() {
    var positive_1: vec4<f32>;
    var negative_1: vec4<f32>;
    var lit: vec3<f32>;
    var count: i32;
    var param_17: vec3<f32>;
    var i: i32;
    var l_1: vec3<f32>;
    var radiance_1: vec3<f32>;
    var param_18: i32;
    var param_19: vec3<f32>;
    var param_20: vec3<f32>;
    var param_21: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: vec3<f32>;
    var mean: f32;
    var color_1: vec3<f32>;
    var fogged: f32;
    var param_25: vec3<f32>;
    var coverage: f32;
    var param_26: vec3<f32>;

    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    let _e71 = v_uv_1;
    let _e72 = textureSample(six_way_positive_tex, six_way_positive_smp, _e71);
    positive_1 = _e72;
    let _e73 = v_uv_1;
    let _e74 = textureSample(six_way_negative_tex, six_way_negative_smp, _e73);
    negative_1 = _e74;
    lit = vec3<f32>(0f, 0f, 0f);
    let _e75 = v_world_position_1;
    param_17 = _e75;
    let _e76 = ContributorLightCount_u0028_vf3_u003b((&param_17));
    count = _e76;
    i = 0i;
    loop {
        let _e77 = i;
        if (_e77 < 32i) {
            let _e79 = i;
            let _e80 = count;
            if (_e79 >= _e80) {
                break;
            }
            let _e82 = i;
            param_18 = _e82;
            let _e83 = v_world_position_1;
            param_19 = _e83;
            ContributorLight_u0028_i1_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            let _e84 = param_20;
            l_1 = _e84;
            let _e85 = param_21;
            radiance_1 = _e85;
            let _e86 = radiance_1;
            let _e87 = l_1;
            param_22 = _e87;
            let _e88 = positive_1;
            param_23 = _e88.xyz;
            let _e90 = negative_1;
            param_24 = _e90.xyz;
            let _e92 = SixWayResponse_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_22), (&param_23), (&param_24));
            let _e94 = lit;
            lit = (_e94 + (_e86 * _e92));
            continue;
        } else {
            break;
        }
        continuing {
            let _e96 = i;
            i = (_e96 + 1i);
        }
    }
    let _e99 = positive_1[0u];
    let _e101 = positive_1[1u];
    let _e104 = positive_1[2u];
    let _e107 = negative_1[0u];
    let _e110 = negative_1[1u];
    let _e113 = negative_1[2u];
    mean = ((((((_e99 + _e101) + _e104) + _e107) + _e110) + _e113) / 6f);
    let _e116 = v_color_1;
    let _e118 = lit;
    let _e120 = six_way_info.ambient;
    let _e122 = mean;
    let _e127 = six_way_info.emission;
    let _e130 = negative_1[3u];
    color_1 = ((_e116.xyz * (_e118 + (_e120.xyz * _e122))) + (_e127.xyz * _e130));
    let _e133 = v_world_position_1;
    param_25 = _e133;
    let _e134 = FogTransmittance_u0028_vf3_u003b((&param_25));
    fogged = _e134;
    let _e136 = fog_info.fog;
    let _e138 = color_1;
    let _e139 = fogged;
    color_1 = mix(_e136.xyz, _e138, vec3(_e139));
    let _e143 = v_color_1[3u];
    let _e145 = positive_1[3u];
    coverage = clamp((_e143 * _e145), 0f, 1f);
    let _e148 = v_world_position_1;
    param_26 = _e148;
    let _e149 = SoftParticleFade_u0028_vf3_u003b((&param_26));
    let _e150 = coverage;
    coverage = (_e150 * _e149);
    let _e152 = color_1;
    let _e153 = coverage;
    let _e154 = (_e152 * _e153);
    let _e155 = coverage;
    frag_color = vec4<f32>(_e154.x, _e154.y, _e154.z, _e155);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    v_world_position_1 = v_world_position;
    v_color_1 = v_color;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ContributorLightInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 528,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SixWayInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 80,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'right', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'up', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emission',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SoftParticleInfo',
          group: 1,
          binding: 4,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_depth_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'six_way_negative',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'six_way_positive',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Splat': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;

fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var local: f32;

    let _e23 = fog_info.projection[0u];
    if (_e23 > 0.5f) {
        let _e25 = (*world);
        let _e27 = fog_info.eye;
        let _e31 = fog_info.forward;
        local = max(dot((_e25 - _e27.xyz), _e31.xyz), 0f);
    } else {
        let _e35 = (*world);
        let _e37 = fog_info.eye;
        local = distance(_e35, _e37.xyz);
    }
    let _e40 = local;
    return _e40;
}

fn FogTransmittance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;
    var param: vec3<f32>;

    let _e27 = fog_info.fog[3u];
    density = _e27;
    let _e28 = density;
    if (_e28 <= 0f) {
        return 1f;
    }
    let _e32 = fog_info.eye[3u];
    falloff = _e32;
    let _e33 = falloff;
    if (_e33 > 0f) {
        let _e35 = falloff;
        let _e37 = (*world_1)[1u];
        let _e40 = fog_info.eye[1u];
        k = (_e35 * (_e37 - _e40));
        let _e43 = k;
        if (abs(_e43) > 0.001f) {
            let _e46 = k;
            let _e50 = k;
            local_1 = ((1f - exp(-(_e46))) / _e50);
        } else {
            let _e52 = k;
            local_1 = (1f - (0.5f * _e52));
        }
        let _e55 = local_1;
        let _e56 = density;
        density = (_e56 * _e55);
    }
    let _e58 = density;
    let _e60 = (*world_1);
    param = _e60;
    let _e61 = FogDistance_u0028_vf3_u003b((&param));
    return clamp(exp((-(_e58) * _e61)), 0f, 1f);
}

fn main_1() {
    var power: f32;
    var alpha: f32;
    var colour: vec3<f32>;
    var visibility: f32;
    var param_1: vec3<f32>;

    let _e24 = v_uv_1;
    let _e25 = v_uv_1;
    power = (-0.5f * dot(_e24, _e25));
    let _e28 = power;
    if (_e28 < -4.5f) {
        discard;
    }
    let _e31 = v_color_1[3u];
    let _e32 = power;
    alpha = (_e31 * exp(_e32));
    let _e35 = alpha;
    if (_e35 < 0.003921569f) {
        discard;
    }
    let _e37 = v_color_1;
    colour = _e37.xyz;
    let _e41 = fog_info.fog[3u];
    if (_e41 > 0f) {
        let _e43 = v_world_position_1;
        param_1 = _e43;
        let _e44 = FogTransmittance_u0028_vf3_u003b((&param_1));
        visibility = _e44;
        let _e46 = fog_info.fog;
        let _e48 = colour;
        let _e49 = visibility;
        colour = mix(_e46.xyz, _e48, vec3(_e49));
    }
    let _e52 = colour;
    let _e53 = alpha;
    let _e54 = (_e52 * _e53);
    let _e55 = alpha;
    frag_color = vec4<f32>(_e54.x, _e54.y, _e54.z, _e55);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    v_color_1 = v_color;
    v_world_position_1 = v_world_position;
    main_1();
    let _e7 = frag_color;
    return _e7;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'SplatHashed': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct SplatHashInfo {
    frame: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
@group(1) @binding(1)
var<uniform> splat_hash_info: SplatHashInfo;
@group(1) @binding(2)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var blue_noise_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var local: f32;

    let _e44 = fog_info.projection[0u];
    if (_e44 > 0.5f) {
        let _e46 = (*world);
        let _e48 = fog_info.eye;
        let _e52 = fog_info.forward;
        local = max(dot((_e46 - _e48.xyz), _e52.xyz), 0f);
    } else {
        let _e56 = (*world);
        let _e58 = fog_info.eye;
        local = distance(_e56, _e58.xyz);
    }
    let _e61 = local;
    return _e61;
}

fn FogTransmittance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;
    var param: vec3<f32>;

    let _e48 = fog_info.fog[3u];
    density = _e48;
    let _e49 = density;
    if (_e49 <= 0f) {
        return 1f;
    }
    let _e53 = fog_info.eye[3u];
    falloff = _e53;
    let _e54 = falloff;
    if (_e54 > 0f) {
        let _e56 = falloff;
        let _e58 = (*world_1)[1u];
        let _e61 = fog_info.eye[1u];
        k = (_e56 * (_e58 - _e61));
        let _e64 = k;
        if (abs(_e64) > 0.001f) {
            let _e67 = k;
            let _e71 = k;
            local_1 = ((1f - exp(-(_e67))) / _e71);
        } else {
            let _e73 = k;
            local_1 = (1f - (0.5f * _e73));
        }
        let _e76 = local_1;
        let _e77 = density;
        density = (_e77 * _e76);
    }
    let _e79 = density;
    let _e81 = (*world_1);
    param = _e81;
    let _e82 = FogDistance_u0028_vf3_u003b((&param));
    return clamp(exp((-(_e79) * _e82)), 0f, 1f);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_2: vec2<f32>;

    let _e42 = (*rows);
    if (_e42 > 0f) {
        let _e45 = gl_FragCoord_1[0u];
        let _e46 = (*rows);
        let _e48 = gl_FragCoord_1[1u];
        local_2 = vec2<f32>(_e45, (_e46 - _e48));
    } else {
        let _e51 = gl_FragCoord_1;
        local_2 = _e51.xy;
    }
    let _e53 = local_2;
    return _e53;
}

fn main_1() {
    var power: f32;
    var alpha: f32;
    var along: f32;
    var identity: f32;
    var mixed: f32;
    var row: f32;
    var offset: vec2<f32>;
    var slice: f32;
    var cell: vec2<f32>;
    var param_1: f32;
    var corner: vec2<f32>;
    var threshold: f32;
    var colour: vec3<f32>;
    var visibility: f32;
    var param_2: vec3<f32>;

    let _e55 = v_uv_1;
    let _e56 = v_uv_1;
    power = (-0.5f * dot(_e55, _e56));
    let _e59 = power;
    if (_e59 < -4.5f) {
        discard;
    }
    let _e62 = v_color_1[3u];
    let _e63 = power;
    alpha = (_e62 * exp(_e63));
    let _e66 = alpha;
    if (_e66 < 0.003921569f) {
        discard;
    }
    let _e68 = v_world_position_1;
    let _e70 = splat_hash_info.eye;
    let _e74 = splat_hash_info.forward;
    along = dot((_e68 - _e70.xyz), _e74.xyz);
    let _e77 = along;
    let _e80 = v_color_1;
    identity = (floor((_e77 * 1000f)) + floor(dot(_e80, vec4<f32>(255f, 1785f, 7905f, 32385f))));
    let _e84 = identity;
    identity = (_e84 - (floor((_e84 / 4096f)) * 4096f));
    let _e89 = identity;
    let _e91 = ((_e89 * 1597f) + 2531f);
    mixed = (_e91 - (floor((_e91 / 4096f)) * 4096f));
    let _e96 = mixed;
    let _e97 = mixed;
    let _e99 = ((2f * _e97) + 1f);
    let _e104 = (_e96 * (_e99 - (floor((_e99 / 4096f)) * 4096f)));
    mixed = (_e104 - (floor((_e104 / 4096f)) * 4096f));
    let _e109 = mixed;
    row = floor((_e109 / 64f));
    let _e112 = mixed;
    let _e113 = row;
    let _e115 = (_e112 + (_e113 * 37f));
    let _e120 = row;
    offset = vec2<f32>((_e115 - (floor((_e115 / 64f)) * 64f)), _e120);
    let _e124 = splat_hash_info.frame[0u];
    slice = _e124;
    let _e127 = splat_hash_info.frame[1u];
    param_1 = _e127;
    let _e128 = FragCoordFromTop_u0028_f1_u003b((&param_1));
    let _e130 = offset;
    let _e131 = (floor(_e128) + _e130);
    let _e132 = vec2(64f);
    cell = (_e131 - (floor((_e131 / _e132)) * _e132));
    let _e137 = slice;
    let _e142 = slice;
    corner = (vec2<f32>((_e137 - (floor((_e137 / 8f)) * 8f)), floor((_e142 / 8f))) * 64f);
    let _e147 = corner;
    let _e148 = cell;
    let _e153 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, (((_e147 + _e148) + vec2(0.5f)) / vec2<f32>(512f, 256f)), 0f);
    threshold = (_e153.x * 0.99609375f);
    let _e156 = alpha;
    let _e157 = threshold;
    if (_e156 <= _e157) {
        discard;
    }
    let _e159 = v_color_1;
    colour = _e159.xyz;
    let _e163 = fog_info.fog[3u];
    if (_e163 > 0f) {
        let _e165 = v_world_position_1;
        param_2 = _e165;
        let _e166 = FogTransmittance_u0028_vf3_u003b((&param_2));
        visibility = _e166;
        let _e168 = fog_info.fog;
        let _e170 = colour;
        let _e171 = visibility;
        colour = mix(_e168.xyz, _e170, vec3(_e171));
    }
    let _e174 = colour;
    frag_color = vec4<f32>(_e174.x, _e174.y, _e174.z, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    v_color_1 = v_color;
    v_world_position_1 = v_world_position;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'SplatHashInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'frame', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ParticleMesh': WebGpuStage(
      wgsl: r'''
struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_color_1: vec4<f32>;

fn FogDistance_u0028_vf3_u003b(world: ptr<function, vec3<f32>>) -> f32 {
    var local: f32;

    let _e22 = fog_info.projection[0u];
    if (_e22 > 0.5f) {
        let _e24 = (*world);
        let _e26 = fog_info.eye;
        let _e30 = fog_info.forward;
        local = max(dot((_e24 - _e26.xyz), _e30.xyz), 0f);
    } else {
        let _e34 = (*world);
        let _e36 = fog_info.eye;
        local = distance(_e34, _e36.xyz);
    }
    let _e39 = local;
    return _e39;
}

fn FogTransmittance_u0028_vf3_u003b(world_1: ptr<function, vec3<f32>>) -> f32 {
    var density: f32;
    var falloff: f32;
    var k: f32;
    var local_1: f32;
    var param: vec3<f32>;

    let _e26 = fog_info.fog[3u];
    density = _e26;
    let _e27 = density;
    if (_e27 <= 0f) {
        return 1f;
    }
    let _e31 = fog_info.eye[3u];
    falloff = _e31;
    let _e32 = falloff;
    if (_e32 > 0f) {
        let _e34 = falloff;
        let _e36 = (*world_1)[1u];
        let _e39 = fog_info.eye[1u];
        k = (_e34 * (_e36 - _e39));
        let _e42 = k;
        if (abs(_e42) > 0.001f) {
            let _e45 = k;
            let _e49 = k;
            local_1 = ((1f - exp(-(_e45))) / _e49);
        } else {
            let _e51 = k;
            local_1 = (1f - (0.5f * _e51));
        }
        let _e54 = local_1;
        let _e55 = density;
        density = (_e55 * _e54);
    }
    let _e57 = density;
    let _e59 = (*world_1);
    param = _e59;
    let _e60 = FogDistance_u0028_vf3_u003b((&param));
    return clamp(exp((-(_e57) * _e60)), 0f, 1f);
}

fn TowardsEyeFrom_u0028_vf3_u003b(world_2: ptr<function, vec3<f32>>) -> vec3<f32> {
    var to_eye: vec3<f32>;
    var length_to_eye: f32;
    var local_2: vec3<f32>;

    let _e24 = fog_info.projection[0u];
    if (_e24 > 0.5f) {
        let _e27 = fog_info.forward;
        return -(_e27.xyz);
    }
    let _e31 = fog_info.eye;
    let _e33 = (*world_2);
    to_eye = (_e31.xyz - _e33);
    let _e35 = to_eye;
    length_to_eye = length(_e35);
    let _e37 = length_to_eye;
    if (_e37 > 0f) {
        let _e39 = to_eye;
        let _e40 = length_to_eye;
        local_2 = (_e39 / vec3(_e40));
    } else {
        local_2 = vec3<f32>(0f, 0f, 0f);
    }
    let _e43 = local_2;
    return _e43;
}

fn main_1() {
    var towards_eye: vec3<f32>;
    var param_1: vec3<f32>;
    var n: vec3<f32>;
    var facing: f32;
    var local_3: f32;
    var intensity: f32;
    var fogged: f32;
    var param_2: vec3<f32>;

    let _e26 = v_world_position_1;
    param_1 = _e26;
    let _e27 = TowardsEyeFrom_u0028_vf3_u003b((&param_1));
    towards_eye = _e27;
    let _e28 = v_normal_1;
    n = normalize(_e28);
    let _e30 = towards_eye;
    let _e31 = towards_eye;
    if (dot(_e30, _e31) > 0f) {
        let _e34 = n;
        let _e35 = towards_eye;
        local_3 = abs(dot(_e34, _e35));
    } else {
        local_3 = 1f;
    }
    let _e38 = local_3;
    facing = _e38;
    let _e39 = facing;
    intensity = mix(0.35f, 1f, _e39);
    let _e41 = v_world_position_1;
    param_2 = _e41;
    let _e42 = FogTransmittance_u0028_vf3_u003b((&param_2));
    fogged = _e42;
    let _e43 = v_color_1;
    let _e46 = v_color_1[3u];
    let _e48 = intensity;
    let _e50 = fogged;
    let _e51 = (((_e43.xyz * _e46) * _e48) * _e50);
    frag_color = vec4<f32>(_e51.x, _e51.y, _e51.z, 1f);
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_color_1 = v_color;
    main_1();
    let _e7 = frag_color;
    return _e7;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'Reflections': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct NoiseInfo {
    noise: vec4<f32>,
}

struct ReflectionInfo {
    view_projection: mat4x4<f32>,
    inverse_view_projection: mat4x4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
    params: vec4<f32>,
    screen: vec4<f32>,
    environment: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(1)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> reflection_info: ReflectionInfo;
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(7)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(5)
var environment_texture_tex: texture_cube<f32>;
@group(1) @binding(6)
var environment_texture_smp: sampler;

fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
    let _e68 = (*at);
    let _e70 = reflection_info.camera;
    let _e74 = reflection_info.forward;
    return dot((_e68 - _e70.xyz), _e74.xyz);
}

fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
    let _e69 = (*ndc)[0u];
    let _e73 = (*ndc)[1u];
    return vec2<f32>(((_e69 * 0.5f) + 0.5f), (0.5f - (_e73 * 0.5f)));
}

fn UvOf_u0028_vf3_u003b(at_1: ptr<function, vec3<f32>>) -> vec2<f32> {
    var clip: vec4<f32>;
    var param: vec2<f32>;

    let _e71 = reflection_info.view_projection;
    let _e72 = (*at_1);
    clip = (_e71 * vec4<f32>(_e72.x, _e72.y, _e72.z, 1f));
    let _e79 = clip[3u];
    if (_e79 <= 0f) {
        return vec2<f32>(-1f, -1f);
    }
    let _e81 = clip;
    let _e84 = clip[3u];
    param = (_e81.xy / vec2(_e84));
    let _e87 = UvFromNdc_u0028_vf2_u003b((&param));
    return _e87;
}

fn BayerCell_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e73 = (*at_2)[0u];
    x = i32((_e73 - (floor((_e73 / 4f)) * 4f)));
    let _e80 = (*at_2)[1u];
    y = i32((_e80 - (floor((_e80 / 4f)) * 4f)));
    let _e86 = y;
    let _e88 = x;
    index = ((_e86 * 4i) + _e88);
    value = 0f;
    let _e90 = index;
    if (_e90 == 0i) {
        value = 0f;
    } else {
        let _e92 = index;
        if (_e92 == 1i) {
            value = 8f;
        } else {
            let _e94 = index;
            if (_e94 == 2i) {
                value = 2f;
            } else {
                let _e96 = index;
                if (_e96 == 3i) {
                    value = 10f;
                } else {
                    let _e98 = index;
                    if (_e98 == 4i) {
                        value = 12f;
                    } else {
                        let _e100 = index;
                        if (_e100 == 5i) {
                            value = 4f;
                        } else {
                            let _e102 = index;
                            if (_e102 == 6i) {
                                value = 14f;
                            } else {
                                let _e104 = index;
                                if (_e104 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e106 = index;
                                    if (_e106 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e108 = index;
                                        if (_e108 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e110 = index;
                                            if (_e110 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e112 = index;
                                                if (_e112 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e114 = index;
                                                    if (_e114 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e116 = index;
                                                        if (_e116 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e118 = index;
                                                            if (_e118 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e120 = value;
    return (_e120 / 16f);
}

fn BlueNoise_u0028_vf2_u003b(at_3: ptr<function, vec2<f32>>) -> f32 {
    var slice: f32;
    var cell: vec2<f32>;
    var corner: vec2<f32>;
    var uv: vec2<f32>;

    let _e74 = noise_info.noise[1u];
    slice = _e74;
    let _e75 = (*at_3);
    let _e76 = floor(_e75);
    let _e77 = vec2(64f);
    cell = (_e76 - (floor((_e76 / _e77)) * _e77));
    let _e82 = slice;
    let _e87 = slice;
    corner = (vec2<f32>((_e82 - (floor((_e82 / 8f)) * 8f)), floor((_e87 / 8f))) * 64f);
    let _e92 = corner;
    let _e93 = cell;
    uv = (((_e92 + _e93) + vec2(0.5f)) / vec2<f32>(512f, 256f));
    let _e98 = uv;
    let _e99 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e98, 0f);
    return (_e99.x * 0.99609375f);
}

fn PixelNoise_u0028_vf2_u003b(at_4: ptr<function, vec2<f32>>) -> f32 {
    var local: f32;
    var param_1: vec2<f32>;
    var param_2: vec2<f32>;

    let _e73 = noise_info.noise[0u];
    if (_e73 > 0.5f) {
        let _e75 = (*at_4);
        param_1 = _e75;
        let _e76 = BlueNoise_u0028_vf2_u003b((&param_1));
        local = _e76;
    } else {
        let _e77 = (*at_4);
        param_2 = _e77;
        let _e78 = BayerCell_u0028_vf2_u003b((&param_2));
        local = _e78;
    }
    let _e79 = local;
    return _e79;
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_1: vec2<f32>;

    let _e69 = (*rows);
    if (_e69 > 0f) {
        let _e72 = gl_FragCoord_1[0u];
        let _e73 = (*rows);
        let _e75 = gl_FragCoord_1[1u];
        local_1 = vec2<f32>(_e72, (_e73 - _e75));
    } else {
        let _e78 = gl_FragCoord_1;
        local_1 = _e78.xy;
    }
    let _e80 = local_1;
    return _e80;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param_3: f32;

    let _e70 = frag_coord_info.origin[0u];
    param_3 = _e70;
    let _e71 = FragCoordFromTop_u0028_f1_u003b((&param_3));
    return _e71;
}

fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_1: ptr<function, vec2<f32>>, origin: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>) {
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;

    let _e74 = (*uv_1)[0u];
    let _e78 = (*uv_1)[1u];
    xy = vec2<f32>(((_e74 * 2f) - 1f), (1f - (_e78 * 2f)));
    let _e83 = reflection_info.inverse_view_projection;
    let _e84 = xy;
    nearH = (_e83 * vec4<f32>(_e84.x, _e84.y, 0f, 1f));
    let _e90 = reflection_info.inverse_view_projection;
    let _e91 = xy;
    farH = (_e90 * vec4<f32>(_e91.x, _e91.y, 1f, 1f));
    let _e96 = nearH;
    let _e99 = nearH[3u];
    (*origin) = (_e96.xyz / vec3(_e99));
    let _e102 = farH;
    let _e105 = farH[3u];
    let _e108 = (*origin);
    (*along) = normalize(((_e102.xyz / vec3(_e105)) - _e108));
    return;
}

fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
    var origin_1: vec3<f32>;
    var along_1: vec3<f32>;
    var param_4: vec2<f32>;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var axis: vec3<f32>;

    let _e75 = (*uv_2);
    param_4 = _e75;
    PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((&param_4), (&param_5), (&param_6));
    let _e76 = param_5;
    origin_1 = _e76;
    let _e77 = param_6;
    along_1 = _e77;
    let _e79 = reflection_info.forward;
    axis = _e79.xyz;
    let _e81 = origin_1;
    let _e82 = along_1;
    let _e83 = (*depth);
    let _e84 = origin_1;
    let _e86 = reflection_info.camera;
    let _e89 = axis;
    let _e92 = along_1;
    let _e93 = axis;
    return (_e81 + (_e82 * ((_e83 - dot((_e84 - _e86.xyz), _e89)) / dot(_e92, _e93))));
}

fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
    var n: vec3<f32>;
    var t: f32;
    var local_2: f32;
    var local_3: f32;

    let _e72 = (*e);
    (*e) = ((_e72 * 2f) - vec2(1f));
    let _e76 = (*e);
    let _e78 = (*e)[0u];
    let _e82 = (*e)[1u];
    n = vec3<f32>(_e76.x, _e76.y, ((1f - abs(_e78)) - abs(_e82)));
    let _e89 = n[2u];
    t = max(-(_e89), 0f);
    let _e93 = n[0u];
    if (_e93 >= 0f) {
        let _e95 = t;
        local_2 = -(_e95);
    } else {
        let _e97 = t;
        local_2 = _e97;
    }
    let _e98 = local_2;
    let _e100 = n[0u];
    n[0u] = (_e100 + _e98);
    let _e104 = n[1u];
    if (_e104 >= 0f) {
        let _e106 = t;
        local_3 = -(_e106);
    } else {
        let _e108 = t;
        local_3 = _e108;
    }
    let _e109 = local_3;
    let _e111 = n[1u];
    n[1u] = (_e111 + _e109);
    let _e114 = n;
    return normalize(_e114);
}

fn main_1() {
    var surface: vec4<f32>;
    var scene: vec3<f32>;
    var debugOnly: bool;
    var background: vec3<f32>;
    var normal: vec3<f32>;
    var param_7: vec2<f32>;
    var roughness: f32;
    var polish: f32;
    var position: vec3<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;
    var rayOrigin: vec3<f32>;
    var viewRay: vec3<f32>;
    var param_10: vec2<f32>;
    var param_11: vec3<f32>;
    var param_12: vec3<f32>;
    var toEye: vec3<f32>;
    var facing: f32;
    var ray: vec3<f32>;
    var steps: i32;
    var stride: f32;
    var thickness: f32;
    var intensity: f32;
    var jitter: f32;
    var param_13: vec2<f32>;
    var travelled: f32;
    var march: vec3<f32>;
    var reach: f32;
    var hitColor: vec3<f32>;
    var hit: f32;
    var i: i32;
    var uv_3: vec2<f32>;
    var param_14: vec3<f32>;
    var sceneDepth: f32;
    var marchDepth: f32;
    var param_15: vec3<f32>;
    var seen: vec3<f32>;
    var param_16: vec2<f32>;
    var param_17: f32;
    var behind: f32;
    var seenNormal: vec3<f32>;
    var param_18: vec2<f32>;
    var lo: vec3<f32>;
    var hi: vec3<f32>;
    var j: i32;
    var mid: vec3<f32>;
    var at_5: vec2<f32>;
    var param_19: vec3<f32>;
    var d: f32;
    var local_4: f32;
    var param_20: vec3<f32>;
    var hitUv: vec2<f32>;
    var param_21: vec3<f32>;
    var edge: vec2<f32>;
    var border: f32;
    var along_2: f32;
    var fresnel: f32;
    var reflection: vec3<f32>;
    var confidence: f32;
    var levels: f32;
    var environment: vec3<f32>;
    var local_5: vec3<f32>;
    var replaced: vec3<f32>;
    var composed: vec3<f32>;
    var local_6: vec3<f32>;
    var phi_653_: bool;
    var phi_660_: bool;
    var phi_667_: bool;
    var phi_718_: bool;
    var phi_772_: bool;

    let _e132 = v_uv_1;
    let _e133 = textureSample(surface_texture_tex, surface_texture_smp, _e132);
    surface = _e133;
    let _e134 = v_uv_1;
    let _e135 = textureSample(scene_texture_tex, scene_texture_smp, _e134);
    scene = _e135.xyz;
    let _e139 = reflection_info.screen[3u];
    debugOnly = (_e139 > 0.5f);
    let _e141 = debugOnly;
    let _e142 = scene;
    background = select(_e142, vec3<f32>(0f, 0f, 0f), vec3(_e141));
    let _e146 = surface[3u];
    if (_e146 <= 0f) {
        let _e148 = background;
        frag_color = vec4<f32>(_e148.x, _e148.y, _e148.z, 1f);
        return;
    }
    let _e153 = surface;
    param_7 = _e153.xy;
    let _e155 = DecodeOctahedral_u0028_vf2_u003b((&param_7));
    normal = _e155;
    let _e157 = surface[2u];
    roughness = _e157;
    let _e158 = roughness;
    polish = (1f - smoothstep(0.05f, 0.25f, _e158));
    let _e161 = polish;
    if (_e161 <= 0f) {
        let _e163 = background;
        frag_color = vec4<f32>(_e163.x, _e163.y, _e163.z, 1f);
        return;
    }
    let _e168 = v_uv_1;
    param_8 = _e168;
    let _e170 = surface[3u];
    param_9 = _e170;
    let _e171 = WorldAt_u0028_vf2_u003b_f1_u003b((&param_8), (&param_9));
    position = _e171;
    let _e172 = v_uv_1;
    param_10 = _e172;
    PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((&param_10), (&param_11), (&param_12));
    let _e173 = param_11;
    rayOrigin = _e173;
    let _e174 = param_12;
    viewRay = _e174;
    let _e175 = viewRay;
    toEye = -(_e175);
    let _e177 = normal;
    let _e178 = toEye;
    facing = dot(_e177, _e178);
    let _e180 = facing;
    if (_e180 <= 0.05f) {
        let _e182 = background;
        frag_color = vec4<f32>(_e182.x, _e182.y, _e182.z, 1f);
        return;
    }
    let _e187 = toEye;
    let _e189 = normal;
    ray = reflect(-(_e187), _e189);
    let _e193 = reflection_info.params[0u];
    steps = i32(_e193);
    let _e197 = reflection_info.params[1u];
    stride = _e197;
    let _e200 = reflection_info.params[2u];
    thickness = _e200;
    let _e203 = reflection_info.params[3u];
    intensity = _e203;
    let _e204 = TargetFragCoord_u0028_();
    param_13 = _e204;
    let _e205 = PixelNoise_u0028_vf2_u003b((&param_13));
    jitter = (0.5f + _e205);
    let _e207 = stride;
    let _e208 = jitter;
    travelled = (_e207 * _e208);
    let _e210 = position;
    let _e211 = normal;
    let _e214 = ray;
    let _e215 = travelled;
    march = ((_e210 + (_e211 * 0.01f)) + (_e214 * _e215));
    let _e218 = stride;
    let _e219 = steps;
    reach = (_e218 * (f32(_e219) + 0.5f));
    hitColor = vec3<f32>(0f, 0f, 0f);
    hit = 0f;
    i = 0i;
    loop {
        let _e223 = i;
        if (_e223 < 64i) {
            let _e225 = i;
            let _e226 = steps;
            if (_e225 >= _e226) {
                break;
            }
            let _e228 = march;
            param_14 = _e228;
            let _e229 = UvOf_u0028_vf3_u003b((&param_14));
            uv_3 = _e229;
            let _e231 = uv_3[0u];
            if (_e231 < -0.5f) {
                break;
            }
            let _e234 = uv_3[0u];
            let _e235 = (_e234 < 0f);
            phi_653_ = _e235;
            if !(_e235) {
                let _e238 = uv_3[0u];
                phi_653_ = (_e238 > 1f);
            }
            let _e241 = phi_653_;
            phi_660_ = _e241;
            if !(_e241) {
                let _e244 = uv_3[1u];
                phi_660_ = (_e244 < 0f);
            }
            let _e247 = phi_660_;
            phi_667_ = _e247;
            if !(_e247) {
                let _e250 = uv_3[1u];
                phi_667_ = (_e250 > 1f);
            }
            let _e253 = phi_667_;
            if _e253 {
                break;
            }
            let _e254 = uv_3;
            let _e255 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e254, 0f);
            sceneDepth = _e255.w;
            let _e257 = march;
            param_15 = _e257;
            let _e258 = DepthOf_u0028_vf3_u003b((&param_15));
            marchDepth = _e258;
            let _e259 = sceneDepth;
            let _e261 = marchDepth;
            let _e262 = sceneDepth;
            if ((_e259 > 0f) && (_e261 > _e262)) {
                let _e265 = uv_3;
                param_16 = _e265;
                let _e266 = sceneDepth;
                param_17 = _e266;
                let _e267 = WorldAt_u0028_vf2_u003b_f1_u003b((&param_16), (&param_17));
                seen = _e267;
                let _e268 = march;
                let _e269 = seen;
                behind = distance(_e268, _e269);
                let _e271 = uv_3;
                let _e272 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e271, 0f);
                param_18 = _e272.xy;
                let _e274 = DecodeOctahedral_u0028_vf2_u003b((&param_18));
                seenNormal = _e274;
                let _e275 = behind;
                let _e276 = thickness;
                let _e277 = (_e275 < _e276);
                phi_718_ = _e277;
                if _e277 {
                    let _e278 = seenNormal;
                    let _e279 = ray;
                    phi_718_ = (dot(_e278, _e279) < 0f);
                }
                let _e283 = phi_718_;
                if _e283 {
                    let _e284 = march;
                    let _e285 = ray;
                    let _e286 = stride;
                    let _e287 = travelled;
                    lo = (_e284 - (_e285 * min(_e286, _e287)));
                    let _e291 = march;
                    hi = _e291;
                    j = 0i;
                    loop {
                        let _e292 = j;
                        if (_e292 < 5i) {
                            let _e294 = lo;
                            let _e295 = hi;
                            mid = ((_e294 + _e295) * 0.5f);
                            let _e298 = mid;
                            param_19 = _e298;
                            let _e299 = UvOf_u0028_vf3_u003b((&param_19));
                            at_5 = _e299;
                            let _e301 = at_5[0u];
                            if (_e301 < -0.5f) {
                                local_4 = 0f;
                            } else {
                                let _e303 = at_5;
                                let _e304 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e303, 0f);
                                local_4 = _e304.w;
                            }
                            let _e306 = local_4;
                            d = _e306;
                            let _e307 = d;
                            let _e308 = (_e307 > 0f);
                            phi_772_ = _e308;
                            if _e308 {
                                let _e309 = mid;
                                param_20 = _e309;
                                let _e310 = DepthOf_u0028_vf3_u003b((&param_20));
                                let _e311 = d;
                                phi_772_ = (_e310 > _e311);
                            }
                            let _e314 = phi_772_;
                            if _e314 {
                                let _e315 = mid;
                                hi = _e315;
                            } else {
                                let _e316 = mid;
                                lo = _e316;
                            }
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e317 = j;
                            j = (_e317 + 1i);
                        }
                    }
                    let _e319 = hi;
                    param_21 = _e319;
                    let _e320 = UvOf_u0028_vf3_u003b((&param_21));
                    hitUv = _e320;
                    let _e322 = hitUv[0u];
                    if (_e322 < -0.5f) {
                        let _e324 = uv_3;
                        hitUv = _e324;
                    }
                    let _e325 = hitUv;
                    let _e326 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e325, 0f);
                    hitColor = _e326.xyz;
                    let _e328 = hitUv;
                    edge = abs(((_e328 * 2f) - vec2(1f)));
                    let _e334 = edge[0u];
                    let _e336 = edge[1u];
                    border = (1f - max(_e334, _e336));
                    let _e339 = travelled;
                    let _e340 = reach;
                    along_2 = clamp((1f - (_e339 / _e340)), 0f, 1f);
                    let _e344 = border;
                    let _e346 = along_2;
                    let _e348 = along_2;
                    hit = ((smoothstep(0f, 0.15f, _e344) * _e346) * _e348);
                    break;
                }
            }
            let _e350 = ray;
            let _e351 = stride;
            let _e353 = march;
            march = (_e353 + (_e350 * _e351));
            let _e355 = stride;
            let _e356 = travelled;
            travelled = (_e356 + _e355);
            continue;
        } else {
            break;
        }
        continuing {
            let _e358 = i;
            i = (_e358 + 1i);
        }
    }
    let _e360 = facing;
    fresnel = (0.04f + (0.96f * pow((1f - _e360), 5f)));
    let _e365 = hitColor;
    let _e366 = hit;
    let _e368 = intensity;
    let _e370 = polish;
    let _e372 = fresnel;
    reflection = ((((_e365 * _e366) * _e368) * _e370) * _e372);
    let _e374 = hit;
    let _e375 = intensity;
    let _e377 = polish;
    confidence = ((_e374 * _e375) * _e377);
    let _e381 = reflection_info.environment[0u];
    levels = _e381;
    let _e382 = levels;
    if (_e382 > 0f) {
        let _e384 = ray;
        let _e385 = roughness;
        let _e386 = levels;
        let _e388 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e384, (_e385 * _e386));
        let _e392 = reflection_info.environment[1u];
        local_5 = (_e388.xyz * _e392);
    } else {
        local_5 = vec3<f32>(0f, 0f, 0f);
    }
    let _e394 = local_5;
    environment = _e394;
    let _e395 = environment;
    let _e396 = confidence;
    let _e398 = fresnel;
    replaced = ((_e395 * _e396) * _e398);
    let _e400 = levels;
    if (_e400 > 0f) {
        let _e402 = scene;
        let _e403 = reflection;
        let _e405 = replaced;
        local_6 = max(((_e402 + _e403) - _e405), vec3<f32>(0f, 0f, 0f));
    } else {
        let _e408 = scene;
        let _e409 = reflection;
        local_6 = (_e408 + _e409);
    }
    let _e411 = local_6;
    composed = _e411;
    let _e412 = debugOnly;
    let _e413 = reflection;
    let _e414 = composed;
    let _e416 = select(_e414, _e413, vec3(_e412));
    frag_color = vec4<f32>(_e416.x, _e416.y, _e416.z, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'NoiseInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
        WebGpuBlock(
          name: 'ReflectionInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 208,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 128,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 144,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 160,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'screen',
              offsetInBytes: 176,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'environment',
              offsetInBytes: 192,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'environment_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Ssao': WebGpuStage(
      wgsl: r'''
struct NoiseInfo {
    noise: vec4<f32>,
}

struct SsaoInfo {
    inverse_view_projection: mat4x4<f32>,
    view_projection: mat4x4<f32>,
    params: vec4<f32>,
    screen: vec4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(4)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var blue_noise_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> ssao_info: SsaoInfo;
@group(1) @binding(8)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var surface_texture_smp: sampler;
@group(1) @binding(6)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var scene_texture_smp: sampler;
@group(1) @binding(2)
var albedo_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var albedo_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
    let _e166 = (*at);
    let _e168 = ssao_info.camera;
    let _e172 = ssao_info.forward;
    return dot((_e166 - _e168.xyz), _e172.xyz);
}

fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
    let _e167 = (*ndc)[0u];
    let _e171 = (*ndc)[1u];
    return vec2<f32>(((_e167 * 0.5f) + 0.5f), (0.5f - (_e171 * 0.5f)));
}

fn KernelTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec3<f32> {
    let _e166 = (*i);
    if (_e166 == 0i) {
        return vec3<f32>(0.5381f, 0.1856f, 0.4319f);
    }
    let _e168 = (*i);
    if (_e168 == 1i) {
        return vec3<f32>(0.1379f, 0.2486f, 0.443f);
    }
    let _e170 = (*i);
    if (_e170 == 2i) {
        return vec3<f32>(0.3371f, 0.5679f, 0.0057f);
    }
    let _e172 = (*i);
    if (_e172 == 3i) {
        return vec3<f32>(-0.6999f, -0.0451f, 0.0019f);
    }
    let _e174 = (*i);
    if (_e174 == 4i) {
        return vec3<f32>(0.0689f, -0.1598f, -0.8547f);
    }
    let _e176 = (*i);
    if (_e176 == 5i) {
        return vec3<f32>(0.056f, 0.0069f, -0.1843f);
    }
    let _e178 = (*i);
    if (_e178 == 6i) {
        return vec3<f32>(-0.0146f, 0.1402f, 0.0762f);
    }
    let _e180 = (*i);
    if (_e180 == 7i) {
        return vec3<f32>(0.01f, -0.1924f, -0.0344f);
    }
    let _e182 = (*i);
    if (_e182 == 8i) {
        return vec3<f32>(-0.3577f, -0.5301f, -0.4358f);
    }
    let _e184 = (*i);
    if (_e184 == 9i) {
        return vec3<f32>(-0.3169f, 0.1063f, 0.0158f);
    }
    let _e186 = (*i);
    if (_e186 == 10i) {
        return vec3<f32>(0.0103f, -0.5869f, 0.0046f);
    }
    return vec3<f32>(-0.0897f, -0.494f, 0.3287f);
}

fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
    var slice: f32;
    var cell: vec2<f32>;
    var corner: vec2<f32>;
    var uv: vec2<f32>;

    let _e172 = noise_info.noise[1u];
    slice = _e172;
    let _e173 = (*at_1);
    let _e174 = floor(_e173);
    let _e175 = vec2(64f);
    cell = (_e174 - (floor((_e174 / _e175)) * _e175));
    let _e180 = slice;
    let _e185 = slice;
    corner = (vec2<f32>((_e180 - (floor((_e180 / 8f)) * 8f)), floor((_e185 / 8f))) * 64f);
    let _e190 = corner;
    let _e191 = cell;
    uv = (((_e190 + _e191) + vec2(0.5f)) / vec2<f32>(512f, 256f));
    let _e196 = uv;
    let _e197 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e196, 0f);
    return (_e197.x * 0.99609375f);
}

fn Rotation_u0028_vf2_u003b(uv_1: ptr<function, vec2<f32>>) -> vec2<f32> {
    var pixel: vec2<f32>;
    var angle: f32;
    var param: vec2<f32>;
    var oddX: bool;
    var oddY: bool;

    let _e171 = (*uv_1);
    let _e173 = ssao_info.screen;
    pixel = floor((_e171 / _e173.xy));
    let _e179 = noise_info.noise[0u];
    if (_e179 > 0.5f) {
        let _e181 = pixel;
        param = _e181;
        let _e182 = BlueNoise_u0028_vf2_u003b((&param));
        angle = (6.2831855f * _e182);
        let _e184 = angle;
        let _e186 = angle;
        return vec2<f32>(cos(_e184), sin(_e186));
    }
    let _e190 = pixel[0u];
    oddX = ((_e190 - (floor((_e190 / 2f)) * 2f)) >= 1f);
    let _e197 = pixel[1u];
    oddY = ((_e197 - (floor((_e197 / 2f)) * 2f)) >= 1f);
    let _e203 = oddX;
    let _e204 = oddY;
    if (_e203 && _e204) {
        return vec2<f32>(-0.7071f, -0.7071f);
    }
    let _e206 = oddX;
    if _e206 {
        return vec2<f32>(0.7071f, -0.7071f);
    }
    let _e207 = oddY;
    if _e207 {
        return vec2<f32>(-0.7071f, 0.7071f);
    }
    return vec2<f32>(1f, 0f);
}

fn MultiBounce_u0028_f1_u003b_vf3_u003b(visible: ptr<function, f32>, albedo: ptr<function, vec3<f32>>) -> f32 {
    var a: vec3<f32>;
    var b: vec3<f32>;
    var c: vec3<f32>;
    var v: vec3<f32>;
    var bounced: vec3<f32>;

    let _e172 = (*albedo);
    a = ((_e172 * 2.0404f) - vec3(0.3324f));
    let _e176 = (*albedo);
    b = ((_e176 * -4.7951f) + vec3(0.6417f));
    let _e180 = (*albedo);
    c = ((_e180 * 2.7552f) + vec3(0.6903f));
    let _e184 = (*visible);
    v = vec3(_e184);
    let _e186 = v;
    let _e187 = v;
    let _e188 = a;
    let _e190 = b;
    let _e192 = v;
    let _e194 = c;
    let _e196 = v;
    bounced = max(_e186, (((((_e187 * _e188) + _e190) * _e192) + _e194) * _e196));
    let _e199 = bounced;
    return dot(_e199, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn SrgbToLinearAlbedo_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e166 = (*srgb);
    let _e169 = (*srgb);
    let _e174 = (*srgb);
    return mix((_e166 / vec3(12.92f)), pow(((_e169 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e174));
}

fn PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_2: ptr<function, vec2<f32>>, origin: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>) {
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;

    let _e172 = (*uv_2)[0u];
    let _e176 = (*uv_2)[1u];
    xy = vec2<f32>(((_e172 * 2f) - 1f), (1f - (_e176 * 2f)));
    let _e181 = ssao_info.inverse_view_projection;
    let _e182 = xy;
    nearH = (_e181 * vec4<f32>(_e182.x, _e182.y, 0f, 1f));
    let _e188 = ssao_info.inverse_view_projection;
    let _e189 = xy;
    farH = (_e188 * vec4<f32>(_e189.x, _e189.y, 1f, 1f));
    let _e194 = nearH;
    let _e197 = nearH[3u];
    (*origin) = (_e194.xyz / vec3(_e197));
    let _e200 = farH;
    let _e203 = farH[3u];
    let _e206 = (*origin);
    (*along) = normalize(((_e200.xyz / vec3(_e203)) - _e206));
    return;
}

fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
    var origin_1: vec3<f32>;
    var along_1: vec3<f32>;
    var param_1: vec2<f32>;
    var param_2: vec3<f32>;
    var param_3: vec3<f32>;
    var axis: vec3<f32>;

    let _e173 = (*uv_3);
    param_1 = _e173;
    PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((&param_1), (&param_2), (&param_3));
    let _e174 = param_2;
    origin_1 = _e174;
    let _e175 = param_3;
    along_1 = _e175;
    let _e177 = ssao_info.forward;
    axis = _e177.xyz;
    let _e179 = origin_1;
    let _e180 = along_1;
    let _e181 = (*depth);
    let _e182 = origin_1;
    let _e184 = ssao_info.camera;
    let _e187 = axis;
    let _e190 = along_1;
    let _e191 = axis;
    return (_e179 + (_e180 * ((_e181 - dot((_e182 - _e184.xyz), _e187)) / dot(_e190, _e191))));
}

fn BayerCell_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e171 = (*at_2)[0u];
    x = i32((_e171 - (floor((_e171 / 4f)) * 4f)));
    let _e178 = (*at_2)[1u];
    y = i32((_e178 - (floor((_e178 / 4f)) * 4f)));
    let _e184 = y;
    let _e186 = x;
    index = ((_e184 * 4i) + _e186);
    value = 0f;
    let _e188 = index;
    if (_e188 == 0i) {
        value = 0f;
    } else {
        let _e190 = index;
        if (_e190 == 1i) {
            value = 8f;
        } else {
            let _e192 = index;
            if (_e192 == 2i) {
                value = 2f;
            } else {
                let _e194 = index;
                if (_e194 == 3i) {
                    value = 10f;
                } else {
                    let _e196 = index;
                    if (_e196 == 4i) {
                        value = 12f;
                    } else {
                        let _e198 = index;
                        if (_e198 == 5i) {
                            value = 4f;
                        } else {
                            let _e200 = index;
                            if (_e200 == 6i) {
                                value = 14f;
                            } else {
                                let _e202 = index;
                                if (_e202 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e204 = index;
                                    if (_e204 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e206 = index;
                                        if (_e206 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e208 = index;
                                            if (_e208 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e210 = index;
                                                if (_e210 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e212 = index;
                                                    if (_e212 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e214 = index;
                                                        if (_e214 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e216 = index;
                                                            if (_e216 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e218 = value;
    return (_e218 / 16f);
}

fn PixelNoise_u0028_vf2_u003b(at_3: ptr<function, vec2<f32>>) -> f32 {
    var local: f32;
    var param_4: vec2<f32>;
    var param_5: vec2<f32>;

    let _e171 = noise_info.noise[0u];
    if (_e171 > 0.5f) {
        let _e173 = (*at_3);
        param_4 = _e173;
        let _e174 = BlueNoise_u0028_vf2_u003b((&param_4));
        local = _e174;
    } else {
        let _e175 = (*at_3);
        param_5 = _e175;
        let _e176 = BayerCell_u0028_vf2_u003b((&param_5));
        local = _e176;
    }
    let _e177 = local;
    return _e177;
}

fn PixelRadius_u0028_vf3_u003b_vf3_u003b_f1_u003b(point: ptr<function, vec3<f32>>, view: ptr<function, vec3<f32>>, radius: ptr<function, f32>) -> f32 {
    var across: vec3<f32>;
    var here: vec4<f32>;
    var there: vec4<f32>;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;

    let _e173 = (*view);
    let _e175 = (*view)[1u];
    across = normalize(cross(_e173, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 1f, 0f), vec3((abs(_e175) < 0.99f)))));
    let _e183 = ssao_info.view_projection;
    let _e184 = (*point);
    here = (_e183 * vec4<f32>(_e184.x, _e184.y, _e184.z, 1f));
    let _e191 = ssao_info.view_projection;
    let _e192 = (*point);
    let _e193 = across;
    let _e194 = (*radius);
    let _e196 = (_e192 + (_e193 * _e194));
    there = (_e191 * vec4<f32>(_e196.x, _e196.y, _e196.z, 1f));
    let _e202 = there;
    let _e205 = there[3u];
    param_6 = (_e202.xy / vec2(_e205));
    let _e208 = UvFromNdc_u0028_vf2_u003b((&param_6));
    let _e209 = here;
    let _e212 = here[3u];
    param_7 = (_e209.xy / vec2(_e212));
    let _e215 = UvFromNdc_u0028_vf2_u003b((&param_7));
    let _e218 = ssao_info.screen;
    return length(((_e208 - _e215) / _e218.xy));
}

fn EyeWard_u0028_vf2_u003b(uv_4: ptr<function, vec2<f32>>) -> vec3<f32> {
    var origin_2: vec3<f32>;
    var along_2: vec3<f32>;
    var param_8: vec2<f32>;
    var param_9: vec3<f32>;
    var param_10: vec3<f32>;

    let _e171 = (*uv_4);
    param_8 = _e171;
    PixelRay_u0028_vf2_u003b_vf3_u003b_vf3_u003b((&param_8), (&param_9), (&param_10));
    let _e172 = param_9;
    origin_2 = _e172;
    let _e173 = param_10;
    along_2 = _e173;
    let _e174 = along_2;
    return -(_e174);
}

fn GtaoVisibility_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_5: ptr<function, vec2<f32>>, point_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>) -> f32 {
    var view_1: vec3<f32>;
    var param_11: vec2<f32>;
    var radius_1: f32;
    var steps: i32;
    var pixelRadius: f32;
    var param_12: vec3<f32>;
    var param_13: vec3<f32>;
    var param_14: f32;
    var pixel_1: vec2<f32>;
    var noise: f32;
    var param_15: vec2<f32>;
    var depth_1: f32;
    var visibility: f32;
    var slices: f32;
    var slice_1: i32;
    var phi: f32;
    var direction: vec2<f32>;
    var along_3: vec3<f32>;
    var param_16: vec2<f32>;
    var param_17: f32;
    var tangent: vec3<f32>;
    var tangentLength: f32;
    var axis_1: vec3<f32>;
    var projected: vec3<f32>;
    var projectedLength: f32;
    var n: f32;
    var side: i32;
    var s: f32;
    var best: f32;
    var i_1: i32;
    var t: f32;
    var at_4: vec2<f32>;
    var d: f32;
    var toSample: vec3<f32>;
    var param_18: vec2<f32>;
    var param_19: f32;
    var distance_: f32;
    var cosine: f32;
    var fade: f32;
    var horizons: array<f32, 2>;
    var h1_: f32;
    var h2_: f32;
    var local_1: f32;
    var phi_886_: bool;
    var phi_893_: bool;
    var phi_900_: bool;

    let _e211 = (*uv_5);
    param_11 = _e211;
    let _e212 = EyeWard_u0028_vf2_u003b((&param_11));
    view_1 = _e212;
    let _e215 = ssao_info.params[0u];
    radius_1 = max(_e215, 0.0001f);
    let _e219 = ssao_info.params[1u];
    steps = clamp((i32((_e219 + 0.5f)) / 4i), 1i, 4i);
    let _e224 = (*point_1);
    param_12 = _e224;
    let _e225 = view_1;
    param_13 = _e225;
    let _e226 = radius_1;
    param_14 = _e226;
    let _e227 = PixelRadius_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_12), (&param_13), (&param_14));
    pixelRadius = _e227;
    let _e228 = (*uv_5);
    let _e230 = ssao_info.screen;
    pixel_1 = floor((_e228 / _e230.xy));
    let _e234 = pixel_1;
    param_15 = _e234;
    let _e235 = PixelNoise_u0028_vf2_u003b((&param_15));
    noise = _e235;
    let _e236 = (*uv_5);
    let _e237 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e236, 0f);
    depth_1 = _e237.w;
    visibility = 0f;
    slices = 0f;
    slice_1 = 0i;
    loop {
        let _e239 = slice_1;
        if (_e239 < 2i) {
            let _e241 = slice_1;
            let _e243 = noise;
            phi = ((f32(_e241) + _e243) * 1.5707963f);
            let _e246 = phi;
            let _e248 = phi;
            let _e252 = ssao_info.screen;
            direction = (vec2<f32>(cos(_e246), sin(_e248)) * _e252.xy);
            let _e255 = (*uv_5);
            let _e256 = direction;
            param_16 = (_e255 + _e256);
            let _e258 = depth_1;
            param_17 = _e258;
            let _e259 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_16), (&param_17));
            let _e260 = (*point_1);
            along_3 = (_e259 - _e260);
            let _e262 = along_3;
            let _e263 = view_1;
            let _e264 = along_3;
            let _e265 = view_1;
            tangent = (_e262 - (_e263 * dot(_e264, _e265)));
            let _e269 = tangent;
            tangentLength = length(_e269);
            let _e271 = tangentLength;
            if (_e271 < 0.000001f) {
                continue;
            }
            let _e273 = tangentLength;
            let _e274 = tangent;
            tangent = (_e274 / vec3(_e273));
            let _e277 = tangent;
            let _e278 = view_1;
            axis_1 = normalize(cross(_e277, _e278));
            let _e281 = (*normal);
            let _e282 = axis_1;
            let _e283 = (*normal);
            let _e284 = axis_1;
            projected = (_e281 - (_e282 * dot(_e283, _e284)));
            let _e288 = projected;
            projectedLength = length(_e288);
            let _e290 = projectedLength;
            if (_e290 < 0.0001f) {
                continue;
            }
            let _e292 = projected;
            let _e293 = tangent;
            let _e296 = projected;
            let _e297 = projectedLength;
            let _e300 = view_1;
            n = (sign(dot(_e292, _e293)) * acos(clamp(dot((_e296 / vec3(_e297)), _e300), 0f, 1f)));
            side = 0i;
            loop {
                let _e305 = side;
                if (_e305 < 2i) {
                    let _e307 = side;
                    s = select(1f, -1f, (_e307 == 0i));
                    best = -1f;
                    i_1 = 0i;
                    loop {
                        let _e310 = i_1;
                        if (_e310 < 4i) {
                            let _e312 = i_1;
                            let _e313 = steps;
                            if (_e312 >= _e313) {
                                break;
                            }
                            let _e315 = i_1;
                            let _e318 = noise;
                            let _e321 = steps;
                            t = (((f32(_e315) + 0.5f) + (0.5f * _e318)) / f32(_e321));
                            let _e324 = (*uv_5);
                            let _e325 = s;
                            let _e326 = direction;
                            let _e328 = pixelRadius;
                            let _e330 = t;
                            at_4 = (_e324 + (((_e326 * _e325) * _e328) * _e330));
                            let _e334 = at_4[0u];
                            let _e335 = (_e334 < 0f);
                            phi_886_ = _e335;
                            if !(_e335) {
                                let _e338 = at_4[0u];
                                phi_886_ = (_e338 > 1f);
                            }
                            let _e341 = phi_886_;
                            phi_893_ = _e341;
                            if !(_e341) {
                                let _e344 = at_4[1u];
                                phi_893_ = (_e344 < 0f);
                            }
                            let _e347 = phi_893_;
                            phi_900_ = _e347;
                            if !(_e347) {
                                let _e350 = at_4[1u];
                                phi_900_ = (_e350 > 1f);
                            }
                            let _e353 = phi_900_;
                            if _e353 {
                                continue;
                            }
                            let _e354 = at_4;
                            let _e355 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e354, 0f);
                            d = _e355.w;
                            let _e357 = d;
                            if (_e357 <= 0f) {
                                continue;
                            }
                            let _e359 = at_4;
                            param_18 = _e359;
                            let _e360 = d;
                            param_19 = _e360;
                            let _e361 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_18), (&param_19));
                            let _e362 = (*point_1);
                            toSample = (_e361 - _e362);
                            let _e364 = toSample;
                            distance_ = length(_e364);
                            let _e366 = distance_;
                            if (_e366 < 0.00001f) {
                                continue;
                            }
                            let _e368 = toSample;
                            let _e369 = distance_;
                            let _e372 = view_1;
                            cosine = dot((_e368 / vec3(_e369)), _e372);
                            let _e374 = distance_;
                            let _e375 = distance_;
                            let _e377 = radius_1;
                            let _e378 = radius_1;
                            fade = clamp((1f - ((_e374 * _e375) / (_e377 * _e378))), 0f, 1f);
                            let _e383 = best;
                            let _e384 = cosine;
                            let _e385 = fade;
                            best = max(_e383, mix(-1f, _e384, _e385));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e388 = i_1;
                            i_1 = (_e388 + 1i);
                        }
                    }
                    let _e390 = side;
                    let _e391 = s;
                    let _e392 = best;
                    horizons[_e390] = (_e391 * acos(clamp(_e392, -1f, 1f)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e397 = side;
                    side = (_e397 + 1i);
                }
            }
            let _e399 = n;
            let _e401 = horizons[0i];
            let _e402 = n;
            h1_ = (_e399 + clamp((_e401 - _e402), -1.5707963f, 1.5707963f));
            let _e406 = n;
            let _e408 = horizons[1i];
            let _e409 = n;
            h2_ = (_e406 + clamp((_e408 - _e409), -1.5707963f, 1.5707963f));
            let _e413 = projectedLength;
            let _e415 = h1_;
            let _e417 = n;
            let _e421 = n;
            let _e424 = h1_;
            let _e426 = n;
            let _e430 = h2_;
            let _e432 = n;
            let _e436 = n;
            let _e439 = h2_;
            let _e441 = n;
            let _e447 = visibility;
            visibility = (_e447 + ((_e413 * 0.25f) * (((-(cos(((2f * _e415) - _e417))) + cos(_e421)) + ((2f * _e424) * sin(_e426))) + ((-(cos(((2f * _e430) - _e432))) + cos(_e436)) + ((2f * _e439) * sin(_e441))))));
            let _e449 = slices;
            slices = (_e449 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e451 = slice_1;
            slice_1 = (_e451 + 1i);
        }
    }
    let _e453 = slices;
    if (_e453 > 0f) {
        let _e455 = visibility;
        let _e456 = slices;
        local_1 = clamp((_e455 / _e456), 0f, 1f);
    } else {
        local_1 = 1f;
    }
    let _e459 = local_1;
    return _e459;
}

fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
    var n_1: vec3<f32>;
    var t_1: f32;
    var local_2: f32;
    var local_3: f32;

    let _e170 = (*e);
    (*e) = ((_e170 * 2f) - vec2(1f));
    let _e174 = (*e);
    let _e176 = (*e)[0u];
    let _e180 = (*e)[1u];
    n_1 = vec3<f32>(_e174.x, _e174.y, ((1f - abs(_e176)) - abs(_e180)));
    let _e187 = n_1[2u];
    t_1 = max(-(_e187), 0f);
    let _e191 = n_1[0u];
    if (_e191 >= 0f) {
        let _e193 = t_1;
        local_2 = -(_e193);
    } else {
        let _e195 = t_1;
        local_2 = _e195;
    }
    let _e196 = local_2;
    let _e198 = n_1[0u];
    n_1[0u] = (_e198 + _e196);
    let _e202 = n_1[1u];
    if (_e202 >= 0f) {
        let _e204 = t_1;
        local_3 = -(_e204);
    } else {
        let _e206 = t_1;
        local_3 = _e206;
    }
    let _e207 = local_3;
    let _e209 = n_1[1u];
    n_1[1u] = (_e209 + _e207);
    let _e212 = n_1;
    return normalize(_e212);
}

fn SectorCount_u0028_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b(m0_: ptr<function, vec4<f32>>, m1_: ptr<function, vec4<f32>>, m2_: ptr<function, vec4<f32>>, m3_: ptr<function, vec4<f32>>) -> f32 {
    let _e169 = (*m0_);
    let _e170 = (*m1_);
    let _e172 = (*m2_);
    let _e174 = (*m3_);
    return dot((((_e169 + _e170) + _e172) + _e174), vec4<f32>(1f, 1f, 1f, 1f));
}

fn SectorRun_u0028_f1_u003b_f1_u003b_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b(low: ptr<function, f32>, high: ptr<function, f32>, m0_1: ptr<function, vec4<f32>>, m1_1: ptr<function, vec4<f32>>, m2_1: ptr<function, vec4<f32>>, m3_1: ptr<function, vec4<f32>>) {
    let _e171 = (*low);
    let _e174 = (*high);
    (*m0_1) = (step(vec4(_e171), vec4<f32>(0.03125f, 0.09375f, 0.15625f, 0.21875f)) * step(vec4<f32>(0.03125f, 0.09375f, 0.15625f, 0.21875f), vec4(_e174)));
    let _e178 = (*low);
    let _e181 = (*high);
    (*m1_1) = (step(vec4(_e178), vec4<f32>(0.28125f, 0.34375f, 0.40625f, 0.46875f)) * step(vec4<f32>(0.28125f, 0.34375f, 0.40625f, 0.46875f), vec4(_e181)));
    let _e185 = (*low);
    let _e188 = (*high);
    (*m2_1) = (step(vec4(_e185), vec4<f32>(0.53125f, 0.59375f, 0.65625f, 0.71875f)) * step(vec4<f32>(0.53125f, 0.59375f, 0.65625f, 0.71875f), vec4(_e188)));
    let _e192 = (*low);
    let _e195 = (*high);
    (*m3_1) = (step(vec4(_e192), vec4<f32>(0.78125f, 0.84375f, 0.90625f, 0.96875f)) * step(vec4<f32>(0.78125f, 0.84375f, 0.90625f, 0.96875f), vec4(_e195)));
    return;
}

fn SsilLight_u0028_vf2_u003b_vf3_u003b_vf3_u003b(uv_6: ptr<function, vec2<f32>>, point_2: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>) -> vec4<f32> {
    var view_2: vec3<f32>;
    var param_20: vec2<f32>;
    var radius_2: f32;
    var thickness: f32;
    var steps_1: i32;
    var pixelRadius_1: f32;
    var param_21: vec3<f32>;
    var param_22: vec3<f32>;
    var param_23: f32;
    var pixel_2: vec2<f32>;
    var noise_1: f32;
    var param_24: vec2<f32>;
    var depth_2: f32;
    var light: vec3<f32>;
    var open: f32;
    var slices_1: f32;
    var slice_2: i32;
    var phi_1: f32;
    var direction_1: vec2<f32>;
    var along_4: vec3<f32>;
    var param_25: vec2<f32>;
    var param_26: f32;
    var tangent_1: vec3<f32>;
    var tangentLength_1: f32;
    var axis_2: vec3<f32>;
    var projected_1: vec3<f32>;
    var projectedLength_1: f32;
    var n_2: f32;
    var c0_: vec4<f32>;
    var c1_: vec4<f32>;
    var c2_: vec4<f32>;
    var c3_: vec4<f32>;
    var side_1: i32;
    var s_1: f32;
    var i_2: i32;
    var t_2: f32;
    var at_5: vec2<f32>;
    var sampled: vec4<f32>;
    var front: vec3<f32>;
    var param_27: vec2<f32>;
    var param_28: f32;
    var toward: vec3<f32>;
    var back: vec3<f32>;
    var a_1: f32;
    var b_1: f32;
    var lowAngle: f32;
    var highAngle: f32;
    var m0_2: vec4<f32>;
    var m1_2: vec4<f32>;
    var m2_2: vec4<f32>;
    var m3_2: vec4<f32>;
    var param_29: f32;
    var param_30: f32;
    var param_31: vec4<f32>;
    var param_32: vec4<f32>;
    var param_33: vec4<f32>;
    var param_34: vec4<f32>;
    var fresh: f32;
    var param_35: vec4<f32>;
    var param_36: vec4<f32>;
    var param_37: vec4<f32>;
    var param_38: vec4<f32>;
    var radiance: vec3<f32>;
    var cosine_1: f32;
    var param_39: vec2<f32>;
    var param_40: vec4<f32>;
    var param_41: vec4<f32>;
    var param_42: vec4<f32>;
    var param_43: vec4<f32>;
    var count: f32;
    var albedo_1: vec3<f32>;
    var local_4: vec3<f32>;
    var param_44: vec3<f32>;
    var local_5: vec4<f32>;
    var phi_1365_: bool;
    var phi_1372_: bool;
    var phi_1379_: bool;

    let _e242 = (*uv_6);
    param_20 = _e242;
    let _e243 = EyeWard_u0028_vf2_u003b((&param_20));
    view_2 = _e243;
    let _e246 = ssao_info.params[0u];
    radius_2 = max(_e246, 0.0001f);
    let _e250 = ssao_info.screen[3u];
    thickness = max(_e250, 0.001f);
    let _e254 = ssao_info.params[1u];
    steps_1 = clamp((i32((_e254 + 0.5f)) / 4i), 1i, 4i);
    let _e259 = (*point_2);
    param_21 = _e259;
    let _e260 = view_2;
    param_22 = _e260;
    let _e261 = radius_2;
    param_23 = _e261;
    let _e262 = PixelRadius_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_21), (&param_22), (&param_23));
    pixelRadius_1 = _e262;
    let _e263 = (*uv_6);
    let _e265 = ssao_info.screen;
    pixel_2 = floor((_e263 / _e265.xy));
    let _e269 = pixel_2;
    param_24 = _e269;
    let _e270 = PixelNoise_u0028_vf2_u003b((&param_24));
    noise_1 = _e270;
    let _e271 = (*uv_6);
    let _e272 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e271, 0f);
    depth_2 = _e272.w;
    light = vec3<f32>(0f, 0f, 0f);
    open = 0f;
    slices_1 = 0f;
    slice_2 = 0i;
    loop {
        let _e274 = slice_2;
        if (_e274 < 2i) {
            let _e276 = slice_2;
            let _e278 = noise_1;
            phi_1 = ((f32(_e276) + _e278) * 1.5707963f);
            let _e281 = phi_1;
            let _e283 = phi_1;
            let _e287 = ssao_info.screen;
            direction_1 = (vec2<f32>(cos(_e281), sin(_e283)) * _e287.xy);
            let _e290 = (*uv_6);
            let _e291 = direction_1;
            param_25 = (_e290 + _e291);
            let _e293 = depth_2;
            param_26 = _e293;
            let _e294 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_25), (&param_26));
            let _e295 = (*point_2);
            along_4 = (_e294 - _e295);
            let _e297 = along_4;
            let _e298 = view_2;
            let _e299 = along_4;
            let _e300 = view_2;
            tangent_1 = (_e297 - (_e298 * dot(_e299, _e300)));
            let _e304 = tangent_1;
            tangentLength_1 = length(_e304);
            let _e306 = tangentLength_1;
            if (_e306 < 0.000001f) {
                continue;
            }
            let _e308 = tangentLength_1;
            let _e309 = tangent_1;
            tangent_1 = (_e309 / vec3(_e308));
            let _e312 = tangent_1;
            let _e313 = view_2;
            axis_2 = normalize(cross(_e312, _e313));
            let _e316 = (*normal_1);
            let _e317 = axis_2;
            let _e318 = (*normal_1);
            let _e319 = axis_2;
            projected_1 = (_e316 - (_e317 * dot(_e318, _e319)));
            let _e323 = projected_1;
            projectedLength_1 = length(_e323);
            let _e325 = projectedLength_1;
            if (_e325 < 0.0001f) {
                continue;
            }
            let _e327 = projected_1;
            let _e328 = tangent_1;
            let _e331 = projected_1;
            let _e332 = projectedLength_1;
            let _e335 = view_2;
            n_2 = (sign(dot(_e327, _e328)) * acos(clamp(dot((_e331 / vec3(_e332)), _e335), 0f, 1f)));
            c0_ = vec4<f32>(0f, 0f, 0f, 0f);
            c1_ = vec4<f32>(0f, 0f, 0f, 0f);
            c2_ = vec4<f32>(0f, 0f, 0f, 0f);
            c3_ = vec4<f32>(0f, 0f, 0f, 0f);
            side_1 = 0i;
            loop {
                let _e340 = side_1;
                if (_e340 < 2i) {
                    let _e342 = side_1;
                    s_1 = select(1f, -1f, (_e342 == 0i));
                    i_2 = 0i;
                    loop {
                        let _e345 = i_2;
                        if (_e345 < 4i) {
                            let _e347 = i_2;
                            let _e348 = steps_1;
                            if (_e347 >= _e348) {
                                break;
                            }
                            let _e350 = i_2;
                            let _e353 = noise_1;
                            let _e356 = steps_1;
                            t_2 = (((f32(_e350) + 0.5f) + (0.5f * _e353)) / f32(_e356));
                            let _e359 = (*uv_6);
                            let _e360 = s_1;
                            let _e361 = direction_1;
                            let _e363 = pixelRadius_1;
                            let _e365 = t_2;
                            at_5 = (_e359 + (((_e361 * _e360) * _e363) * _e365));
                            let _e369 = at_5[0u];
                            let _e370 = (_e369 < 0f);
                            phi_1365_ = _e370;
                            if !(_e370) {
                                let _e373 = at_5[0u];
                                phi_1365_ = (_e373 > 1f);
                            }
                            let _e376 = phi_1365_;
                            phi_1372_ = _e376;
                            if !(_e376) {
                                let _e379 = at_5[1u];
                                phi_1372_ = (_e379 < 0f);
                            }
                            let _e382 = phi_1372_;
                            phi_1379_ = _e382;
                            if !(_e382) {
                                let _e385 = at_5[1u];
                                phi_1379_ = (_e385 > 1f);
                            }
                            let _e388 = phi_1379_;
                            if _e388 {
                                continue;
                            }
                            let _e389 = at_5;
                            let _e390 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e389, 0f);
                            sampled = _e390;
                            let _e392 = sampled[3u];
                            if (_e392 <= 0f) {
                                continue;
                            }
                            let _e394 = at_5;
                            param_27 = _e394;
                            let _e396 = sampled[3u];
                            param_28 = _e396;
                            let _e397 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_27), (&param_28));
                            let _e398 = (*point_2);
                            front = (_e397 - _e398);
                            let _e400 = front;
                            let _e402 = radius_2;
                            if (length(_e400) > _e402) {
                                continue;
                            }
                            let _e404 = front;
                            toward = normalize(_e404);
                            let _e406 = front;
                            let _e407 = view_2;
                            let _e408 = thickness;
                            back = (_e406 - (_e407 * _e408));
                            let _e411 = s_1;
                            let _e412 = toward;
                            let _e413 = view_2;
                            a_1 = (_e411 * acos(clamp(dot(_e412, _e413), -1f, 1f)));
                            let _e418 = s_1;
                            let _e419 = back;
                            let _e421 = view_2;
                            b_1 = (_e418 * acos(clamp(dot(normalize(_e419), _e421), -1f, 1f)));
                            let _e426 = a_1;
                            let _e427 = b_1;
                            let _e429 = n_2;
                            lowAngle = (((min(_e426, _e427) - _e429) + 1.5707963f) / 3.1415927f);
                            let _e433 = a_1;
                            let _e434 = b_1;
                            let _e436 = n_2;
                            highAngle = (((max(_e433, _e434) - _e436) + 1.5707963f) / 3.1415927f);
                            let _e440 = lowAngle;
                            param_29 = _e440;
                            let _e441 = highAngle;
                            param_30 = _e441;
                            SectorRun_u0028_f1_u003b_f1_u003b_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34));
                            let _e442 = param_31;
                            m0_2 = _e442;
                            let _e443 = param_32;
                            m1_2 = _e443;
                            let _e444 = param_33;
                            m2_2 = _e444;
                            let _e445 = param_34;
                            m3_2 = _e445;
                            let _e446 = m0_2;
                            let _e447 = c0_;
                            let _e451 = m1_2;
                            let _e452 = c1_;
                            let _e456 = m2_2;
                            let _e457 = c2_;
                            let _e461 = m3_2;
                            let _e462 = c3_;
                            param_35 = (_e446 * (vec4(1f) - _e447));
                            param_36 = (_e451 * (vec4(1f) - _e452));
                            param_37 = (_e456 * (vec4(1f) - _e457));
                            param_38 = (_e461 * (vec4(1f) - _e462));
                            let _e466 = SectorCount_u0028_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b((&param_35), (&param_36), (&param_37), (&param_38));
                            fresh = _e466;
                            let _e467 = at_5;
                            let _e468 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e467, 0f);
                            radiance = _e468.xyz;
                            let _e470 = (*normal_1);
                            let _e471 = toward;
                            let _e474 = sampled;
                            param_39 = _e474.xy;
                            let _e476 = DecodeOctahedral_u0028_vf2_u003b((&param_39));
                            let _e477 = toward;
                            cosine_1 = (max(dot(_e470, _e471), 0f) * max(dot(_e476, -(_e477)), 0f));
                            let _e482 = radiance;
                            let _e483 = cosine_1;
                            let _e485 = fresh;
                            let _e489 = light;
                            light = (_e489 + (((_e482 * _e483) * _e485) / vec3(16f)));
                            let _e491 = c0_;
                            let _e492 = m0_2;
                            c0_ = max(_e491, _e492);
                            let _e494 = c1_;
                            let _e495 = m1_2;
                            c1_ = max(_e494, _e495);
                            let _e497 = c2_;
                            let _e498 = m2_2;
                            c2_ = max(_e497, _e498);
                            let _e500 = c3_;
                            let _e501 = m3_2;
                            c3_ = max(_e500, _e501);
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e503 = i_2;
                            i_2 = (_e503 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e505 = side_1;
                    side_1 = (_e505 + 1i);
                }
            }
            let _e507 = c0_;
            param_40 = _e507;
            let _e508 = c1_;
            param_41 = _e508;
            let _e509 = c2_;
            param_42 = _e509;
            let _e510 = c3_;
            param_43 = _e510;
            let _e511 = SectorCount_u0028_vf4_u003b_vf4_u003b_vf4_u003b_vf4_u003b((&param_40), (&param_41), (&param_42), (&param_43));
            let _e514 = open;
            open = (_e514 + (1f - (_e511 / 16f)));
            let _e516 = slices_1;
            slices_1 = (_e516 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e518 = slice_2;
            slice_2 = (_e518 + 1i);
        }
    }
    let _e520 = slices_1;
    count = max(_e520, 1f);
    let _e524 = ssao_info.params[2u];
    if (_e524 > 0.5f) {
        let _e526 = (*uv_6);
        let _e527 = textureSampleLevel(albedo_texture_tex, albedo_texture_smp, _e526, 0f);
        param_44 = _e527.xyz;
        let _e529 = SrgbToLinearAlbedo_u0028_vf3_u003b((&param_44));
        local_4 = _e529;
    } else {
        local_4 = vec3<f32>(0.5f, 0.5f, 0.5f);
    }
    let _e530 = local_4;
    albedo_1 = _e530;
    let _e531 = slices_1;
    if (_e531 > 0f) {
        let _e533 = light;
        let _e534 = count;
        let _e537 = albedo_1;
        let _e538 = ((_e533 / vec3(_e534)) * _e537);
        let _e539 = open;
        let _e540 = count;
        local_5 = vec4<f32>(_e538.x, _e538.y, _e538.z, (_e539 / _e540));
    } else {
        local_5 = vec4<f32>(0f, 0f, 0f, 1f);
    }
    let _e546 = local_5;
    return _e546;
}

fn main_1() {
    var surface: vec4<f32>;
    var normal_2: vec3<f32>;
    var param_45: vec2<f32>;
    var param_46: vec2<f32>;
    var param_47: f32;
    var param_48: vec2<f32>;
    var param_49: vec3<f32>;
    var param_50: vec3<f32>;
    var visible_1: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: vec2<f32>;
    var param_54: vec3<f32>;
    var param_55: vec3<f32>;
    var shaded: f32;
    var local_6: f32;
    var param_56: vec3<f32>;
    var param_57: f32;
    var param_58: vec3<f32>;
    var radius_3: f32;
    var samples: i32;
    var origin_3: vec3<f32>;
    var param_59: vec2<f32>;
    var param_60: f32;
    var rot: vec2<f32>;
    var param_61: vec2<f32>;
    var occluded: f32;
    var i_3: i32;
    var tap: vec3<f32>;
    var param_62: i32;
    var spun: vec3<f32>;
    var at_6: vec3<f32>;
    var clip: vec4<f32>;
    var ndc_1: vec3<f32>;
    var uv_7: vec2<f32>;
    var param_63: vec2<f32>;
    var there_1: vec4<f32>;
    var param_64: vec3<f32>;
    var seen: vec3<f32>;
    var param_65: vec2<f32>;
    var param_66: f32;
    var phi_1815_: bool;

    let _e206 = v_uv_1;
    let _e207 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e206, 0f);
    surface = _e207;
    let _e209 = surface[3u];
    if (_e209 <= 0f) {
        let _e213 = ssao_info.screen[2u];
        frag_color = select(vec4<f32>(1f, 1f, 1f, 1f), vec4<f32>(0f, 0f, 0f, 1f), vec4((_e213 > 1.5f)));
        return;
    }
    let _e217 = surface;
    param_45 = _e217.xy;
    let _e219 = DecodeOctahedral_u0028_vf2_u003b((&param_45));
    normal_2 = _e219;
    let _e222 = ssao_info.screen[2u];
    if (_e222 > 1.5f) {
        let _e224 = v_uv_1;
        param_46 = _e224;
        let _e226 = surface[3u];
        param_47 = _e226;
        let _e227 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_46), (&param_47));
        let _e228 = v_uv_1;
        param_48 = _e228;
        param_49 = _e227;
        let _e229 = normal_2;
        param_50 = _e229;
        let _e230 = SsilLight_u0028_vf2_u003b_vf3_u003b_vf3_u003b((&param_48), (&param_49), (&param_50));
        frag_color = _e230;
        return;
    }
    let _e233 = ssao_info.screen[2u];
    if (_e233 > 0.5f) {
        let _e235 = v_uv_1;
        param_51 = _e235;
        let _e237 = surface[3u];
        param_52 = _e237;
        let _e238 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_51), (&param_52));
        let _e239 = v_uv_1;
        param_53 = _e239;
        param_54 = _e238;
        let _e240 = normal_2;
        param_55 = _e240;
        let _e241 = GtaoVisibility_u0028_vf2_u003b_vf3_u003b_vf3_u003b((&param_53), (&param_54), (&param_55));
        visible_1 = _e241;
        let _e244 = ssao_info.params[2u];
        if (_e244 > 0.5f) {
            let _e246 = v_uv_1;
            let _e247 = textureSampleLevel(albedo_texture_tex, albedo_texture_smp, _e246, 0f);
            param_56 = _e247.xyz;
            let _e249 = SrgbToLinearAlbedo_u0028_vf3_u003b((&param_56));
            let _e250 = visible_1;
            param_57 = _e250;
            param_58 = _e249;
            let _e251 = MultiBounce_u0028_f1_u003b_vf3_u003b((&param_57), (&param_58));
            local_6 = _e251;
        } else {
            let _e252 = visible_1;
            local_6 = _e252;
        }
        let _e253 = local_6;
        shaded = _e253;
        let _e254 = shaded;
        frag_color = vec4(_e254);
        return;
    }
    let _e258 = ssao_info.params[0u];
    radius_3 = max(_e258, 0.0001f);
    let _e262 = ssao_info.params[1u];
    samples = clamp(i32((_e262 + 0.5f)), 1i, 12i);
    let _e266 = v_uv_1;
    param_59 = _e266;
    let _e268 = surface[3u];
    param_60 = _e268;
    let _e269 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_59), (&param_60));
    let _e270 = normal_2;
    let _e273 = ssao_info.params[3u];
    origin_3 = (_e269 + (_e270 * _e273));
    let _e276 = v_uv_1;
    param_61 = _e276;
    let _e277 = Rotation_u0028_vf2_u003b((&param_61));
    rot = _e277;
    occluded = 0f;
    i_3 = 0i;
    loop {
        let _e278 = i_3;
        if (_e278 < 12i) {
            let _e280 = i_3;
            let _e281 = samples;
            if (_e280 >= _e281) {
                break;
            }
            let _e283 = i_3;
            param_62 = _e283;
            let _e284 = KernelTap_u0028_i1_u003b((&param_62));
            tap = _e284;
            let _e286 = tap[0u];
            let _e288 = rot[0u];
            let _e291 = tap[1u];
            let _e293 = rot[1u];
            let _e297 = tap[0u];
            let _e299 = rot[1u];
            let _e302 = tap[1u];
            let _e304 = rot[0u];
            let _e308 = tap[2u];
            spun = vec3<f32>(((_e286 * _e288) - (_e291 * _e293)), ((_e297 * _e299) + (_e302 * _e304)), _e308);
            let _e310 = spun;
            let _e311 = normal_2;
            if (dot(_e310, _e311) < 0f) {
                let _e314 = spun;
                spun = -(_e314);
            }
            let _e316 = origin_3;
            let _e317 = spun;
            let _e318 = radius_3;
            at_6 = (_e316 + (_e317 * _e318));
            let _e322 = ssao_info.view_projection;
            let _e323 = at_6;
            clip = (_e322 * vec4<f32>(_e323.x, _e323.y, _e323.z, 1f));
            let _e330 = clip[3u];
            if (_e330 <= 0f) {
                continue;
            }
            let _e332 = clip;
            let _e335 = clip[3u];
            ndc_1 = (_e332.xyz / vec3(_e335));
            let _e339 = ndc_1[0u];
            let _e341 = (abs(_e339) > 1f);
            phi_1815_ = _e341;
            if !(_e341) {
                let _e344 = ndc_1[1u];
                phi_1815_ = (abs(_e344) > 1f);
            }
            let _e348 = phi_1815_;
            if _e348 {
                continue;
            }
            let _e349 = ndc_1;
            param_63 = _e349.xy;
            let _e351 = UvFromNdc_u0028_vf2_u003b((&param_63));
            uv_7 = _e351;
            let _e352 = uv_7;
            let _e353 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e352, 0f);
            there_1 = _e353;
            let _e355 = there_1[3u];
            if (_e355 <= 0f) {
                continue;
            }
            let _e358 = there_1[3u];
            let _e359 = at_6;
            param_64 = _e359;
            let _e360 = DepthOf_u0028_vf3_u003b((&param_64));
            if (_e358 >= _e360) {
                continue;
            }
            let _e362 = uv_7;
            param_65 = _e362;
            let _e364 = there_1[3u];
            param_66 = _e364;
            let _e365 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_65), (&param_66));
            seen = _e365;
            let _e366 = radius_3;
            let _e367 = seen;
            let _e368 = origin_3;
            let _e373 = occluded;
            occluded = (_e373 + smoothstep(0f, 1f, (_e366 / max(distance(_e367, _e368), 0.0001f))));
            continue;
        } else {
            break;
        }
        continuing {
            let _e375 = i_3;
            i_3 = (_e375 + 1i);
        }
    }
    let _e377 = occluded;
    let _e378 = samples;
    frag_color = vec4(clamp((1f - (_e377 / f32(_e378))), 0f, 1f));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'NoiseInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
        WebGpuBlock(
          name: 'SsaoInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'view_projection',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 128,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'screen',
              offsetInBytes: 144,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 160,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 176,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'albedo_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'SsaoBlur': WebGpuStage(
      wgsl: r'''
struct SsaoBlurInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> blur_info: SsaoBlurInfo;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;

fn main_1() {
    var taps: f32;
    var centre: vec4<f32>;
    var centreDepth: f32;
    var falloff: f32;
    var total: vec4<f32>;
    var weightSum: f32;
    var i: i32;
    var offset: f32;
    var steps: array<vec2<f32>, 4>;
    var s: i32;
    var at: vec2<f32>;
    var depth: f32;
    var closeness: f32;
    var weight: f32;

    let _e38 = blur_info.params[2u];
    taps = _e38;
    let _e39 = v_uv_1;
    let _e40 = textureSample(ao_texture_tex, ao_texture_smp, _e39);
    centre = _e40;
    let _e41 = taps;
    if (_e41 < 1f) {
        let _e43 = centre;
        frag_color = _e43;
        return;
    }
    let _e44 = v_uv_1;
    let _e45 = textureSample(surface_texture_tex, surface_texture_smp, _e44);
    centreDepth = _e45.w;
    let _e49 = blur_info.params[3u];
    falloff = max(_e49, 0.0001f);
    let _e51 = centre;
    total = _e51;
    weightSum = 1f;
    i = 1i;
    loop {
        let _e52 = i;
        if (_e52 <= 8i) {
            let _e54 = i;
            let _e56 = taps;
            if (f32(_e54) > _e56) {
                break;
            }
            let _e58 = i;
            offset = f32(_e58);
            let _e62 = blur_info.params[0u];
            let _e63 = offset;
            steps[0i] = vec2<f32>((_e62 * _e63), 0f);
            let _e69 = blur_info.params[0u];
            let _e71 = offset;
            steps[1i] = vec2<f32>((-(_e69) * _e71), 0f);
            let _e77 = blur_info.params[1u];
            let _e78 = offset;
            steps[2i] = vec2<f32>(0f, (_e77 * _e78));
            let _e84 = blur_info.params[1u];
            let _e86 = offset;
            steps[3i] = vec2<f32>(0f, (-(_e84) * _e86));
            s = 0i;
            loop {
                let _e90 = s;
                if (_e90 < 4i) {
                    let _e92 = v_uv_1;
                    let _e93 = s;
                    let _e95 = steps[_e93];
                    at = (_e92 + _e95);
                    let _e97 = at;
                    let _e98 = textureSample(surface_texture_tex, surface_texture_smp, _e97);
                    depth = _e98.w;
                    let _e100 = depth;
                    let _e101 = centreDepth;
                    let _e105 = falloff;
                    let _e106 = centreDepth;
                    closeness = exp((-(abs((_e100 - _e101))) / (_e105 * max(_e106, 0.001f))));
                    let _e111 = closeness;
                    let _e112 = offset;
                    weight = (_e111 / _e112);
                    let _e114 = at;
                    let _e115 = textureSample(ao_texture_tex, ao_texture_smp, _e114);
                    let _e116 = weight;
                    let _e118 = total;
                    total = (_e118 + (_e115 * _e116));
                    let _e120 = weight;
                    let _e121 = weightSum;
                    weightSum = (_e121 + _e120);
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e123 = s;
                    s = (_e123 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e125 = i;
            i = (_e125 + 1i);
        }
    }
    let _e127 = total;
    let _e128 = weightSum;
    frag_color = (_e127 / vec4(_e128));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'SsaoBlurInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'ao_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ContactShadow': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct NoiseInfo {
    noise: vec4<f32>,
}

struct ContactShadowInfo {
    inverse_view_projection: mat4x4<f32>,
    view_projection: mat4x4<f32>,
    params: vec4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
    to_light: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(2)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> contact_info: ContactShadowInfo;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
    let _e57 = (*ndc)[0u];
    let _e61 = (*ndc)[1u];
    return vec2<f32>(((_e57 * 0.5f) + 0.5f), (0.5f - (_e61 * 0.5f)));
}

fn DepthOf_u0028_vf3_u003b(at: ptr<function, vec3<f32>>) -> f32 {
    let _e56 = (*at);
    let _e58 = contact_info.camera;
    let _e62 = contact_info.forward;
    return dot((_e56 - _e58.xyz), _e62.xyz);
}

fn BayerCell_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e61 = (*at_1)[0u];
    x = i32((_e61 - (floor((_e61 / 4f)) * 4f)));
    let _e68 = (*at_1)[1u];
    y = i32((_e68 - (floor((_e68 / 4f)) * 4f)));
    let _e74 = y;
    let _e76 = x;
    index = ((_e74 * 4i) + _e76);
    value = 0f;
    let _e78 = index;
    if (_e78 == 0i) {
        value = 0f;
    } else {
        let _e80 = index;
        if (_e80 == 1i) {
            value = 8f;
        } else {
            let _e82 = index;
            if (_e82 == 2i) {
                value = 2f;
            } else {
                let _e84 = index;
                if (_e84 == 3i) {
                    value = 10f;
                } else {
                    let _e86 = index;
                    if (_e86 == 4i) {
                        value = 12f;
                    } else {
                        let _e88 = index;
                        if (_e88 == 5i) {
                            value = 4f;
                        } else {
                            let _e90 = index;
                            if (_e90 == 6i) {
                                value = 14f;
                            } else {
                                let _e92 = index;
                                if (_e92 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e94 = index;
                                    if (_e94 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e96 = index;
                                        if (_e96 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e98 = index;
                                            if (_e98 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e100 = index;
                                                if (_e100 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e102 = index;
                                                    if (_e102 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e104 = index;
                                                        if (_e104 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e106 = index;
                                                            if (_e106 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e108 = value;
    return (_e108 / 16f);
}

fn BlueNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
    var slice: f32;
    var cell: vec2<f32>;
    var corner: vec2<f32>;
    var uv: vec2<f32>;

    let _e62 = noise_info.noise[1u];
    slice = _e62;
    let _e63 = (*at_2);
    let _e64 = floor(_e63);
    let _e65 = vec2(64f);
    cell = (_e64 - (floor((_e64 / _e65)) * _e65));
    let _e70 = slice;
    let _e75 = slice;
    corner = (vec2<f32>((_e70 - (floor((_e70 / 8f)) * 8f)), floor((_e75 / 8f))) * 64f);
    let _e80 = corner;
    let _e81 = cell;
    uv = (((_e80 + _e81) + vec2(0.5f)) / vec2<f32>(512f, 256f));
    let _e86 = uv;
    let _e87 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e86, 0f);
    return (_e87.x * 0.99609375f);
}

fn PixelNoise_u0028_vf2_u003b(at_3: ptr<function, vec2<f32>>) -> f32 {
    var local: f32;
    var param: vec2<f32>;
    var param_1: vec2<f32>;

    let _e61 = noise_info.noise[0u];
    if (_e61 > 0.5f) {
        let _e63 = (*at_3);
        param = _e63;
        let _e64 = BlueNoise_u0028_vf2_u003b((&param));
        local = _e64;
    } else {
        let _e65 = (*at_3);
        param_1 = _e65;
        let _e66 = BayerCell_u0028_vf2_u003b((&param_1));
        local = _e66;
    }
    let _e67 = local;
    return _e67;
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_1: vec2<f32>;

    let _e57 = (*rows);
    if (_e57 > 0f) {
        let _e60 = gl_FragCoord_1[0u];
        let _e61 = (*rows);
        let _e63 = gl_FragCoord_1[1u];
        local_1 = vec2<f32>(_e60, (_e61 - _e63));
    } else {
        let _e66 = gl_FragCoord_1;
        local_1 = _e66.xy;
    }
    let _e68 = local_1;
    return _e68;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param_2: f32;

    let _e58 = frag_coord_info.origin[0u];
    param_2 = _e58;
    let _e59 = FragCoordFromTop_u0028_f1_u003b((&param_2));
    return _e59;
}

fn WorldAtDepth_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;
    var origin: vec3<f32>;
    var along: vec3<f32>;
    var axis: vec3<f32>;

    let _e64 = (*uv_1)[0u];
    let _e68 = (*uv_1)[1u];
    xy = vec2<f32>(((_e64 * 2f) - 1f), (1f - (_e68 * 2f)));
    let _e73 = contact_info.inverse_view_projection;
    let _e74 = xy;
    nearH = (_e73 * vec4<f32>(_e74.x, _e74.y, 0f, 1f));
    let _e80 = contact_info.inverse_view_projection;
    let _e81 = xy;
    farH = (_e80 * vec4<f32>(_e81.x, _e81.y, 1f, 1f));
    let _e86 = nearH;
    let _e89 = nearH[3u];
    origin = (_e86.xyz / vec3(_e89));
    let _e92 = farH;
    let _e95 = farH[3u];
    let _e98 = origin;
    along = normalize(((_e92.xyz / vec3(_e95)) - _e98));
    let _e102 = contact_info.forward;
    axis = _e102.xyz;
    let _e104 = origin;
    let _e105 = along;
    let _e106 = (*depth);
    let _e107 = origin;
    let _e109 = contact_info.camera;
    let _e112 = axis;
    let _e115 = along;
    let _e116 = axis;
    return (_e104 + (_e105 * ((_e106 - dot((_e107 - _e109.xyz), _e112)) / dot(_e115, _e116))));
}

fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
    var n: vec3<f32>;
    var t: f32;
    var local_2: f32;
    var local_3: f32;

    let _e60 = (*e);
    (*e) = ((_e60 * 2f) - vec2(1f));
    let _e64 = (*e);
    let _e66 = (*e)[0u];
    let _e70 = (*e)[1u];
    n = vec3<f32>(_e64.x, _e64.y, ((1f - abs(_e66)) - abs(_e70)));
    let _e77 = n[2u];
    t = max(-(_e77), 0f);
    let _e81 = n[0u];
    if (_e81 >= 0f) {
        let _e83 = t;
        local_2 = -(_e83);
    } else {
        let _e85 = t;
        local_2 = _e85;
    }
    let _e86 = local_2;
    let _e88 = n[0u];
    n[0u] = (_e88 + _e86);
    let _e92 = n[1u];
    if (_e92 >= 0f) {
        let _e94 = t;
        local_3 = -(_e94);
    } else {
        let _e96 = t;
        local_3 = _e96;
    }
    let _e97 = local_3;
    let _e99 = n[1u];
    n[1u] = (_e99 + _e97);
    let _e102 = n;
    return normalize(_e102);
}

fn main_1() {
    var surface: vec4<f32>;
    var normal: vec3<f32>;
    var param_3: vec2<f32>;
    var toLight: vec3<f32>;
    var reach: f32;
    var steps: i32;
    var thickness: f32;
    var origin_1: vec3<f32>;
    var param_4: vec2<f32>;
    var param_5: f32;
    var stride: f32;
    var jitter: f32;
    var param_6: vec2<f32>;
    var stepDepth: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var tolerance: f32;
    var i: i32;
    var along_1: f32;
    var at_4: vec3<f32>;
    var clip: vec4<f32>;
    var uv_2: vec2<f32>;
    var param_9: vec2<f32>;
    var there: vec4<f32>;
    var marched: f32;
    var param_10: vec3<f32>;
    var gap: f32;
    var phi_580_: bool;
    var phi_587_: bool;
    var phi_594_: bool;

    let _e82 = v_uv_1;
    let _e83 = textureSample(surface_texture_tex, surface_texture_smp, _e82);
    surface = _e83;
    let _e85 = surface[3u];
    if (_e85 <= 0f) {
        frag_color = vec4<f32>(1f, 1f, 1f, 1f);
        return;
    }
    let _e87 = surface;
    param_3 = _e87.xy;
    let _e89 = DecodeOctahedral_u0028_vf2_u003b((&param_3));
    normal = _e89;
    let _e91 = contact_info.to_light;
    toLight = normalize(_e91.xyz);
    let _e94 = normal;
    let _e95 = toLight;
    if (dot(_e94, _e95) <= 0f) {
        frag_color = vec4<f32>(1f, 1f, 1f, 1f);
        return;
    }
    let _e100 = contact_info.params[0u];
    reach = max(_e100, 0.0001f);
    let _e104 = contact_info.params[1u];
    steps = clamp(i32((_e104 + 0.5f)), 1i, 16i);
    let _e110 = contact_info.params[2u];
    thickness = max(_e110, 0.0001f);
    let _e112 = v_uv_1;
    param_4 = _e112;
    let _e114 = surface[3u];
    param_5 = _e114;
    let _e115 = WorldAtDepth_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));
    let _e116 = normal;
    let _e119 = contact_info.params[3u];
    origin_1 = (_e115 + (_e116 * _e119));
    let _e122 = reach;
    let _e123 = steps;
    stride = (_e122 / f32(_e123));
    let _e126 = TargetFragCoord_u0028_();
    param_6 = _e126;
    let _e127 = PixelNoise_u0028_vf2_u003b((&param_6));
    jitter = _e127;
    let _e128 = origin_1;
    let _e129 = toLight;
    let _e130 = stride;
    param_7 = (_e128 + (_e129 * _e130));
    let _e133 = DepthOf_u0028_vf3_u003b((&param_7));
    let _e134 = origin_1;
    param_8 = _e134;
    let _e135 = DepthOf_u0028_vf3_u003b((&param_8));
    stepDepth = abs((_e133 - _e135));
    let _e138 = thickness;
    let _e139 = stepDepth;
    tolerance = max(_e138, (2f * _e139));
    i = 0i;
    loop {
        let _e142 = i;
        if (_e142 < 16i) {
            let _e144 = i;
            let _e145 = steps;
            if (_e144 >= _e145) {
                break;
            }
            let _e147 = i;
            let _e150 = jitter;
            along_1 = ((f32(_e147) + 1f) - _e150);
            let _e152 = origin_1;
            let _e153 = toLight;
            let _e154 = stride;
            let _e155 = along_1;
            at_4 = (_e152 + (_e153 * (_e154 * _e155)));
            let _e160 = contact_info.view_projection;
            let _e161 = at_4;
            clip = (_e160 * vec4<f32>(_e161.x, _e161.y, _e161.z, 1f));
            let _e168 = clip[3u];
            if (_e168 <= 0f) {
                break;
            }
            let _e170 = clip;
            let _e173 = clip[3u];
            param_9 = (_e170.xy / vec2(_e173));
            let _e176 = UvFromNdc_u0028_vf2_u003b((&param_9));
            uv_2 = _e176;
            let _e178 = uv_2[0u];
            let _e179 = (_e178 < 0f);
            phi_580_ = _e179;
            if !(_e179) {
                let _e182 = uv_2[0u];
                phi_580_ = (_e182 > 1f);
            }
            let _e185 = phi_580_;
            phi_587_ = _e185;
            if !(_e185) {
                let _e188 = uv_2[1u];
                phi_587_ = (_e188 < 0f);
            }
            let _e191 = phi_587_;
            phi_594_ = _e191;
            if !(_e191) {
                let _e194 = uv_2[1u];
                phi_594_ = (_e194 > 1f);
            }
            let _e197 = phi_594_;
            if _e197 {
                break;
            }
            let _e198 = uv_2;
            let _e199 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e198, 0f);
            there = _e199;
            let _e201 = there[3u];
            if (_e201 <= 0f) {
                continue;
            }
            let _e203 = at_4;
            param_10 = _e203;
            let _e204 = DepthOf_u0028_vf3_u003b((&param_10));
            marched = _e204;
            let _e205 = marched;
            let _e207 = there[3u];
            gap = (_e205 - _e207);
            let _e209 = gap;
            let _e211 = gap;
            let _e212 = tolerance;
            if ((_e209 > 0f) && (_e211 < _e212)) {
                let _e215 = along_1;
                let _e218 = steps;
                frag_color = vec4((max((_e215 - 1f), 0f) / f32(_e218)));
                return;
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e222 = i;
            i = (_e222 + 1i);
        }
    }
    frag_color = vec4<f32>(1f, 1f, 1f, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ContactShadowInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 192,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'view_projection',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 128,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 144,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 160,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'to_light',
              offsetInBytes: 176,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'NoiseInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ContactShadowResolve': WebGpuStage(
      wgsl: r'''
struct ContactShadowResolveInfo {
    params: vec4<f32>,
}

@group(1) @binding(1)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var contact_shadow_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(0)
var<uniform> resolve_info: ContactShadowResolveInfo;

fn main_1() {
    var centre: vec4<f32>;
    var centreDepth: f32;
    var falloff: f32;
    var total: vec4<f32>;
    var weightSum: f32;
    var y: i32;
    var x: i32;
    var at: vec2<f32>;
    var depth: f32;
    var weight: f32;

    let _e26 = v_uv_1;
    let _e27 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e26);
    centre = _e27;
    let _e28 = v_uv_1;
    let _e29 = textureSample(surface_texture_tex, surface_texture_smp, _e28);
    centreDepth = _e29.w;
    let _e31 = centreDepth;
    if (_e31 <= 0f) {
        let _e33 = centre;
        frag_color = _e33;
        return;
    }
    let _e36 = resolve_info.params[2u];
    let _e38 = centreDepth;
    falloff = (max(_e36, 0.0001f) * max(_e38, 0.001f));
    total = vec4<f32>(0f, 0f, 0f, 0f);
    weightSum = 0f;
    y = -2i;
    loop {
        let _e41 = y;
        if (_e41 <= 1i) {
            x = -2i;
            loop {
                let _e43 = x;
                if (_e43 <= 1i) {
                    let _e45 = v_uv_1;
                    let _e46 = x;
                    let _e48 = y;
                    let _e52 = resolve_info.params;
                    at = (_e45 + (vec2<f32>(f32(_e46), f32(_e48)) * _e52.xy));
                    let _e56 = at;
                    let _e57 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e56, 0f);
                    depth = _e57.w;
                    let _e59 = depth;
                    if (_e59 <= 0f) {
                        continue;
                    }
                    let _e61 = depth;
                    let _e62 = centreDepth;
                    let _e66 = falloff;
                    weight = exp((-(abs((_e61 - _e62))) / _e66));
                    let _e69 = at;
                    let _e70 = textureSampleLevel(contact_shadow_texture_tex, contact_shadow_texture_smp, _e69, 0f);
                    let _e71 = weight;
                    let _e73 = total;
                    total = (_e73 + (_e70 * _e71));
                    let _e75 = weight;
                    let _e76 = weightSum;
                    weightSum = (_e76 + _e75);
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e78 = x;
                    x = (_e78 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e80 = y;
            y = (_e80 + 1i);
        }
    }
    let _e82 = total;
    let _e83 = weightSum;
    frag_color = (_e82 / vec4(max(_e83, 0.0001f)));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ContactShadowResolveInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'contact_shadow_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'CameraVelocity': WebGpuStage(
      wgsl: r'''
struct CameraVelocityInfo {
    inverse_view_projection: mat4x4<f32>,
    previous_view_projection: mat4x4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
}

@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> velocity_info: CameraVelocityInfo;
var<private> frag_color: vec4<f32>;

fn UvFromNdc_u0028_vf2_u003b(ndc: ptr<function, vec2<f32>>) -> vec2<f32> {
    let _e19 = (*ndc)[0u];
    let _e23 = (*ndc)[1u];
    return vec2<f32>(((_e19 * 0.5f) + 0.5f), (0.5f - (_e23 * 0.5f)));
}

fn main_1() {
    var surface: vec4<f32>;
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;
    var origin: vec3<f32>;
    var along: vec3<f32>;
    var then: vec4<f32>;
    var axis: vec3<f32>;
    var world: vec3<f32>;
    var param: vec2<f32>;

    let _e27 = v_uv_1;
    let _e28 = textureSample(surface_texture_tex, surface_texture_smp, _e27);
    surface = _e28;
    let _e30 = v_uv_1[0u];
    let _e34 = v_uv_1[1u];
    xy = vec2<f32>(((_e30 * 2f) - 1f), (1f - (_e34 * 2f)));
    let _e39 = velocity_info.inverse_view_projection;
    let _e40 = xy;
    nearH = (_e39 * vec4<f32>(_e40.x, _e40.y, 0f, 1f));
    let _e46 = velocity_info.inverse_view_projection;
    let _e47 = xy;
    farH = (_e46 * vec4<f32>(_e47.x, _e47.y, 1f, 1f));
    let _e52 = nearH;
    let _e55 = nearH[3u];
    origin = (_e52.xyz / vec3(_e55));
    let _e58 = farH;
    let _e61 = farH[3u];
    let _e64 = origin;
    along = normalize(((_e58.xyz / vec3(_e61)) - _e64));
    let _e68 = surface[3u];
    if (_e68 <= 0f) {
        let _e71 = velocity_info.previous_view_projection;
        let _e72 = along;
        then = (_e71 * vec4<f32>(_e72.x, _e72.y, _e72.z, 0f));
    } else {
        let _e79 = velocity_info.forward;
        axis = _e79.xyz;
        let _e81 = origin;
        let _e82 = along;
        let _e84 = surface[3u];
        let _e85 = origin;
        let _e87 = velocity_info.camera;
        let _e90 = axis;
        let _e93 = along;
        let _e94 = axis;
        world = (_e81 + (_e82 * ((_e84 - dot((_e85 - _e87.xyz), _e90)) / dot(_e93, _e94))));
        let _e100 = velocity_info.previous_view_projection;
        let _e101 = world;
        then = (_e100 * vec4<f32>(_e101.x, _e101.y, _e101.z, 1f));
    }
    let _e108 = then[3u];
    if (_e108 <= 0f) {
        frag_color = vec4<f32>(0f, 0f, 0f, 1f);
        return;
    }
    let _e110 = v_uv_1;
    let _e111 = then;
    let _e114 = then[3u];
    param = (_e111.xy / vec2(_e114));
    let _e117 = UvFromNdc_u0028_vf2_u003b((&param));
    let _e118 = (_e110 - _e117);
    frag_color = vec4<f32>(_e118.x, _e118.y, 0f, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'CameraVelocityInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 160,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'previous_view_projection',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 128,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 144,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Velocity': WebGpuStage(
      wgsl: r'''
struct VelocityInfo {
    target_: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> velocity_info: VelocityInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_depth_1: f32;
var<private> v_previous_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_current_1: vec4<f32>;

fn UvFromClip_u0028_vf4_u003b(clip: ptr<function, vec4<f32>>) -> vec2<f32> {
    var ndc: vec2<f32>;

    let _e20 = (*clip);
    let _e23 = (*clip)[3u];
    ndc = (_e20.xy / vec2(_e23));
    let _e27 = ndc[0u];
    let _e31 = ndc[1u];
    return vec2<f32>(((_e27 * 0.5f) + 0.5f), (0.5f - (_e31 * 0.5f)));
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e20 = (*rows);
    if (_e20 > 0f) {
        let _e23 = gl_FragCoord_1[0u];
        let _e24 = (*rows);
        let _e26 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e23, (_e24 - _e26));
    } else {
        let _e29 = gl_FragCoord_1;
        local = _e29.xy;
    }
    let _e31 = local;
    return _e31;
}

fn main_1() {
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var param_1: vec4<f32>;
    var param_2: vec4<f32>;
    var phi_113_: bool;

    let _e25 = velocity_info.target_[2u];
    param = _e25;
    let _e26 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e28 = velocity_info.target_;
    uv = (_e26 * _e28.xy);
    let _e31 = uv;
    let _e32 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e31, 0f);
    stored = _e32.w;
    let _e34 = stored;
    let _e35 = (_e34 <= 0f);
    phi_113_ = _e35;
    if !(_e35) {
        let _e37 = v_depth_1;
        let _e38 = stored;
        let _e41 = velocity_info.target_[3u];
        phi_113_ = (_e37 > ((_e38 * (1f + _e41)) + 0.001f));
    }
    let _e47 = phi_113_;
    if _e47 {
        discard;
    }
    let _e49 = v_previous_1[3u];
    if (_e49 <= 0f) {
        frag_color = vec4<f32>(0f, 0f, 0f, 1f);
        return;
    }
    let _e51 = v_current_1;
    param_1 = _e51;
    let _e52 = UvFromClip_u0028_vf4_u003b((&param_1));
    let _e53 = v_previous_1;
    param_2 = _e53;
    let _e54 = UvFromClip_u0028_vf4_u003b((&param_2));
    let _e55 = (_e52 - _e54);
    frag_color = vec4<f32>(_e55.x, _e55.y, 0f, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_depth: f32, @location(2) v_previous: vec4<f32>, @location(0) v_current: vec4<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_depth_1 = v_depth;
    v_previous_1 = v_previous;
    v_current_1 = v_current;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'VelocityInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Reactive': WebGpuStage(
      wgsl: r'''
struct ReactiveInfo {
    target_: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    params: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> reactive_info: ReactiveInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_depth_1: f32;
var<private> frag_color: vec4<f32>;
var<private> v_current_1: vec4<f32>;
var<private> v_previous_1: vec4<f32>;

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e19 = (*rows);
    if (_e19 > 0f) {
        let _e22 = gl_FragCoord_1[0u];
        let _e23 = (*rows);
        let _e25 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e22, (_e23 - _e25));
    } else {
        let _e28 = gl_FragCoord_1;
        local = _e28.xy;
    }
    let _e30 = local;
    return _e30;
}

fn main_1() {
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var hidden: bool;
    var coverage: f32;
    var phi_90_: bool;

    let _e24 = reactive_info.target_[2u];
    param = _e24;
    let _e25 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e27 = reactive_info.target_;
    uv = (_e25 * _e27.xy);
    let _e30 = uv;
    let _e31 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e30, 0f);
    stored = _e31.w;
    let _e33 = stored;
    let _e34 = (_e33 > 0f);
    phi_90_ = _e34;
    if _e34 {
        let _e35 = v_depth_1;
        let _e36 = stored;
        let _e39 = reactive_info.target_[3u];
        phi_90_ = (_e35 > ((_e36 * (1f + _e39)) + 0.001f));
    }
    let _e45 = phi_90_;
    hidden = _e45;
    let _e48 = reactive_info.params[0u];
    let _e51 = reactive_info.params[2u];
    coverage = (_e48 * _e51);
    let _e53 = hidden;
    let _e54 = coverage;
    if (_e53 || (_e54 <= 0f)) {
        discard;
    }
    let _e57 = coverage;
    frag_color = vec4<f32>(0f, 0f, _e57, 0f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_depth: f32, @location(0) v_current: vec4<f32>, @location(2) v_previous: vec4<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_depth_1 = v_depth;
    v_current_1 = v_current;
    v_previous_1 = v_previous;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ReactiveInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ReactiveSprite': WebGpuStage(
      wgsl: r'''
struct ReactiveInfo {
    target_: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    params: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var sprite_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var sprite_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> reactive_info: ReactiveInfo;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e28 = (*rows);
    if (_e28 > 0f) {
        let _e31 = gl_FragCoord_1[0u];
        let _e32 = (*rows);
        let _e34 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e31, (_e32 - _e34));
    } else {
        let _e37 = gl_FragCoord_1;
        local = _e37.xy;
    }
    let _e39 = local;
    return _e39;
}

fn main_1() {
    var spriteAlpha: f32;
    var centred: vec2<f32>;
    var falloff: f32;
    var disc: f32;
    var power: f32;
    var gaussian: f32;
    var local_1: f32;
    var shape: f32;
    var coverage: f32;
    var local_2: f32;
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var depth: f32;
    var hidden: bool;
    var reactive: f32;
    var phi_171_: bool;

    let _e42 = v_uv_1;
    let _e43 = textureSample(sprite_texture_tex, sprite_texture_smp, _e42);
    spriteAlpha = _e43.w;
    let _e45 = v_uv_1;
    centred = ((_e45 * 2f) - vec2(1f));
    let _e49 = centred;
    falloff = (1f - smoothstep(0f, 1f, length(_e49)));
    let _e53 = falloff;
    let _e54 = falloff;
    disc = (_e53 * _e54);
    let _e56 = v_uv_1;
    let _e57 = v_uv_1;
    power = (-0.5f * dot(_e56, _e57));
    let _e60 = power;
    if (_e60 < -4.5f) {
        local_1 = 0f;
    } else {
        let _e62 = power;
        local_1 = exp(_e62);
    }
    let _e64 = local_1;
    gaussian = _e64;
    let _e67 = reactive_info.params[1u];
    shape = _e67;
    let _e69 = v_color_1[3u];
    let _e70 = shape;
    if (_e70 < 0.5f) {
        let _e72 = disc;
        local_2 = _e72;
    } else {
        let _e73 = shape;
        let _e75 = gaussian;
        let _e76 = spriteAlpha;
        local_2 = select(_e76, _e75, (_e73 < 1.5f));
    }
    let _e78 = local_2;
    coverage = (_e69 * _e78);
    let _e82 = reactive_info.target_[2u];
    param = _e82;
    let _e83 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e85 = reactive_info.target_;
    uv = (_e83 * _e85.xy);
    let _e88 = uv;
    let _e89 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e88, 0f);
    stored = _e89.w;
    let _e91 = v_world_position_1;
    let _e93 = reactive_info.eye;
    let _e97 = reactive_info.forward;
    depth = dot((_e91 - _e93.xyz), _e97.xyz);
    let _e100 = stored;
    let _e101 = (_e100 > 0f);
    phi_171_ = _e101;
    if _e101 {
        let _e102 = depth;
        let _e103 = stored;
        let _e106 = reactive_info.target_[3u];
        phi_171_ = (_e102 > ((_e103 * (1f + _e106)) + 0.001f));
    }
    let _e112 = phi_171_;
    hidden = _e112;
    let _e115 = reactive_info.params[0u];
    let _e116 = coverage;
    reactive = (_e115 * _e116);
    let _e118 = hidden;
    let _e119 = reactive;
    if (_e118 || (_e119 <= 0f)) {
        discard;
    }
    let _e122 = reactive;
    frag_color = vec4<f32>(0f, 0f, _e122, 0f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    v_color_1 = v_color;
    v_world_position_1 = v_world_position;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ReactiveInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'sprite_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'TemporalResolve': WebGpuStage(
      wgsl: r'''
struct TemporalInfo {
    scene_texel: vec4<f32>,
    jitter: vec4<f32>,
    params: vec4<f32>,
    clip: vec4<f32>,
    clip_axes: array<vec4<f32>, 16>,
}

@group(1) @binding(0)
var<uniform> temporal_info: TemporalInfo;
@group(1) @binding(1)
var history_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var history_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(3)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var scene_texture_smp: sampler;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
@group(1) @binding(7)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var velocity_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn Luma_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {
    let _e52 = (*c);
    return dot(_e52, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn Unweigh_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {
    var param: vec3<f32>;

    let _e53 = (*c_1);
    let _e54 = (*c_1);
    param = _e54;
    let _e55 = Luma_u0028_vf3_u003b((&param));
    let _e58 = temporal_info.params[0u];
    return (_e53 / vec3(max((1f - (_e55 * _e58)), 0.0001f)));
}

fn YCoCgToRgb_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e53 = (*c_2)[0u];
    let _e55 = (*c_2)[1u];
    let _e58 = (*c_2)[2u];
    let _e61 = (*c_2)[0u];
    let _e63 = (*c_2)[2u];
    let _e66 = (*c_2)[0u];
    let _e68 = (*c_2)[1u];
    let _e71 = (*c_2)[2u];
    return vec3<f32>(((_e53 + _e55) - _e58), (_e61 + _e63), ((_e66 - _e68) - _e71));
}

fn ClipToBox_u0028_vf3_u003b_vf3_u003b_vf3_u003b(lo: ptr<function, vec3<f32>>, hi: ptr<function, vec3<f32>>, q: ptr<function, vec3<f32>>) -> vec3<f32> {
    var centre: vec3<f32>;
    var extent: vec3<f32>;
    var v: vec3<f32>;
    var units: vec3<f32>;
    var most: f32;
    var local: vec3<f32>;

    let _e60 = (*hi);
    let _e61 = (*lo);
    centre = ((_e60 + _e61) * 0.5f);
    let _e64 = (*hi);
    let _e65 = (*lo);
    extent = (((_e64 - _e65) * 0.5f) + vec3<f32>(0.00001f, 0.00001f, 0.00001f));
    let _e69 = (*q);
    let _e70 = centre;
    v = (_e69 - _e70);
    let _e72 = v;
    let _e73 = extent;
    units = abs((_e72 / _e73));
    let _e77 = units[0u];
    let _e79 = units[1u];
    let _e81 = units[2u];
    most = max(_e77, max(_e79, _e81));
    let _e84 = most;
    if (_e84 > 1f) {
        let _e86 = centre;
        let _e87 = v;
        let _e88 = most;
        local = (_e86 + (_e87 / vec3(_e88)));
    } else {
        let _e92 = (*q);
        local = _e92;
    }
    let _e93 = local;
    return _e93;
}

fn ClipToDop_u0028_vf3_u003b_vf3_u003b_vf3_u005b_9_u005d_u003b(current: ptr<function, vec3<f32>>, history: ptr<function, vec3<f32>>, around: ptr<function, array<vec3<f32>, 9>>) -> vec3<f32> {
    var toward: vec3<f32>;
    var reach: f32;
    var a: i32;
    var axis: vec3<f32>;
    var at: f32;
    var lowest: f32;
    var highest: f32;
    var sum: f32;
    var sumSquares: f32;
    var n: i32;
    var p: f32;
    var mean: f32;
    var sigma: f32;
    var lo_1: f32;
    var hi_1: f32;
    var along: f32;
    var leave: f32;
    var local_1: f32;
    var local_2: f32;

    let _e73 = (*history);
    let _e74 = (*current);
    toward = (_e73 - _e74);
    reach = 1f;
    a = 0i;
    loop {
        let _e76 = a;
        if (_e76 < 16i) {
            let _e78 = a;
            let _e82 = temporal_info.clip[0u];
            if (f32(_e78) < _e82) {
                let _e84 = a;
                let _e87 = temporal_info.clip_axes[_e84];
                axis = _e87.xyz;
                let _e89 = (*current);
                let _e90 = axis;
                at = dot(_e89, _e90);
                lowest = 1000000000000000000000000000000f;
                highest = -1000000000000000000000000000000f;
                sum = 0f;
                sumSquares = 0f;
                n = 0i;
                loop {
                    let _e92 = n;
                    if (_e92 < 9i) {
                        let _e94 = n;
                        let _e96 = (*around)[_e94];
                        let _e97 = axis;
                        p = dot(_e96, _e97);
                        let _e99 = lowest;
                        let _e100 = p;
                        lowest = min(_e99, _e100);
                        let _e102 = highest;
                        let _e103 = p;
                        highest = max(_e102, _e103);
                        let _e105 = p;
                        let _e106 = sum;
                        sum = (_e106 + _e105);
                        let _e108 = p;
                        let _e109 = p;
                        let _e111 = sumSquares;
                        sumSquares = (_e111 + (_e108 * _e109));
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e113 = n;
                        n = (_e113 + 1i);
                    }
                }
                let _e115 = sum;
                mean = (_e115 / 9f);
                let _e117 = sumSquares;
                let _e119 = mean;
                let _e120 = mean;
                sigma = sqrt(max(((_e117 / 9f) - (_e119 * _e120)), 0f));
                let _e125 = lowest;
                let _e126 = mean;
                let _e127 = sigma;
                let _e131 = at;
                lo_1 = min(max(_e125, (_e126 - (1.25f * _e127))), _e131);
                let _e133 = highest;
                let _e134 = mean;
                let _e135 = sigma;
                let _e139 = at;
                hi_1 = max(min(_e133, (_e134 + (1.25f * _e135))), _e139);
                let _e141 = toward;
                let _e142 = axis;
                along = dot(_e141, _e142);
                let _e144 = along;
                if (_e144 > 0.00000001f) {
                    let _e146 = hi_1;
                    let _e147 = at;
                    let _e149 = along;
                    local_1 = ((_e146 - _e147) / _e149);
                } else {
                    let _e151 = along;
                    if (_e151 < -0.00000001f) {
                        let _e153 = lo_1;
                        let _e154 = at;
                        let _e156 = along;
                        local_2 = ((_e153 - _e154) / _e156);
                    } else {
                        local_2 = 1f;
                    }
                    let _e158 = local_2;
                    local_1 = _e158;
                }
                let _e159 = local_1;
                leave = _e159;
                let _e160 = reach;
                let _e161 = leave;
                reach = min(_e160, _e161);
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e163 = a;
            a = (_e163 + 1i);
        }
    }
    let _e165 = (*current);
    let _e166 = toward;
    let _e167 = reach;
    return (_e165 + (_e166 * max(_e167, 0f)));
}

fn HistoryAt_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {
    var size: vec2<f32>;
    var position: vec2<f32>;
    var centre1_: vec2<f32>;
    var f: vec2<f32>;
    var w0_: vec2<f32>;
    var w1_: vec2<f32>;
    var w2_: vec2<f32>;
    var w3_: vec2<f32>;
    var w12_: vec2<f32>;
    var at0_: vec2<f32>;
    var at3_: vec2<f32>;
    var at12_: vec2<f32>;
    var sum_1: vec3<f32>;

    let _e66 = temporal_info.params;
    size = _e66.zw;
    let _e68 = (*uv);
    let _e69 = size;
    position = (_e68 * _e69);
    let _e71 = position;
    centre1_ = (floor((_e71 - vec2(0.5f))) + vec2(0.5f));
    let _e77 = position;
    let _e78 = centre1_;
    f = (_e77 - _e78);
    let _e80 = f;
    let _e81 = f;
    let _e82 = f;
    w0_ = (_e80 * (vec2(-0.5f) + (_e81 * (vec2(1f) - (_e82 * 0.5f)))));
    let _e90 = f;
    let _e91 = f;
    let _e93 = f;
    w1_ = (vec2(1f) + ((_e90 * _e91) * (vec2(-2.5f) + (_e93 * 1.5f))));
    let _e100 = f;
    let _e101 = f;
    let _e102 = f;
    w2_ = (_e100 * (vec2(0.5f) + (_e101 * (vec2(2f) - (_e102 * 1.5f)))));
    let _e110 = f;
    let _e111 = f;
    let _e113 = f;
    w3_ = ((_e110 * _e111) * (vec2(-0.5f) + (_e113 * 0.5f)));
    let _e118 = w1_;
    let _e119 = w2_;
    w12_ = (_e118 + _e119);
    let _e121 = centre1_;
    let _e124 = size;
    at0_ = ((_e121 - vec2(1f)) / _e124);
    let _e126 = centre1_;
    let _e129 = size;
    at3_ = ((_e126 + vec2(2f)) / _e129);
    let _e131 = centre1_;
    let _e132 = w2_;
    let _e133 = w12_;
    let _e136 = size;
    at12_ = ((_e131 + (_e132 / _e133)) / _e136);
    sum_1 = vec3<f32>(0f, 0f, 0f);
    let _e139 = at0_[0u];
    let _e141 = at0_[1u];
    let _e143 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e139, _e141), 0f);
    let _e146 = w0_[0u];
    let _e149 = w0_[1u];
    let _e151 = sum_1;
    sum_1 = (_e151 + ((_e143.xyz * _e146) * _e149));
    let _e154 = at12_[0u];
    let _e156 = at0_[1u];
    let _e158 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e154, _e156), 0f);
    let _e161 = w12_[0u];
    let _e164 = w0_[1u];
    let _e166 = sum_1;
    sum_1 = (_e166 + ((_e158.xyz * _e161) * _e164));
    let _e169 = at3_[0u];
    let _e171 = at0_[1u];
    let _e173 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e169, _e171), 0f);
    let _e176 = w3_[0u];
    let _e179 = w0_[1u];
    let _e181 = sum_1;
    sum_1 = (_e181 + ((_e173.xyz * _e176) * _e179));
    let _e184 = at0_[0u];
    let _e186 = at12_[1u];
    let _e188 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e184, _e186), 0f);
    let _e191 = w0_[0u];
    let _e194 = w12_[1u];
    let _e196 = sum_1;
    sum_1 = (_e196 + ((_e188.xyz * _e191) * _e194));
    let _e199 = at12_[0u];
    let _e201 = at12_[1u];
    let _e203 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e199, _e201), 0f);
    let _e206 = w12_[0u];
    let _e209 = w12_[1u];
    let _e211 = sum_1;
    sum_1 = (_e211 + ((_e203.xyz * _e206) * _e209));
    let _e214 = at3_[0u];
    let _e216 = at12_[1u];
    let _e218 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e214, _e216), 0f);
    let _e221 = w3_[0u];
    let _e224 = w12_[1u];
    let _e226 = sum_1;
    sum_1 = (_e226 + ((_e218.xyz * _e221) * _e224));
    let _e229 = at0_[0u];
    let _e231 = at3_[1u];
    let _e233 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e229, _e231), 0f);
    let _e236 = w0_[0u];
    let _e239 = w3_[1u];
    let _e241 = sum_1;
    sum_1 = (_e241 + ((_e233.xyz * _e236) * _e239));
    let _e244 = at12_[0u];
    let _e246 = at3_[1u];
    let _e248 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e244, _e246), 0f);
    let _e251 = w12_[0u];
    let _e254 = w3_[1u];
    let _e256 = sum_1;
    sum_1 = (_e256 + ((_e248.xyz * _e251) * _e254));
    let _e259 = at3_[0u];
    let _e261 = at3_[1u];
    let _e263 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e259, _e261), 0f);
    let _e266 = w3_[0u];
    let _e269 = w3_[1u];
    let _e271 = sum_1;
    sum_1 = (_e271 + ((_e263.xyz * _e266) * _e269));
    let _e273 = sum_1;
    return max(_e273, vec3<f32>(0f, 0f, 0f));
}

fn SameSurface_u0028_f1_u003b_f1_u003b(depth: ptr<function, f32>, then: ptr<function, f32>) -> f32 {
    var sky: bool;
    var bothSky: bool;
    var close: bool;
    var phi_391_: bool;

    let _e56 = (*depth);
    sky = (_e56 <= 0f);
    let _e58 = sky;
    let _e59 = (*then);
    bothSky = (_e58 && (_e59 <= 0f));
    let _e62 = sky;
    let _e64 = (*then);
    let _e66 = (!(_e62) && (_e64 > 0f));
    phi_391_ = _e66;
    if _e66 {
        let _e67 = (*then);
        let _e68 = (*depth);
        let _e73 = temporal_info.params[1u];
        let _e74 = (*depth);
        let _e75 = (*then);
        phi_391_ = (abs((_e67 - _e68)) <= (_e73 * min(_e74, _e75)));
    }
    let _e80 = phi_391_;
    close = _e80;
    let _e81 = bothSky;
    let _e82 = close;
    return select(0f, 1f, (_e81 || _e82));
}

fn DepthTrust_u0028_f1_u003b_vf2_u003b(depth_1: ptr<function, f32>, uv_1: ptr<function, vec2<f32>>) -> f32 {
    var size_1: vec2<f32>;
    var position_1: vec2<f32>;
    var corner: vec2<f32>;
    var f_1: vec2<f32>;
    var at0_1: vec2<f32>;
    var at1_: vec2<f32>;
    var d00_: f32;
    var d10_: f32;
    var d01_: f32;
    var d11_: f32;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: f32;
    var param_5: f32;
    var param_6: f32;
    var param_7: f32;
    var param_8: f32;

    let _e72 = temporal_info.params;
    size_1 = _e72.zw;
    let _e74 = (*uv_1);
    let _e75 = size_1;
    position_1 = ((_e74 * _e75) - vec2(0.5f));
    let _e79 = position_1;
    corner = floor(_e79);
    let _e81 = position_1;
    let _e82 = corner;
    f_1 = (_e81 - _e82);
    let _e84 = corner;
    let _e87 = size_1;
    at0_1 = ((_e84 + vec2(0.5f)) / _e87);
    let _e89 = corner;
    let _e92 = size_1;
    at1_ = ((_e89 + vec2(1.5f)) / _e92);
    let _e94 = at0_1;
    let _e95 = textureSampleLevel(history_texture_tex, history_texture_smp, _e94, 0f);
    d00_ = _e95.w;
    let _e98 = at1_[0u];
    let _e100 = at0_1[1u];
    let _e102 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e98, _e100), 0f);
    d10_ = _e102.w;
    let _e105 = at0_1[0u];
    let _e107 = at1_[1u];
    let _e109 = textureSampleLevel(history_texture_tex, history_texture_smp, vec2<f32>(_e105, _e107), 0f);
    d01_ = _e109.w;
    let _e111 = at1_;
    let _e112 = textureSampleLevel(history_texture_tex, history_texture_smp, _e111, 0f);
    d11_ = _e112.w;
    let _e114 = (*depth_1);
    param_1 = _e114;
    let _e115 = d00_;
    param_2 = _e115;
    let _e116 = SameSurface_u0028_f1_u003b_f1_u003b((&param_1), (&param_2));
    let _e118 = f_1[0u];
    let _e122 = f_1[1u];
    let _e125 = (*depth_1);
    param_3 = _e125;
    let _e126 = d10_;
    param_4 = _e126;
    let _e127 = SameSurface_u0028_f1_u003b_f1_u003b((&param_3), (&param_4));
    let _e129 = f_1[0u];
    let _e132 = f_1[1u];
    let _e136 = (*depth_1);
    param_5 = _e136;
    let _e137 = d01_;
    param_6 = _e137;
    let _e138 = SameSurface_u0028_f1_u003b_f1_u003b((&param_5), (&param_6));
    let _e140 = f_1[0u];
    let _e144 = f_1[1u];
    let _e147 = (*depth_1);
    param_7 = _e147;
    let _e148 = d11_;
    param_8 = _e148;
    let _e149 = SameSurface_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));
    let _e151 = f_1[0u];
    let _e154 = f_1[1u];
    return (((((_e116 * (1f - _e118)) * (1f - _e122)) + ((_e127 * _e129) * (1f - _e132))) + ((_e138 * (1f - _e140)) * _e144)) + ((_e149 * _e151) * _e154));
}

fn RgbToYCoCg_u0028_vf3_u003b(c_3: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e53 = (*c_3)[0u];
    let _e56 = (*c_3)[1u];
    let _e60 = (*c_3)[2u];
    let _e64 = (*c_3)[0u];
    let _e67 = (*c_3)[2u];
    let _e71 = (*c_3)[0u];
    let _e74 = (*c_3)[1u];
    let _e78 = (*c_3)[2u];
    return vec3<f32>((((0.25f * _e53) + (0.5f * _e56)) + (0.25f * _e60)), ((0.5f * _e64) - (0.5f * _e67)), (((-0.25f * _e71) + (0.5f * _e74)) - (0.25f * _e78)));
}

fn Weigh_u0028_vf3_u003b(c_4: ptr<function, vec3<f32>>) -> vec3<f32> {
    var param_9: vec3<f32>;

    let _e53 = (*c_4);
    let _e54 = (*c_4);
    param_9 = _e54;
    let _e55 = Luma_u0028_vf3_u003b((&param_9));
    let _e58 = temporal_info.params[0u];
    return (_e53 / vec3((1f + (_e55 * _e58))));
}

fn main_1() {
    var texel: vec2<f32>;
    var sceneUv: vec2<f32>;
    var centre_1: vec2<f32>;
    var sum_2: vec3<f32>;
    var sumSquares_1: vec3<f32>;
    var lowest_1: vec3<f32>;
    var highest_1: vec3<f32>;
    var nearest: f32;
    var nearestUv: vec2<f32>;
    var dy: i32;
    var dx: i32;
    var at_1: vec2<f32>;
    var c_5: vec3<f32>;
    var param_10: vec3<f32>;
    var param_11: vec3<f32>;
    var around_1: array<vec3<f32>, 9>;
    var depth_2: f32;
    var current_1: vec3<f32>;
    var depth_3: f32;
    var then_1: vec2<f32>;
    var trust: f32;
    var param_12: f32;
    var param_13: vec2<f32>;
    var mean_1: vec3<f32>;
    var sigma_1: vec3<f32>;
    var lo_2: vec3<f32>;
    var hi_2: vec3<f32>;
    var remembered: vec3<f32>;
    var param_14: vec2<f32>;
    var param_15: vec3<f32>;
    var param_16: vec3<f32>;
    var clipped: vec3<f32>;
    var local_3: vec3<f32>;
    var param_17: vec3<f32>;
    var param_18: vec3<f32>;
    var param_19: vec3<f32>;
    var param_20: vec3<f32>;
    var param_21: array<vec3<f32>, 9>;
    var param_22: vec3<f32>;
    var param_23: vec3<f32>;
    var param_24: vec3<f32>;
    var history_1: vec3<f32>;
    var param_25: vec3<f32>;
    var param_26: vec3<f32>;
    var reactive: f32;
    var keep: f32;
    var exposure: f32;
    var wCurrent: f32;
    var param_27: vec3<f32>;
    var wHistory: f32;
    var param_28: vec3<f32>;
    var resolved: vec3<f32>;
    var phi_931_: bool;
    var phi_938_: bool;
    var phi_945_: bool;
    var phi_952_: bool;

    let _e104 = temporal_info.scene_texel;
    texel = _e104.xy;
    let _e106 = v_uv_1;
    let _e108 = temporal_info.jitter;
    sceneUv = (_e106 + _e108.xy);
    let _e111 = sceneUv;
    let _e113 = temporal_info.scene_texel;
    let _e119 = texel;
    centre_1 = ((floor((_e111 * _e113.zw)) + vec2(0.5f)) * _e119);
    sum_2 = vec3<f32>(0f, 0f, 0f);
    sumSquares_1 = vec3<f32>(0f, 0f, 0f);
    lowest_1 = vec3<f32>(1000000000000000000000000000000f, 1000000000000000000000000000000f, 1000000000000000000000000000000f);
    highest_1 = vec3<f32>(-1000000000000000000000000000000f, -1000000000000000000000000000000f, -1000000000000000000000000000000f);
    nearest = 1000000000000000000000000000000f;
    let _e121 = centre_1;
    nearestUv = _e121;
    dy = -1i;
    loop {
        let _e122 = dy;
        if (_e122 <= 1i) {
            dx = -1i;
            loop {
                let _e124 = dx;
                if (_e124 <= 1i) {
                    let _e126 = centre_1;
                    let _e127 = dx;
                    let _e129 = dy;
                    let _e132 = texel;
                    at_1 = (_e126 + (vec2<f32>(f32(_e127), f32(_e129)) * _e132));
                    let _e135 = at_1;
                    let _e136 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e135, 0f);
                    param_10 = _e136.xyz;
                    let _e138 = Weigh_u0028_vf3_u003b((&param_10));
                    param_11 = _e138;
                    let _e139 = RgbToYCoCg_u0028_vf3_u003b((&param_11));
                    c_5 = _e139;
                    let _e140 = dy;
                    let _e143 = dx;
                    let _e146 = c_5;
                    around_1[((((_e140 + 1i) * 3i) + _e143) + 1i)] = _e146;
                    let _e148 = c_5;
                    let _e149 = sum_2;
                    sum_2 = (_e149 + _e148);
                    let _e151 = c_5;
                    let _e152 = c_5;
                    let _e154 = sumSquares_1;
                    sumSquares_1 = (_e154 + (_e151 * _e152));
                    let _e156 = lowest_1;
                    let _e157 = c_5;
                    lowest_1 = min(_e156, _e157);
                    let _e159 = highest_1;
                    let _e160 = c_5;
                    highest_1 = max(_e159, _e160);
                    let _e162 = at_1;
                    let _e163 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e162, 0f);
                    depth_2 = _e163.w;
                    let _e165 = depth_2;
                    let _e167 = depth_2;
                    let _e168 = nearest;
                    if ((_e165 > 0f) && (_e167 < _e168)) {
                        let _e171 = depth_2;
                        nearest = _e171;
                        let _e172 = at_1;
                        nearestUv = _e172;
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e173 = dx;
                    dx = (_e173 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e175 = dy;
            dy = (_e175 + 1i);
        }
    }
    let _e177 = sceneUv;
    let _e178 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e177, 0f);
    current_1 = _e178.xyz;
    let _e180 = nearest;
    let _e182 = nearest;
    depth_3 = select(0f, _e182, (_e180 < 1000000000000000000000000000000f));
    let _e184 = v_uv_1;
    let _e185 = nearestUv;
    let _e186 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e185, 0f);
    then_1 = (_e184 - _e186.xy);
    let _e191 = temporal_info.jitter[3u];
    let _e192 = (_e191 < 0.5f);
    phi_931_ = _e192;
    if !(_e192) {
        let _e195 = then_1[0u];
        phi_931_ = (_e195 < 0f);
    }
    let _e198 = phi_931_;
    phi_938_ = _e198;
    if !(_e198) {
        let _e201 = then_1[0u];
        phi_938_ = (_e201 > 1f);
    }
    let _e204 = phi_938_;
    phi_945_ = _e204;
    if !(_e204) {
        let _e207 = then_1[1u];
        phi_945_ = (_e207 < 0f);
    }
    let _e210 = phi_945_;
    phi_952_ = _e210;
    if !(_e210) {
        let _e213 = then_1[1u];
        phi_952_ = (_e213 > 1f);
    }
    let _e216 = phi_952_;
    if _e216 {
        let _e217 = current_1;
        let _e218 = depth_3;
        frag_color = vec4<f32>(_e217.x, _e217.y, _e217.z, _e218);
        return;
    }
    let _e223 = depth_3;
    param_12 = _e223;
    let _e224 = then_1;
    param_13 = _e224;
    let _e225 = DepthTrust_u0028_f1_u003b_vf2_u003b((&param_12), (&param_13));
    trust = _e225;
    let _e226 = sum_2;
    mean_1 = (_e226 / vec3(9f));
    let _e229 = sumSquares_1;
    let _e232 = mean_1;
    let _e233 = mean_1;
    sigma_1 = sqrt(max(((_e229 / vec3(9f)) - (_e232 * _e233)), vec3<f32>(0f, 0f, 0f)));
    let _e238 = lowest_1;
    let _e239 = mean_1;
    let _e240 = sigma_1;
    lo_2 = max(_e238, (_e239 - (_e240 * 1.25f)));
    let _e244 = highest_1;
    let _e245 = mean_1;
    let _e246 = sigma_1;
    hi_2 = min(_e244, (_e245 + (_e246 * 1.25f)));
    let _e250 = then_1;
    param_14 = _e250;
    let _e251 = HistoryAt_u0028_vf2_u003b((&param_14));
    param_15 = _e251;
    let _e252 = Weigh_u0028_vf3_u003b((&param_15));
    param_16 = _e252;
    let _e253 = RgbToYCoCg_u0028_vf3_u003b((&param_16));
    remembered = _e253;
    let _e256 = temporal_info.clip[0u];
    if (_e256 > 0.5f) {
        let _e258 = current_1;
        param_17 = _e258;
        let _e259 = Weigh_u0028_vf3_u003b((&param_17));
        param_18 = _e259;
        let _e260 = RgbToYCoCg_u0028_vf3_u003b((&param_18));
        param_19 = _e260;
        let _e261 = remembered;
        param_20 = _e261;
        let _e262 = around_1;
        param_21 = _e262;
        let _e263 = ClipToDop_u0028_vf3_u003b_vf3_u003b_vf3_u005b_9_u005d_u003b((&param_19), (&param_20), (&param_21));
        local_3 = _e263;
    } else {
        let _e264 = lo_2;
        param_22 = _e264;
        let _e265 = hi_2;
        param_23 = _e265;
        let _e266 = remembered;
        param_24 = _e266;
        let _e267 = ClipToBox_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_22), (&param_23), (&param_24));
        local_3 = _e267;
    }
    let _e268 = local_3;
    clipped = _e268;
    let _e269 = clipped;
    param_25 = _e269;
    let _e270 = YCoCgToRgb_u0028_vf3_u003b((&param_25));
    param_26 = _e270;
    let _e271 = Unweigh_u0028_vf3_u003b((&param_26));
    history_1 = _e271;
    let _e272 = centre_1;
    let _e273 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e272, 0f);
    reactive = clamp(_e273.z, 0f, 1f);
    let _e278 = temporal_info.jitter[2u];
    let _e279 = trust;
    let _e281 = reactive;
    keep = ((_e278 * _e279) * (1f - _e281));
    let _e286 = temporal_info.params[0u];
    exposure = _e286;
    let _e287 = keep;
    let _e289 = current_1;
    param_27 = _e289;
    let _e290 = Luma_u0028_vf3_u003b((&param_27));
    let _e291 = exposure;
    wCurrent = ((1f - _e287) / (1f + (_e290 * _e291)));
    let _e295 = keep;
    let _e296 = history_1;
    param_28 = _e296;
    let _e297 = Luma_u0028_vf3_u003b((&param_28));
    let _e298 = exposure;
    wHistory = (_e295 / (1f + (_e297 * _e298)));
    let _e302 = current_1;
    let _e303 = wCurrent;
    let _e305 = history_1;
    let _e306 = wHistory;
    let _e309 = wCurrent;
    let _e310 = wHistory;
    resolved = (((_e302 * _e303) + (_e305 * _e306)) / vec3(max((_e309 + _e310), 0.000001f)));
    let _e315 = resolved;
    let _e316 = depth_3;
    frag_color = vec4<f32>(_e315.x, _e315.y, _e315.z, _e316);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'TemporalInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 320,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'scene_texel',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'jitter',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'clip', offsetInBytes: 48, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'clip_axes',
              offsetInBytes: 64,
              sizeInBytes: 256,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'history_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'velocity_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'TemporalAccumulate': WebGpuStage(
      wgsl: r'''
struct AccumulateInfo {
    params: vec4<f32>,
}

@group(1) @binding(1)
var current_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var current_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(5)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var velocity_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> accumulate_info: AccumulateInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var history_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var history_texture_smp: sampler;

fn main_1() {
    var now: vec4<f32>;
    var then: vec2<f32>;
    var texel: vec2<f32>;
    var lowest: vec4<f32>;
    var highest: vec4<f32>;
    var dy: i32;
    var dx: i32;
    var around: vec4<f32>;
    var past: vec4<f32>;
    var phi_59_: bool;
    var phi_67_: bool;
    var phi_74_: bool;
    var phi_81_: bool;

    let _e26 = v_uv_1;
    let _e27 = textureSampleLevel(current_texture_tex, current_texture_smp, _e26, 0f);
    now = _e27;
    let _e28 = v_uv_1;
    let _e29 = v_uv_1;
    let _e30 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e29, 0f);
    then = (_e28 - _e30.xy);
    let _e35 = accumulate_info.params[1u];
    let _e36 = (_e35 < 0.5f);
    phi_59_ = _e36;
    if !(_e36) {
        let _e39 = then[0u];
        phi_59_ = (_e39 < 0f);
    }
    let _e42 = phi_59_;
    phi_67_ = _e42;
    if !(_e42) {
        let _e45 = then[0u];
        phi_67_ = (_e45 > 1f);
    }
    let _e48 = phi_67_;
    phi_74_ = _e48;
    if !(_e48) {
        let _e51 = then[1u];
        phi_74_ = (_e51 < 0f);
    }
    let _e54 = phi_74_;
    phi_81_ = _e54;
    if !(_e54) {
        let _e57 = then[1u];
        phi_81_ = (_e57 > 1f);
    }
    let _e60 = phi_81_;
    if _e60 {
        let _e61 = now;
        frag_color = _e61;
        return;
    }
    let _e63 = accumulate_info.params;
    texel = _e63.zw;
    let _e65 = now;
    lowest = _e65;
    let _e66 = now;
    highest = _e66;
    dy = -1i;
    loop {
        let _e67 = dy;
        if (_e67 <= 1i) {
            dx = -1i;
            loop {
                let _e69 = dx;
                if (_e69 <= 1i) {
                    let _e71 = v_uv_1;
                    let _e72 = dx;
                    let _e74 = dy;
                    let _e77 = texel;
                    let _e80 = textureSampleLevel(current_texture_tex, current_texture_smp, (_e71 + (vec2<f32>(f32(_e72), f32(_e74)) * _e77)), 0f);
                    around = _e80;
                    let _e81 = lowest;
                    let _e82 = around;
                    lowest = min(_e81, _e82);
                    let _e84 = highest;
                    let _e85 = around;
                    highest = max(_e84, _e85);
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e87 = dx;
                    dx = (_e87 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e89 = dy;
            dy = (_e89 + 1i);
        }
    }
    let _e91 = then;
    let _e92 = textureSampleLevel(history_texture_tex, history_texture_smp, _e91, 0f);
    let _e93 = lowest;
    let _e94 = highest;
    past = clamp(_e92, _e93, _e94);
    let _e96 = now;
    let _e97 = past;
    let _e100 = accumulate_info.params[0u];
    frag_color = mix(_e96, _e97, vec4(_e100));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'AccumulateInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'current_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'history_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'velocity_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'LightShafts': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct NoiseInfo {
    noise: vec4<f32>,
}

struct ShaftInfo {
    inverse_view_projection: mat4x4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
    scatter: vec4<f32>,
    cascades: vec4<f32>,
    sun: vec4<f32>,
    bias: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(1)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> shaft_info: ShaftInfo;
@group(1) @binding(7)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var shadow_texture_smp: sampler;
@group(1) @binding(5)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;

fn HenyeyGreenstein_u0028_f1_u003b_f1_u003b(cosine: ptr<function, f32>, g: ptr<function, f32>) -> f32 {
    var g2_: f32;
    var denominator: f32;

    let _e64 = (*g);
    let _e65 = (*g);
    g2_ = (_e64 * _e65);
    let _e67 = g2_;
    let _e69 = (*g);
    let _e71 = (*cosine);
    denominator = max(((1f + _e67) - ((2f * _e69) * _e71)), 0.0001f);
    let _e75 = g2_;
    let _e77 = denominator;
    let _e79 = denominator;
    return ((1f - _e75) / ((12.566371f * _e77) * sqrt(_e79)));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, mode: ptr<function, f32>) -> f32 {
    var local: f32;

    let _e63 = (*mode);
    if (_e63 > 0.5f) {
        let _e65 = (*stored);
        local = (1f - _e65);
    } else {
        let _e67 = (*stored);
        local = _e67;
    }
    let _e68 = local;
    return _e68;
}

fn LitAt_u0028_vf3_u003b_f1_u003b(world: ptr<function, vec3<f32>>, viewDistance: ptr<function, f32>) -> f32 {
    var cascadeCount: i32;
    var cascade: i32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_1: mat4x4<f32>;
    var local_2: mat4x4<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var uv: vec2<f32>;
    var stored_1: f32;
    var param: f32;
    var param_1: f32;
    var bias: f32;
    var local_3: f32;
    var local_4: f32;
    var phi_328_: bool;
    var phi_339_: bool;
    var phi_425_: bool;
    var phi_432_: bool;
    var phi_439_: bool;

    let _e81 = shaft_info.cascades[2u];
    cascadeCount = i32((_e81 + 0.5f));
    cascade = 0i;
    let _e84 = cascadeCount;
    let _e85 = (_e84 > 1i);
    phi_328_ = _e85;
    if _e85 {
        let _e86 = (*viewDistance);
        let _e89 = shaft_info.cascades[0u];
        phi_328_ = (_e86 > _e89);
    }
    let _e92 = phi_328_;
    if _e92 {
        cascade = 1i;
    }
    let _e93 = cascadeCount;
    let _e94 = (_e93 > 2i);
    phi_339_ = _e94;
    if _e94 {
        let _e95 = (*viewDistance);
        let _e98 = shaft_info.cascades[1u];
        phi_339_ = (_e95 > _e98);
    }
    let _e101 = phi_339_;
    if _e101 {
        cascade = 2i;
    }
    attempt = 0i;
    loop {
        let _e102 = attempt;
        if (_e102 < 3i) {
            let _e104 = cascade;
            let _e105 = attempt;
            which = (_e104 + _e105);
            let _e107 = which;
            let _e108 = cascadeCount;
            if (_e107 >= _e108) {
                break;
            }
            let _e110 = which;
            if (_e110 == 0i) {
                let _e113 = shaft_info.shadow_matrix;
                local_1 = _e113;
            } else {
                let _e114 = which;
                if (_e114 == 1i) {
                    let _e117 = shaft_info.shadow_matrix_far;
                    local_2 = _e117;
                } else {
                    let _e119 = shaft_info.shadow_matrix_farthest;
                    local_2 = _e119;
                }
                let _e120 = local_2;
                local_1 = _e120;
            }
            let _e121 = local_1;
            matrix = _e121;
            let _e122 = matrix;
            let _e123 = (*world);
            lightSpace = (_e122 * vec4<f32>(_e123.x, _e123.y, _e123.z, 1f));
            let _e130 = lightSpace[3u];
            if (_e130 <= 0f) {
                continue;
            }
            let _e132 = lightSpace;
            let _e135 = lightSpace[3u];
            candidate = (_e132.xyz / vec3(_e135));
            let _e139 = candidate[0u];
            let _e143 = candidate[1u];
            inTile = vec2<f32>(((_e139 * 0.5f) + 0.5f), (0.5f - (_e143 * 0.5f)));
            let _e148 = inTile[0u];
            let _e149 = (_e148 < 0f);
            phi_425_ = _e149;
            if !(_e149) {
                let _e152 = inTile[0u];
                phi_425_ = (_e152 > 1f);
            }
            let _e155 = phi_425_;
            phi_432_ = _e155;
            if !(_e155) {
                let _e158 = inTile[1u];
                phi_432_ = (_e158 < 0f);
            }
            let _e161 = phi_432_;
            phi_439_ = _e161;
            if !(_e161) {
                let _e164 = inTile[1u];
                phi_439_ = (_e164 > 1f);
            }
            let _e167 = phi_439_;
            if _e167 {
                continue;
            }
            let _e169 = candidate[2u];
            if (_e169 > 1f) {
                let _e171 = which;
                let _e172 = cascadeCount;
                if (_e171 < (_e172 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e177 = inTile[0u];
            let _e178 = which;
            let _e181 = cascadeCount;
            let _e185 = inTile[1u];
            uv = vec2<f32>(((_e177 + f32(_e178)) / f32(_e181)), _e185);
            let _e187 = uv;
            let _e188 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e187, 0f);
            param = _e188.x;
            let _e192 = shaft_info.bias[3u];
            param_1 = _e192;
            let _e193 = ShadowStored_u0028_f1_u003b_f1_u003b((&param), (&param_1));
            stored_1 = _e193;
            let _e194 = which;
            if (_e194 == 0i) {
                let _e198 = shaft_info.bias[0u];
                local_3 = _e198;
            } else {
                let _e199 = which;
                if (_e199 == 1i) {
                    let _e203 = shaft_info.bias[1u];
                    local_4 = _e203;
                } else {
                    let _e206 = shaft_info.bias[2u];
                    local_4 = _e206;
                }
                let _e207 = local_4;
                local_3 = _e207;
            }
            let _e208 = local_3;
            bias = _e208;
            let _e210 = candidate[2u];
            let _e211 = bias;
            let _e213 = stored_1;
            return select(1f, 0f, ((_e210 - _e211) > _e213));
        } else {
            break;
        }
        continuing {
            let _e216 = attempt;
            attempt = (_e216 + 1i);
        }
    }
    return 1f;
}

fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e66 = (*at)[0u];
    x = i32((_e66 - (floor((_e66 / 4f)) * 4f)));
    let _e73 = (*at)[1u];
    y = i32((_e73 - (floor((_e73 / 4f)) * 4f)));
    let _e79 = y;
    let _e81 = x;
    index = ((_e79 * 4i) + _e81);
    value = 0f;
    let _e83 = index;
    if (_e83 == 0i) {
        value = 0f;
    } else {
        let _e85 = index;
        if (_e85 == 1i) {
            value = 8f;
        } else {
            let _e87 = index;
            if (_e87 == 2i) {
                value = 2f;
            } else {
                let _e89 = index;
                if (_e89 == 3i) {
                    value = 10f;
                } else {
                    let _e91 = index;
                    if (_e91 == 4i) {
                        value = 12f;
                    } else {
                        let _e93 = index;
                        if (_e93 == 5i) {
                            value = 4f;
                        } else {
                            let _e95 = index;
                            if (_e95 == 6i) {
                                value = 14f;
                            } else {
                                let _e97 = index;
                                if (_e97 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e99 = index;
                                    if (_e99 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e101 = index;
                                        if (_e101 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e103 = index;
                                            if (_e103 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e105 = index;
                                                if (_e105 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e107 = index;
                                                    if (_e107 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e109 = index;
                                                        if (_e109 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e111 = index;
                                                            if (_e111 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e113 = value;
    return (_e113 / 16f);
}

fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
    var slice: f32;
    var cell: vec2<f32>;
    var corner: vec2<f32>;
    var uv_1: vec2<f32>;

    let _e67 = noise_info.noise[1u];
    slice = _e67;
    let _e68 = (*at_1);
    let _e69 = floor(_e68);
    let _e70 = vec2(64f);
    cell = (_e69 - (floor((_e69 / _e70)) * _e70));
    let _e75 = slice;
    let _e80 = slice;
    corner = (vec2<f32>((_e75 - (floor((_e75 / 8f)) * 8f)), floor((_e80 / 8f))) * 64f);
    let _e85 = corner;
    let _e86 = cell;
    uv_1 = (((_e85 + _e86) + vec2(0.5f)) / vec2<f32>(512f, 256f));
    let _e91 = uv_1;
    let _e92 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e91, 0f);
    return (_e92.x * 0.99609375f);
}

fn PixelNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
    var local_5: f32;
    var param_2: vec2<f32>;
    var param_3: vec2<f32>;

    let _e66 = noise_info.noise[0u];
    if (_e66 > 0.5f) {
        let _e68 = (*at_2);
        param_2 = _e68;
        let _e69 = BlueNoise_u0028_vf2_u003b((&param_2));
        local_5 = _e69;
    } else {
        let _e70 = (*at_2);
        param_3 = _e70;
        let _e71 = BayerCell_u0028_vf2_u003b((&param_3));
        local_5 = _e71;
    }
    let _e72 = local_5;
    return _e72;
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_6: vec2<f32>;

    let _e62 = (*rows);
    if (_e62 > 0f) {
        let _e65 = gl_FragCoord_1[0u];
        let _e66 = (*rows);
        let _e68 = gl_FragCoord_1[1u];
        local_6 = vec2<f32>(_e65, (_e66 - _e68));
    } else {
        let _e71 = gl_FragCoord_1;
        local_6 = _e71.xy;
    }
    let _e73 = local_6;
    return _e73;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param_4: f32;

    let _e63 = frag_coord_info.origin[0u];
    param_4 = _e63;
    let _e64 = FragCoordFromTop_u0028_f1_u003b((&param_4));
    return _e64;
}

fn main_1() {
    var scene: vec4<f32>;
    var steps: i32;
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;
    var nearPoint: vec3<f32>;
    var along: vec3<f32>;
    var cosine_1: f32;
    var origin: vec3<f32>;
    var surfaceDepth: f32;
    var toSurface: f32;
    var local_7: f32;
    var distance_: f32;
    var stride: f32;
    var offset: f32;
    var param_5: vec2<f32>;
    var sigma: f32;
    var stepTransmittance: f32;
    var transmittance: f32;
    var inscatter: f32;
    var i: i32;
    var travelled: f32;
    var at_3: vec3<f32>;
    var lit: f32;
    var param_6: vec3<f32>;
    var param_7: f32;
    var phase: f32;
    var param_8: f32;
    var param_9: f32;
    var shaft: vec3<f32>;

    let _e90 = v_uv_1;
    let _e91 = textureSample(scene_texture_tex, scene_texture_smp, _e90);
    scene = _e91;
    let _e94 = shaft_info.forward[3u];
    steps = i32((_e94 + 0.5f));
    let _e97 = steps;
    if (_e97 < 1i) {
        let _e99 = scene;
        frag_color = _e99;
        return;
    }
    let _e101 = v_uv_1[0u];
    let _e105 = v_uv_1[1u];
    xy = vec2<f32>(((_e101 * 2f) - 1f), (1f - (_e105 * 2f)));
    let _e110 = shaft_info.inverse_view_projection;
    let _e111 = xy;
    nearH = (_e110 * vec4<f32>(_e111.x, _e111.y, 0f, 1f));
    let _e117 = shaft_info.inverse_view_projection;
    let _e118 = xy;
    farH = (_e117 * vec4<f32>(_e118.x, _e118.y, 1f, 1f));
    let _e123 = nearH;
    let _e126 = nearH[3u];
    nearPoint = (_e123.xyz / vec3(_e126));
    let _e129 = farH;
    let _e132 = farH[3u];
    let _e135 = nearPoint;
    along = normalize(((_e129.xyz / vec3(_e132)) - _e135));
    let _e138 = along;
    let _e140 = shaft_info.forward;
    cosine_1 = max(dot(_e138, _e140.xyz), 0.0001f);
    let _e144 = nearPoint;
    let _e145 = along;
    let _e146 = nearPoint;
    let _e148 = shaft_info.camera;
    let _e152 = shaft_info.forward;
    let _e155 = cosine_1;
    origin = (_e144 - (_e145 * (dot((_e146 - _e148.xyz), _e152.xyz) / _e155)));
    let _e159 = v_uv_1;
    let _e160 = textureSample(surface_texture_tex, surface_texture_smp, _e159);
    surfaceDepth = _e160.w;
    let _e162 = surfaceDepth;
    if (_e162 > 0f) {
        let _e164 = surfaceDepth;
        let _e165 = cosine_1;
        local_7 = (_e164 / _e165);
    } else {
        local_7 = 1000000000f;
    }
    let _e167 = local_7;
    toSurface = _e167;
    let _e170 = shaft_info.camera[3u];
    let _e171 = toSurface;
    distance_ = min(_e170, _e171);
    let _e173 = distance_;
    if (_e173 <= 0f) {
        let _e175 = scene;
        frag_color = _e175;
        return;
    }
    let _e176 = distance_;
    let _e177 = steps;
    stride = (_e176 / f32(_e177));
    let _e180 = TargetFragCoord_u0028_();
    param_5 = _e180;
    let _e181 = PixelNoise_u0028_vf2_u003b((&param_5));
    let _e182 = stride;
    offset = (_e181 * _e182);
    let _e186 = shaft_info.scatter[3u];
    sigma = max(_e186, 0f);
    let _e188 = sigma;
    let _e190 = stride;
    stepTransmittance = exp((-(_e188) * _e190));
    let _e193 = sigma;
    let _e195 = offset;
    transmittance = exp((-(_e193) * _e195));
    inscatter = 0f;
    i = 0i;
    loop {
        let _e198 = i;
        if (_e198 < 64i) {
            let _e200 = i;
            let _e201 = steps;
            if (_e200 >= _e201) {
                break;
            }
            let _e203 = offset;
            let _e204 = i;
            let _e206 = stride;
            travelled = (_e203 + (f32(_e204) * _e206));
            let _e209 = origin;
            let _e210 = along;
            let _e211 = travelled;
            at_3 = (_e209 + (_e210 * _e211));
            let _e214 = at_3;
            param_6 = _e214;
            let _e215 = travelled;
            param_7 = _e215;
            let _e216 = LitAt_u0028_vf3_u003b_f1_u003b((&param_6), (&param_7));
            lit = _e216;
            let _e217 = transmittance;
            let _e218 = stepTransmittance;
            let _e221 = lit;
            let _e223 = inscatter;
            inscatter = (_e223 + ((_e217 * (1f - _e218)) * _e221));
            let _e225 = stepTransmittance;
            let _e226 = transmittance;
            transmittance = (_e226 * _e225);
            continue;
        } else {
            break;
        }
        continuing {
            let _e228 = i;
            i = (_e228 + 1i);
        }
    }
    let _e230 = along;
    let _e232 = shaft_info.sun;
    param_8 = dot(_e230, _e232.xyz);
    let _e237 = shaft_info.sun[3u];
    param_9 = _e237;
    let _e238 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((&param_8), (&param_9));
    phase = _e238;
    let _e240 = shaft_info.scatter;
    let _e242 = phase;
    let _e243 = inscatter;
    shaft = (_e240.xyz * (_e242 * _e243));
    let _e246 = scene;
    let _e248 = shaft;
    let _e249 = (_e246.xyz + _e248);
    let _e251 = scene[3u];
    frag_color = vec4<f32>(_e249.x, _e249.y, _e249.z, _e251);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'NoiseInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
        WebGpuBlock(
          name: 'ShaftInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 352,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 192,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 256,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'scatter',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cascades',
              offsetInBytes: 304,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'sun', offsetInBytes: 320, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'bias',
              offsetInBytes: 336,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VolumetricFog': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct NoiseInfo {
    noise: vec4<f32>,
}

struct VolumeFogInfo {
    inverse_view_projection: mat4x4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    cluster_view_projection: mat4x4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
    sun: vec4<f32>,
    sun_radiance: vec4<f32>,
    cascades: vec4<f32>,
    bias: vec4<f32>,
    medium: vec4<f32>,
    albedo: vec4<f32>,
    ambient: vec4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    list: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(1)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(4)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var blue_noise_texture_smp: sampler;
@group(1) @binding(3)
var<uniform> fog_info: VolumeFogInfo;
@group(1) @binding(12)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var shadow_texture_smp: sampler;
@group(1) @binding(2)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(10)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var point_shadow_texture_smp: sampler;
@group(1) @binding(8)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(6)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var light_list_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(14)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn HenyeyGreenstein_u0028_f1_u003b_f1_u003b(cosine: ptr<function, f32>, g: ptr<function, f32>) -> f32 {
    var g2_: f32;
    var denominator: f32;

    let _e85 = (*g);
    let _e86 = (*g);
    g2_ = (_e85 * _e86);
    let _e88 = g2_;
    let _e90 = (*g);
    let _e92 = (*cosine);
    denominator = max(((1f + _e88) - ((2f * _e90) * _e92)), 0.0001f);
    let _e96 = g2_;
    let _e98 = denominator;
    let _e100 = denominator;
    return ((1f - _e96) / ((12.566371f * _e98) * sqrt(_e100)));
}

fn LocalLitAt_u0028_vf3_u003b_vf4_u003b(world: ptr<function, vec3<f32>>, cone: ptr<function, vec4<f32>>) -> f32 {
    var strength: f32;
    var slot: i32;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv: vec2<f32>;
    var inset: f32;
    var local: vec2<f32>;
    var atlas: vec2<f32>;
    var stored: f32;
    var lit: f32;
    var phi_629_: bool;
    var phi_690_: bool;

    let _e100 = point_shadow.params[2u];
    strength = _e100;
    let _e102 = (*cone)[2u];
    let _e104 = strength;
    if ((_e102 < 0.5f) || (_e104 <= 0f)) {
        return 1f;
    }
    let _e108 = (*cone)[2u];
    slot = i32((_e108 - 0.5f));
    let _e111 = (*world);
    let _e112 = slot;
    let _e115 = point_shadow.lights[_e112];
    toFragment = (_e111 - _e115.xyz);
    let _e118 = toFragment;
    distance_ = length(_e118);
    let _e120 = slot;
    let _e124 = point_shadow.lights[_e120][3u];
    range = max(_e124, 0.0001f);
    let _e126 = distance_;
    let _e127 = range;
    if (_e126 >= _e127) {
        return 1f;
    }
    face = 0i;
    let _e130 = (*cone)[3u];
    if (_e130 < 0.5f) {
        let _e132 = toFragment;
        a = abs(_e132);
        let _e135 = a[0u];
        let _e137 = a[1u];
        let _e138 = (_e135 >= _e137);
        phi_629_ = _e138;
        if _e138 {
            let _e140 = a[0u];
            let _e142 = a[2u];
            phi_629_ = (_e140 >= _e142);
        }
        let _e145 = phi_629_;
        if _e145 {
            let _e147 = toFragment[0u];
            face = select(1i, 0i, (_e147 > 0f));
        } else {
            let _e151 = a[1u];
            let _e153 = a[2u];
            if (_e151 >= _e153) {
                let _e156 = toFragment[1u];
                face = select(3i, 2i, (_e156 > 0f));
            } else {
                let _e160 = toFragment[2u];
                face = select(5i, 4i, (_e160 > 0f));
            }
        }
    }
    let _e163 = slot;
    let _e165 = face;
    let _e169 = point_shadow.faces[((_e163 * 6i) + _e165)];
    let _e170 = (*world);
    clip = (_e169 * vec4<f32>(_e170.x, _e170.y, _e170.z, 1f));
    let _e177 = clip[3u];
    if (_e177 <= 0f) {
        return 1f;
    }
    let _e179 = clip;
    let _e182 = clip[3u];
    ndc = (_e179.xy / vec2(_e182));
    let _e186 = ndc[0u];
    let _e188 = (abs(_e186) > 1f);
    phi_690_ = _e188;
    if !(_e188) {
        let _e191 = ndc[1u];
        phi_690_ = (abs(_e191) > 1f);
    }
    let _e195 = phi_690_;
    if _e195 {
        return 1f;
    }
    let _e197 = ndc[0u];
    let _e201 = ndc[1u];
    uv = vec2<f32>(((_e197 * 0.5f) + 0.5f), (0.5f - (_e201 * 0.5f)));
    let _e207 = point_shadow.params[0u];
    inset = _e207;
    let _e208 = uv;
    let _e209 = inset;
    let _e210 = inset;
    local = clamp(_e208, vec2(_e209), vec2((1f - _e210)));
    let _e215 = local;
    let _e216 = face;
    let _e218 = slot;
    atlas = ((_e215 + vec2<f32>(f32(_e216), f32(_e218))) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e225 = point_shadow.params3_[0u];
    if (_e225 > 0.5f) {
        let _e228 = atlas[1u];
        atlas[1u] = (1f - _e228);
    }
    let _e231 = atlas;
    let _e232 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e231, 0f);
    let _e234 = atlas;
    let _e235 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e234, 0f);
    let _e238 = range;
    stored = (min(_e232.x, _e235.x) * _e238);
    let _e240 = stored;
    let _e241 = range;
    if (_e240 >= (_e241 * 0.999f)) {
        return 1f;
    }
    let _e244 = distance_;
    let _e247 = point_shadow.params[1u];
    let _e249 = stored;
    lit = select(1f, 0f, ((_e244 - _e247) > _e249));
    let _e252 = lit;
    let _e253 = strength;
    return mix(1f, _e252, clamp(_e253, 0f, 1f));
}

fn Lane_u0028_vf4_u003b_f1_u003b(four: ptr<function, vec4<f32>>, lane: ptr<function, f32>) -> f32 {
    var local_1: f32;
    var local_2: f32;
    var local_3: f32;

    let _e86 = (*lane);
    if (_e86 < 0.5f) {
        let _e89 = (*four)[0u];
        local_1 = _e89;
    } else {
        let _e90 = (*lane);
        if (_e90 < 1.5f) {
            let _e93 = (*four)[1u];
            local_2 = _e93;
        } else {
            let _e94 = (*lane);
            if (_e94 < 2.5f) {
                let _e97 = (*four)[2u];
                local_3 = _e97;
            } else {
                let _e99 = (*four)[3u];
                local_3 = _e99;
            }
            let _e100 = local_3;
            local_2 = _e100;
        }
        let _e101 = local_2;
        local_1 = _e101;
    }
    let _e102 = local_1;
    return _e102;
}

fn ListTexel_u0028_f1_u003b_f1_u003b(texel: ptr<function, f32>, row: ptr<function, f32>) -> vec4<f32> {
    let _e83 = (*texel);
    let _e87 = fog_info.list[0u];
    let _e89 = (*row);
    let _e93 = fog_info.list[1u];
    let _e96 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e83 + 0.5f) * _e87), ((_e89 + 0.5f) * _e93)), 0f);
    return _e96;
}

fn ClusterLight_u0028_vf3_u003b_vf3_u003b_f1_u003b(world_1: ptr<function, vec3<f32>>, along: ptr<function, vec3<f32>>, g_1: ptr<function, f32>) -> vec3<f32> {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_4: f32;
    var cell: f32;
    var headerRow: f32;
    var header: vec4<f32>;
    var param: f32;
    var param_1: f32;
    var count: i32;
    var total: vec3<f32>;
    var i: i32;
    var entry: f32;
    var entryRow: f32;
    var within: f32;
    var texel_1: f32;
    var four_1: vec4<f32>;
    var param_2: f32;
    var param_3: f32;
    var row_1: f32;
    var param_4: vec4<f32>;
    var param_5: f32;
    var position: vec4<f32>;
    var param_6: f32;
    var param_7: f32;
    var color: vec4<f32>;
    var param_8: f32;
    var param_9: f32;
    var direction: vec4<f32>;
    var param_10: f32;
    var param_11: f32;
    var cone_1: vec4<f32>;
    var param_12: f32;
    var param_13: f32;
    var type_30: f32;
    var toLight: vec3<f32>;
    var distance_1: f32;
    var usable: f32;
    var l: vec3<f32>;
    var attenuation: f32;
    var ratio: f32;
    var window: f32;
    var cosAngle: f32;
    var ramp: f32;
    var visibility: f32;
    var local_5: f32;
    var param_14: vec3<f32>;
    var param_15: vec4<f32>;
    var param_16: f32;
    var param_17: f32;

    let _e139 = fog_info.cluster_view_projection;
    let _e140 = (*world_1);
    clip_1 = (_e139 * vec4<f32>(_e140.x, _e140.y, _e140.z, 1f));
    let _e146 = clip_1;
    let _e149 = clip_1[3u];
    ndc_1 = (_e146.xy / vec2(max(_e149, 0.000001f)));
    let _e154 = fog_info.cluster_grid;
    grid = _e154.xyz;
    let _e158 = fog_info.cluster_depth[0u];
    near = _e158;
    let _e160 = ndc_1[0u];
    let _e164 = grid[0u];
    let _e168 = grid[0u];
    tx = clamp(floor((((_e160 * 0.5f) + 0.5f) * _e164)), 0f, (_e168 - 1f));
    let _e172 = ndc_1[1u];
    let _e176 = grid[1u];
    let _e180 = grid[1u];
    ty = clamp(floor((((_e172 * 0.5f) + 0.5f) * _e176)), 0f, (_e180 - 1f));
    let _e184 = clip_1[3u];
    let _e185 = near;
    if (_e184 <= _e185) {
        local_4 = 0f;
    } else {
        let _e188 = clip_1[3u];
        let _e189 = near;
        let _e194 = fog_info.cluster_depth[1u];
        let _e198 = grid[2u];
        local_4 = clamp(floor((log((_e188 / _e189)) * _e194)), 0f, (_e198 - 1f));
    }
    let _e201 = local_4;
    tz = _e201;
    let _e202 = tx;
    let _e203 = ty;
    let _e205 = grid[0u];
    let _e208 = tz;
    let _e210 = grid[0u];
    let _e213 = grid[1u];
    cell = ((_e202 + (_e203 * _e205)) + ((_e208 * _e210) * _e213));
    let _e216 = cell;
    headerRow = floor((_e216 / 4f));
    let _e219 = cell;
    let _e220 = headerRow;
    let _e225 = fog_info.cluster_depth[2u];
    let _e226 = headerRow;
    param = (_e219 - (_e220 * 4f));
    param_1 = (_e225 + _e226);
    let _e228 = ListTexel_u0028_f1_u003b_f1_u003b((&param), (&param_1));
    header = _e228;
    let _e230 = header[1u];
    count = i32((_e230 + 0.5f));
    total = vec3<f32>(0f, 0f, 0f);
    i = 0i;
    loop {
        let _e233 = i;
        if (_e233 < 16i) {
            let _e235 = i;
            let _e236 = count;
            if (_e235 >= _e236) {
                break;
            }
            let _e239 = header[0u];
            let _e240 = i;
            entry = (_e239 + f32(_e240));
            let _e243 = entry;
            entryRow = floor((_e243 / 16f));
            let _e246 = entry;
            let _e247 = entryRow;
            within = (_e246 - (_e247 * 16f));
            let _e250 = within;
            texel_1 = floor((_e250 / 4f));
            let _e255 = fog_info.cluster_depth[3u];
            let _e256 = entryRow;
            let _e258 = texel_1;
            param_2 = _e258;
            param_3 = (_e255 + _e256);
            let _e259 = ListTexel_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));
            four_1 = _e259;
            let _e260 = within;
            let _e261 = texel_1;
            let _e264 = four_1;
            param_4 = _e264;
            param_5 = (_e260 - (_e261 * 4f));
            let _e265 = Lane_u0028_vf4_u003b_f1_u003b((&param_4), (&param_5));
            row_1 = _e265;
            param_6 = 0f;
            let _e266 = row_1;
            param_7 = _e266;
            let _e267 = ListTexel_u0028_f1_u003b_f1_u003b((&param_6), (&param_7));
            position = _e267;
            param_8 = 1f;
            let _e268 = row_1;
            param_9 = _e268;
            let _e269 = ListTexel_u0028_f1_u003b_f1_u003b((&param_8), (&param_9));
            color = _e269;
            param_10 = 2f;
            let _e270 = row_1;
            param_11 = _e270;
            let _e271 = ListTexel_u0028_f1_u003b_f1_u003b((&param_10), (&param_11));
            direction = _e271;
            param_12 = 3f;
            let _e272 = row_1;
            param_13 = _e272;
            let _e273 = ListTexel_u0028_f1_u003b_f1_u003b((&param_12), (&param_13));
            cone_1 = _e273;
            let _e275 = position[3u];
            type_30 = _e275;
            let _e276 = position;
            let _e278 = (*world_1);
            toLight = (_e276.xyz - _e278);
            let _e280 = toLight;
            distance_1 = length(_e280);
            let _e282 = type_30;
            let _e284 = type_30;
            let _e287 = distance_1;
            usable = select(0f, 1f, (((_e282 > 0.5f) && (_e284 < 2.5f)) && (_e287 > 0.0001f)));
            let _e291 = toLight;
            let _e292 = distance_1;
            l = (_e291 / vec3(max(_e292, 0.0001f)));
            let _e296 = distance_1;
            let _e297 = distance_1;
            attenuation = (1f / max((_e296 * _e297), 0.0001f));
            let _e302 = direction[3u];
            if (_e302 > 0f) {
                let _e304 = distance_1;
                let _e306 = direction[3u];
                ratio = (_e304 / _e306);
                let _e308 = ratio;
                let _e309 = ratio;
                let _e311 = ratio;
                let _e313 = ratio;
                window = clamp((1f - (((_e308 * _e309) * _e311) * _e313)), 0f, 1f);
                let _e317 = window;
                let _e318 = window;
                let _e320 = attenuation;
                attenuation = (_e320 * (_e317 * _e318));
            }
            let _e322 = type_30;
            let _e324 = type_30;
            if ((_e322 > 1.5f) && (_e324 < 2.5f)) {
                let _e327 = direction;
                let _e330 = l;
                cosAngle = dot(normalize(_e327.xyz), -(_e330));
                let _e333 = cosAngle;
                let _e335 = cone_1[1u];
                let _e338 = cone_1[0u];
                let _e340 = cone_1[1u];
                ramp = clamp(((_e333 - _e335) / (_e338 - _e340)), 0f, 1f);
                let _e344 = ramp;
                let _e345 = ramp;
                let _e347 = attenuation;
                attenuation = (_e347 * (_e344 * _e345));
            }
            let _e349 = attenuation;
            let _e350 = usable;
            if ((_e349 * _e350) > 0f) {
                let _e353 = (*world_1);
                param_14 = _e353;
                let _e354 = cone_1;
                param_15 = _e354;
                let _e355 = LocalLitAt_u0028_vf3_u003b_vf4_u003b((&param_14), (&param_15));
                local_5 = _e355;
            } else {
                local_5 = 1f;
            }
            let _e356 = local_5;
            visibility = _e356;
            let _e357 = color;
            let _e360 = color[3u];
            let _e361 = attenuation;
            let _e363 = usable;
            let _e365 = visibility;
            let _e367 = (*along);
            let _e368 = l;
            param_16 = dot(_e367, _e368);
            let _e370 = (*g_1);
            param_17 = _e370;
            let _e371 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((&param_16), (&param_17));
            let _e374 = total;
            total = (_e374 + (_e357.xyz * ((((_e360 * _e361) * _e363) * _e365) * _e371)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e376 = i;
            i = (_e376 + 1i);
        }
    }
    let _e378 = total;
    return _e378;
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_1: ptr<function, f32>, mode: ptr<function, f32>) -> f32 {
    var local_6: f32;

    let _e84 = (*mode);
    if (_e84 > 0.5f) {
        let _e86 = (*stored_1);
        local_6 = (1f - _e86);
    } else {
        let _e88 = (*stored_1);
        local_6 = _e88;
    }
    let _e89 = local_6;
    return _e89;
}

fn LitAt_u0028_vf3_u003b_f1_u003b(world_2: ptr<function, vec3<f32>>, viewDistance: ptr<function, f32>) -> f32 {
    var cascadeCount: i32;
    var cascade: i32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_7: mat4x4<f32>;
    var local_8: mat4x4<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var uv_1: vec2<f32>;
    var stored_2: f32;
    var param_18: f32;
    var param_19: f32;
    var bias: f32;
    var local_9: f32;
    var local_10: f32;
    var phi_374_: bool;
    var phi_385_: bool;
    var phi_470_: bool;
    var phi_477_: bool;
    var phi_484_: bool;

    let _e102 = fog_info.cascades[2u];
    cascadeCount = i32((_e102 + 0.5f));
    cascade = 0i;
    let _e105 = cascadeCount;
    let _e106 = (_e105 > 1i);
    phi_374_ = _e106;
    if _e106 {
        let _e107 = (*viewDistance);
        let _e110 = fog_info.cascades[0u];
        phi_374_ = (_e107 > _e110);
    }
    let _e113 = phi_374_;
    if _e113 {
        cascade = 1i;
    }
    let _e114 = cascadeCount;
    let _e115 = (_e114 > 2i);
    phi_385_ = _e115;
    if _e115 {
        let _e116 = (*viewDistance);
        let _e119 = fog_info.cascades[1u];
        phi_385_ = (_e116 > _e119);
    }
    let _e122 = phi_385_;
    if _e122 {
        cascade = 2i;
    }
    attempt = 0i;
    loop {
        let _e123 = attempt;
        if (_e123 < 3i) {
            let _e125 = cascade;
            let _e126 = attempt;
            which = (_e125 + _e126);
            let _e128 = which;
            let _e129 = cascadeCount;
            if (_e128 >= _e129) {
                break;
            }
            let _e131 = which;
            if (_e131 == 0i) {
                let _e134 = fog_info.shadow_matrix;
                local_7 = _e134;
            } else {
                let _e135 = which;
                if (_e135 == 1i) {
                    let _e138 = fog_info.shadow_matrix_far;
                    local_8 = _e138;
                } else {
                    let _e140 = fog_info.shadow_matrix_farthest;
                    local_8 = _e140;
                }
                let _e141 = local_8;
                local_7 = _e141;
            }
            let _e142 = local_7;
            matrix = _e142;
            let _e143 = matrix;
            let _e144 = (*world_2);
            lightSpace = (_e143 * vec4<f32>(_e144.x, _e144.y, _e144.z, 1f));
            let _e151 = lightSpace[3u];
            if (_e151 <= 0f) {
                continue;
            }
            let _e153 = lightSpace;
            let _e156 = lightSpace[3u];
            candidate = (_e153.xyz / vec3(_e156));
            let _e160 = candidate[0u];
            let _e164 = candidate[1u];
            inTile = vec2<f32>(((_e160 * 0.5f) + 0.5f), (0.5f - (_e164 * 0.5f)));
            let _e169 = inTile[0u];
            let _e170 = (_e169 < 0f);
            phi_470_ = _e170;
            if !(_e170) {
                let _e173 = inTile[0u];
                phi_470_ = (_e173 > 1f);
            }
            let _e176 = phi_470_;
            phi_477_ = _e176;
            if !(_e176) {
                let _e179 = inTile[1u];
                phi_477_ = (_e179 < 0f);
            }
            let _e182 = phi_477_;
            phi_484_ = _e182;
            if !(_e182) {
                let _e185 = inTile[1u];
                phi_484_ = (_e185 > 1f);
            }
            let _e188 = phi_484_;
            if _e188 {
                continue;
            }
            let _e190 = candidate[2u];
            if (_e190 > 1f) {
                let _e192 = which;
                let _e193 = cascadeCount;
                if (_e192 < (_e193 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e198 = inTile[0u];
            let _e199 = which;
            let _e202 = cascadeCount;
            let _e206 = inTile[1u];
            uv_1 = vec2<f32>(((_e198 + f32(_e199)) / f32(_e202)), _e206);
            let _e208 = uv_1;
            let _e209 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, _e208, 0f);
            param_18 = _e209.x;
            let _e213 = fog_info.bias[3u];
            param_19 = _e213;
            let _e214 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_18), (&param_19));
            stored_2 = _e214;
            let _e215 = which;
            if (_e215 == 0i) {
                let _e219 = fog_info.bias[0u];
                local_9 = _e219;
            } else {
                let _e220 = which;
                if (_e220 == 1i) {
                    let _e224 = fog_info.bias[1u];
                    local_10 = _e224;
                } else {
                    let _e227 = fog_info.bias[2u];
                    local_10 = _e227;
                }
                let _e228 = local_10;
                local_9 = _e228;
            }
            let _e229 = local_9;
            bias = _e229;
            let _e231 = candidate[2u];
            let _e232 = bias;
            let _e234 = stored_2;
            return select(1f, 0f, ((_e231 - _e232) > _e234));
        } else {
            break;
        }
        continuing {
            let _e237 = attempt;
            attempt = (_e237 + 1i);
        }
    }
    return 1f;
}

fn Density_u0028_f1_u003b(y: ptr<function, f32>) -> f32 {
    var exponent: f32;

    let _e85 = fog_info.medium[1u];
    let _e87 = (*y);
    let _e90 = fog_info.medium[2u];
    exponent = clamp((-(_e85) * (_e87 - _e90)), -30f, 30f);
    let _e96 = fog_info.medium[0u];
    let _e98 = exponent;
    return (max(_e96, 0f) * exp(_e98));
}

fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y_1: i32;
    var index: i32;
    var value: f32;

    let _e87 = (*at)[0u];
    x = i32((_e87 - (floor((_e87 / 4f)) * 4f)));
    let _e94 = (*at)[1u];
    y_1 = i32((_e94 - (floor((_e94 / 4f)) * 4f)));
    let _e100 = y_1;
    let _e102 = x;
    index = ((_e100 * 4i) + _e102);
    value = 0f;
    let _e104 = index;
    if (_e104 == 0i) {
        value = 0f;
    } else {
        let _e106 = index;
        if (_e106 == 1i) {
            value = 8f;
        } else {
            let _e108 = index;
            if (_e108 == 2i) {
                value = 2f;
            } else {
                let _e110 = index;
                if (_e110 == 3i) {
                    value = 10f;
                } else {
                    let _e112 = index;
                    if (_e112 == 4i) {
                        value = 12f;
                    } else {
                        let _e114 = index;
                        if (_e114 == 5i) {
                            value = 4f;
                        } else {
                            let _e116 = index;
                            if (_e116 == 6i) {
                                value = 14f;
                            } else {
                                let _e118 = index;
                                if (_e118 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e120 = index;
                                    if (_e120 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e122 = index;
                                        if (_e122 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e124 = index;
                                            if (_e124 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e126 = index;
                                                if (_e126 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e128 = index;
                                                    if (_e128 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e130 = index;
                                                        if (_e130 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e132 = index;
                                                            if (_e132 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e134 = value;
    return (_e134 / 16f);
}

fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
    var slice: f32;
    var cell_1: vec2<f32>;
    var corner: vec2<f32>;
    var uv_2: vec2<f32>;

    let _e88 = noise_info.noise[1u];
    slice = _e88;
    let _e89 = (*at_1);
    let _e90 = floor(_e89);
    let _e91 = vec2(64f);
    cell_1 = (_e90 - (floor((_e90 / _e91)) * _e91));
    let _e96 = slice;
    let _e101 = slice;
    corner = (vec2<f32>((_e96 - (floor((_e96 / 8f)) * 8f)), floor((_e101 / 8f))) * 64f);
    let _e106 = corner;
    let _e107 = cell_1;
    uv_2 = (((_e106 + _e107) + vec2(0.5f)) / vec2<f32>(512f, 256f));
    let _e112 = uv_2;
    let _e113 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e112, 0f);
    return (_e113.x * 0.99609375f);
}

fn PixelNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
    var local_11: f32;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;

    let _e87 = noise_info.noise[0u];
    if (_e87 > 0.5f) {
        let _e89 = (*at_2);
        param_20 = _e89;
        let _e90 = BlueNoise_u0028_vf2_u003b((&param_20));
        local_11 = _e90;
    } else {
        let _e91 = (*at_2);
        param_21 = _e91;
        let _e92 = BayerCell_u0028_vf2_u003b((&param_21));
        local_11 = _e92;
    }
    let _e93 = local_11;
    return _e93;
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_12: vec2<f32>;

    let _e83 = (*rows);
    if (_e83 > 0f) {
        let _e86 = gl_FragCoord_1[0u];
        let _e87 = (*rows);
        let _e89 = gl_FragCoord_1[1u];
        local_12 = vec2<f32>(_e86, (_e87 - _e89));
    } else {
        let _e92 = gl_FragCoord_1;
        local_12 = _e92.xy;
    }
    let _e94 = local_12;
    return _e94;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param_22: f32;

    let _e84 = frag_coord_info.origin[0u];
    param_22 = _e84;
    let _e85 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    return _e85;
}

fn main_1() {
    var steps: i32;
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;
    var nearPoint: vec3<f32>;
    var along_1: vec3<f32>;
    var cosine_1: f32;
    var origin: vec3<f32>;
    var surfaceDepth: f32;
    var toSurface: f32;
    var local_13: f32;
    var distance_2: f32;
    var stride: f32;
    var offset: f32;
    var param_23: vec2<f32>;
    var g_2: f32;
    var sunPhase: f32;
    var param_24: f32;
    var param_25: f32;
    var clustered: bool;
    var transmittance: f32;
    var inscatter: vec3<f32>;
    var i_1: i32;
    var travelled: f32;
    var at_3: vec3<f32>;
    var stepTransmittance: f32;
    var param_26: f32;
    var light: vec3<f32>;
    var param_27: vec3<f32>;
    var param_28: f32;
    var param_29: vec3<f32>;
    var param_30: vec3<f32>;
    var param_31: f32;

    let _e116 = fog_info.forward[3u];
    steps = i32((_e116 + 0.5f));
    let _e120 = v_uv_1[0u];
    let _e124 = v_uv_1[1u];
    xy = vec2<f32>(((_e120 * 2f) - 1f), (1f - (_e124 * 2f)));
    let _e129 = fog_info.inverse_view_projection;
    let _e130 = xy;
    nearH = (_e129 * vec4<f32>(_e130.x, _e130.y, 0f, 1f));
    let _e136 = fog_info.inverse_view_projection;
    let _e137 = xy;
    farH = (_e136 * vec4<f32>(_e137.x, _e137.y, 1f, 1f));
    let _e142 = nearH;
    let _e145 = nearH[3u];
    nearPoint = (_e142.xyz / vec3(_e145));
    let _e148 = farH;
    let _e151 = farH[3u];
    let _e154 = nearPoint;
    along_1 = normalize(((_e148.xyz / vec3(_e151)) - _e154));
    let _e157 = along_1;
    let _e159 = fog_info.forward;
    cosine_1 = max(dot(_e157, _e159.xyz), 0.0001f);
    let _e163 = nearPoint;
    let _e164 = along_1;
    let _e165 = nearPoint;
    let _e167 = fog_info.camera;
    let _e171 = fog_info.forward;
    let _e174 = cosine_1;
    origin = (_e163 - (_e164 * (dot((_e165 - _e167.xyz), _e171.xyz) / _e174)));
    let _e178 = v_uv_1;
    let _e179 = textureSample(surface_texture_tex, surface_texture_smp, _e178);
    surfaceDepth = _e179.w;
    let _e181 = surfaceDepth;
    if (_e181 > 0f) {
        let _e183 = surfaceDepth;
        let _e184 = cosine_1;
        local_13 = (_e183 / _e184);
    } else {
        local_13 = 1000000000f;
    }
    let _e186 = local_13;
    toSurface = _e186;
    let _e189 = fog_info.camera[3u];
    let _e190 = toSurface;
    distance_2 = min(_e189, _e190);
    let _e192 = steps;
    let _e194 = distance_2;
    if ((_e192 < 1i) || (_e194 <= 0f)) {
        frag_color = vec4<f32>(0f, 0f, 0f, 1f);
        return;
    }
    let _e197 = distance_2;
    let _e198 = steps;
    stride = (_e197 / f32(_e198));
    let _e201 = TargetFragCoord_u0028_();
    param_23 = _e201;
    let _e202 = PixelNoise_u0028_vf2_u003b((&param_23));
    let _e203 = stride;
    offset = (_e202 * _e203);
    let _e207 = fog_info.sun[3u];
    g_2 = _e207;
    let _e208 = along_1;
    let _e210 = fog_info.sun;
    param_24 = dot(_e208, _e210.xyz);
    let _e213 = g_2;
    param_25 = _e213;
    let _e214 = HenyeyGreenstein_u0028_f1_u003b_f1_u003b((&param_24), (&param_25));
    sunPhase = _e214;
    let _e217 = fog_info.albedo[3u];
    clustered = (_e217 > 0.5f);
    transmittance = 1f;
    inscatter = vec3<f32>(0f, 0f, 0f);
    i_1 = 0i;
    loop {
        let _e219 = i_1;
        if (_e219 < 64i) {
            let _e221 = i_1;
            let _e222 = steps;
            if (_e221 >= _e222) {
                break;
            }
            let _e224 = offset;
            let _e225 = i_1;
            let _e227 = stride;
            travelled = (_e224 + (f32(_e225) * _e227));
            let _e230 = origin;
            let _e231 = along_1;
            let _e232 = travelled;
            at_3 = (_e230 + (_e231 * _e232));
            let _e236 = at_3[1u];
            param_26 = _e236;
            let _e237 = Density_u0028_f1_u003b((&param_26));
            let _e239 = stride;
            stepTransmittance = exp((-(_e237) * _e239));
            let _e243 = fog_info.sun_radiance;
            let _e245 = sunPhase;
            let _e246 = at_3;
            param_27 = _e246;
            let _e247 = travelled;
            param_28 = _e247;
            let _e248 = LitAt_u0028_vf3_u003b_f1_u003b((&param_27), (&param_28));
            let _e252 = fog_info.ambient;
            light = ((_e243.xyz * (_e245 * _e248)) + (_e252.xyz * 0.07957747f));
            let _e256 = clustered;
            if _e256 {
                let _e258 = fog_info.albedo;
                let _e260 = at_3;
                param_29 = _e260;
                let _e261 = along_1;
                param_30 = _e261;
                let _e262 = g_2;
                param_31 = _e262;
                let _e263 = ClusterLight_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_29), (&param_30), (&param_31));
                let _e265 = light;
                light = (_e265 + (_e258.xyz * _e263));
            }
            let _e267 = light;
            let _e268 = transmittance;
            let _e269 = stepTransmittance;
            let _e273 = inscatter;
            inscatter = (_e273 + (_e267 * (_e268 * (1f - _e269))));
            let _e275 = stepTransmittance;
            let _e276 = transmittance;
            transmittance = (_e276 * _e275);
            continue;
        } else {
            break;
        }
        continuing {
            let _e278 = i_1;
            i_1 = (_e278 + 1i);
        }
    }
    let _e280 = inscatter;
    let _e281 = transmittance;
    frag_color = vec4<f32>(_e280.x, _e280.y, _e280.z, _e281);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'NoiseInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 2,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'VolumeFogInfo',
          group: 1,
          binding: 3,
          sizeInBytes: 512,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 64,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 192,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 256,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 320,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 336,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'sun', offsetInBytes: 352, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'sun_radiance',
              offsetInBytes: 368,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cascades',
              offsetInBytes: 384,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'bias',
              offsetInBytes: 400,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'medium',
              offsetInBytes: 416,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'albedo',
              offsetInBytes: 432,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient',
              offsetInBytes: 448,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 464,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 480,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'list',
              offsetInBytes: 496,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VolumetricFogUpsample': WebGpuStage(
      wgsl: r'''
struct FogUpsampleInfo {
    size: vec4<f32>,
    occlusion: vec4<f32>,
}

@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> upsample_info: FogUpsampleInfo;
@group(1) @binding(5)
var fog_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var fog_texture_smp: sampler;
@group(1) @binding(7)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var ao_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var ao_texture_smp: sampler;
@group(1) @binding(3)
var contact_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var contact_shadow_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn DepthAt_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> f32 {
    var depth: f32;

    let _e35 = (*uv);
    let _e36 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e35, 0f);
    depth = _e36.w;
    let _e38 = depth;
    let _e40 = depth;
    return select(1000000f, _e40, (_e38 > 0f));
}

fn Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b(cell: ptr<function, vec2<f32>>, share: ptr<function, f32>, here: ptr<function, f32>, sum: ptr<function, vec4<f32>>, weight: ptr<function, f32>) {
    var size: vec2<f32>;
    var uv_1: vec2<f32>;
    var difference: f32;
    var param: vec2<f32>;
    var w: f32;

    let _e44 = upsample_info.size;
    size = _e44.xy;
    let _e46 = (*cell);
    let _e47 = size;
    let _e53 = size;
    uv_1 = ((clamp(_e46, vec2<f32>(0f, 0f), (_e47 - vec2(1f))) + vec2(0.5f)) / _e53);
    let _e55 = uv_1;
    param = _e55;
    let _e56 = DepthAt_u0028_vf2_u003b((&param));
    let _e57 = (*here);
    let _e60 = (*here);
    difference = (abs((_e56 - _e57)) / max(_e60, 0.001f));
    let _e63 = (*share);
    let _e64 = difference;
    w = (_e63 / (0.01f + _e64));
    let _e67 = uv_1;
    let _e68 = textureSampleLevel(fog_texture_tex, fog_texture_smp, _e67, 0f);
    let _e69 = w;
    let _e71 = (*sum);
    (*sum) = (_e71 + (_e68 * _e69));
    let _e73 = w;
    let _e74 = (*weight);
    (*weight) = (_e74 + _e73);
    return;
}

fn main_1() {
    var scene: vec4<f32>;
    var size_1: vec2<f32>;
    var at: vec2<f32>;
    var base: vec2<f32>;
    var f: vec2<f32>;
    var here_1: f32;
    var param_1: vec2<f32>;
    var sum_1: vec4<f32>;
    var weight_1: f32;
    var param_2: vec2<f32>;
    var param_3: f32;
    var param_4: f32;
    var param_5: vec4<f32>;
    var param_6: f32;
    var param_7: vec2<f32>;
    var param_8: f32;
    var param_9: f32;
    var param_10: vec4<f32>;
    var param_11: f32;
    var param_12: vec2<f32>;
    var param_13: f32;
    var param_14: f32;
    var param_15: vec4<f32>;
    var param_16: f32;
    var param_17: vec2<f32>;
    var param_18: f32;
    var param_19: f32;
    var param_20: vec4<f32>;
    var param_21: f32;
    var fog: vec4<f32>;
    var local: vec4<f32>;
    var half_texel: vec2<f32>;
    var occlusion: vec4<f32>;
    var strength: f32;
    var ao: f32;
    var contact: f32;
    var surfaceLight: vec3<f32>;

    let _e70 = v_uv_1;
    let _e71 = textureSample(scene_texture_tex, scene_texture_smp, _e70);
    scene = _e71;
    let _e73 = upsample_info.size;
    size_1 = max(_e73.xy, vec2<f32>(1f, 1f));
    let _e76 = v_uv_1;
    let _e77 = size_1;
    at = ((_e76 * _e77) - vec2(0.5f));
    let _e81 = at;
    base = floor(_e81);
    let _e83 = at;
    let _e84 = base;
    f = (_e83 - _e84);
    let _e86 = v_uv_1;
    param_1 = _e86;
    let _e87 = DepthAt_u0028_vf2_u003b((&param_1));
    here_1 = _e87;
    sum_1 = vec4<f32>(0f, 0f, 0f, 0f);
    weight_1 = 0f;
    let _e89 = f[0u];
    let _e92 = f[1u];
    let _e95 = base;
    param_2 = _e95;
    param_3 = ((1f - _e89) * (1f - _e92));
    let _e96 = here_1;
    param_4 = _e96;
    let _e97 = sum_1;
    param_5 = _e97;
    let _e98 = weight_1;
    param_6 = _e98;
    Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((&param_2), (&param_3), (&param_4), (&param_5), (&param_6));
    let _e99 = param_5;
    sum_1 = _e99;
    let _e100 = param_6;
    weight_1 = _e100;
    let _e101 = base;
    let _e104 = f[0u];
    let _e106 = f[1u];
    param_7 = (_e101 + vec2<f32>(1f, 0f));
    param_8 = (_e104 * (1f - _e106));
    let _e109 = here_1;
    param_9 = _e109;
    let _e110 = sum_1;
    param_10 = _e110;
    let _e111 = weight_1;
    param_11 = _e111;
    Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((&param_7), (&param_8), (&param_9), (&param_10), (&param_11));
    let _e112 = param_10;
    sum_1 = _e112;
    let _e113 = param_11;
    weight_1 = _e113;
    let _e114 = base;
    let _e117 = f[0u];
    let _e120 = f[1u];
    param_12 = (_e114 + vec2<f32>(0f, 1f));
    param_13 = ((1f - _e117) * _e120);
    let _e122 = here_1;
    param_14 = _e122;
    let _e123 = sum_1;
    param_15 = _e123;
    let _e124 = weight_1;
    param_16 = _e124;
    Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15), (&param_16));
    let _e125 = param_15;
    sum_1 = _e125;
    let _e126 = param_16;
    weight_1 = _e126;
    let _e127 = base;
    let _e130 = f[0u];
    let _e132 = f[1u];
    param_17 = (_e127 + vec2<f32>(1f, 1f));
    param_18 = (_e130 * _e132);
    let _e134 = here_1;
    param_19 = _e134;
    let _e135 = sum_1;
    param_20 = _e135;
    let _e136 = weight_1;
    param_21 = _e136;
    Tap_u0028_vf2_u003b_f1_u003b_f1_u003b_vf4_u003b_f1_u003b((&param_17), (&param_18), (&param_19), (&param_20), (&param_21));
    let _e137 = param_20;
    sum_1 = _e137;
    let _e138 = param_21;
    weight_1 = _e138;
    let _e139 = weight_1;
    if (_e139 > 0.000001f) {
        let _e141 = sum_1;
        let _e142 = weight_1;
        local = (_e141 / vec4(_e142));
    } else {
        local = vec4<f32>(0f, 0f, 0f, 1f);
    }
    let _e145 = local;
    fog = _e145;
    let _e147 = upsample_info.size;
    half_texel = (_e147.zw * 0.5f);
    let _e150 = v_uv_1;
    let _e152 = half_texel[0u];
    let _e154 = half_texel[1u];
    let _e157 = textureSample(ao_texture_tex, ao_texture_smp, (_e150 + vec2<f32>(_e152, _e154)));
    let _e158 = v_uv_1;
    let _e160 = half_texel[0u];
    let _e163 = half_texel[1u];
    let _e166 = textureSample(ao_texture_tex, ao_texture_smp, (_e158 + vec2<f32>(-(_e160), _e163)));
    let _e168 = v_uv_1;
    let _e170 = half_texel[0u];
    let _e172 = half_texel[1u];
    let _e176 = textureSample(ao_texture_tex, ao_texture_smp, (_e168 + vec2<f32>(_e170, -(_e172))));
    let _e178 = v_uv_1;
    let _e180 = half_texel[0u];
    let _e183 = half_texel[1u];
    let _e187 = textureSample(ao_texture_tex, ao_texture_smp, (_e178 + vec2<f32>(-(_e180), -(_e183))));
    occlusion = ((((_e157 + _e166) + _e176) + _e187) * 0.25f);
    let _e192 = upsample_info.occlusion[0u];
    strength = clamp(_e192, 0f, 1f);
    let _e195 = occlusion[3u];
    let _e196 = strength;
    ao = mix(1f, _e195, _e196);
    let _e198 = v_uv_1;
    let _e199 = textureSample(contact_shadow_texture_tex, contact_shadow_texture_smp, _e198);
    contact = _e199.x;
    let _e201 = contact;
    let _e204 = upsample_info.occlusion[1u];
    let _e207 = ao;
    ao = (_e207 * mix(1f, _e201, clamp(_e204, 0f, 1f)));
    let _e209 = scene;
    let _e211 = ao;
    let _e213 = occlusion;
    let _e217 = upsample_info.occlusion[2u];
    let _e219 = strength;
    surfaceLight = ((_e209.xyz * _e211) + ((_e213.xyz * _e217) * _e219));
    let _e222 = surfaceLight;
    let _e224 = fog[3u];
    let _e226 = fog;
    let _e228 = ((_e222 * _e224) + _e226.xyz);
    let _e230 = scene[3u];
    frag_color = vec4<f32>(_e228.x, _e228.y, _e228.z, _e230);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogUpsampleInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'size', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'occlusion',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'ao_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'contact_shadow_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'fog_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'DepthOfField': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct DofInfo {
    lens: vec4<f32>,
    params: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(1)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(0)
var<uniform> dof_info: DofInfo;
@group(1) @binding(4)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(6)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var surface_texture_smp: sampler;
@group(1) @binding(2)
var coc_tile_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var coc_tile_texture_smp: sampler;

fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e63 = (*at)[0u];
    x = i32((_e63 - (floor((_e63 / 4f)) * 4f)));
    let _e70 = (*at)[1u];
    y = i32((_e70 - (floor((_e70 / 4f)) * 4f)));
    let _e76 = y;
    let _e78 = x;
    index = ((_e76 * 4i) + _e78);
    value = 0f;
    let _e80 = index;
    if (_e80 == 0i) {
        value = 0f;
    } else {
        let _e82 = index;
        if (_e82 == 1i) {
            value = 8f;
        } else {
            let _e84 = index;
            if (_e84 == 2i) {
                value = 2f;
            } else {
                let _e86 = index;
                if (_e86 == 3i) {
                    value = 10f;
                } else {
                    let _e88 = index;
                    if (_e88 == 4i) {
                        value = 12f;
                    } else {
                        let _e90 = index;
                        if (_e90 == 5i) {
                            value = 4f;
                        } else {
                            let _e92 = index;
                            if (_e92 == 6i) {
                                value = 14f;
                            } else {
                                let _e94 = index;
                                if (_e94 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e96 = index;
                                    if (_e96 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e98 = index;
                                        if (_e98 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e100 = index;
                                            if (_e100 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e102 = index;
                                                if (_e102 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e104 = index;
                                                    if (_e104 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e106 = index;
                                                        if (_e106 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e108 = index;
                                                            if (_e108 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e110 = value;
    return (_e110 / 16f);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e59 = (*rows);
    if (_e59 > 0f) {
        let _e62 = gl_FragCoord_1[0u];
        let _e63 = (*rows);
        let _e65 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e62, (_e63 - _e65));
    } else {
        let _e68 = gl_FragCoord_1;
        local = _e68.xy;
    }
    let _e70 = local;
    return _e70;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param: f32;

    let _e60 = frag_coord_info.origin[0u];
    param = _e60;
    let _e61 = FragCoordFromTop_u0028_f1_u003b((&param));
    return _e61;
}

fn CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b(depth: ptr<function, f32>, lens: ptr<function, vec4<f32>>, params: ptr<function, vec4<f32>>) -> f32 {
    var focus: f32;
    var focal: f32;
    var fnumber: f32;
    var denominator: f32;
    var ratio: f32;
    var local_1: f32;
    var diameter: f32;

    let _e68 = (*lens)[0u];
    focus = max(_e68, 0.001f);
    let _e71 = (*lens)[1u];
    focal = max(_e71, 0.0001f);
    let _e74 = (*lens)[2u];
    fnumber = max(_e74, 0.001f);
    let _e76 = fnumber;
    let _e77 = focus;
    let _e78 = focal;
    denominator = max((_e76 * (_e77 - _e78)), 0.000001f);
    let _e82 = (*depth);
    if (_e82 <= 0f) {
        local_1 = 1f;
    } else {
        let _e84 = (*depth);
        let _e85 = focus;
        let _e88 = (*depth);
        local_1 = (abs((_e84 - _e85)) / _e88);
    }
    let _e90 = local_1;
    ratio = _e90;
    let _e91 = ratio;
    let _e92 = focal;
    let _e93 = focal;
    let _e96 = denominator;
    diameter = ((_e91 * (_e92 * _e93)) / _e96);
    let _e98 = diameter;
    let _e101 = (*params)[3u];
    let _e104 = (*params)[2u];
    return min(((_e98 * 0.5f) * _e101), max(_e104, 0f));
}

fn CircleAt_u0028_f1_u003b(depth_1: ptr<function, f32>) -> f32 {
    var param_1: f32;
    var param_2: vec4<f32>;
    var param_3: vec4<f32>;

    let _e61 = (*depth_1);
    param_1 = _e61;
    let _e63 = dof_info.lens;
    param_2 = _e63;
    let _e65 = dof_info.params;
    param_3 = _e65;
    let _e66 = CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b((&param_1), (&param_2), (&param_3));
    return _e66;
}

fn main_1() {
    var centre: vec4<f32>;
    var samples: i32;
    var centreDepth: f32;
    var radius: f32;
    var param_4: f32;
    var gather: f32;
    var total: vec3<f32>;
    var weight: f32;
    var nearTotal: vec3<f32>;
    var nearWeight: f32;
    var nearCover: f32;
    var centreFar: f32;
    var turn: f32;
    var param_5: vec2<f32>;
    var i: i32;
    var t: f32;
    var r: f32;
    var angle: f32;
    var at_1: vec2<f32>;
    var tap: vec4<f32>;
    var tapDepth: f32;
    var tapRadius: f32;
    var param_6: f32;
    var tapFar: f32;
    var tapReach: f32;
    var local_2: f32;
    var reach: f32;
    var spread: f32;
    var far: vec3<f32>;
    var near: vec3<f32>;
    var cover: f32;

    let _e88 = v_uv_1;
    let _e89 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e88, 0f);
    centre = _e89;
    let _e92 = dof_info.lens[3u];
    samples = i32((_e92 + 0.5f));
    let _e95 = samples;
    if (_e95 < 1i) {
        let _e97 = centre;
        frag_color = _e97;
        return;
    }
    let _e98 = v_uv_1;
    let _e99 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e98, 0f);
    centreDepth = _e99.w;
    let _e101 = centreDepth;
    param_4 = _e101;
    let _e102 = CircleAt_u0028_f1_u003b((&param_4));
    radius = _e102;
    let _e103 = v_uv_1;
    let _e104 = textureSampleLevel(coc_tile_texture_tex, coc_tile_texture_smp, _e103, 0f);
    let _e106 = radius;
    gather = max(_e104.x, _e106);
    let _e108 = gather;
    if (_e108 < 0.5f) {
        let _e110 = centre;
        frag_color = _e110;
        return;
    }
    let _e111 = centre;
    total = _e111.xyz;
    weight = 1f;
    nearTotal = vec3<f32>(0f, 0f, 0f);
    nearWeight = 0f;
    nearCover = 0f;
    let _e113 = centreDepth;
    let _e115 = centreDepth;
    centreFar = select(_e115, 1000000000f, (_e113 <= 0f));
    let _e117 = TargetFragCoord_u0028_();
    param_5 = _e117;
    let _e118 = BayerCell_u0028_vf2_u003b((&param_5));
    turn = (6.2831855f * _e118);
    i = 1i;
    loop {
        let _e120 = i;
        if (_e120 <= 64i) {
            let _e122 = i;
            let _e123 = samples;
            if (_e122 > _e123) {
                break;
            }
            let _e125 = i;
            let _e128 = samples;
            t = ((f32(_e125) - 0.5f) / f32(_e128));
            let _e131 = t;
            let _e133 = gather;
            r = (sqrt(_e131) * _e133);
            let _e135 = i;
            let _e138 = turn;
            angle = ((f32(_e135) * 2.3999631f) + _e138);
            let _e140 = v_uv_1;
            let _e141 = angle;
            let _e143 = angle;
            let _e146 = r;
            let _e149 = dof_info.params;
            at_1 = (_e140 + ((vec2<f32>(cos(_e141), sin(_e143)) * _e146) * _e149.xy));
            let _e153 = at_1;
            let _e154 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e153, 0f);
            tap = _e154;
            let _e155 = at_1;
            let _e156 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e155, 0f);
            tapDepth = _e156.w;
            let _e158 = tapDepth;
            param_6 = _e158;
            let _e159 = CircleAt_u0028_f1_u003b((&param_6));
            tapRadius = _e159;
            let _e160 = tapDepth;
            let _e162 = tapDepth;
            tapFar = select(_e162, 1000000000f, (_e160 <= 0f));
            let _e164 = tapFar;
            let _e165 = centreFar;
            if (_e164 > _e165) {
                let _e167 = tapRadius;
                let _e168 = radius;
                local_2 = min(_e167, _e168);
            } else {
                let _e170 = tapRadius;
                local_2 = _e170;
            }
            let _e171 = local_2;
            tapReach = _e171;
            let _e172 = tapReach;
            let _e173 = r;
            reach = clamp(((_e172 - _e173) + 0.5f), 0f, 1f);
            let _e177 = tapFar;
            let _e178 = centreFar;
            let _e180 = tapRadius;
            let _e181 = radius;
            if ((_e177 < _e178) && (_e180 > _e181)) {
                let _e184 = gather;
                let _e185 = tapRadius;
                spread = (_e184 / max(_e185, 0.5f));
                let _e188 = tap;
                let _e190 = reach;
                let _e192 = nearTotal;
                nearTotal = (_e192 + (_e188.xyz * _e190));
                let _e194 = reach;
                let _e195 = nearWeight;
                nearWeight = (_e195 + _e194);
                let _e197 = reach;
                let _e198 = spread;
                let _e200 = spread;
                let _e202 = nearCover;
                nearCover = (_e202 + ((_e197 * _e198) * _e200));
            } else {
                let _e204 = tap;
                let _e206 = reach;
                let _e208 = total;
                total = (_e208 + (_e204.xyz * _e206));
                let _e210 = reach;
                let _e211 = weight;
                weight = (_e211 + _e210);
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e213 = i;
            i = (_e213 + 1i);
        }
    }
    let _e215 = total;
    let _e216 = weight;
    far = (_e215 / vec3(_e216));
    let _e219 = nearTotal;
    let _e220 = nearWeight;
    near = (_e219 / vec3(max(_e220, 0.00001f)));
    let _e224 = nearCover;
    let _e225 = samples;
    cover = clamp((_e224 / f32(_e225)), 0f, 1f);
    let _e229 = far;
    let _e230 = near;
    let _e231 = cover;
    let _e233 = mix(_e229, _e230, vec3(_e231));
    let _e235 = centre[3u];
    frag_color = vec4<f32>(_e233.x, _e233.y, _e233.z, _e235);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'DofInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'lens', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'coc_tile_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'DofTileMax': WebGpuStage(
      wgsl: r'''
struct DofTileInfo {
    lens: vec4<f32>,
    params: vec4<f32>,
    source: vec4<f32>,
    target_: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> dof_tile_info: DofTileInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b(depth: ptr<function, f32>, lens: ptr<function, vec4<f32>>, params: ptr<function, vec4<f32>>) -> f32 {
    var focus: f32;
    var focal: f32;
    var fnumber: f32;
    var denominator: f32;
    var ratio: f32;
    var local: f32;
    var diameter: f32;

    let _e31 = (*lens)[0u];
    focus = max(_e31, 0.001f);
    let _e34 = (*lens)[1u];
    focal = max(_e34, 0.0001f);
    let _e37 = (*lens)[2u];
    fnumber = max(_e37, 0.001f);
    let _e39 = fnumber;
    let _e40 = focus;
    let _e41 = focal;
    denominator = max((_e39 * (_e40 - _e41)), 0.000001f);
    let _e45 = (*depth);
    if (_e45 <= 0f) {
        local = 1f;
    } else {
        let _e47 = (*depth);
        let _e48 = focus;
        let _e51 = (*depth);
        local = (abs((_e47 - _e48)) / _e51);
    }
    let _e53 = local;
    ratio = _e53;
    let _e54 = ratio;
    let _e55 = focal;
    let _e56 = focal;
    let _e59 = denominator;
    diameter = ((_e54 * (_e55 * _e56)) / _e59);
    let _e61 = diameter;
    let _e64 = (*params)[3u];
    let _e67 = (*params)[2u];
    return min(((_e61 * 0.5f) * _e64), max(_e67, 0f));
}

fn main_1() {
    var taps: i32;
    var texel: vec2<f32>;
    var row: f32;
    var first: f32;
    var largest: f32;
    var i: i32;
    var at: vec2<f32>;
    var depth_1: f32;
    var param: f32;
    var param_1: vec4<f32>;
    var param_2: vec4<f32>;

    let _e33 = dof_tile_info.source[2u];
    taps = i32((_e33 + 0.5f));
    let _e36 = v_uv_1;
    let _e38 = dof_tile_info.target_;
    texel = floor((_e36 * _e38.xy));
    let _e43 = texel[1u];
    let _e47 = dof_tile_info.source[1u];
    row = ((_e43 + 0.5f) * _e47);
    let _e50 = texel[0u];
    let _e51 = taps;
    first = (_e50 * f32(_e51));
    largest = 0f;
    i = 0i;
    loop {
        let _e54 = i;
        if (_e54 < 64i) {
            let _e56 = i;
            let _e57 = taps;
            if (_e56 >= _e57) {
                break;
            }
            let _e59 = first;
            let _e60 = i;
            let _e66 = dof_tile_info.source[0u];
            let _e68 = row;
            at = vec2<f32>((((_e59 + f32(_e60)) + 0.5f) * _e66), _e68);
            let _e70 = at;
            let _e71 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e70, 0f);
            depth_1 = _e71.w;
            let _e73 = largest;
            let _e74 = depth_1;
            param = _e74;
            let _e76 = dof_tile_info.lens;
            param_1 = _e76;
            let _e78 = dof_tile_info.params;
            param_2 = _e78;
            let _e79 = CircleOfConfusion_u0028_f1_u003b_vf4_u003b_vf4_u003b((&param), (&param_1), (&param_2));
            largest = max(_e73, _e79);
            continue;
        } else {
            break;
        }
        continuing {
            let _e81 = i;
            i = (_e81 + 1i);
        }
    }
    let _e83 = largest;
    frag_color = vec4<f32>(_e83, 0f, 0f, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'DofTileInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'lens', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'source',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VelocityTileMax': WebGpuStage(
      wgsl: r'''
struct TileMaxInfo {
    source: vec4<f32>,
    params: vec4<f32>,
    target_: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> tile_info: TileMaxInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var velocity_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn HalfMotion_u0028_vf2_u003b(motion: ptr<function, vec2<f32>>) -> vec2<f32> {
    var pixels: vec2<f32>;
    var span: f32;
    var most: f32;
    var local: vec2<f32>;

    let _e21 = (*motion);
    let _e23 = tile_info.params;
    pixels = (_e21 * _e23.xy);
    let _e26 = pixels;
    span = length(_e26);
    let _e30 = tile_info.params[2u];
    most = max(_e30, 0f);
    let _e32 = span;
    let _e33 = most;
    if (_e32 > _e33) {
        let _e35 = pixels;
        let _e36 = most;
        let _e37 = span;
        local = (_e35 * (_e36 / _e37));
    } else {
        let _e40 = pixels;
        local = _e40;
    }
    let _e41 = local;
    return _e41;
}

fn main_1() {
    var walk: vec2<f32>;
    var tile: vec2<f32>;
    var taps: i32;
    var start: vec2<f32>;
    var longest: vec2<f32>;
    var longestSpan: f32;
    var i: i32;
    var at: vec2<f32>;
    var motion_1: vec2<f32>;
    var param: vec2<f32>;
    var span_1: f32;

    let _e28 = tile_info.source;
    walk = _e28.zw;
    let _e30 = v_uv_1;
    let _e32 = tile_info.target_;
    tile = floor((_e30 * _e32.xy));
    let _e38 = tile_info.params[3u];
    taps = i32((_e38 + 0.5f));
    let _e41 = tile;
    let _e42 = taps;
    let _e45 = walk;
    start = (_e41 * mix(vec2<f32>(1f, 1f), vec2(f32(_e42)), _e45));
    longest = vec2<f32>(0f, 0f);
    longestSpan = 0f;
    i = 0i;
    loop {
        let _e48 = i;
        if (_e48 < 64i) {
            let _e50 = i;
            let _e51 = taps;
            if (_e50 >= _e51) {
                break;
            }
            let _e53 = start;
            let _e54 = walk;
            let _e55 = i;
            let _e62 = tile_info.source;
            at = (((_e53 + (_e54 * f32(_e55))) + vec2(0.5f)) * _e62.xy);
            let _e65 = at;
            let _e66 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e65, 0f);
            param = _e66.xy;
            let _e68 = HalfMotion_u0028_vf2_u003b((&param));
            motion_1 = _e68;
            let _e69 = motion_1;
            let _e70 = motion_1;
            span_1 = dot(_e69, _e70);
            let _e72 = span_1;
            let _e73 = longestSpan;
            if (_e72 > _e73) {
                let _e75 = motion_1;
                longest = _e75;
                let _e76 = span_1;
                longestSpan = _e76;
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e77 = i;
            i = (_e77 + 1i);
        }
    }
    let _e79 = longest;
    frag_color = vec4<f32>(_e79.x, _e79.y, 0f, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'TileMaxInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'source',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'velocity_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VelocityNeighborMax': WebGpuStage(
      wgsl: r'''
struct NeighborMaxInfo {
    texel: vec4<f32>,
}

var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> neighbor_info: NeighborMaxInfo;
@group(1) @binding(1)
var tile_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var tile_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var longest: vec2<f32>;
    var longestSpan: f32;
    var dy: i32;
    var dx: i32;
    var at: vec2<f32>;
    var motion: vec2<f32>;
    var span: f32;

    longest = vec2<f32>(0f, 0f);
    longestSpan = 0f;
    dy = -1i;
    loop {
        let _e18 = dy;
        if (_e18 <= 1i) {
            dx = -1i;
            loop {
                let _e20 = dx;
                if (_e20 <= 1i) {
                    let _e22 = v_uv_1;
                    let _e23 = dx;
                    let _e25 = dy;
                    let _e29 = neighbor_info.texel;
                    at = (_e22 + (vec2<f32>(f32(_e23), f32(_e25)) * _e29.xy));
                    let _e33 = at;
                    let _e34 = textureSampleLevel(tile_texture_tex, tile_texture_smp, _e33, 0f);
                    motion = _e34.xy;
                    let _e36 = motion;
                    let _e37 = motion;
                    span = dot(_e36, _e37);
                    let _e39 = span;
                    let _e40 = longestSpan;
                    if (_e39 > _e40) {
                        let _e42 = motion;
                        longest = _e42;
                        let _e43 = span;
                        longestSpan = _e43;
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e44 = dx;
                    dx = (_e44 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e46 = dy;
            dy = (_e46 + 1i);
        }
    }
    let _e48 = longest;
    frag_color = vec4<f32>(_e48.x, _e48.y, 0f, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'NeighborMaxInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'texel', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'tile_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'MotionBlur': WebGpuStage(
      wgsl: r'''
struct FragCoordInfo {
    origin: vec4<f32>,
}

struct NoiseInfo {
    noise: vec4<f32>,
}

struct MotionBlurInfo {
    scene: vec4<f32>,
    params: vec4<f32>,
    tiles: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> frag_coord_info: FragCoordInfo;
@group(1) @binding(2)
var<uniform> noise_info: NoiseInfo;
@group(1) @binding(3)
var blue_noise_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var blue_noise_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> blur_info: MotionBlurInfo;
@group(1) @binding(7)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(8)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(5)
var neighbor_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var neighbor_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(11)
var velocity_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var velocity_texture_smp: sampler;
@group(1) @binding(9)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(10)
var surface_texture_smp: sampler;

fn Reaches_u0028_f1_u003b_f1_u003b(gap: ptr<function, f32>, span: ptr<function, f32>) -> f32 {
    let _e65 = (*span);
    let _e67 = (*span);
    let _e69 = (*gap);
    return (1f - smoothstep((_e65 - 0.5f), (_e67 + 0.5f), _e69));
}

fn BayerCell_u0028_vf2_u003b(at: ptr<function, vec2<f32>>) -> f32 {
    var x: i32;
    var y: i32;
    var index: i32;
    var value: f32;

    let _e69 = (*at)[0u];
    x = i32((_e69 - (floor((_e69 / 4f)) * 4f)));
    let _e76 = (*at)[1u];
    y = i32((_e76 - (floor((_e76 / 4f)) * 4f)));
    let _e82 = y;
    let _e84 = x;
    index = ((_e82 * 4i) + _e84);
    value = 0f;
    let _e86 = index;
    if (_e86 == 0i) {
        value = 0f;
    } else {
        let _e88 = index;
        if (_e88 == 1i) {
            value = 8f;
        } else {
            let _e90 = index;
            if (_e90 == 2i) {
                value = 2f;
            } else {
                let _e92 = index;
                if (_e92 == 3i) {
                    value = 10f;
                } else {
                    let _e94 = index;
                    if (_e94 == 4i) {
                        value = 12f;
                    } else {
                        let _e96 = index;
                        if (_e96 == 5i) {
                            value = 4f;
                        } else {
                            let _e98 = index;
                            if (_e98 == 6i) {
                                value = 14f;
                            } else {
                                let _e100 = index;
                                if (_e100 == 7i) {
                                    value = 6f;
                                } else {
                                    let _e102 = index;
                                    if (_e102 == 8i) {
                                        value = 3f;
                                    } else {
                                        let _e104 = index;
                                        if (_e104 == 9i) {
                                            value = 11f;
                                        } else {
                                            let _e106 = index;
                                            if (_e106 == 10i) {
                                                value = 1f;
                                            } else {
                                                let _e108 = index;
                                                if (_e108 == 11i) {
                                                    value = 9f;
                                                } else {
                                                    let _e110 = index;
                                                    if (_e110 == 12i) {
                                                        value = 15f;
                                                    } else {
                                                        let _e112 = index;
                                                        if (_e112 == 13i) {
                                                            value = 7f;
                                                        } else {
                                                            let _e114 = index;
                                                            if (_e114 == 14i) {
                                                                value = 13f;
                                                            } else {
                                                                value = 5f;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e116 = value;
    return (_e116 / 16f);
}

fn BlueNoise_u0028_vf2_u003b(at_1: ptr<function, vec2<f32>>) -> f32 {
    var slice: f32;
    var cell: vec2<f32>;
    var corner: vec2<f32>;
    var uv: vec2<f32>;

    let _e70 = noise_info.noise[1u];
    slice = _e70;
    let _e71 = (*at_1);
    let _e72 = floor(_e71);
    let _e73 = vec2(64f);
    cell = (_e72 - (floor((_e72 / _e73)) * _e73));
    let _e78 = slice;
    let _e83 = slice;
    corner = (vec2<f32>((_e78 - (floor((_e78 / 8f)) * 8f)), floor((_e83 / 8f))) * 64f);
    let _e88 = corner;
    let _e89 = cell;
    uv = (((_e88 + _e89) + vec2(0.5f)) / vec2<f32>(512f, 256f));
    let _e94 = uv;
    let _e95 = textureSampleLevel(blue_noise_texture_tex, blue_noise_texture_smp, _e94, 0f);
    return (_e95.x * 0.99609375f);
}

fn PixelNoise_u0028_vf2_u003b(at_2: ptr<function, vec2<f32>>) -> f32 {
    var local: f32;
    var param: vec2<f32>;
    var param_1: vec2<f32>;

    let _e69 = noise_info.noise[0u];
    if (_e69 > 0.5f) {
        let _e71 = (*at_2);
        param = _e71;
        let _e72 = BlueNoise_u0028_vf2_u003b((&param));
        local = _e72;
    } else {
        let _e73 = (*at_2);
        param_1 = _e73;
        let _e74 = BayerCell_u0028_vf2_u003b((&param_1));
        local = _e74;
    }
    let _e75 = local;
    return _e75;
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_1: vec2<f32>;

    let _e65 = (*rows);
    if (_e65 > 0f) {
        let _e68 = gl_FragCoord_1[0u];
        let _e69 = (*rows);
        let _e71 = gl_FragCoord_1[1u];
        local_1 = vec2<f32>(_e68, (_e69 - _e71));
    } else {
        let _e74 = gl_FragCoord_1;
        local_1 = _e74.xy;
    }
    let _e76 = local_1;
    return _e76;
}

fn TargetFragCoord_u0028_() -> vec2<f32> {
    var param_2: f32;

    let _e66 = frag_coord_info.origin[0u];
    param_2 = _e66;
    let _e67 = FragCoordFromTop_u0028_f1_u003b((&param_2));
    return _e67;
}

fn Far_u0028_f1_u003b(depth: ptr<function, f32>) -> f32 {
    let _e64 = (*depth);
    let _e66 = (*depth);
    return select(_e66, 1000000000f, (_e64 <= 0f));
}

fn HalfMotion_u0028_vf2_u003b(motion: ptr<function, vec2<f32>>) -> vec2<f32> {
    var pixels: vec2<f32>;
    var span_1: f32;
    var most: f32;
    var local_2: vec2<f32>;

    let _e68 = (*motion);
    let _e70 = blur_info.params;
    pixels = (_e68 * _e70.xy);
    let _e73 = pixels;
    span_1 = length(_e73);
    let _e77 = blur_info.params[2u];
    most = max(_e77, 0f);
    let _e79 = span_1;
    let _e80 = most;
    if (_e79 > _e80) {
        let _e82 = pixels;
        let _e83 = most;
        let _e84 = span_1;
        local_2 = (_e82 * (_e83 / _e84));
    } else {
        let _e87 = pixels;
        local_2 = _e87;
    }
    let _e88 = local_2;
    return _e88;
}

fn main_1() {
    var centre: vec4<f32>;
    var here: vec2<f32>;
    var tile: vec2<f32>;
    var dominant: vec2<f32>;
    var reach: f32;
    var samples: i32;
    var ownSpan: f32;
    var param_3: vec2<f32>;
    var ownDepth: f32;
    var param_4: f32;
    var extent: f32;
    var stride: f32;
    var ownShare: f32;
    var front: vec3<f32>;
    var frontCover: f32;
    var level: vec3<f32>;
    var levelCover: f32;
    var back: vec3<f32>;
    var backWeight: f32;
    var jitter: f32;
    var param_5: vec2<f32>;
    var middle: i32;
    var i: i32;
    var t: f32;
    var there: vec2<f32>;
    var at_3: vec2<f32>;
    var gap_1: f32;
    var tap: vec3<f32>;
    var tapSpan: f32;
    var param_6: vec2<f32>;
    var tapDepth: f32;
    var param_7: f32;
    var nearer: f32;
    var behind: f32;
    var share: f32;
    var param_8: f32;
    var param_9: f32;
    var nearness: f32;
    var own: vec3<f32>;
    var behindColor: vec3<f32>;
    var local_3: vec3<f32>;
    var under: vec3<f32>;
    var over: vec3<f32>;
    var local_4: vec3<f32>;

    let _e107 = v_uv_1;
    let _e108 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e107, 0f);
    centre = _e108;
    let _e109 = v_uv_1;
    let _e111 = blur_info.scene;
    here = (_e109 * _e111.zw);
    let _e114 = here;
    let _e117 = blur_info.tiles[2u];
    tile = floor((_e114 / vec2(max(_e117, 1f))));
    let _e122 = tile;
    let _e126 = blur_info.tiles;
    let _e129 = textureSampleLevel(neighbor_texture_tex, neighbor_texture_smp, ((_e122 + vec2(0.5f)) / _e126.xy), 0f);
    dominant = _e129.xy;
    let _e131 = dominant;
    reach = length(_e131);
    let _e135 = blur_info.params[3u];
    samples = i32((_e135 + 0.5f));
    let _e138 = reach;
    let _e140 = samples;
    if ((_e138 <= 0.5f) || (_e140 < 1i)) {
        let _e143 = centre;
        frag_color = _e143;
        return;
    }
    let _e144 = v_uv_1;
    let _e145 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e144, 0f);
    param_3 = _e145.xy;
    let _e147 = HalfMotion_u0028_vf2_u003b((&param_3));
    ownSpan = max(length(_e147), 0.5f);
    let _e150 = v_uv_1;
    let _e151 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e150, 0f);
    param_4 = _e151.w;
    let _e153 = Far_u0028_f1_u003b((&param_4));
    ownDepth = _e153;
    let _e156 = blur_info.tiles[3u];
    extent = max(_e156, 0.0001f);
    let _e158 = reach;
    let _e160 = samples;
    stride = ((2f * _e158) / f32((_e160 + 1i)));
    let _e164 = stride;
    let _e166 = ownSpan;
    ownShare = min((max(_e164, 1f) / (2f * _e166)), 1f);
    front = vec3<f32>(0f, 0f, 0f);
    frontCover = 0f;
    let _e170 = centre;
    let _e172 = ownShare;
    level = (_e170.xyz * _e172);
    let _e174 = ownShare;
    levelCover = _e174;
    back = vec3<f32>(0f, 0f, 0f);
    backWeight = 0f;
    let _e175 = TargetFragCoord_u0028_();
    param_5 = _e175;
    let _e176 = PixelNoise_u0028_vf2_u003b((&param_5));
    jitter = (_e176 - 0.5f);
    let _e178 = samples;
    middle = ((_e178 - 1i) / 2i);
    i = 0i;
    loop {
        let _e181 = i;
        if (_e181 < 64i) {
            let _e183 = i;
            let _e184 = samples;
            if (_e183 >= _e184) {
                break;
            }
            let _e186 = i;
            let _e187 = middle;
            if (_e186 == _e187) {
                continue;
            }
            let _e189 = i;
            let _e191 = jitter;
            let _e194 = samples;
            t = mix(-1f, 1f, (((f32(_e189) + _e191) + 1f) / f32((_e194 + 1i))));
            let _e199 = here;
            let _e200 = dominant;
            let _e201 = t;
            there = (floor((_e199 + (_e200 * _e201))) + vec2(0.5f));
            let _e207 = there;
            let _e209 = blur_info.scene;
            at_3 = (_e207 * _e209.xy);
            let _e212 = there;
            let _e213 = here;
            gap_1 = length((_e212 - _e213));
            let _e216 = at_3;
            let _e217 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e216, 0f);
            tap = _e217.xyz;
            let _e219 = at_3;
            let _e220 = textureSampleLevel(velocity_texture_tex, velocity_texture_smp, _e219, 0f);
            param_6 = _e220.xy;
            let _e222 = HalfMotion_u0028_vf2_u003b((&param_6));
            tapSpan = max(length(_e222), 0.5f);
            let _e225 = at_3;
            let _e226 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e225, 0f);
            param_7 = _e226.w;
            let _e228 = Far_u0028_f1_u003b((&param_7));
            tapDepth = _e228;
            let _e229 = ownDepth;
            let _e230 = tapDepth;
            let _e232 = extent;
            nearer = clamp(((_e229 - _e230) / _e232), 0f, 1f);
            let _e235 = tapDepth;
            let _e236 = ownDepth;
            let _e238 = extent;
            behind = clamp(((_e235 - _e236) / _e238), 0f, 1f);
            let _e241 = gap_1;
            param_8 = _e241;
            let _e242 = tapSpan;
            param_9 = _e242;
            let _e243 = Reaches_u0028_f1_u003b_f1_u003b((&param_8), (&param_9));
            let _e244 = stride;
            let _e245 = tapSpan;
            share = (_e243 * min((_e244 / (2f * _e245)), 1f));
            let _e250 = tap;
            let _e251 = nearer;
            let _e252 = share;
            let _e255 = front;
            front = (_e255 + (_e250 * (_e251 * _e252)));
            let _e257 = nearer;
            let _e258 = share;
            let _e260 = frontCover;
            frontCover = (_e260 + (_e257 * _e258));
            let _e262 = tap;
            let _e263 = nearer;
            let _e265 = behind;
            let _e267 = share;
            let _e270 = level;
            level = (_e270 + (_e262 * (((1f - _e263) - _e265) * _e267)));
            let _e272 = nearer;
            let _e274 = behind;
            let _e276 = share;
            let _e278 = levelCover;
            levelCover = (_e278 + (((1f - _e272) - _e274) * _e276));
            let _e280 = behind;
            let _e281 = gap_1;
            let _e282 = gap_1;
            nearness = (_e280 / max((_e281 * _e282), 1f));
            let _e286 = tap;
            let _e287 = nearness;
            let _e289 = back;
            back = (_e289 + (_e286 * _e287));
            let _e291 = nearness;
            let _e292 = backWeight;
            backWeight = (_e292 + _e291);
            continue;
        } else {
            break;
        }
        continuing {
            let _e294 = i;
            i = (_e294 + 1i);
        }
    }
    let _e296 = level;
    let _e297 = levelCover;
    own = (_e296 / vec3(_e297));
    let _e300 = backWeight;
    if (_e300 > 0f) {
        let _e302 = back;
        let _e303 = backWeight;
        local_3 = (_e302 / vec3(_e303));
    } else {
        let _e306 = own;
        local_3 = _e306;
    }
    let _e307 = local_3;
    behindColor = _e307;
    let _e308 = behindColor;
    let _e309 = own;
    let _e310 = levelCover;
    under = mix(_e308, _e309, vec3(min(_e310, 1f)));
    let _e314 = frontCover;
    if (_e314 > 0f) {
        let _e316 = front;
        let _e317 = frontCover;
        local_4 = (_e316 / vec3(_e317));
    } else {
        let _e320 = under;
        local_4 = _e320;
    }
    let _e321 = local_4;
    over = _e321;
    let _e322 = under;
    let _e323 = over;
    let _e324 = frontCover;
    let _e327 = mix(_e322, _e323, vec3(min(_e324, 1f)));
    let _e329 = centre[3u];
    frag_color = vec4<f32>(_e327.x, _e327.y, _e327.z, _e329);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_uv_1 = v_uv;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FragCoordInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'origin',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'MotionBlurInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'scene', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'NoiseInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'noise', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'blue_noise_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'neighbor_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'velocity_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ViewportShade': WebGpuStage(
      wgsl: r'''
struct ShadeInfo {
    params: vec4<f32>,
    screen: vec4<f32>,
    light: vec4<f32>,
}

@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> shade_info: ShadeInfo;
var<private> frag_color: vec4<f32>;
@group(1) @binding(3)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var surface_texture_smp: sampler;

fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
    var n: vec3<f32>;
    var t: f32;
    var local: f32;
    var local_1: f32;

    let _e27 = (*e);
    (*e) = ((_e27 * 2f) - vec2(1f));
    let _e31 = (*e);
    let _e33 = (*e)[0u];
    let _e37 = (*e)[1u];
    n = vec3<f32>(_e31.x, _e31.y, ((1f - abs(_e33)) - abs(_e37)));
    let _e44 = n[2u];
    t = max(-(_e44), 0f);
    let _e48 = n[0u];
    if (_e48 >= 0f) {
        let _e50 = t;
        local = -(_e50);
    } else {
        let _e52 = t;
        local = _e52;
    }
    let _e53 = local;
    let _e55 = n[0u];
    n[0u] = (_e55 + _e53);
    let _e59 = n[1u];
    if (_e59 >= 0f) {
        let _e61 = t;
        local_1 = -(_e61);
    } else {
        let _e63 = t;
        local_1 = _e63;
    }
    let _e64 = local_1;
    let _e66 = n[1u];
    n[1u] = (_e66 + _e64);
    let _e69 = n;
    return normalize(_e69);
}

fn main_1() {
    var scene: vec4<f32>;
    var mode: i32;
    var mix_amount: f32;
    var surface: vec4<f32>;
    var depth: f32;
    var normal: vec3<f32>;
    var param: vec2<f32>;
    var shaded: vec3<f32>;
    var ambient: f32;
    var lambert: f32;
    var texel: vec2<f32>;
    var depthEdge: f32;
    var normalEdge: f32;
    var offsets: array<vec2<f32>, 4>;
    var i: i32;
    var tap: vec4<f32>;
    var param_1: vec2<f32>;
    var depthHit: f32;
    var normalHit: f32;
    var edge: f32;
    var texel_1: vec2<f32>;
    var right: vec3<f32>;
    var param_2: vec2<f32>;
    var left: vec3<f32>;
    var param_3: vec2<f32>;
    var down: vec3<f32>;
    var param_4: vec2<f32>;
    var up: vec3<f32>;
    var param_5: vec2<f32>;
    var curvature: f32;
    var cavity: f32;
    var ridge: f32;

    let _e54 = v_uv_1;
    let _e55 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e54, 0f);
    scene = _e55;
    let _e58 = shade_info.params[0u];
    mode = i32((_e58 + 0.5f));
    let _e63 = shade_info.params[1u];
    mix_amount = clamp(_e63, 0f, 1f);
    let _e65 = mode;
    let _e67 = mix_amount;
    if ((_e65 < 1i) || (_e67 <= 0f)) {
        let _e70 = scene;
        frag_color = _e70;
        return;
    }
    let _e71 = v_uv_1;
    let _e72 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e71, 0f);
    surface = _e72;
    let _e74 = surface[3u];
    depth = _e74;
    let _e75 = depth;
    if (_e75 <= 0f) {
        let _e77 = scene;
        frag_color = _e77;
        return;
    }
    let _e78 = surface;
    param = _e78.xy;
    let _e80 = DecodeOctahedral_u0028_vf2_u003b((&param));
    normal = _e80;
    let _e81 = scene;
    shaded = _e81.xyz;
    let _e83 = mode;
    if (_e83 == 1i) {
        let _e85 = normal;
        shaded = ((_e85 * 0.5f) + vec3(0.5f));
    } else {
        let _e89 = mode;
        if (_e89 == 2i) {
            let _e93 = shade_info.params[2u];
            ambient = clamp(_e93, 0f, 1f);
            let _e95 = normal;
            let _e97 = shade_info.light;
            lambert = max(dot(_e95, normalize(_e97.xyz)), 0f);
            let _e102 = ambient;
            let _e103 = ambient;
            let _e105 = lambert;
            shaded = vec3((_e102 + ((1f - _e103) * _e105)));
        } else {
            let _e109 = mode;
            if (_e109 == 3i) {
                let _e112 = shade_info.screen;
                let _e116 = shade_info.screen[2u];
                texel = (_e112.xy * max(_e116, 1f));
                depthEdge = 0f;
                normalEdge = 0f;
                let _e120 = texel[0u];
                let _e123 = texel[0u];
                let _e127 = texel[1u];
                let _e130 = texel[1u];
                offsets = array<vec2<f32>, 4>(vec2<f32>(_e120, 0f), vec2<f32>(-(_e123), 0f), vec2<f32>(0f, _e127), vec2<f32>(0f, -(_e130)));
                i = 0i;
                loop {
                    let _e134 = i;
                    if (_e134 < 4i) {
                        let _e136 = v_uv_1;
                        let _e137 = i;
                        let _e139 = offsets[_e137];
                        let _e141 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e136 + _e139), 0f);
                        tap = _e141;
                        let _e143 = tap[3u];
                        if (_e143 <= 0f) {
                            depthEdge = 1f;
                            continue;
                        }
                        let _e145 = depthEdge;
                        let _e147 = tap[3u];
                        let _e148 = depth;
                        depthEdge = max(_e145, abs((_e147 - _e148)));
                        let _e152 = normalEdge;
                        let _e153 = tap;
                        param_1 = _e153.xy;
                        let _e155 = DecodeOctahedral_u0028_vf2_u003b((&param_1));
                        let _e156 = normal;
                        normalEdge = max(_e152, (1f - dot(_e155, _e156)));
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e160 = i;
                        i = (_e160 + 1i);
                    }
                }
                let _e164 = shade_info.params[2u];
                let _e166 = depthEdge;
                depthHit = step(max(_e164, 0.0001f), _e166);
                let _e170 = shade_info.params[3u];
                let _e172 = normalEdge;
                normalHit = step(max(_e170, 0.0001f), _e172);
                let _e174 = depthHit;
                let _e175 = normalHit;
                edge = max(_e174, _e175);
                let _e177 = scene;
                let _e179 = edge;
                shaded = (_e177.xyz * (1f - _e179));
            } else {
                let _e182 = mode;
                if (_e182 == 4i) {
                    let _e185 = shade_info.screen;
                    texel_1 = _e185.xy;
                    let _e187 = v_uv_1;
                    let _e189 = texel_1[0u];
                    let _e192 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e187 + vec2<f32>(_e189, 0f)), 0f);
                    param_2 = _e192.xy;
                    let _e194 = DecodeOctahedral_u0028_vf2_u003b((&param_2));
                    right = _e194;
                    let _e195 = v_uv_1;
                    let _e197 = texel_1[0u];
                    let _e200 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e195 - vec2<f32>(_e197, 0f)), 0f);
                    param_3 = _e200.xy;
                    let _e202 = DecodeOctahedral_u0028_vf2_u003b((&param_3));
                    left = _e202;
                    let _e203 = v_uv_1;
                    let _e205 = texel_1[1u];
                    let _e208 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e203 + vec2<f32>(0f, _e205)), 0f);
                    param_4 = _e208.xy;
                    let _e210 = DecodeOctahedral_u0028_vf2_u003b((&param_4));
                    down = _e210;
                    let _e211 = v_uv_1;
                    let _e213 = texel_1[1u];
                    let _e216 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e211 - vec2<f32>(0f, _e213)), 0f);
                    param_5 = _e216.xy;
                    let _e218 = DecodeOctahedral_u0028_vf2_u003b((&param_5));
                    up = _e218;
                    let _e220 = right[0u];
                    let _e222 = left[0u];
                    let _e225 = down[1u];
                    let _e227 = up[1u];
                    let _e232 = shade_info.params[2u];
                    curvature = (((_e220 - _e222) + (_e225 - _e227)) * max(_e232, 0f));
                    let _e235 = curvature;
                    let _e240 = shade_info.params[3u];
                    cavity = (clamp(-(_e235), 0f, 1f) * clamp(_e240, 0f, 1f));
                    let _e243 = curvature;
                    ridge = clamp(_e243, 0f, 1f);
                    let _e245 = ridge;
                    let _e248 = cavity;
                    shaded = vec3(clamp(((0.5f + (_e245 * 0.5f)) - _e248), 0f, 1f));
                }
            }
        }
    }
    let _e252 = scene;
    let _e254 = shaded;
    let _e255 = mix_amount;
    let _e257 = mix(_e252.xyz, _e254, vec3(_e255));
    let _e259 = scene[3u];
    frag_color = vec4<f32>(_e257.x, _e257.y, _e257.z, _e259);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ShadeInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'screen',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'light',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'OutlineMask': WebGpuStage(
      wgsl: r'''
struct OutlineMaskInfo {
    target_: vec4<f32>,
    color: vec4<f32>,
}

var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(0)
var<uniform> mask_info: OutlineMaskInfo;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> v_depth_1: f32;
var<private> frag_color: vec4<f32>;
var<private> v_current_1: vec4<f32>;
var<private> v_previous_1: vec4<f32>;

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local: vec2<f32>;

    let _e19 = (*rows);
    if (_e19 > 0f) {
        let _e22 = gl_FragCoord_1[0u];
        let _e23 = (*rows);
        let _e25 = gl_FragCoord_1[1u];
        local = vec2<f32>(_e22, (_e23 - _e25));
    } else {
        let _e28 = gl_FragCoord_1;
        local = _e28.xy;
    }
    let _e30 = local;
    return _e30;
}

fn main_1() {
    var uv: vec2<f32>;
    var param: f32;
    var stored: f32;
    var hidden: bool;
    var phi_90_: bool;

    let _e23 = mask_info.target_[2u];
    param = _e23;
    let _e24 = FragCoordFromTop_u0028_f1_u003b((&param));
    let _e26 = mask_info.target_;
    uv = (_e24 * _e26.xy);
    let _e29 = uv;
    let _e30 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e29, 0f);
    stored = _e30.w;
    let _e32 = stored;
    let _e33 = (_e32 > 0f);
    phi_90_ = _e33;
    if _e33 {
        let _e34 = v_depth_1;
        let _e35 = stored;
        let _e38 = mask_info.target_[3u];
        phi_90_ = (_e34 > ((_e35 * (1f + _e38)) + 0.001f));
    }
    let _e44 = phi_90_;
    hidden = _e44;
    let _e45 = hidden;
    if _e45 {
        discard;
    }
    let _e47 = mask_info.color;
    let _e48 = _e47.xyz;
    frag_color = vec4<f32>(_e48.x, _e48.y, _e48.z, 1f);
    return;
}

@fragment
fn main(@builtin(position) gl_FragCoord: vec4<f32>, @location(1) v_depth: f32, @location(0) v_current: vec4<f32>, @location(2) v_previous: vec4<f32>) -> @location(0) vec4<f32> {
    gl_FragCoord_1 = gl_FragCoord;
    v_depth_1 = v_depth;
    v_current_1 = v_current;
    v_previous_1 = v_previous;
    main_1();
    let _e9 = frag_color;
    return _e9;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'OutlineMaskInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'target',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'color',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'HighContrast': WebGpuStage(
      wgsl: r'''
struct HighContrastInfo {
    look: vec4<f32>,
    edges: vec4<f32>,
    line: vec4<f32>,
    screen: vec4<f32>,
}

@group(1) @binding(3)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(4)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> contrast_info: HighContrastInfo;
@group(1) @binding(5)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var surface_texture_smp: sampler;
@group(1) @binding(1)
var mask_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var mask_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn DepthBend_u0028_f1_u003b_f1_u003b_f1_u003b(a: ptr<function, f32>, centre: ptr<function, f32>, b: ptr<function, f32>) -> f32 {
    let _e48 = (*a);
    let _e50 = (*b);
    if ((_e48 <= 0f) || (_e50 <= 0f)) {
        return 1000000f;
    }
    let _e53 = (*a);
    let _e54 = (*b);
    let _e56 = (*centre);
    let _e60 = (*centre);
    return (abs(((_e53 + _e54) - (2f * _e56))) / _e60);
}

fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
    var n: vec3<f32>;
    var t: f32;
    var local: f32;
    var local_1: f32;

    let _e50 = (*e);
    (*e) = ((_e50 * 2f) - vec2(1f));
    let _e54 = (*e);
    let _e56 = (*e)[0u];
    let _e60 = (*e)[1u];
    n = vec3<f32>(_e54.x, _e54.y, ((1f - abs(_e56)) - abs(_e60)));
    let _e67 = n[2u];
    t = max(-(_e67), 0f);
    let _e71 = n[0u];
    if (_e71 >= 0f) {
        let _e73 = t;
        local = -(_e73);
    } else {
        let _e75 = t;
        local = _e75;
    }
    let _e76 = local;
    let _e78 = n[0u];
    n[0u] = (_e78 + _e76);
    let _e82 = n[1u];
    if (_e82 >= 0f) {
        let _e84 = t;
        local_1 = -(_e84);
    } else {
        let _e86 = t;
        local_1 = _e86;
    }
    let _e87 = local_1;
    let _e89 = n[1u];
    n[1u] = (_e89 + _e87);
    let _e92 = n;
    return normalize(_e92);
}

fn main_1() {
    var scene: vec4<f32>;
    var colour: vec3<f32>;
    var texel: vec2<f32>;
    var hasSurface: bool;
    var hasMask: bool;
    var surface: vec4<f32>;
    var depth: f32;
    var normal: vec3<f32>;
    var local_2: vec3<f32>;
    var param: vec2<f32>;
    var bend: f32;
    var turn: f32;
    var flatten: f32;
    var spacing: vec2<f32>;
    var sum: vec3<f32>;
    var count: f32;
    var y: i32;
    var x: i32;
    var uv: vec2<f32>;
    var tap: vec4<f32>;
    var ring: f32;
    var same: bool;
    var param_1: vec2<f32>;
    var luma: f32;
    var reach: f32;
    var dx: vec2<f32>;
    var dy: vec2<f32>;
    var left: vec4<f32>;
    var right: vec4<f32>;
    var up: vec4<f32>;
    var down: vec4<f32>;
    var across: bool;
    var along: bool;
    var bent: f32;
    var local_3: f32;
    var param_2: f32;
    var param_3: f32;
    var param_4: f32;
    var local_4: f32;
    var param_5: f32;
    var param_6: f32;
    var param_7: f32;
    var turned: f32;
    var param_8: vec2<f32>;
    var param_9: vec2<f32>;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var ringWidth: f32;
    var own: vec4<f32>;
    var directions: array<vec2<f32>, 8>;
    var found: vec4<f32>;
    var i: i32;
    var d: i32;
    var tap_1: vec4<f32>;
    var phi_267_: bool;
    var phi_279_: bool;
    var phi_405_: bool;
    var phi_421_: bool;
    var phi_588_: bool;
    var phi_623_: bool;

    let _e99 = v_uv_1;
    let _e100 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e99, 0f);
    scene = _e100;
    let _e101 = scene;
    colour = _e101.xyz;
    let _e104 = contrast_info.screen;
    texel = _e104.xy;
    let _e108 = contrast_info.screen[2u];
    hasSurface = (_e108 > 0.5f);
    let _e112 = contrast_info.screen[3u];
    hasMask = (_e112 > 0.5f);
    surface = vec4<f32>(0f, 0f, 0f, 0f);
    let _e114 = hasSurface;
    if _e114 {
        let _e115 = v_uv_1;
        let _e116 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e115, 0f);
        surface = _e116;
    }
    let _e118 = surface[3u];
    depth = _e118;
    let _e119 = depth;
    if (_e119 > 0f) {
        let _e121 = surface;
        param = _e121.xy;
        let _e123 = DecodeOctahedral_u0028_vf2_u003b((&param));
        local_2 = _e123;
    } else {
        local_2 = vec3<f32>(0f, 0f, 1f);
    }
    let _e124 = local_2;
    normal = _e124;
    let _e127 = contrast_info.edges[0u];
    bend = max(_e127, 0.0001f);
    let _e131 = contrast_info.edges[1u];
    turn = max(_e131, 0.0001f);
    let _e135 = contrast_info.look[0u];
    flatten = clamp(_e135, 0f, 1f);
    let _e137 = depth;
    let _e139 = flatten;
    if ((_e137 > 0f) && (_e139 > 0f)) {
        let _e142 = texel;
        let _e145 = contrast_info.edges[3u];
        spacing = (_e142 * max(_e145, 1f));
        sum = vec3<f32>(0f, 0f, 0f);
        count = 0f;
        y = -2i;
        loop {
            let _e148 = y;
            if (_e148 <= 2i) {
                x = -2i;
                loop {
                    let _e150 = x;
                    if (_e150 <= 2i) {
                        let _e152 = v_uv_1;
                        let _e153 = x;
                        let _e155 = y;
                        let _e158 = spacing;
                        uv = (_e152 + (vec2<f32>(f32(_e153), f32(_e155)) * _e158));
                        let _e161 = uv;
                        let _e162 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e161, 0f);
                        tap = _e162;
                        let _e163 = x;
                        let _e165 = y;
                        ring = f32(max(abs(_e163), abs(_e165)));
                        let _e170 = tap[3u];
                        let _e171 = (_e170 > 0f);
                        phi_267_ = _e171;
                        if _e171 {
                            let _e173 = tap[3u];
                            let _e174 = depth;
                            let _e177 = bend;
                            let _e178 = depth;
                            let _e180 = ring;
                            phi_267_ = (abs((_e173 - _e174)) <= ((_e177 * _e178) * max(_e180, 1f)));
                        }
                        let _e185 = phi_267_;
                        phi_279_ = _e185;
                        if _e185 {
                            let _e186 = tap;
                            param_1 = _e186.xy;
                            let _e188 = DecodeOctahedral_u0028_vf2_u003b((&param_1));
                            let _e189 = normal;
                            let _e192 = turn;
                            phi_279_ = ((1f - dot(_e188, _e189)) < _e192);
                        }
                        let _e195 = phi_279_;
                        same = _e195;
                        let _e196 = same;
                        if _e196 {
                            let _e197 = uv;
                            let _e198 = textureSampleLevel(scene_texture_tex, scene_texture_smp, _e197, 0f);
                            let _e200 = sum;
                            sum = (_e200 + _e198.xyz);
                            let _e202 = count;
                            count = (_e202 + 1f);
                        }
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e204 = x;
                        x = (_e204 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e206 = y;
                y = (_e206 + 1i);
            }
        }
        let _e208 = count;
        if (_e208 > 0f) {
            let _e210 = colour;
            let _e211 = sum;
            let _e212 = count;
            let _e215 = flatten;
            colour = mix(_e210, (_e211 / vec3(_e212)), vec3(_e215));
        }
    }
    let _e218 = colour;
    luma = dot(_e218, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
    let _e220 = luma;
    let _e222 = colour;
    let _e225 = contrast_info.look[2u];
    colour = mix(vec3(_e220), _e222, vec3(clamp(_e225, 0f, 1f)));
    let _e229 = colour;
    let _e234 = contrast_info.look[1u];
    colour = clamp((((_e229 - vec3(0.5f)) * max(_e234, 0f)) + vec3(0.5f)), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e242 = contrast_info.edges[2u];
    reach = _e242;
    let _e243 = depth;
    let _e245 = reach;
    if ((_e243 > 0f) && (_e245 > 0f)) {
        let _e249 = texel[0u];
        let _e250 = reach;
        dx = vec2<f32>((_e249 * _e250), 0f);
        let _e254 = texel[1u];
        let _e255 = reach;
        dy = vec2<f32>(0f, (_e254 * _e255));
        let _e258 = v_uv_1;
        let _e259 = dx;
        let _e261 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e258 - _e259), 0f);
        left = _e261;
        let _e262 = v_uv_1;
        let _e263 = dx;
        let _e265 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e262 + _e263), 0f);
        right = _e265;
        let _e266 = v_uv_1;
        let _e267 = dy;
        let _e269 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e266 - _e267), 0f);
        up = _e269;
        let _e270 = v_uv_1;
        let _e271 = dy;
        let _e273 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e270 + _e271), 0f);
        down = _e273;
        let _e275 = v_uv_1[0u];
        let _e277 = dx[0u];
        let _e279 = ((_e275 - _e277) >= 0f);
        phi_405_ = _e279;
        if _e279 {
            let _e281 = v_uv_1[0u];
            let _e283 = dx[0u];
            phi_405_ = ((_e281 + _e283) <= 1f);
        }
        let _e287 = phi_405_;
        across = _e287;
        let _e289 = v_uv_1[1u];
        let _e291 = dy[1u];
        let _e293 = ((_e289 - _e291) >= 0f);
        phi_421_ = _e293;
        if _e293 {
            let _e295 = v_uv_1[1u];
            let _e297 = dy[1u];
            phi_421_ = ((_e295 + _e297) <= 1f);
        }
        let _e301 = phi_421_;
        along = _e301;
        let _e302 = across;
        if _e302 {
            let _e304 = left[3u];
            param_2 = _e304;
            let _e305 = depth;
            param_3 = _e305;
            let _e307 = right[3u];
            param_4 = _e307;
            let _e308 = DepthBend_u0028_f1_u003b_f1_u003b_f1_u003b((&param_2), (&param_3), (&param_4));
            local_3 = _e308;
        } else {
            local_3 = 0f;
        }
        let _e309 = local_3;
        let _e310 = along;
        if _e310 {
            let _e312 = up[3u];
            param_5 = _e312;
            let _e313 = depth;
            param_6 = _e313;
            let _e315 = down[3u];
            param_7 = _e315;
            let _e316 = DepthBend_u0028_f1_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
            local_4 = _e316;
        } else {
            local_4 = 0f;
        }
        let _e317 = local_4;
        bent = max(_e309, _e317);
        turned = 0f;
        let _e320 = left[3u];
        if (_e320 > 0f) {
            let _e322 = turned;
            let _e323 = left;
            param_8 = _e323.xy;
            let _e325 = DecodeOctahedral_u0028_vf2_u003b((&param_8));
            let _e326 = normal;
            turned = max(_e322, (1f - dot(_e325, _e326)));
        }
        let _e331 = right[3u];
        if (_e331 > 0f) {
            let _e333 = turned;
            let _e334 = right;
            param_9 = _e334.xy;
            let _e336 = DecodeOctahedral_u0028_vf2_u003b((&param_9));
            let _e337 = normal;
            turned = max(_e333, (1f - dot(_e336, _e337)));
        }
        let _e342 = up[3u];
        if (_e342 > 0f) {
            let _e344 = turned;
            let _e345 = up;
            param_10 = _e345.xy;
            let _e347 = DecodeOctahedral_u0028_vf2_u003b((&param_10));
            let _e348 = normal;
            turned = max(_e344, (1f - dot(_e347, _e348)));
        }
        let _e353 = down[3u];
        if (_e353 > 0f) {
            let _e355 = turned;
            let _e356 = down;
            param_11 = _e356.xy;
            let _e358 = DecodeOctahedral_u0028_vf2_u003b((&param_11));
            let _e359 = normal;
            turned = max(_e355, (1f - dot(_e358, _e359)));
        }
        let _e363 = bent;
        let _e364 = bend;
        let _e366 = turned;
        let _e367 = turn;
        if ((_e363 >= _e364) || (_e366 >= _e367)) {
            let _e371 = contrast_info.line;
            colour = _e371.xyz;
        }
    }
    let _e375 = contrast_info.line[3u];
    ringWidth = _e375;
    let _e376 = hasMask;
    if _e376 {
        let _e377 = v_uv_1;
        let _e378 = textureSampleLevel(mask_texture_tex, mask_texture_smp, _e377, 0f);
        own = _e378;
        let _e380 = own[3u];
        if (_e380 > 0.5f) {
            let _e382 = colour;
            let _e383 = own;
            let _e387 = contrast_info.look[3u];
            colour = mix(_e382, _e383.xyz, vec3(clamp(_e387, 0f, 1f)));
        } else {
            let _e391 = ringWidth;
            if (_e391 > 0f) {
                directions = array<vec2<f32>, 8>(vec2<f32>(1f, 0f), vec2<f32>(-1f, 0f), vec2<f32>(0f, 1f), vec2<f32>(0f, -1f), vec2<f32>(1f, 1f), vec2<f32>(-1f, 1f), vec2<f32>(1f, -1f), vec2<f32>(-1f, -1f));
                found = vec4<f32>(0f, 0f, 0f, 0f);
                i = 1i;
                loop {
                    let _e393 = i;
                    if (_e393 <= 4i) {
                        let _e395 = i;
                        let _e397 = ringWidth;
                        let _e398 = (f32(_e395) <= _e397);
                        phi_588_ = _e398;
                        if _e398 {
                            let _e400 = found[3u];
                            phi_588_ = (_e400 < 0.5f);
                        }
                        let _e403 = phi_588_;
                        if _e403 {
                            d = 0i;
                            loop {
                                let _e404 = d;
                                if (_e404 < 8i) {
                                    let _e406 = v_uv_1;
                                    let _e407 = d;
                                    let _e409 = directions[_e407];
                                    let _e410 = texel;
                                    let _e412 = i;
                                    let _e416 = textureSampleLevel(mask_texture_tex, mask_texture_smp, (_e406 + ((_e409 * _e410) * f32(_e412))), 0f);
                                    tap_1 = _e416;
                                    let _e418 = found[3u];
                                    let _e419 = (_e418 < 0.5f);
                                    phi_623_ = _e419;
                                    if _e419 {
                                        let _e421 = tap_1[3u];
                                        phi_623_ = (_e421 > 0.5f);
                                    }
                                    let _e424 = phi_623_;
                                    if _e424 {
                                        let _e425 = tap_1;
                                        found = _e425;
                                    }
                                    continue;
                                } else {
                                    break;
                                }
                                continuing {
                                    let _e426 = d;
                                    d = (_e426 + 1i);
                                }
                            }
                        }
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e428 = i;
                        i = (_e428 + 1i);
                    }
                }
                let _e431 = found[3u];
                if (_e431 > 0.5f) {
                    let _e433 = found;
                    colour = _e433.xyz;
                }
            }
        }
    }
    let _e435 = colour;
    let _e437 = scene[3u];
    frag_color = vec4<f32>(_e435.x, _e435.y, _e435.z, _e437);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'HighContrastInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'look', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'edges',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(name: 'line', offsetInBytes: 32, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'screen',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'mask_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Decal': WebGpuStage(
      wgsl: r'''
struct DecalInfo {
    inverse_view_projection: mat4x4<f32>,
    camera: vec4<f32>,
    forward: vec4<f32>,
    params: vec4<f32>,
    view: vec4<f32>,
    slots: array<vec4<f32>, 4>,
    axis_x: array<vec4<f32>, 16>,
    axis_y: array<vec4<f32>, 16>,
    axis_z: array<vec4<f32>, 16>,
    region: array<vec4<f32>, 16>,
    color: array<vec4<f32>, 16>,
    fade: array<vec4<f32>, 16>,
    emissive: array<vec4<f32>, 16>,
}

@group(1) @binding(0)
var<uniform> decal_info: DecalInfo;
@group(1) @binding(11)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(12)
var surface_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(9)
var decal_texture_3_tex: texture_2d<f32>;
@group(1) @binding(10)
var decal_texture_3_smp: sampler;
@group(1) @binding(7)
var decal_texture_2_tex: texture_2d<f32>;
@group(1) @binding(8)
var decal_texture_2_smp: sampler;
@group(1) @binding(5)
var decal_texture_1_tex: texture_2d<f32>;
@group(1) @binding(6)
var decal_texture_1_smp: sampler;
@group(1) @binding(3)
var decal_texture_0_tex: texture_2d<f32>;
@group(1) @binding(4)
var decal_texture_0_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var albedo_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var albedo_texture_smp: sampler;

fn SampleSlot_u0028_f1_u003b_vf2_u003b_f1_u003b(slot: ptr<function, f32>, uv: ptr<function, vec2<f32>>, lod: ptr<function, f32>) -> vec4<f32> {
    var picture: vec4<f32>;

    picture = vec4<f32>(1f, 1f, 1f, 1f);
    let _e64 = (*slot);
    if (_e64 > 2.5f) {
        let _e66 = (*uv);
        let _e67 = (*lod);
        let _e68 = textureSampleLevel(decal_texture_3_tex, decal_texture_3_smp, _e66, _e67);
        picture = _e68;
    } else {
        let _e69 = (*slot);
        if (_e69 > 1.5f) {
            let _e71 = (*uv);
            let _e72 = (*lod);
            let _e73 = textureSampleLevel(decal_texture_2_tex, decal_texture_2_smp, _e71, _e72);
            picture = _e73;
        } else {
            let _e74 = (*slot);
            if (_e74 > 0.5f) {
                let _e76 = (*uv);
                let _e77 = (*lod);
                let _e78 = textureSampleLevel(decal_texture_1_tex, decal_texture_1_smp, _e76, _e77);
                picture = _e78;
            } else {
                let _e79 = (*slot);
                if (_e79 > -0.5f) {
                    let _e81 = (*uv);
                    let _e82 = (*lod);
                    let _e83 = textureSampleLevel(decal_texture_0_tex, decal_texture_0_smp, _e81, _e82);
                    picture = _e83;
                }
            }
        }
    }
    let _e84 = picture;
    return _e84;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e61 = (*srgb);
    let _e64 = (*srgb);
    let _e69 = (*srgb);
    return mix((_e61 / vec3(12.92f)), pow(((_e64 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e69));
}

fn WorldAt_u0028_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, depth: ptr<function, f32>) -> vec3<f32> {
    var inView: vec2<f32>;
    var xy: vec2<f32>;
    var nearH: vec4<f32>;
    var farH: vec4<f32>;
    var origin: vec3<f32>;
    var along: vec3<f32>;
    var axis: vec3<f32>;

    let _e69 = (*uv_1);
    let _e71 = decal_info.view;
    let _e75 = decal_info.view;
    inView = ((_e69 - _e71.xy) / _e75.zw);
    let _e79 = inView[0u];
    let _e83 = inView[1u];
    xy = vec2<f32>(((_e79 * 2f) - 1f), (1f - (_e83 * 2f)));
    let _e88 = decal_info.inverse_view_projection;
    let _e89 = xy;
    nearH = (_e88 * vec4<f32>(_e89.x, _e89.y, 0f, 1f));
    let _e95 = decal_info.inverse_view_projection;
    let _e96 = xy;
    farH = (_e95 * vec4<f32>(_e96.x, _e96.y, 1f, 1f));
    let _e101 = nearH;
    let _e104 = nearH[3u];
    origin = (_e101.xyz / vec3(_e104));
    let _e107 = farH;
    let _e110 = farH[3u];
    let _e113 = origin;
    along = normalize(((_e107.xyz / vec3(_e110)) - _e113));
    let _e117 = decal_info.forward;
    axis = _e117.xyz;
    let _e119 = origin;
    let _e120 = along;
    let _e121 = (*depth);
    let _e122 = origin;
    let _e124 = decal_info.camera;
    let _e127 = axis;
    let _e130 = along;
    let _e131 = axis;
    return (_e119 + (_e120 * ((_e121 - dot((_e122 - _e124.xyz), _e127)) / dot(_e130, _e131))));
}

fn WorldStep_u0028_vf2_u003b_f1_u003b_vf3_u003b(step_: ptr<function, vec2<f32>>, depth_1: ptr<function, f32>, at: ptr<function, vec3<f32>>) -> vec3<f32> {
    var ahead: vec4<f32>;
    var behind: vec4<f32>;
    var aheadGap: f32;
    var local: f32;
    var behindGap: f32;
    var local_1: f32;
    var forward: vec3<f32>;
    var param: vec2<f32>;
    var param_1: f32;
    var backward: vec3<f32>;
    var param_2: vec2<f32>;
    var param_3: f32;
    var chosen: vec3<f32>;

    let _e76 = v_uv_1;
    let _e77 = (*step_);
    let _e79 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e76 + _e77), 0f);
    ahead = _e79;
    let _e80 = v_uv_1;
    let _e81 = (*step_);
    let _e83 = textureSampleLevel(surface_texture_tex, surface_texture_smp, (_e80 - _e81), 0f);
    behind = _e83;
    let _e85 = ahead[3u];
    if (_e85 > 0f) {
        let _e88 = ahead[3u];
        let _e89 = (*depth_1);
        local = abs((_e88 - _e89));
    } else {
        local = 1000000000000000000000000000000f;
    }
    let _e92 = local;
    aheadGap = _e92;
    let _e94 = behind[3u];
    if (_e94 > 0f) {
        let _e97 = behind[3u];
        let _e98 = (*depth_1);
        local_1 = abs((_e97 - _e98));
    } else {
        local_1 = 1000000000000000000000000000000f;
    }
    let _e101 = local_1;
    behindGap = _e101;
    let _e102 = v_uv_1;
    let _e103 = (*step_);
    param = (_e102 + _e103);
    let _e106 = ahead[3u];
    param_1 = _e106;
    let _e107 = WorldAt_u0028_vf2_u003b_f1_u003b((&param), (&param_1));
    let _e108 = (*at);
    forward = (_e107 - _e108);
    let _e110 = (*at);
    let _e111 = v_uv_1;
    let _e112 = (*step_);
    param_2 = (_e111 - _e112);
    let _e115 = behind[3u];
    param_3 = _e115;
    let _e116 = WorldAt_u0028_vf2_u003b_f1_u003b((&param_2), (&param_3));
    backward = (_e110 - _e116);
    let _e118 = aheadGap;
    let _e119 = behindGap;
    let _e121 = forward;
    let _e122 = backward;
    chosen = select(_e122, _e121, vec3((_e118 <= _e119)));
    let _e125 = aheadGap;
    let _e126 = behindGap;
    let _e129 = chosen;
    return select(vec3<f32>(0f, 0f, 0f), _e129, vec3((min(_e125, _e126) < 100000000000000000000000000000f)));
}

fn DecodeOctahedral_u0028_vf2_u003b(e: ptr<function, vec2<f32>>) -> vec3<f32> {
    var n: vec3<f32>;
    var t: f32;
    var local_2: f32;
    var local_3: f32;

    let _e65 = (*e);
    (*e) = ((_e65 * 2f) - vec2(1f));
    let _e69 = (*e);
    let _e71 = (*e)[0u];
    let _e75 = (*e)[1u];
    n = vec3<f32>(_e69.x, _e69.y, ((1f - abs(_e71)) - abs(_e75)));
    let _e82 = n[2u];
    t = max(-(_e82), 0f);
    let _e86 = n[0u];
    if (_e86 >= 0f) {
        let _e88 = t;
        local_2 = -(_e88);
    } else {
        let _e90 = t;
        local_2 = _e90;
    }
    let _e91 = local_2;
    let _e93 = n[0u];
    n[0u] = (_e93 + _e91);
    let _e97 = n[1u];
    if (_e97 >= 0f) {
        let _e99 = t;
        local_3 = -(_e99);
    } else {
        let _e101 = t;
        local_3 = _e101;
    }
    let _e102 = local_3;
    let _e104 = n[1u];
    n[1u] = (_e104 + _e102);
    let _e107 = n;
    return normalize(_e107);
}

fn main_1() {
    var factor: bool;
    var surface: vec4<f32>;
    var keepFactor: vec3<f32>;
    var keepTerm: vec3<f32>;
    var depth_2: f32;
    var at_1: vec3<f32>;
    var param_4: vec2<f32>;
    var param_5: f32;
    var normal: vec3<f32>;
    var param_6: vec2<f32>;
    var dx: vec3<f32>;
    var param_7: vec2<f32>;
    var param_8: f32;
    var param_9: vec3<f32>;
    var dy: vec3<f32>;
    var param_10: vec2<f32>;
    var param_11: f32;
    var param_12: vec3<f32>;
    var albedo: vec3<f32>;
    var param_13: vec3<f32>;
    var painted: vec3<f32>;
    var kept: f32;
    var laid: vec3<f32>;
    var emitted: vec3<f32>;
    var count: i32;
    var i: i32;
    var rowX: vec4<f32>;
    var rowY: vec4<f32>;
    var rowZ: vec4<f32>;
    var local_4: vec3<f32>;
    var fade: vec4<f32>;
    var facing: f32;
    var byAngle: f32;
    var byDepth: f32;
    var local_5: f32;
    var region: vec4<f32>;
    var uv_2: vec2<f32>;
    var slot_1: f32;
    var size: vec2<f32>;
    var alongX: vec2<f32>;
    var alongY: vec2<f32>;
    var footprint: f32;
    var lod_1: f32;
    var local_6: f32;
    var picture_1: vec4<f32>;
    var param_14: f32;
    var param_15: vec2<f32>;
    var param_16: f32;
    var tint: vec4<f32>;
    var colour: vec3<f32>;
    var param_17: vec3<f32>;
    var alpha: f32;
    var named: f32;
    var swap: vec3<f32>;
    var multiply: vec3<f32>;
    var add: vec3<f32>;

    let _e118 = decal_info.params[3u];
    factor = (_e118 < 0.5f);
    let _e120 = v_uv_1;
    let _e121 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e120, 0f);
    surface = _e121;
    keepFactor = vec3<f32>(1f, 1f, 1f);
    keepTerm = vec3<f32>(0f, 0f, 0f);
    let _e123 = surface[3u];
    if (_e123 <= 0f) {
        let _e125 = factor;
        let _e126 = keepFactor;
        let _e127 = keepTerm;
        let _e129 = select(_e127, _e126, vec3(_e125));
        frag_color = vec4<f32>(_e129.x, _e129.y, _e129.z, 1f);
        return;
    }
    let _e135 = surface[3u];
    depth_2 = _e135;
    let _e136 = v_uv_1;
    param_4 = _e136;
    let _e137 = depth_2;
    param_5 = _e137;
    let _e138 = WorldAt_u0028_vf2_u003b_f1_u003b((&param_4), (&param_5));
    at_1 = _e138;
    let _e139 = surface;
    param_6 = _e139.xy;
    let _e141 = DecodeOctahedral_u0028_vf2_u003b((&param_6));
    normal = _e141;
    let _e144 = decal_info.params[1u];
    param_7 = vec2<f32>(_e144, 0f);
    let _e146 = depth_2;
    param_8 = _e146;
    let _e147 = at_1;
    param_9 = _e147;
    let _e148 = WorldStep_u0028_vf2_u003b_f1_u003b_vf3_u003b((&param_7), (&param_8), (&param_9));
    dx = _e148;
    let _e151 = decal_info.params[2u];
    param_10 = vec2<f32>(0f, _e151);
    let _e153 = depth_2;
    param_11 = _e153;
    let _e154 = at_1;
    param_12 = _e154;
    let _e155 = WorldStep_u0028_vf2_u003b_f1_u003b_vf3_u003b((&param_10), (&param_11), (&param_12));
    dy = _e155;
    let _e156 = v_uv_1;
    let _e157 = textureSampleLevel(albedo_texture_tex, albedo_texture_smp, _e156, 0f);
    param_13 = _e157.xyz;
    let _e159 = SrgbToLinear_u0028_vf3_u003b((&param_13));
    albedo = _e159;
    let _e160 = albedo;
    painted = _e160;
    kept = 1f;
    laid = vec3<f32>(0f, 0f, 0f);
    emitted = vec3<f32>(0f, 0f, 0f);
    let _e163 = decal_info.params[0u];
    count = i32((_e163 + 0.5f));
    i = 0i;
    loop {
        let _e166 = i;
        if (_e166 < 16i) {
            let _e168 = i;
            let _e169 = count;
            if (_e168 >= _e169) {
                break;
            }
            let _e171 = i;
            let _e174 = decal_info.axis_x[_e171];
            rowX = _e174;
            let _e175 = i;
            let _e178 = decal_info.axis_y[_e175];
            rowY = _e178;
            let _e179 = i;
            let _e182 = decal_info.axis_z[_e179];
            rowZ = _e182;
            let _e183 = rowX;
            let _e185 = at_1;
            let _e188 = rowX[3u];
            let _e190 = rowY;
            let _e192 = at_1;
            let _e195 = rowY[3u];
            let _e197 = rowZ;
            let _e199 = at_1;
            let _e202 = rowZ[3u];
            local_4 = vec3<f32>((dot(_e183.xyz, _e185) + _e188), (dot(_e190.xyz, _e192) + _e195), (dot(_e197.xyz, _e199) + _e202));
            let _e205 = local_4;
            if any((abs(_e205) > vec3<f32>(0.5f, 0.5f, 0.5f))) {
                continue;
            }
            let _e209 = i;
            let _e212 = decal_info.fade[_e209];
            fade = _e212;
            let _e213 = normal;
            let _e214 = rowY;
            facing = dot(_e213, normalize(_e214.xyz));
            let _e218 = facing;
            let _e220 = fade[1u];
            let _e223 = fade[2u];
            byAngle = clamp(((_e218 - _e220) / max(_e223, 0.0001f)), 0f, 1f);
            let _e228 = fade[3u];
            if (_e228 > 0f) {
                let _e231 = local_4[1u];
                let _e235 = fade[3u];
                local_5 = clamp(((0.5f - abs(_e231)) / (_e235 * 0.5f)), 0f, 1f);
            } else {
                local_5 = 1f;
            }
            let _e239 = local_5;
            byDepth = _e239;
            let _e240 = i;
            let _e243 = decal_info.region[_e240];
            region = _e243;
            let _e244 = region;
            let _e246 = local_4;
            let _e250 = region;
            uv_2 = (_e244.xy + ((_e246.xz + vec2(0.5f)) * _e250.zw));
            let _e255 = fade[0u];
            slot_1 = _e255;
            let _e256 = slot_1;
            let _e261 = decal_info.slots[i32(clamp(_e256, 0f, 3f))];
            size = _e261.xy;
            let _e263 = rowX;
            let _e265 = dx;
            let _e267 = rowZ;
            let _e269 = dx;
            let _e272 = region;
            alongX = (vec2<f32>(dot(_e263.xyz, _e265), dot(_e267.xyz, _e269)) * _e272.zw);
            let _e275 = rowX;
            let _e277 = dy;
            let _e279 = rowZ;
            let _e281 = dy;
            let _e284 = region;
            alongY = (vec2<f32>(dot(_e275.xyz, _e277), dot(_e279.xyz, _e281)) * _e284.zw);
            let _e288 = alongX[0u];
            let _e291 = alongY[0u];
            let _e295 = size[0u];
            let _e298 = alongX[1u];
            let _e301 = alongY[1u];
            let _e305 = size[1u];
            footprint = max((max(abs(_e288), abs(_e291)) * _e295), (max(abs(_e298), abs(_e301)) * _e305));
            let _e308 = footprint;
            if (_e308 > 1f) {
                let _e310 = footprint;
                local_6 = log2(_e310);
            } else {
                local_6 = 0f;
            }
            let _e312 = local_6;
            lod_1 = _e312;
            let _e313 = slot_1;
            param_14 = _e313;
            let _e314 = uv_2;
            param_15 = _e314;
            let _e315 = lod_1;
            param_16 = _e315;
            let _e316 = SampleSlot_u0028_f1_u003b_vf2_u003b_f1_u003b((&param_14), (&param_15), (&param_16));
            picture_1 = _e316;
            let _e317 = i;
            let _e320 = decal_info.color[_e317];
            tint = _e320;
            let _e321 = picture_1;
            param_17 = _e321.xyz;
            let _e323 = SrgbToLinear_u0028_vf3_u003b((&param_17));
            let _e324 = tint;
            colour = (_e323 * _e324.xyz);
            let _e328 = picture_1[3u];
            let _e330 = tint[3u];
            let _e332 = byAngle;
            let _e334 = byDepth;
            alpha = clamp((((_e328 * _e330) * _e332) * _e334), 0f, 1f);
            let _e337 = painted;
            let _e338 = colour;
            let _e339 = alpha;
            painted = mix(_e337, _e338, vec3(_e339));
            let _e342 = alpha;
            let _e344 = kept;
            kept = (_e344 * (1f - _e342));
            let _e346 = laid;
            let _e347 = colour;
            let _e348 = alpha;
            laid = mix(_e346, _e347, vec3(_e348));
            let _e351 = emitted;
            let _e352 = colour;
            let _e353 = i;
            let _e356 = decal_info.emissive[_e353];
            let _e359 = alpha;
            emitted = mix(_e351, (_e352 * _e356.xyz), vec3(_e359));
            continue;
        } else {
            break;
        }
        continuing {
            let _e362 = i;
            i = (_e362 + 1i);
        }
    }
    let _e365 = albedo[0u];
    let _e367 = albedo[1u];
    let _e369 = albedo[2u];
    named = clamp((max(_e365, max(_e367, _e369)) / 0.08f), 0f, 1f);
    let _e374 = painted;
    let _e375 = albedo;
    let _e377 = albedo;
    swap = (vec3<f32>(1f, 1f, 1f) + ((_e374 - _e375) / max(_e377, vec3<f32>(0.08f, 0.08f, 0.08f))));
    let _e381 = swap;
    let _e382 = named;
    let _e384 = kept;
    let _e385 = named;
    multiply = ((_e381 * _e382) + vec3((_e384 * (1f - _e385))));
    let _e390 = laid;
    let _e391 = named;
    let _e394 = emitted;
    add = ((_e390 * (1f - _e391)) + _e394);
    let _e396 = factor;
    let _e397 = multiply;
    let _e398 = add;
    let _e400 = select(_e398, _e397, vec3(_e396));
    frag_color = vec4<f32>(_e400.x, _e400.y, _e400.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'DecalInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 1984,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'inverse_view_projection',
              offsetInBytes: 0,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'camera',
              offsetInBytes: 64,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 80,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 96,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'view',
              offsetInBytes: 112,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 128,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'axis_x',
              offsetInBytes: 192,
              sizeInBytes: 256,
            ),
            WebGpuBlockMember(
              name: 'axis_y',
              offsetInBytes: 448,
              sizeInBytes: 256,
            ),
            WebGpuBlockMember(
              name: 'axis_z',
              offsetInBytes: 704,
              sizeInBytes: 256,
            ),
            WebGpuBlockMember(
              name: 'region',
              offsetInBytes: 960,
              sizeInBytes: 256,
            ),
            WebGpuBlockMember(
              name: 'color',
              offsetInBytes: 1216,
              sizeInBytes: 256,
            ),
            WebGpuBlockMember(
              name: 'fade',
              offsetInBytes: 1472,
              sizeInBytes: 256,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 1728,
              sizeInBytes: 256,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'albedo_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'decal_texture_0',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'decal_texture_1',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'decal_texture_2',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'decal_texture_3',
          group: 1,
          textureBinding: 9,
          samplerBinding: 10,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 11,
          samplerBinding: 12,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ProbePrefilter': WebGpuStage(
      wgsl: r'''
struct ProbeInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> probe_info: ProbeInfo;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var capture_texture_tex: texture_cube<f32>;
@group(1) @binding(2)
var capture_texture_smp: sampler;

fn FaceDirection_u0028_i1_u003b_vf2_u003b(face: ptr<function, i32>, st: ptr<function, vec2<f32>>) -> vec3<f32> {
    var u: f32;
    var v: f32;

    let _e31 = (*st)[0u];
    u = ((_e31 * 2f) - 1f);
    let _e35 = (*st)[1u];
    v = ((_e35 * 2f) - 1f);
    let _e38 = (*face);
    if (_e38 == 0i) {
        let _e40 = v;
        let _e42 = u;
        return normalize(vec3<f32>(1f, -(_e40), -(_e42)));
    }
    let _e46 = (*face);
    if (_e46 == 1i) {
        let _e48 = v;
        let _e50 = u;
        return normalize(vec3<f32>(-1f, -(_e48), _e50));
    }
    let _e53 = (*face);
    if (_e53 == 2i) {
        let _e55 = u;
        let _e56 = v;
        return normalize(vec3<f32>(_e55, 1f, _e56));
    }
    let _e59 = (*face);
    if (_e59 == 3i) {
        let _e61 = u;
        let _e62 = v;
        return normalize(vec3<f32>(_e61, -1f, -(_e62)));
    }
    let _e66 = (*face);
    if (_e66 == 4i) {
        let _e68 = u;
        let _e69 = v;
        return normalize(vec3<f32>(_e68, -(_e69), 1f));
    }
    let _e73 = u;
    let _e75 = v;
    return normalize(vec3<f32>(-(_e73), -(_e75), -1f));
}

fn main_1() {
    var face_1: i32;
    var roughness: f32;
    var lod: f32;
    var samples: i32;
    var axis: vec3<f32>;
    var param: i32;
    var param_1: vec2<f32>;
    var alpha: f32;
    var alpha2_: f32;
    var up: vec3<f32>;
    var right: vec3<f32>;
    var ahead: vec3<f32>;
    var sum: vec3<f32>;
    var weight: f32;
    var i: i32;
    var e: f32;
    var theta: f32;
    var cosH: f32;
    var sinH: f32;
    var tap: vec3<f32>;
    var dir: vec3<f32>;
    var cosine: f32;
    var local: vec3<f32>;

    let _e51 = probe_info.params[0u];
    face_1 = i32((_e51 + 0.5f));
    let _e56 = probe_info.params[1u];
    roughness = _e56;
    let _e59 = probe_info.params[2u];
    lod = _e59;
    let _e62 = probe_info.params[3u];
    samples = clamp(i32((_e62 + 0.5f)), 1i, 128i);
    let _e66 = face_1;
    param = _e66;
    let _e67 = v_uv_1;
    param_1 = _e67;
    let _e68 = FaceDirection_u0028_i1_u003b_vf2_u003b((&param), (&param_1));
    axis = _e68;
    let _e69 = samples;
    if (_e69 == 1i) {
        let _e71 = axis;
        let _e72 = lod;
        let _e73 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e71, _e72);
        let _e74 = _e73.xyz;
        frag_color = vec4<f32>(_e74.x, _e74.y, _e74.z, 1f);
        return;
    }
    let _e79 = roughness;
    let _e80 = roughness;
    alpha = max((_e79 * _e80), 0.001f);
    let _e83 = alpha;
    let _e84 = alpha;
    alpha2_ = (_e83 * _e84);
    let _e87 = axis[2u];
    up = select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e87) < 0.999f)));
    let _e92 = up;
    let _e93 = axis;
    right = normalize(cross(_e92, _e93));
    let _e96 = axis;
    let _e97 = right;
    ahead = cross(_e96, _e97);
    sum = vec3<f32>(0f, 0f, 0f);
    weight = 0f;
    i = 0i;
    loop {
        let _e99 = i;
        if (_e99 < 128i) {
            let _e101 = i;
            let _e102 = samples;
            if (_e101 >= _e102) {
                break;
            }
            let _e104 = i;
            let _e107 = samples;
            e = ((f32(_e104) + 0.5f) / f32(_e107));
            let _e110 = i;
            theta = (2.3999631f * f32(_e110));
            let _e113 = e;
            let _e115 = alpha2_;
            let _e117 = e;
            cosH = sqrt(((1f - _e113) / (1f + ((_e115 - 1f) * _e117))));
            let _e122 = cosH;
            let _e123 = cosH;
            sinH = sqrt(max((1f - (_e122 * _e123)), 0f));
            let _e128 = cosH;
            let _e130 = sinH;
            let _e132 = theta;
            let _e135 = cosH;
            let _e137 = sinH;
            let _e139 = theta;
            let _e142 = cosH;
            let _e144 = cosH;
            tap = vec3<f32>((((2f * _e128) * _e130) * cos(_e132)), (((2f * _e135) * _e137) * sin(_e139)), (((2f * _e142) * _e144) - 1f));
            let _e148 = right;
            let _e150 = tap[0u];
            let _e152 = ahead;
            let _e154 = tap[1u];
            let _e157 = axis;
            let _e159 = tap[2u];
            dir = (((_e148 * _e150) + (_e152 * _e154)) + (_e157 * _e159));
            let _e162 = dir;
            let _e163 = axis;
            cosine = dot(_e162, _e163);
            let _e165 = cosine;
            if (_e165 <= 0f) {
                continue;
            }
            let _e167 = dir;
            let _e168 = lod;
            let _e169 = textureSampleLevel(capture_texture_tex, capture_texture_smp, _e167, _e168);
            let _e171 = cosine;
            let _e173 = sum;
            sum = (_e173 + (_e169.xyz * _e171));
            let _e175 = cosine;
            let _e176 = weight;
            weight = (_e176 + _e175);
            continue;
        } else {
            break;
        }
        continuing {
            let _e178 = i;
            i = (_e178 + 1i);
        }
    }
    let _e180 = weight;
    if (_e180 > 0f) {
        let _e182 = sum;
        let _e183 = weight;
        local = (_e182 / vec3(_e183));
    } else {
        local = vec3<f32>(0f, 0f, 0f);
    }
    let _e186 = local;
    frag_color = vec4<f32>(_e186.x, _e186.y, _e186.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ProbeInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'capture_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.cube,
        ),
      ],
    ),
    'RenderTextureEncode': WebGpuStage(
      wgsl: r'''
struct RenderTextureInfo {
    params: vec4<f32>,
}

var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> encode_info: RenderTextureInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e22 = (*linear);
    let _e24 = (*linear);
    let _e29 = (*linear);
    return mix((_e22 * 12.92f), ((pow(max(_e24, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e29));
}

fn main_1() {
    var uv: vec2<f32>;
    var light: vec3<f32>;
    var param: vec3<f32>;

    let _e24 = v_uv_1;
    uv = _e24;
    let _e27 = encode_info.params[1u];
    if (_e27 > 0.5f) {
        let _e30 = uv[1u];
        uv[1u] = (1f - _e30);
    }
    let _e33 = uv;
    let _e34 = textureSampleLevel(source_texture_tex, source_texture_smp, _e33, 0f);
    let _e38 = encode_info.params[0u];
    light = (_e34.xyz * _e38);
    let _e40 = light;
    param = clamp(_e40, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e42 = LinearToSrgb_u0028_vf3_u003b((&param));
    frag_color = vec4<f32>(_e42.x, _e42.y, _e42.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'RenderTextureInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ShadowDistance': WebGpuStage(
      wgsl: r'''
struct ShadowLight {
    light: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
@group(1) @binding(0)
var<uniform> shadow_light: ShadowLight;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    var range: f32;
    var distance_: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e25 = shadow_light.light[3u];
    range = max(_e25, 0.0001f);
    let _e27 = v_world_position_1;
    let _e29 = shadow_light.light;
    distance_ = length((_e27 - _e29.xyz));
    let _e33 = distance_;
    let _e34 = range;
    frag_color = vec4<f32>(clamp((_e33 / _e34), 0f, 1f), 0f, 0f, 1f);
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_texcoord_1 = v_texcoord;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e13 = frag_color;
    return _e13;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ShadowLight',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[],
    ),
    'ShadowDepthMasked': WebGpuStage(
      wgsl: r'''
struct MaskInfo {
    mask: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> mask_info: MaskInfo;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    var alpha: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e27 = v_texcoord_1;
    let _e28 = textureSample(base_color_texture_tex, base_color_texture_smp, _e27);
    let _e32 = mask_info.mask[1u];
    alpha = (_e28.w * _e32);
    let _e34 = alpha;
    let _e37 = mask_info.mask[0u];
    if (_e34 < _e37) {
        discard;
    }
    let _e40 = gl_FragCoord_1[2u];
    frag_color = vec4<f32>(_e40, 0f, 0f, 1f);
    return;
}

@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_texcoord_1 = v_texcoord;
    gl_FragCoord_1 = gl_FragCoord;
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'MaskInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ShadowDistanceMasked': WebGpuStage(
      wgsl: r'''
struct MaskInfo {
    mask: vec4<f32>,
}

struct ShadowLight {
    light: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
@group(1) @binding(2)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> mask_info: MaskInfo;
@group(1) @binding(1)
var<uniform> shadow_light: ShadowLight;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    var alpha: f32;
    var range: f32;
    var distance_: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e29 = v_texcoord_1;
    let _e30 = textureSample(base_color_texture_tex, base_color_texture_smp, _e29);
    let _e34 = mask_info.mask[1u];
    alpha = (_e30.w * _e34);
    let _e36 = alpha;
    let _e39 = mask_info.mask[0u];
    if (_e36 < _e39) {
        discard;
    }
    let _e43 = shadow_light.light[3u];
    range = max(_e43, 0.0001f);
    let _e45 = v_world_position_1;
    let _e47 = shadow_light.light;
    distance_ = length((_e45 - _e47.xyz));
    let _e51 = distance_;
    let _e52 = range;
    frag_color = vec4<f32>(clamp((_e51 / _e52), 0f, 1f), 0f, 0f, 1f);
    return;
}

@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_texcoord_1 = v_texcoord;
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e13 = frag_color;
    return _e13;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'MaskInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'mask', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
        WebGpuBlock(
          name: 'ShadowLight',
          group: 1,
          binding: 1,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'light', offsetInBytes: 0, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'CausticSurface': WebGpuStage(
      wgsl: r'''
var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> frag_color: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e18 = v_normal_1;
    let _e19 = normalize(_e18);
    let _e21 = gl_FragCoord_1[2u];
    frag_color = vec4<f32>(_e19.x, _e19.y, _e19.z, _e21);
    return;
}

@fragment
fn main(@location(3) v_normal: vec3<f32>, @builtin(position) gl_FragCoord: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(5) v_texcoord: vec2<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_normal_1 = v_normal;
    gl_FragCoord_1 = gl_FragCoord;
    v_world_position_1 = v_world_position;
    v_texcoord_1 = v_texcoord;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'CausticPhoton': WebGpuStage(
      wgsl: r'''
var<private> v_uv_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var r2_: f32;
    var k: f32;
    var e: vec3<f32>;

    let _e11 = v_uv_1;
    let _e12 = v_uv_1;
    r2_ = dot(_e11, _e12);
    let _e14 = r2_;
    if (_e14 >= 1f) {
        discard;
    }
    let _e16 = r2_;
    let _e18 = r2_;
    k = ((1f - _e16) * (1f - _e18));
    let _e21 = v_color_1;
    let _e23 = k;
    e = (_e21.xyz * _e23);
    let _e26 = e[0u];
    let _e28 = e[1u];
    let _e30 = e[2u];
    frag_color = vec4<f32>(0f, _e26, _e28, _e30);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>, @location(0) v_color: vec4<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    v_color_1 = v_color;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'ShadowTransmittance': WebGpuStage(
      wgsl: r'''
struct TransmittanceInfo {
    color: vec4<f32>,
    light: vec4<f32>,
    params: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
@group(1) @binding(0)
var<uniform> transmittance_info: TransmittanceInfo;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_color_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    var opacity: f32;
    var transmission: f32;
    var tint: vec3<f32>;
    var body: vec3<f32>;
    var facing: f32;
    var f0_: f32;
    var fresnel: f32;
    var lost: f32;
    var through: vec3<f32>;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e41 = transmittance_info.color[3u];
    opacity = clamp(_e41, 0f, 1f);
    let _e45 = transmittance_info.params[0u];
    transmission = clamp(_e45, 0f, 1f);
    let _e48 = transmittance_info.color;
    let _e51 = v_texcoord_1;
    let _e52 = textureSample(base_color_texture_tex, base_color_texture_smp, _e51);
    tint = (max(_e48.xyz, vec3<f32>(0f, 0f, 0f)) * _e52.xyz);
    let _e55 = opacity;
    let _e58 = opacity;
    let _e59 = transmission;
    let _e61 = tint;
    body = (vec3((1f - _e55)) + (_e61 * (_e58 * _e59)));
    let _e64 = v_normal_1;
    let _e67 = transmittance_info.light;
    facing = clamp(abs(dot(normalize(_e64), _e67.xyz)), 0f, 1f);
    let _e74 = transmittance_info.params[1u];
    f0_ = clamp(_e74, 0f, 1f);
    let _e76 = f0_;
    let _e77 = f0_;
    let _e79 = facing;
    fresnel = (_e76 + ((1f - _e77) * pow((1f - _e79), 5f)));
    let _e84 = fresnel;
    let _e85 = facing;
    let _e87 = facing;
    lost = (_e84 * min(((2f * _e85) * _e87), 1f));
    let _e91 = body;
    let _e94 = lost;
    through = (sqrt(max(_e91, vec3<f32>(0f, 0f, 0f))) * (1f - _e94));
    let _e99 = transmittance_info.params[2u];
    if (_e99 > 0.5f) {
        through = vec3<f32>(0f, 0f, 0f);
    }
    let _e102 = through[0u];
    let _e105 = through[1u];
    let _e108 = through[2u];
    frag_color = vec4<f32>(0f, (1f - _e102), (1f - _e105), _e108);
    return;
}

@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @location(3) v_normal: vec3<f32>, @location(7) v_world_position: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(0) v_color: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_texcoord_1 = v_texcoord;
    v_normal_1 = v_normal;
    v_world_position_1 = v_world_position;
    v_tangent_1 = v_tangent;
    v_color_1 = v_color;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e13 = frag_color;
    return _e13;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'TransmittanceInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'color', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'light',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ShadowCopy': WebGpuStage(
      wgsl: r'''
struct ShadowCopyInfo {
    tile: vec4<f32>,
    shift: vec4<f32>,
}

struct FragmentOutput {
    @location(0) member: vec4<f32>,
    @builtin(frag_depth) member_1: f32,
}

var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> copy_info: ShadowCopyInfo;
@group(1) @binding(1)
var static_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var static_shadow_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
var<private> gl_FragDepth: f32 = 0f;

fn main_1() {
    var from_: vec2<f32>;
    var inside: bool;
    var stored: f32;
    var mode: f32;
    var nothing: f32;
    var depth: f32;
    var local: f32;
    var phi_40_: bool;

    let _e24 = v_uv_1;
    let _e26 = copy_info.shift;
    from_ = (_e24 - _e26.xy);
    let _e29 = from_;
    let _e31 = all((_e29 >= vec2<f32>(0f, 0f)));
    phi_40_ = _e31;
    if _e31 {
        let _e32 = from_;
        phi_40_ = all((_e32 <= vec2<f32>(1f, 1f)));
    }
    let _e36 = phi_40_;
    inside = _e36;
    let _e38 = copy_info.tile;
    let _e40 = from_;
    let _e45 = copy_info.tile;
    let _e49 = textureSampleLevel(static_shadow_texture_tex, static_shadow_texture_smp, (_e38.xy + (clamp(_e40, vec2(0f), vec2(1f)) * _e45.zw)), 0f);
    stored = _e49.x;
    let _e53 = copy_info.shift[3u];
    mode = _e53;
    let _e54 = mode;
    nothing = select(1f, 0f, (_e54 > 0.5f));
    let _e57 = inside;
    let _e58 = stored;
    let _e59 = nothing;
    if (_e57 && (_e58 != _e59)) {
        let _e62 = stored;
        let _e65 = copy_info.shift[2u];
        local = clamp((_e62 + _e65), 0f, 1f);
    } else {
        let _e68 = nothing;
        local = _e68;
    }
    let _e69 = local;
    depth = _e69;
    let _e70 = mode;
    if (_e70 > 1.5f) {
        let _e72 = depth;
        depth = (1f - _e72);
    }
    let _e74 = depth;
    frag_color = vec4<f32>(_e74, 0f, 0f, 1f);
    let _e76 = depth;
    gl_FragDepth = _e76;
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> FragmentOutput {
    v_uv_1 = v_uv;
    main_1();
    let _e4 = frag_color;
    let _e5 = gl_FragDepth;
    return FragmentOutput(_e4, _e5);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ShadowCopyInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'tile', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'shift',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'static_shadow_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'EvsmFilter': WebGpuStage(
      wgsl: r'''
struct EvsmFilterInfo {
    axis: vec4<f32>,
    tile: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> evsm_info: EvsmFilterInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var evsm_source_tex: texture_2d<f32>;
@group(1) @binding(2)
var evsm_source_smp: sampler;
var<private> frag_color: vec4<f32>;

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d: f32;

    let _e24 = (*depth);
    d = ((2f * clamp(_e24, 0f, 1f)) - 1f);
    let _e28 = d;
    let _e31 = d;
    return vec2<f32>(exp((40f * _e28)), -(exp((-5f * _e31))));
}

fn EvsmMoments_u0028_f1_u003b(depth_1: ptr<function, f32>) -> vec4<f32> {
    var warped: vec2<f32>;
    var param: f32;

    let _e25 = (*depth_1);
    param = _e25;
    let _e26 = EvsmWarp_u0028_f1_u003b((&param));
    warped = _e26;
    let _e28 = warped[0u];
    let _e30 = warped[0u];
    let _e32 = warped[0u];
    let _e35 = warped[1u];
    let _e37 = warped[1u];
    let _e39 = warped[1u];
    return vec4<f32>(_e28, (_e30 * _e32), _e35, (_e37 * _e39));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored: ptr<function, f32>, mode: ptr<function, f32>) -> f32 {
    var local: f32;

    let _e25 = (*mode);
    if (_e25 > 0.5f) {
        let _e27 = (*stored);
        local = (1f - _e27);
    } else {
        let _e29 = (*stored);
        local = _e29;
    }
    let _e30 = local;
    return _e30;
}

fn main_1() {
    var count: f32;
    var which: f32;
    var lo: vec2<f32>;
    var hi: vec2<f32>;
    var taps: f32;
    var sigma: f32;
    var warp: bool;
    var total: vec4<f32>;
    var weightSum: f32;
    var i: i32;
    var offset: f32;
    var at: vec2<f32>;
    var texel: vec4<f32>;
    var value: vec4<f32>;
    var local_1: vec4<f32>;
    var param_1: f32;
    var param_2: f32;
    var param_3: f32;
    var weight: f32;

    let _e43 = evsm_info.tile[0u];
    count = max(_e43, 1f);
    let _e46 = v_uv_1[0u];
    let _e47 = count;
    let _e50 = count;
    which = min(floor((_e46 * _e47)), (_e50 - 1f));
    let _e53 = which;
    let _e54 = count;
    let _e58 = evsm_info.tile[1u];
    let _e62 = evsm_info.tile[2u];
    lo = vec2<f32>(((_e53 / _e54) + _e58), _e62);
    let _e64 = which;
    let _e66 = count;
    let _e70 = evsm_info.tile[1u];
    let _e74 = evsm_info.tile[2u];
    hi = vec2<f32>((((_e64 + 1f) / _e66) - _e70), (1f - _e74));
    let _e79 = evsm_info.axis[2u];
    taps = clamp(_e79, 0f, 8f);
    let _e81 = taps;
    sigma = max((_e81 * 0.5f), 0.5f);
    let _e86 = evsm_info.axis[3u];
    warp = (_e86 > 0.5f);
    total = vec4<f32>(0f, 0f, 0f, 0f);
    weightSum = 0f;
    i = -8i;
    loop {
        let _e88 = i;
        if (_e88 <= 8i) {
            let _e90 = i;
            offset = f32(_e90);
            let _e92 = offset;
            let _e94 = taps;
            if (abs(_e92) > _e94) {
                continue;
            }
            let _e96 = v_uv_1;
            let _e98 = evsm_info.axis;
            let _e100 = offset;
            let _e103 = lo;
            let _e104 = hi;
            at = clamp((_e96 + (_e98.xy * _e100)), _e103, _e104);
            let _e106 = at;
            let _e107 = textureSampleLevel(evsm_source_tex, evsm_source_smp, _e106, 0f);
            texel = _e107;
            let _e108 = warp;
            if _e108 {
                let _e110 = texel[0u];
                param_1 = _e110;
                let _e113 = evsm_info.tile[3u];
                param_2 = _e113;
                let _e114 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_1), (&param_2));
                param_3 = _e114;
                let _e115 = EvsmMoments_u0028_f1_u003b((&param_3));
                local_1 = _e115;
            } else {
                let _e116 = texel;
                local_1 = _e116;
            }
            let _e117 = local_1;
            value = _e117;
            let _e118 = offset;
            let _e119 = offset;
            let _e122 = sigma;
            let _e124 = sigma;
            weight = exp((-((_e118 * _e119)) / ((2f * _e122) * _e124)));
            let _e128 = value;
            let _e129 = weight;
            let _e131 = total;
            total = (_e131 + (_e128 * _e129));
            let _e133 = weight;
            let _e134 = weightSum;
            weightSum = (_e134 + _e133);
            continue;
        } else {
            break;
        }
        continuing {
            let _e136 = i;
            i = (_e136 + 1i);
        }
    }
    let _e138 = total;
    let _e139 = weightSum;
    frag_color = (_e138 / vec4(_e139));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'EvsmFilterInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'axis', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'tile', offsetInBytes: 16, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'evsm_source',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ShadowTileReset': WebGpuStage(
      wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_uv_1: vec2<f32>;

fn main_1() {
    frag_color = vec4<f32>(1f, 1f, 1f, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'Sky': WebGpuStage(
      wgsl: r'''
var<private> v_ray_1: vec3<f32>;
var<private> v_zenith_1: vec4<f32>;
var<private> v_nadir_1: vec4<f32>;
var<private> v_horizon_1: vec4<f32>;
var<private> v_sun_1: vec4<f32>;
var<private> v_glow_1: vec4<f32>;
var<private> v_disc_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var direction: vec3<f32>;
    var height: f32;
    var far: vec3<f32>;
    var local: vec3<f32>;
    var t: f32;
    var colour: vec3<f32>;
    var towards: f32;
    var disc: f32;
    var local_1: f32;

    let _e26 = v_ray_1;
    direction = normalize(_e26);
    let _e29 = direction[1u];
    height = clamp(_e29, -1f, 1f);
    let _e31 = height;
    if (_e31 >= 0f) {
        let _e33 = v_zenith_1;
        local = _e33.xyz;
    } else {
        let _e35 = v_nadir_1;
        local = _e35.xyz;
    }
    let _e37 = local;
    far = _e37;
    let _e38 = height;
    t = abs(_e38);
    let _e40 = t;
    let _e41 = t;
    let _e43 = t;
    t = ((_e40 * _e41) * (3f - (2f * _e43)));
    let _e47 = v_horizon_1;
    let _e49 = far;
    let _e50 = t;
    colour = mix(_e47.xyz, _e49, vec3(_e50));
    let _e53 = direction;
    let _e54 = v_sun_1;
    towards = dot(_e53, _e54.xyz);
    let _e57 = towards;
    if (_e57 > 0f) {
        let _e59 = v_glow_1;
        let _e62 = v_glow_1[3u];
        let _e63 = towards;
        let _e65 = v_sun_1[3u];
        let _e69 = colour;
        colour = (_e69 + (_e59.xyz * (_e62 * pow(_e63, _e65))));
    }
    let _e72 = v_disc_1[1u];
    if (_e72 > 0f) {
        let _e75 = v_disc_1[0u];
        let _e77 = v_disc_1[1u];
        let _e80 = v_disc_1[0u];
        let _e81 = towards;
        local_1 = smoothstep((_e75 - _e77), _e80, _e81);
    } else {
        let _e84 = v_disc_1[0u];
        let _e85 = towards;
        local_1 = step(_e84, _e85);
    }
    let _e87 = local_1;
    disc = _e87;
    let _e88 = v_glow_1;
    let _e90 = disc;
    let _e92 = v_disc_1[2u];
    let _e95 = colour;
    colour = (_e95 + (_e88.xyz * (_e90 * _e92)));
    let _e97 = colour;
    frag_color = vec4<f32>(_e97.x, _e97.y, _e97.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_ray: vec3<f32>, @location(11) v_zenith: vec4<f32>, @location(4) v_nadir: vec4<f32>, @location(2) v_horizon: vec4<f32>, @location(9) v_sun: vec4<f32>, @location(1) v_glow: vec4<f32>, @location(0) v_disc: vec4<f32>) -> @location(0) vec4<f32> {
    v_ray_1 = v_ray;
    v_zenith_1 = v_zenith;
    v_nadir_1 = v_nadir;
    v_horizon_1 = v_horizon;
    v_sun_1 = v_sun;
    v_glow_1 = v_glow;
    v_disc_1 = v_disc;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'SkyCube': WebGpuStage(
      wgsl: r'''
@group(1) @binding(0)
var sky_texture_tex: texture_cube<f32>;
@group(1) @binding(1)
var sky_texture_smp: sampler;
var<private> v_ray_1: vec3<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_tint_1: vec4<f32>;

fn main_1() {
    var texel: vec3<f32>;
    var linear: vec3<f32>;

    let _e15 = v_ray_1;
    let _e17 = textureSample(sky_texture_tex, sky_texture_smp, normalize(_e15));
    texel = _e17.xyz;
    let _e19 = texel;
    let _e22 = texel;
    let _e28 = texel;
    linear = mix((_e19 / vec3(12.92f)), pow(((_e22 + vec3(0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e28));
    let _e31 = linear;
    let _e32 = v_tint_1;
    let _e34 = (_e31 * _e32.xyz);
    frag_color = vec4<f32>(_e34.x, _e34.y, _e34.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_ray: vec3<f32>, @location(10) v_tint: vec4<f32>) -> @location(0) vec4<f32> {
    v_ray_1 = v_ray;
    v_tint_1 = v_tint;
    main_1();
    let _e5 = frag_color;
    return _e5;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'sky_texture',
          group: 1,
          textureBinding: 0,
          samplerBinding: 1,
          dimension: WebGpuTextureDimension.cube,
        ),
      ],
    ),
    'SkyPhysical': WebGpuStage(
      wgsl: r'''
var<private> v_rayleigh_1: vec4<f32>;
var<private> v_mie_1: vec4<f32>;
var<private> v_planet_1: vec4<f32>;
var<private> v_stars_1: vec4<f32>;
var<private> v_ray_1: vec3<f32>;
var<private> v_sun_1: vec4<f32>;
var<private> v_disc_1: vec4<f32>;
var<private> frag_color: vec4<f32>;

fn Hash_u0028_vf3_u003b(p: ptr<function, vec3<f32>>) -> f32 {
    let _e53 = (*p);
    (*p) = fract((_e53 * 0.1031f));
    let _e56 = (*p);
    let _e57 = (*p);
    let _e62 = (*p);
    (*p) = (_e62 + vec3(dot(_e56, (_e57.zyx + vec3(31.32f)))));
    let _e66 = (*p)[0u];
    let _e68 = (*p)[1u];
    let _e71 = (*p)[2u];
    return fract(((_e66 + _e68) * _e71));
}

fn StarField_u0028_vf3_u003b(d: ptr<function, vec3<f32>>) -> f32 {
    var a: vec3<f32>;
    var face: f32;
    var uv: vec2<f32>;
    var grid: vec2<f32>;
    var cell: vec2<f32>;
    var key: vec3<f32>;
    var param: vec3<f32>;
    var centre: vec2<f32>;
    var param_1: vec3<f32>;
    var param_2: vec3<f32>;
    var off: f32;
    var magnitude: f32;
    var param_3: vec3<f32>;
    var phi_279_: bool;

    let _e66 = (*d);
    a = abs(_e66);
    let _e69 = a[0u];
    let _e71 = a[1u];
    let _e72 = (_e69 >= _e71);
    phi_279_ = _e72;
    if _e72 {
        let _e74 = a[0u];
        let _e76 = a[2u];
        phi_279_ = (_e74 >= _e76);
    }
    let _e79 = phi_279_;
    if _e79 {
        let _e81 = (*d)[0u];
        face = select(1f, 0f, (_e81 > 0f));
        let _e84 = (*d);
        let _e87 = a[0u];
        uv = (_e84.zy / vec2(_e87));
    } else {
        let _e91 = a[1u];
        let _e93 = a[2u];
        if (_e91 >= _e93) {
            let _e96 = (*d)[1u];
            face = select(3f, 2f, (_e96 > 0f));
            let _e99 = (*d);
            let _e102 = a[1u];
            uv = (_e99.xz / vec2(_e102));
        } else {
            let _e106 = (*d)[2u];
            face = select(5f, 4f, (_e106 > 0f));
            let _e109 = (*d);
            let _e112 = a[2u];
            uv = (_e109.xy / vec2(_e112));
        }
    }
    let _e115 = uv;
    let _e120 = v_stars_1[2u];
    grid = (((_e115 * 0.5f) + vec2(0.5f)) * _e120);
    let _e122 = grid;
    cell = floor(_e122);
    let _e124 = cell;
    let _e125 = face;
    key = vec3<f32>(_e124.x, _e124.y, _e125);
    let _e129 = key;
    param = _e129;
    let _e130 = Hash_u0028_vf3_u003b((&param));
    let _e132 = v_stars_1[1u];
    if (_e130 >= _e132) {
        return 0f;
    }
    let _e134 = key;
    param_1 = (_e134 + vec3<f32>(17f, 0f, 0f));
    let _e136 = Hash_u0028_vf3_u003b((&param_1));
    let _e137 = key;
    param_2 = (_e137 + vec3<f32>(0f, 29f, 0f));
    let _e139 = Hash_u0028_vf3_u003b((&param_2));
    centre = ((vec2<f32>(_e136, _e139) * 0.6f) + vec2(0.2f));
    let _e144 = grid;
    let _e145 = cell;
    let _e147 = centre;
    off = length(((_e144 - _e145) - _e147));
    let _e150 = key;
    param_3 = (_e150 + vec3<f32>(0f, 0f, 13f));
    let _e152 = Hash_u0028_vf3_u003b((&param_3));
    magnitude = _e152;
    let _e153 = off;
    let _e156 = magnitude;
    let _e158 = magnitude;
    let _e160 = magnitude;
    return ((1f - smoothstep(0f, 0.35f, _e153)) * (0.15f + (((0.85f * _e156) * _e158) * _e160)));
}

fn Through_u0028_vf3_u003b(air: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e53 = v_rayleigh_1;
    let _e56 = (*air)[0u];
    let _e59 = v_mie_1[1u];
    let _e61 = (*air)[1u];
    let _e66 = v_stars_1[3u];
    let _e68 = (*air)[2u];
    return exp(-((((_e53.xyz * _e56) + vec3((_e59 * _e61))) + (vec3<f32>(0.00065f, 0.001881f, 0.000085f) * (_e66 * _e68)))));
}

fn OzoneDensity_u0028_f1_u003b(h: ptr<function, f32>) -> f32 {
    let _e53 = (*h);
    return max(0f, (1f - (abs((_e53 - 25f)) / 15f)));
}

fn AirAt_u0028_f1_u003b(h_1: ptr<function, f32>) -> vec3<f32> {
    var param_4: f32;

    let _e54 = (*h_1);
    let _e57 = v_rayleigh_1[3u];
    let _e59 = v_mie_1[2u];
    let _e63 = exp((vec2(-(_e54)) / vec2<f32>(_e57, _e59)));
    let _e64 = (*h_1);
    param_4 = _e64;
    let _e65 = OzoneDensity_u0028_f1_u003b((&param_4));
    return vec3<f32>(_e63.x, _e63.y, _e65);
}

fn Leave_u0028_f1_u003b_f1_u003b_f1_u003b(r: ptr<function, f32>, mu: ptr<function, f32>, radius: ptr<function, f32>) -> f32 {
    var b: f32;
    var d_1: f32;
    var local: f32;

    let _e58 = (*r);
    let _e59 = (*mu);
    b = (_e58 * _e59);
    let _e61 = b;
    let _e62 = b;
    let _e64 = (*r);
    let _e65 = (*radius);
    let _e67 = (*r);
    let _e68 = (*radius);
    d_1 = ((_e61 * _e62) - ((_e64 - _e65) * (_e67 + _e68)));
    let _e72 = d_1;
    if (_e72 < 0f) {
        local = -1f;
    } else {
        let _e74 = b;
        let _e76 = d_1;
        local = (-(_e74) + sqrt(_e76));
    }
    let _e79 = local;
    return _e79;
}

fn SunwardAir_u0028_vf3_u003b_vf3_u003b(p_1: ptr<function, vec3<f32>>, s: ptr<function, vec3<f32>>) -> vec3<f32> {
    var r_1: f32;
    var span: f32;
    var param_5: f32;
    var param_6: f32;
    var param_7: f32;
    var stride: f32;
    var air_1: vec3<f32>;
    var j: i32;
    var q: vec3<f32>;
    var param_8: f32;

    let _e64 = (*p_1);
    r_1 = length(_e64);
    let _e66 = (*p_1);
    let _e67 = (*s);
    let _e69 = r_1;
    let _e71 = r_1;
    param_5 = _e71;
    param_6 = (dot(_e66, _e67) / _e69);
    let _e73 = v_planet_1[1u];
    param_7 = _e73;
    let _e74 = Leave_u0028_f1_u003b_f1_u003b_f1_u003b((&param_5), (&param_6), (&param_7));
    span = _e74;
    let _e75 = span;
    stride = (_e75 / 8f);
    air_1 = vec3<f32>(0f, 0f, 0f);
    j = 0i;
    loop {
        let _e77 = j;
        if (_e77 < 8i) {
            let _e79 = (*p_1);
            let _e80 = (*s);
            let _e81 = j;
            let _e84 = stride;
            q = (_e79 + (_e80 * ((f32(_e81) + 0.5f) * _e84)));
            let _e88 = q;
            let _e91 = v_planet_1[0u];
            param_8 = (length(_e88) - _e91);
            let _e93 = AirAt_u0028_f1_u003b((&param_8));
            let _e94 = stride;
            let _e96 = air_1;
            air_1 = (_e96 + (_e93 * _e94));
            continue;
        } else {
            break;
        }
        continuing {
            let _e98 = j;
            j = (_e98 + 1i);
        }
    }
    let _e100 = air_1;
    return _e100;
}

fn Meet_u0028_f1_u003b_f1_u003b_f1_u003b(r_2: ptr<function, f32>, mu_1: ptr<function, f32>, radius_1: ptr<function, f32>) -> f32 {
    var b_1: f32;
    var d_2: f32;
    var local_1: f32;

    let _e58 = (*r_2);
    let _e59 = (*mu_1);
    b_1 = (_e58 * _e59);
    let _e61 = b_1;
    let _e62 = b_1;
    let _e64 = (*r_2);
    let _e65 = (*radius_1);
    let _e67 = (*r_2);
    let _e68 = (*radius_1);
    d_2 = ((_e61 * _e62) - ((_e64 - _e65) * (_e67 + _e68)));
    let _e72 = d_2;
    if (_e72 < 0f) {
        local_1 = -1f;
    } else {
        let _e74 = b_1;
        let _e76 = d_2;
        local_1 = (-(_e74) - sqrt(_e76));
    }
    let _e79 = local_1;
    return _e79;
}

fn main_1() {
    var d_3: vec3<f32>;
    var s_1: vec3<f32>;
    var eye: vec3<f32>;
    var ground: f32;
    var param_9: f32;
    var param_10: f32;
    var param_11: f32;
    var grounded: bool;
    var span_1: f32;
    var local_2: f32;
    var param_12: f32;
    var param_13: f32;
    var param_14: f32;
    var seenAir: vec3<f32>;
    var molecules: vec3<f32>;
    var haze: vec3<f32>;
    var i: i32;
    var a0_: f32;
    var a1_: f32;
    var t: f32;
    var stride_1: f32;
    var p_2: vec3<f32>;
    var r_3: f32;
    var air_2: vec3<f32>;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: f32;
    var through: vec3<f32>;
    var param_19: vec3<f32>;
    var param_20: vec3<f32>;
    var param_21: vec3<f32>;
    var mu_2: f32;
    var g: f32;
    var gg: f32;
    var rayleighPhase: f32;
    var miePhase: f32;
    var colour: vec3<f32>;
    var seen: vec3<f32>;
    var param_22: vec3<f32>;
    var p_3: vec3<f32>;
    var lit: f32;
    var param_23: vec3<f32>;
    var param_24: vec3<f32>;
    var param_25: vec3<f32>;
    var disc: f32;
    var local_3: f32;
    var night: f32;
    var param_26: vec3<f32>;

    let _e101 = v_ray_1;
    d_3 = normalize(_e101);
    let _e103 = v_sun_1;
    s_1 = _e103.xyz;
    let _e106 = v_planet_1[2u];
    eye = vec3<f32>(0f, _e106, 0f);
    let _e109 = v_planet_1[2u];
    param_9 = _e109;
    let _e111 = d_3[1u];
    param_10 = _e111;
    let _e113 = v_planet_1[0u];
    param_11 = _e113;
    let _e114 = Meet_u0028_f1_u003b_f1_u003b_f1_u003b((&param_9), (&param_10), (&param_11));
    ground = _e114;
    let _e115 = ground;
    grounded = (_e115 > 0f);
    let _e117 = grounded;
    if _e117 {
        let _e118 = ground;
        local_2 = _e118;
    } else {
        let _e120 = v_planet_1[2u];
        param_12 = _e120;
        let _e122 = d_3[1u];
        param_13 = _e122;
        let _e124 = v_planet_1[1u];
        param_14 = _e124;
        let _e125 = Leave_u0028_f1_u003b_f1_u003b_f1_u003b((&param_12), (&param_13), (&param_14));
        local_2 = _e125;
    }
    let _e126 = local_2;
    span_1 = _e126;
    seenAir = vec3<f32>(0f, 0f, 0f);
    molecules = vec3<f32>(0f, 0f, 0f);
    haze = vec3<f32>(0f, 0f, 0f);
    i = 0i;
    loop {
        let _e127 = i;
        if (_e127 < 16i) {
            let _e129 = i;
            a0_ = (f32(_e129) / 16f);
            let _e132 = i;
            a1_ = (f32((_e132 + 1i)) / 16f);
            let _e136 = span_1;
            let _e138 = a0_;
            let _e139 = a0_;
            let _e141 = a1_;
            let _e142 = a1_;
            t = ((_e136 * 0.5f) * ((_e138 * _e139) + (_e141 * _e142)));
            let _e146 = span_1;
            let _e147 = a1_;
            let _e148 = a1_;
            let _e150 = a0_;
            let _e151 = a0_;
            stride_1 = (_e146 * ((_e147 * _e148) - (_e150 * _e151)));
            let _e155 = eye;
            let _e156 = d_3;
            let _e157 = t;
            p_2 = (_e155 + (_e156 * _e157));
            let _e160 = p_2;
            r_3 = length(_e160);
            let _e162 = r_3;
            let _e164 = v_planet_1[0u];
            param_15 = (_e162 - _e164);
            let _e166 = AirAt_u0028_f1_u003b((&param_15));
            let _e167 = stride_1;
            air_2 = (_e166 * _e167);
            let _e169 = air_2;
            let _e170 = seenAir;
            seenAir = (_e170 + _e169);
            let _e172 = p_2;
            let _e173 = s_1;
            let _e175 = r_3;
            let _e177 = r_3;
            param_16 = _e177;
            param_17 = (dot(_e172, _e173) / _e175);
            let _e179 = v_planet_1[0u];
            param_18 = _e179;
            let _e180 = Meet_u0028_f1_u003b_f1_u003b_f1_u003b((&param_16), (&param_17), (&param_18));
            if (_e180 > 0f) {
                continue;
            }
            let _e182 = seenAir;
            let _e183 = air_2;
            let _e186 = p_2;
            param_19 = _e186;
            let _e187 = s_1;
            param_20 = _e187;
            let _e188 = SunwardAir_u0028_vf3_u003b_vf3_u003b((&param_19), (&param_20));
            param_21 = ((_e182 - (_e183 * 0.5f)) + _e188);
            let _e190 = Through_u0028_vf3_u003b((&param_21));
            through = _e190;
            let _e192 = air_2[0u];
            let _e193 = through;
            let _e195 = molecules;
            molecules = (_e195 + (_e193 * _e192));
            let _e198 = air_2[1u];
            let _e199 = through;
            let _e201 = haze;
            haze = (_e201 + (_e199 * _e198));
            continue;
        } else {
            break;
        }
        continuing {
            let _e203 = i;
            i = (_e203 + 1i);
        }
    }
    let _e205 = d_3;
    let _e206 = s_1;
    mu_2 = dot(_e205, _e206);
    let _e209 = v_mie_1[3u];
    g = _e209;
    let _e210 = g;
    let _e211 = g;
    gg = (_e210 * _e211);
    let _e213 = mu_2;
    let _e214 = mu_2;
    rayleighPhase = (0.059683103f * (1f + (_e213 * _e214)));
    let _e218 = gg;
    let _e220 = mu_2;
    let _e221 = mu_2;
    let _e226 = gg;
    let _e228 = gg;
    let _e230 = g;
    let _e232 = mu_2;
    miePhase = ((0.119366206f * ((1f - _e218) * (1f + (_e220 * _e221)))) / ((2f + _e226) * pow(((1f + _e228) - ((2f * _e230) * _e232)), 1.5f)));
    let _e239 = v_sun_1[3u];
    let _e240 = molecules;
    let _e241 = v_rayleigh_1;
    let _e244 = rayleighPhase;
    let _e246 = haze;
    let _e248 = v_mie_1[0u];
    let _e249 = miePhase;
    colour = ((((_e240 * _e241.xyz) * _e244) + (_e246 * (_e248 * _e249))) * _e239);
    let _e254 = seenAir;
    param_22 = _e254;
    let _e255 = Through_u0028_vf3_u003b((&param_22));
    seen = _e255;
    let _e256 = grounded;
    if _e256 {
        let _e257 = eye;
        let _e258 = d_3;
        let _e259 = span_1;
        p_3 = (_e257 + (_e258 * _e259));
        let _e262 = p_3;
        let _e264 = s_1;
        lit = dot(normalize(_e262), _e264);
        let _e266 = lit;
        if (_e266 > 0f) {
            let _e268 = seen;
            let _e269 = p_3;
            param_23 = _e269;
            let _e270 = s_1;
            param_24 = _e270;
            let _e271 = SunwardAir_u0028_vf3_u003b_vf3_u003b((&param_23), (&param_24));
            param_25 = _e271;
            let _e272 = Through_u0028_vf3_u003b((&param_25));
            let _e275 = v_planet_1[3u];
            let _e277 = lit;
            let _e280 = v_sun_1[3u];
            let _e283 = colour;
            colour = (_e283 + ((_e268 * _e272) * (((_e275 / 3.1415927f) * _e277) * _e280)));
        }
    } else {
        let _e286 = v_disc_1[1u];
        if (_e286 > 0f) {
            let _e289 = v_disc_1[0u];
            let _e291 = v_disc_1[1u];
            let _e294 = v_disc_1[0u];
            let _e295 = mu_2;
            local_3 = smoothstep((_e289 - _e291), _e294, _e295);
        } else {
            let _e298 = v_disc_1[0u];
            let _e299 = mu_2;
            local_3 = step(_e298, _e299);
        }
        let _e301 = local_3;
        disc = _e301;
        let _e302 = seen;
        let _e303 = disc;
        let _e305 = v_disc_1[2u];
        let _e308 = colour;
        colour = (_e308 + (_e302 * (_e303 * _e305)));
        let _e311 = s_1[1u];
        night = (1f - smoothstep(-0.2f, 0.1f, _e311));
        let _e315 = v_stars_1[0u];
        let _e317 = night;
        if ((_e315 > 0f) && (_e317 > 0f)) {
            let _e320 = seen;
            let _e322 = v_stars_1[0u];
            let _e323 = night;
            let _e325 = d_3;
            param_26 = _e325;
            let _e326 = StarField_u0028_vf3_u003b((&param_26));
            let _e329 = colour;
            colour = (_e329 + (_e320 * ((_e322 * _e323) * _e326)));
        }
    }
    let _e331 = colour;
    frag_color = vec4<f32>(_e331.x, _e331.y, _e331.z, 1f);
    return;
}

@fragment
fn main(@location(7) v_rayleigh: vec4<f32>, @location(3) v_mie: vec4<f32>, @location(5) v_planet: vec4<f32>, @location(8) v_stars: vec4<f32>, @location(6) v_ray: vec3<f32>, @location(9) v_sun: vec4<f32>, @location(0) v_disc: vec4<f32>) -> @location(0) vec4<f32> {
    v_rayleigh_1 = v_rayleigh;
    v_mie_1 = v_mie;
    v_planet_1 = v_planet;
    v_stars_1 = v_stars;
    v_ray_1 = v_ray;
    v_sun_1 = v_sun;
    v_disc_1 = v_disc;
    main_1();
    let _e15 = frag_color;
    return _e15;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'Luminance': WebGpuStage(
      wgsl: r'''
struct LuminanceInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> luminance_info: LuminanceInfo;
@group(1) @binding(1)
var scene_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var scene_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn Luma_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> f32 {
    let _e21 = (*color);
    return dot(_e21, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
}

fn main_1() {
    var footprint: vec2<f32>;
    var sum: f32;
    var j: i32;
    var i: i32;
    var offset: vec2<f32>;
    var param: vec3<f32>;
    var mean: f32;
    var stops: f32;
    var encoded: f32;

    let _e30 = luminance_info.params;
    footprint = _e30.xy;
    sum = 0f;
    j = 0i;
    loop {
        let _e32 = j;
        if (_e32 < 4i) {
            i = 0i;
            loop {
                let _e34 = i;
                if (_e34 < 4i) {
                    let _e36 = i;
                    let _e38 = j;
                    let _e47 = footprint;
                    offset = ((((vec2<f32>(f32(_e36), f32(_e38)) + vec2(0.5f)) / vec2(4f)) - vec2(0.5f)) * _e47);
                    let _e49 = v_uv_1;
                    let _e50 = offset;
                    let _e52 = textureSample(scene_texture_tex, scene_texture_smp, (_e49 + _e50));
                    param = _e52.xyz;
                    let _e54 = Luma_u0028_vf3_u003b((&param));
                    let _e55 = sum;
                    sum = (_e55 + _e54);
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e57 = i;
                    i = (_e57 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e59 = j;
            j = (_e59 + 1i);
        }
    }
    let _e61 = sum;
    mean = (_e61 / 16f);
    let _e63 = mean;
    stops = log2(max(_e63, 0.000001f));
    let _e66 = stops;
    let _e69 = luminance_info.params[2u];
    let _e73 = luminance_info.params[3u];
    encoded = clamp(((_e66 - _e69) * _e73), 0f, 1f);
    let _e76 = encoded;
    frag_color = vec4<f32>(_e76, _e76, _e76, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'LuminanceInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'scene_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'DepthPyramid': WebGpuStage(
      wgsl: r'''
struct DepthPyramidInfo {
    block: vec4<f32>,
    range: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> pyramid_info: DepthPyramidInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var surface_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var surface_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var blockUv: vec2<f32>;
    var tapsX: f32;
    var tapsY: f32;
    var corner: vec2<f32>;
    var stepUv: vec2<f32>;
    var farthest: f32;
    var nearest: f32;
    var empty: f32;
    var j: i32;
    var i: i32;
    var at: vec2<f32>;
    var depth: f32;
    var steps: f32;
    var scaled: f32;
    var high: f32;
    var rest: f32;
    var middle: f32;
    var low: f32;
    var ratio: f32;
    var local: f32;
    var flatness: f32;
    var local_1: f32;

    let _e46 = pyramid_info.block;
    blockUv = _e46.xy;
    let _e50 = pyramid_info.block[2u];
    tapsX = clamp(ceil((_e50 - 0.001f)), 1f, 32f);
    let _e56 = pyramid_info.block[3u];
    tapsY = clamp(ceil((_e56 - 0.001f)), 1f, 32f);
    let _e60 = v_uv_1;
    let _e61 = blockUv;
    corner = (_e60 - (_e61 * 0.5f));
    let _e64 = blockUv;
    let _e65 = tapsX;
    let _e66 = tapsY;
    stepUv = (_e64 / vec2<f32>(_e65, _e66));
    farthest = 0f;
    nearest = 300000000000000000000000000000000000000f;
    empty = 0f;
    j = 0i;
    loop {
        let _e69 = j;
        if (_e69 < 32i) {
            let _e71 = j;
            let _e73 = tapsY;
            if (f32(_e71) >= _e73) {
                break;
            }
            i = 0i;
            loop {
                let _e75 = i;
                if (_e75 < 32i) {
                    let _e77 = i;
                    let _e79 = tapsX;
                    if (f32(_e77) >= _e79) {
                        break;
                    }
                    let _e81 = corner;
                    let _e82 = i;
                    let _e84 = j;
                    let _e89 = stepUv;
                    at = (_e81 + ((vec2<f32>(f32(_e82), f32(_e84)) + vec2(0.5f)) * _e89));
                    let _e92 = at;
                    let _e93 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e92, 0f);
                    depth = _e93.w;
                    let _e95 = depth;
                    let _e97 = empty;
                    empty = select(1f, _e97, (_e95 > 0f));
                    let _e99 = farthest;
                    let _e100 = depth;
                    farthest = max(_e99, _e100);
                    let _e102 = nearest;
                    let _e103 = depth;
                    nearest = min(_e102, _e103);
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e105 = i;
                    i = (_e105 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e107 = j;
            j = (_e107 + 1i);
        }
    }
    steps = 16777215f;
    let _e109 = farthest;
    let _e112 = pyramid_info.range[0u];
    let _e115 = steps;
    scaled = ceil((clamp((_e109 * _e112), 0f, 1f) * _e115));
    let _e118 = scaled;
    high = floor((_e118 / 65536f));
    let _e121 = scaled;
    let _e122 = high;
    rest = (_e121 - (_e122 * 65536f));
    let _e125 = rest;
    middle = floor((_e125 / 256f));
    let _e128 = rest;
    let _e129 = middle;
    low = (_e128 - (_e129 * 256f));
    let _e132 = farthest;
    if (_e132 > 0f) {
        let _e134 = nearest;
        let _e135 = farthest;
        local = clamp((_e134 / _e135), 0f, 1f);
    } else {
        local = 0f;
    }
    let _e138 = local;
    ratio = _e138;
    let _e139 = ratio;
    flatness = (128f + floor(((_e139 * 127f) + 0.001f)));
    let _e144 = high;
    let _e146 = middle;
    let _e148 = low;
    let _e150 = empty;
    if (_e150 > 0f) {
        local_1 = 0f;
    } else {
        let _e152 = flatness;
        local_1 = (_e152 / 255f);
    }
    let _e154 = local_1;
    frag_color = vec4<f32>((_e144 / 255f), (_e146 / 255f), (_e148 / 255f), _e154);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'DepthPyramidInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'block', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'range',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ObjectId': WebGpuStage(
      wgsl: r'''
struct IdInfo {
    id: vec4<f32>,
    mask: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
@group(1) @binding(0)
var<uniform> id_info: IdInfo;
@group(1) @binding(1)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
var<private> frag_color: vec4<f32>;
var<private> v_world_position_1: vec3<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn main_1() {
    var cutoff: f32;
    var alpha: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    let _e29 = id_info.mask[0u];
    cutoff = _e29;
    let _e30 = cutoff;
    if (_e30 >= 0f) {
        let _e32 = v_texcoord_1;
        let _e33 = textureSample(base_color_texture_tex, base_color_texture_smp, _e32);
        let _e37 = id_info.mask[1u];
        let _e40 = v_color_1[3u];
        alpha = ((_e33.w * _e37) * _e40);
        let _e42 = alpha;
        let _e43 = cutoff;
        if (_e42 < _e43) {
            discard;
        }
    }
    let _e46 = id_info.id;
    let _e47 = _e46.xyz;
    frag_color = vec4<f32>(_e47.x, _e47.y, _e47.z, 1f);
    return;
}

@fragment
fn main(@location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e13 = frag_color;
    return _e13;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'IdInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 32,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'id', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'mask', offsetInBytes: 16, sizeInBytes: 16),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'VertexTextureProbe': WebGpuStage(
      wgsl: r'''
var<private> frag_color: vec4<f32>;
var<private> v_sampled_1: vec4<f32>;

fn main_1() {
    let _e2 = v_sampled_1;
    frag_color = _e2;
    return;
}

@fragment
fn main(@location(0) v_sampled: vec4<f32>) -> @location(0) vec4<f32> {
    v_sampled_1 = v_sampled;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[],
    ),
    'FieldDecay': WebGpuStage(
      wgsl: r'''
struct FieldDecayInfo {
    params: vec4<f32>,
}

var<private> frag_color: vec4<f32>;
@group(1) @binding(1)
var field_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var field_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(0)
var<uniform> field_decay: FieldDecayInfo;

fn main_1() {
    let _e9 = v_uv_1;
    let _e10 = textureSampleLevel(field_texture_tex, field_texture_smp, _e9, 0f);
    let _e13 = field_decay.params[0u];
    let _e17 = field_decay.params[1u];
    frag_color = ((_e10 * _e13) + vec4(_e17));
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FieldDecayInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'field_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'IrradianceConvolve': WebGpuStage(
      wgsl: r'''
struct ConvolveInfo {
    probe: vec4<f32>,
    tiles: vec4<f32>,
    atlas: vec4<f32>,
}

@group(1) @binding(7)
var surface_texture_tex: texture_cube<f32>;
@group(1) @binding(8)
var surface_texture_smp: sampler;
@group(1) @binding(0)
var<uniform> convolve_info: ConvolveInfo;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(1)
var field_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var field_texture_smp: sampler;
var<private> frag_color: vec4<f32>;
@group(1) @binding(5)
var seed_texture_tex: texture_2d<f32>;
@group(1) @binding(6)
var seed_texture_smp: sampler;
@group(1) @binding(3)
var radiance_texture_tex: texture_cube<f32>;
@group(1) @binding(4)
var radiance_texture_smp: sampler;

fn DistanceAlong_u0028_vf3_u003b(direction: ptr<function, vec3<f32>>) -> f32 {
    var depth: f32;
    var axis: f32;

    let _e29 = (*direction);
    let _e30 = textureSampleLevel(surface_texture_tex, surface_texture_smp, _e29, 0f);
    depth = _e30.w;
    let _e32 = depth;
    if (_e32 <= 0f) {
        let _e36 = convolve_info.tiles[3u];
        return _e36;
    }
    let _e38 = (*direction)[0u];
    let _e41 = (*direction)[1u];
    let _e44 = (*direction)[2u];
    axis = max(abs(_e38), max(abs(_e41), abs(_e44)));
    let _e48 = depth;
    let _e49 = axis;
    return (_e48 / max(_e49, 0.0001f));
}

fn CubeTexel_u0028_i1_u003b_f1_u003b_f1_u003b(face: ptr<function, i32>, a: ptr<function, f32>, b: ptr<function, f32>) -> vec3<f32> {
    var side: f32;
    var axis_1: i32;

    let _e31 = (*face);
    side = select(-1f, 1f, ((_e31 & 1i) == 0i));
    let _e35 = (*face);
    axis_1 = (_e35 >> bitcast<u32>(1i));
    let _e38 = axis_1;
    if (_e38 == 0i) {
        let _e40 = side;
        let _e41 = (*a);
        let _e42 = (*b);
        return vec3<f32>(_e40, _e41, _e42);
    }
    let _e44 = axis_1;
    if (_e44 == 1i) {
        let _e46 = (*a);
        let _e47 = side;
        let _e48 = (*b);
        return vec3<f32>(_e46, _e47, _e48);
    }
    let _e50 = (*a);
    let _e51 = (*b);
    let _e52 = side;
    return vec3<f32>(_e50, _e51, _e52);
}

fn DecodeProbeOctahedral_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {
    var xy: vec2<f32>;
    var z: f32;
    var t: f32;
    var n: vec3<f32>;
    var local: f32;
    var local_1: f32;

    let _e33 = (*uv);
    xy = ((_e33 * 2f) - vec2(1f));
    let _e38 = xy[0u];
    let _e42 = xy[1u];
    z = ((1f - abs(_e38)) - abs(_e42));
    let _e45 = z;
    t = max(-(_e45), 0f);
    let _e49 = xy[0u];
    let _e51 = xy[0u];
    if (_e51 >= 0f) {
        let _e53 = t;
        local = -(_e53);
    } else {
        let _e55 = t;
        local = _e55;
    }
    let _e56 = local;
    let _e59 = xy[1u];
    let _e61 = xy[1u];
    if (_e61 >= 0f) {
        let _e63 = t;
        local_1 = -(_e63);
    } else {
        let _e65 = t;
        local_1 = _e65;
    }
    let _e66 = local_1;
    let _e68 = z;
    n = vec3<f32>((_e49 + _e56), (_e59 + _e66), _e68);
    let _e70 = n;
    return normalize(_e70);
}

fn InteriorOf_u0028_vf2_u003b_f1_u003b(local_2: ptr<function, vec2<f32>>, interior: ptr<function, f32>) -> vec2<f32> {
    var last: f32;
    var i: vec2<f32>;
    var left: bool;
    var right: bool;
    var top: bool;
    var bottom: bool;
    var phi_165_: bool;

    let _e34 = (*interior);
    last = (_e34 - 1f);
    let _e36 = (*local_2);
    i = (_e36 - vec2(1f));
    let _e40 = (*local_2)[0u];
    left = (_e40 < 0.5f);
    let _e43 = (*local_2)[0u];
    let _e44 = (*interior);
    right = (_e43 > (_e44 + 0.5f));
    let _e48 = (*local_2)[1u];
    top = (_e48 < 0.5f);
    let _e51 = (*local_2)[1u];
    let _e52 = (*interior);
    bottom = (_e51 > (_e52 + 0.5f));
    let _e55 = left;
    let _e56 = right;
    let _e57 = (_e55 || _e56);
    phi_165_ = _e57;
    if _e57 {
        let _e58 = top;
        let _e59 = bottom;
        phi_165_ = (_e58 || _e59);
    }
    let _e62 = phi_165_;
    if _e62 {
        let _e63 = left;
        let _e64 = last;
        let _e66 = top;
        let _e67 = last;
        return vec2<f32>(select(0f, _e64, _e63), select(0f, _e67, _e66));
    }
    let _e70 = top;
    if _e70 {
        let _e71 = last;
        let _e73 = i[0u];
        return vec2<f32>((_e71 - _e73), 0f);
    }
    let _e76 = bottom;
    if _e76 {
        let _e77 = last;
        let _e79 = i[0u];
        let _e81 = last;
        return vec2<f32>((_e77 - _e79), _e81);
    }
    let _e83 = left;
    if _e83 {
        let _e84 = last;
        let _e86 = i[1u];
        return vec2<f32>(0f, (_e84 - _e86));
    }
    let _e89 = right;
    if _e89 {
        let _e90 = last;
        let _e91 = last;
        let _e93 = i[1u];
        return vec2<f32>(_e90, (_e91 - _e93));
    }
    let _e96 = i;
    return _e96;
}

fn main_1() {
    var size: vec2<f32>;
    var pixel: vec2<f32>;
    var old: vec4<f32>;
    var columns: f32;
    var target_: f32;
    var irradianceTile: f32;
    var depthTile: f32;
    var momentsTop: f32;
    var moments: bool;
    var stride: f32;
    var local_3: vec2<f32>;
    var local_4: vec2<f32>;
    var tile: vec2<f32>;
    var interior_1: f32;
    var texel: vec2<f32>;
    var param: vec2<f32>;
    var param_1: f32;
    var normal: vec3<f32>;
    var param_2: vec2<f32>;
    var captureSide: i32;
    var span: f32;
    var light: vec3<f32>;
    var mean: f32;
    var square: f32;
    var weight: f32;
    var face_1: i32;
    var row: i32;
    var column: i32;
    var a_1: f32;
    var b_1: f32;
    var inverse: f32;
    var direction_1: vec3<f32>;
    var param_3: i32;
    var param_4: f32;
    var param_5: f32;
    var solidAngle: f32;
    var cosine: f32;
    var c2_: f32;
    var w: f32;
    var distance_: f32;
    var param_6: vec3<f32>;
    var w_1: f32;
    var keep: f32;
    var fresh: vec2<f32>;
    var local_5: vec2<f32>;
    var fresh_1: vec3<f32>;
    var local_6: vec3<f32>;
    var phi_375_: bool;

    let _e74 = convolve_info.atlas;
    size = _e74.xy;
    let _e76 = v_uv_1;
    let _e77 = size;
    pixel = floor((_e76 * _e77));
    let _e80 = pixel;
    let _e83 = size;
    let _e85 = textureSampleLevel(field_texture_tex, field_texture_smp, ((_e80 + vec2(0.5f)) / _e83), 0f);
    old = _e85;
    let _e88 = convolve_info.probe[1u];
    if (_e88 > 0.5f) {
        let _e90 = pixel;
        let _e93 = size;
        let _e95 = textureSampleLevel(seed_texture_tex, seed_texture_smp, ((_e90 + vec2(0.5f)) / _e93), 0f);
        frag_color = _e95;
        return;
    }
    let _e98 = convolve_info.probe[3u];
    columns = _e98;
    let _e101 = convolve_info.probe[0u];
    target_ = _e101;
    let _e104 = convolve_info.tiles[0u];
    irradianceTile = _e104;
    let _e107 = convolve_info.tiles[1u];
    depthTile = _e107;
    let _e110 = convolve_info.tiles[2u];
    momentsTop = _e110;
    let _e112 = pixel[1u];
    let _e113 = momentsTop;
    moments = (_e112 >= _e113);
    let _e115 = moments;
    let _e116 = depthTile;
    let _e117 = irradianceTile;
    stride = (select(_e117, _e116, _e115) + 2f);
    let _e120 = moments;
    if _e120 {
        let _e122 = pixel[0u];
        let _e124 = pixel[1u];
        let _e125 = momentsTop;
        local_4 = vec2<f32>(_e122, (_e124 - _e125));
    } else {
        let _e128 = pixel;
        local_4 = _e128;
    }
    let _e129 = local_4;
    local_3 = _e129;
    let _e130 = local_3;
    let _e131 = stride;
    tile = floor((_e130 / vec2(_e131)));
    let _e136 = tile[1u];
    let _e137 = columns;
    let _e140 = tile[0u];
    let _e142 = target_;
    let _e143 = (((_e136 * _e137) + _e140) != _e142);
    phi_375_ = _e143;
    if !(_e143) {
        let _e146 = tile[0u];
        let _e147 = columns;
        phi_375_ = (_e146 >= _e147);
    }
    let _e150 = phi_375_;
    if _e150 {
        let _e151 = old;
        frag_color = _e151;
        return;
    }
    let _e152 = moments;
    let _e153 = depthTile;
    let _e154 = irradianceTile;
    interior_1 = select(_e154, _e153, _e152);
    let _e156 = local_3;
    let _e157 = tile;
    let _e158 = stride;
    param = (_e156 - (_e157 * _e158));
    let _e161 = interior_1;
    param_1 = _e161;
    let _e162 = InteriorOf_u0028_vf2_u003b_f1_u003b((&param), (&param_1));
    texel = _e162;
    let _e163 = texel;
    let _e166 = interior_1;
    param_2 = ((_e163 + vec2(0.5f)) / vec2(_e166));
    let _e169 = DecodeProbeOctahedral_u0028_vf2_u003b((&param_2));
    normal = _e169;
    let _e172 = convolve_info.atlas[2u];
    captureSide = max(i32((_e172 + 0.5f)), 1i);
    let _e176 = captureSide;
    span = (2f / f32(_e176));
    light = vec3<f32>(0f, 0f, 0f);
    mean = 0f;
    square = 0f;
    weight = 0f;
    face_1 = 0i;
    loop {
        let _e179 = face_1;
        if (_e179 < 6i) {
            row = 0i;
            loop {
                let _e181 = row;
                let _e182 = captureSide;
                if (_e181 < _e182) {
                    column = 0i;
                    loop {
                        let _e184 = column;
                        let _e185 = captureSide;
                        if (_e184 < _e185) {
                            let _e187 = column;
                            let _e190 = span;
                            a_1 = (((f32(_e187) + 0.5f) * _e190) - 1f);
                            let _e193 = row;
                            let _e196 = span;
                            b_1 = (((f32(_e193) + 0.5f) * _e196) - 1f);
                            let _e199 = a_1;
                            let _e200 = a_1;
                            let _e203 = b_1;
                            let _e204 = b_1;
                            inverse = inverseSqrt(((1f + (_e199 * _e200)) + (_e203 * _e204)));
                            let _e208 = face_1;
                            param_3 = _e208;
                            let _e209 = a_1;
                            param_4 = _e209;
                            let _e210 = b_1;
                            param_5 = _e210;
                            let _e211 = CubeTexel_u0028_i1_u003b_f1_u003b_f1_u003b((&param_3), (&param_4), (&param_5));
                            let _e212 = inverse;
                            direction_1 = (_e211 * _e212);
                            let _e214 = inverse;
                            let _e215 = inverse;
                            let _e217 = inverse;
                            solidAngle = ((_e214 * _e215) * _e217);
                            let _e219 = normal;
                            let _e220 = direction_1;
                            cosine = dot(_e219, _e220);
                            let _e222 = cosine;
                            if (_e222 <= 0f) {
                                continue;
                            }
                            let _e224 = moments;
                            if _e224 {
                                let _e225 = cosine;
                                let _e226 = cosine;
                                c2_ = (_e225 * _e226);
                                let _e228 = c2_;
                                let _e229 = c2_;
                                let _e231 = c2_;
                                let _e233 = solidAngle;
                                w = (((_e228 * _e229) * _e231) * _e233);
                                let _e235 = direction_1;
                                param_6 = _e235;
                                let _e236 = DistanceAlong_u0028_vf3_u003b((&param_6));
                                distance_ = _e236;
                                let _e237 = distance_;
                                let _e238 = w;
                                let _e240 = mean;
                                mean = (_e240 + (_e237 * _e238));
                                let _e242 = distance_;
                                let _e243 = distance_;
                                let _e245 = w;
                                let _e247 = square;
                                square = (_e247 + ((_e242 * _e243) * _e245));
                                let _e249 = w;
                                let _e250 = weight;
                                weight = (_e250 + _e249);
                            } else {
                                let _e252 = cosine;
                                let _e253 = solidAngle;
                                w_1 = (_e252 * _e253);
                                let _e255 = direction_1;
                                let _e256 = textureSampleLevel(radiance_texture_tex, radiance_texture_smp, _e255, 0f);
                                let _e258 = w_1;
                                let _e260 = light;
                                light = (_e260 + (_e256.xyz * _e258));
                                let _e262 = w_1;
                                let _e263 = weight;
                                weight = (_e263 + _e262);
                            }
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e265 = column;
                            column = (_e265 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e267 = row;
                    row = (_e267 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e269 = face_1;
            face_1 = (_e269 + 1i);
        }
    }
    let _e273 = convolve_info.probe[2u];
    keep = _e273;
    let _e274 = moments;
    if _e274 {
        let _e275 = weight;
        if (_e275 > 0f) {
            let _e277 = mean;
            let _e278 = square;
            let _e280 = weight;
            local_5 = (vec2<f32>(_e277, _e278) / vec2(_e280));
        } else {
            let _e283 = old;
            local_5 = _e283.xy;
        }
        let _e285 = local_5;
        fresh = _e285;
        let _e286 = fresh;
        let _e287 = old;
        let _e289 = keep;
        let _e291 = mix(_e286, _e287.xy, vec2(_e289));
        frag_color = vec4<f32>(_e291.x, _e291.y, 0f, 1f);
    } else {
        let _e295 = weight;
        if (_e295 > 0f) {
            let _e297 = light;
            let _e298 = weight;
            local_6 = (_e297 / vec3(_e298));
        } else {
            let _e301 = old;
            local_6 = _e301.xyz;
        }
        let _e303 = local_6;
        fresh_1 = _e303;
        let _e304 = fresh_1;
        let _e305 = old;
        let _e307 = keep;
        let _e309 = mix(_e304, _e305.xyz, vec3(_e307));
        let _e311 = old[3u];
        frag_color = vec4<f32>(_e309.x, _e309.y, _e309.z, _e311);
    }
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'ConvolveInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 48,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'probe', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'tiles',
              offsetInBytes: 16,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'atlas',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'field_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'radiance_texture',
          group: 1,
          textureBinding: 3,
          samplerBinding: 4,
          dimension: WebGpuTextureDimension.cube,
        ),
        WebGpuSampler(
          name: 'seed_texture',
          group: 1,
          textureBinding: 5,
          samplerBinding: 6,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'surface_texture',
          group: 1,
          textureBinding: 7,
          samplerBinding: 8,
          dimension: WebGpuTextureDimension.cube,
        ),
      ],
    ),
    'WboitResolve': WebGpuStage(
      wgsl: r'''
@group(1) @binding(0)
var accumulation_texture_tex: texture_2d<f32>;
@group(1) @binding(1)
var accumulation_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
@group(1) @binding(2)
var revealage_texture_tex: texture_2d<f32>;
@group(1) @binding(3)
var revealage_texture_smp: sampler;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var accumulation: vec4<f32>;
    var coverage: f32;
    var average: vec3<f32>;

    let _e15 = v_uv_1;
    let _e16 = textureSample(accumulation_texture_tex, accumulation_texture_smp, _e15);
    accumulation = _e16;
    let _e17 = v_uv_1;
    let _e18 = textureSample(revealage_texture_tex, revealage_texture_smp, _e17);
    coverage = (1f - _e18.x);
    let _e21 = accumulation;
    let _e25 = accumulation[3u];
    average = (min(_e21.xyz, vec3<f32>(65504f, 65504f, 65504f)) / vec3(clamp(_e25, 0.00001f, 65504f)));
    let _e29 = average;
    let _e30 = coverage;
    let _e31 = (_e29 * _e30);
    let _e32 = coverage;
    frag_color = vec4<f32>(_e31.x, _e31.y, _e31.z, _e32);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'accumulation_texture',
          group: 1,
          textureBinding: 0,
          samplerBinding: 1,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'revealage_texture',
          group: 1,
          textureBinding: 2,
          samplerBinding: 3,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'SceneColorCopy': WebGpuStage(
      wgsl: r'''
struct SceneCopyInfo {
    params: vec4<f32>,
}

@group(1) @binding(0)
var<uniform> copy_info: SceneCopyInfo;
@group(1) @binding(1)
var source_texture_tex: texture_2d<f32>;
@group(1) @binding(2)
var source_texture_smp: sampler;
var<private> v_uv_1: vec2<f32>;
var<private> frag_color: vec4<f32>;

fn main_1() {
    var taps: f32;
    var texel: vec2<f32>;
    var first: f32;
    var sum: vec3<f32>;
    var j: i32;
    var i: i32;
    var offset: vec2<f32>;

    let _e22 = copy_info.params[0u];
    taps = _e22;
    let _e24 = copy_info.params;
    texel = _e24.yz;
    let _e26 = taps;
    first = (1f - _e26);
    sum = vec3<f32>(0f, 0f, 0f);
    j = 0i;
    loop {
        let _e28 = j;
        if (_e28 < 16i) {
            let _e30 = j;
            let _e32 = taps;
            if (f32(_e30) >= _e32) {
                break;
            }
            i = 0i;
            loop {
                let _e34 = i;
                if (_e34 < 16i) {
                    let _e36 = i;
                    let _e38 = taps;
                    if (f32(_e36) >= _e38) {
                        break;
                    }
                    let _e40 = first;
                    let _e41 = i;
                    let _e45 = first;
                    let _e46 = j;
                    let _e51 = texel;
                    offset = (vec2<f32>((_e40 + (2f * f32(_e41))), (_e45 + (2f * f32(_e46)))) * _e51);
                    let _e53 = v_uv_1;
                    let _e54 = offset;
                    let _e56 = textureSampleLevel(source_texture_tex, source_texture_smp, (_e53 + _e54), 0f);
                    let _e58 = sum;
                    sum = (_e58 + _e56.xyz);
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e60 = i;
                    i = (_e60 + 1i);
                }
            }
            continue;
        } else {
            break;
        }
        continuing {
            let _e62 = j;
            j = (_e62 + 1i);
        }
    }
    let _e64 = sum;
    let _e65 = taps;
    let _e66 = taps;
    let _e69 = (_e64 / vec3((_e65 * _e66)));
    frag_color = vec4<f32>(_e69.x, _e69.y, _e69.z, 1f);
    return;
}

@fragment
fn main(@location(6) v_uv: vec2<f32>) -> @location(0) vec4<f32> {
    v_uv_1 = v_uv;
    main_1();
    let _e3 = frag_color;
    return _e3;
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'SceneCopyInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 16,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 0,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'source_texture',
          group: 1,
          textureBinding: 1,
          samplerBinding: 2,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'Impostor': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(6)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(12)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var point_shadow_texture_smp: sampler;
@group(1) @binding(10)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var point_shadow_static_texture_smp: sampler;
@group(1) @binding(14)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var shadow_texture_smp: sampler;
@group(1) @binding(8)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var normal_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e172 = v_world_position_1;
    let _e174 = fog_info.eye;
    let _e178 = fog_info.forward;
    return dot((_e172 - _e174.xyz), _e178.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e177 = ViewDepth_u0028_();
    z = abs(_e177);
    let _e179 = z;
    near = (_e179 / 5f);
    let _e181 = z;
    far = (_e181 / 200f);
    let _e183 = far;
    let _e184 = far;
    let _e186 = far;
    far3_ = ((_e183 * _e184) * _e186);
    let _e188 = (*alpha);
    let _e189 = near;
    let _e190 = near;
    let _e193 = far3_;
    let _e194 = far3_;
    return (_e188 * clamp((10f / ((0.00001f + (_e189 * _e190)) + (_e193 * _e194))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e181 = fog_info.forward[3u];
    mode = _e181;
    let _e182 = mode;
    if (_e182 > 0.5f) {
        let _e185 = frag_color[3u];
        alpha_1 = _e185;
        let _e186 = alpha_1;
        param = _e186;
        let _e187 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e187;
        let _e188 = frag_color;
        let _e190 = weight;
        let _e191 = (_e188.xyz * _e190);
        let _e192 = alpha_1;
        let _e193 = weight;
        accumulate = vec4<f32>(_e191.x, _e191.y, _e191.z, (_e192 * _e193));
        let _e199 = mode;
        let _e201 = mode;
        revealage = ((_e199 > 1.5f) && (_e201 < 2.5f));
        let _e204 = revealage;
        if _e204 {
            let _e205 = alpha_1;
            local = vec4(_e205);
        } else {
            let _e207 = accumulate;
            local = _e207;
        }
        let _e208 = local;
        frag_color = _e208;
        let _e209 = mode;
        if (_e209 > 2.5f) {
            let _e211 = alpha_1;
            frag_surface = vec4(_e211);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e175 = (*n)[0u];
    let _e178 = (*n)[1u];
    let _e182 = (*n)[2u];
    let _e185 = (*n);
    (*n) = (_e185 / vec3(((abs(_e175) + abs(_e178)) + abs(_e182))));
    let _e188 = (*n);
    e = _e188.xy;
    let _e191 = (*n)[2u];
    if (_e191 < 0f) {
        let _e193 = (*n);
        let _e199 = (*n)[0u];
        let _e203 = (*n)[1u];
        e = ((vec2(1f) - abs(_e193.yx)) * vec2<f32>(select(-1f, 1f, (_e199 >= 0f)), select(-1f, 1f, (_e203 >= 0f))));
    }
    let _e208 = e;
    return ((_e208 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e173 = (*linear);
    let _e175 = (*linear);
    let _e179 = (*linear);
    return mix((_e173 * 12.92f), ((pow(_e175, 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), _e179));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e176 = g_albedo;
    param_1 = clamp(_e176, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e178 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e178.x, _e178.y, _e178.z, 1f);
    let _e183 = g_debug_surface_on;
    if _e183 {
        let _e184 = g_debug_surface;
        let _e185 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e184.x, _e184.y, _e184.z, _e185);
        return;
    }
    let _e190 = v_normal_1;
    geometric = normalize(_e190);
    let _e192 = gl_FrontFacing_1;
    if !(_e192) {
        let _e194 = geometric;
        geometric = -(_e194);
    }
    let _e196 = geometric;
    param_2 = _e196;
    let _e197 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e198 = (*roughness);
    let _e200 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e197.x, _e197.y, clamp(_e198, 0f, 1f), _e200);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e174 = fog_info.projection[0u];
    return (_e174 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e173 = Orthographic_u0028_();
    if _e173 {
        let _e174 = ViewDepth_u0028_();
        local_1 = max(_e174, 0f);
    } else {
        let _e176 = v_world_position_1;
        let _e178 = fog_info.eye;
        local_1 = distance(_e176, _e178.xyz);
    }
    let _e181 = local_1;
    return _e181;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e180 = fog_info.fog[3u];
    density = _e180;
    let _e181 = density;
    if (_e181 <= 0f) {
        let _e183 = (*color);
        return _e183;
    }
    let _e184 = EyeDistance_u0028_();
    d = _e184;
    let _e187 = fog_info.eye[3u];
    falloff = _e187;
    let _e188 = falloff;
    if (_e188 > 0f) {
        let _e190 = falloff;
        let _e192 = v_world_position_1[1u];
        let _e195 = fog_info.eye[1u];
        k = (_e190 * (_e192 - _e195));
        let _e198 = k;
        if (abs(_e198) > 0.001f) {
            let _e201 = k;
            let _e205 = k;
            local_2 = ((1f - exp(-(_e201))) / _e205);
        } else {
            let _e207 = k;
            local_2 = (1f - (0.5f * _e207));
        }
        let _e210 = local_2;
        let _e211 = density;
        density = (_e211 * _e210);
    }
    let _e214 = fog_info.fog;
    let _e216 = (*color);
    let _e217 = density;
    let _e219 = d;
    return mix(_e214.xyz, _e216, vec3(clamp(exp((-(_e217) * _e219)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e178 = g_premultiply;
    let _e179 = (*alpha_2);
    weight_1 = select(1f, _e179, _e178);
    let _e181 = (*linearColor);
    param_3 = _e181;
    let _e182 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e183 = weight_1;
    let _e184 = (_e182 * _e183);
    let _e185 = (*alpha_2);
    let _e186 = g_pass_through;
    frag_color = vec4<f32>(_e184.x, _e184.y, _e184.z, (_e185 * (1f - _e186)));
    let _e193 = (*roughness_1);
    param_4 = _e193;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    let _e175 = (*s).albedo;
    return _e175;
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e173 = (*i);
    if (_e173 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e175 = (*i);
    if (_e175 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e177 = (*i);
    if (_e177 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e179 = (*i);
    if (_e179 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e181 = (*i);
    if (_e181 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e183 = (*i);
    if (_e183 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e185 = (*i);
    if (_e185 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_5: i32;

    let _e178 = (*i_1);
    param_5 = _e178;
    let _e179 = PointShadowDiskTap_u0028_i1_u003b((&param_5));
    p = _e179;
    let _e181 = p[0u];
    let _e182 = (*ca);
    let _e185 = p[1u];
    let _e186 = (*sa);
    let _e190 = p[0u];
    let _e191 = (*sa);
    let _e194 = p[1u];
    let _e195 = (*ca);
    let _e199 = (*radius);
    return (vec2<f32>(((_e181 * _e182) - (_e185 * _e186)), ((_e190 * _e191) + (_e194 * _e195))) * _e199);
}

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_3: vec2<f32>;
    var atlas: vec2<f32>;

    let _e181 = point_shadow.params[0u];
    inset = _e181;
    let _e182 = (*uv);
    let _e183 = (*offset);
    let _e185 = inset;
    let _e186 = inset;
    local_3 = clamp((_e182 + _e183), vec2(_e185), vec2((1f - _e186)));
    let _e191 = local_3;
    let _e192 = (*tile);
    atlas = ((_e191 + _e192) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e197 = point_shadow.params3_[0u];
    if (_e197 > 0.5f) {
        let _e200 = atlas[1u];
        atlas[1u] = (1f - _e200);
    }
    let _e203 = atlas;
    let _e204 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e203, 0f);
    let _e206 = atlas;
    let _e207 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e206, 0f);
    let _e210 = (*range);
    return (min(_e204.x, _e207.x) * _e210);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_6: vec2<f32>;
    var param_7: vec2<f32>;
    var param_8: vec2<f32>;
    var param_9: f32;

    let _e182 = (*uv_1);
    param_6 = _e182;
    let _e183 = (*offset_1);
    param_7 = _e183;
    let _e184 = (*tile_1);
    param_8 = _e184;
    let _e185 = (*range_1);
    param_9 = _e185;
    let _e186 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_6), (&param_7), (&param_8), (&param_9));
    stored = _e186;
    let _e187 = stored;
    let _e188 = (*range_1);
    if (_e187 >= (_e188 * 0.999f)) {
        return 1f;
    }
    let _e191 = (*receiver);
    let _e192 = stored;
    return select(1f, 0f, (_e191 > _e192));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_10: vec2<f32>;
    var param_11: vec2<f32>;
    var param_12: vec2<f32>;
    var param_13: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_14: i32;
    var param_15: f32;
    var param_16: f32;
    var param_17: f32;
    var param_18: vec2<f32>;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e203 = point_shadow.params2_[1u];
    lightRadius = _e203;
    let _e206 = point_shadow.params2_[0u];
    minRadius = _e206;
    let _e209 = point_shadow.params2_[2u];
    maxRadius = _e209;
    let _e210 = lightRadius;
    if (_e210 <= 0f) {
        let _e212 = (*uv_2);
        param_10 = _e212;
        param_11 = vec2<f32>(0f, 0f);
        let _e213 = (*tile_2);
        param_12 = _e213;
        let _e214 = (*range_2);
        param_13 = _e214;
        let _e215 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_10), (&param_11), (&param_12), (&param_13));
        (*blockerOut) = _e215;
        let _e216 = minRadius;
        return _e216;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e217 = i_2;
        if (_e217 < 8i) {
            let _e219 = i_2;
            param_14 = _e219;
            let _e220 = (*ca_1);
            param_15 = _e220;
            let _e221 = (*sa_1);
            param_16 = _e221;
            let _e222 = maxRadius;
            param_17 = _e222;
            let _e223 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_14), (&param_15), (&param_16), (&param_17));
            let _e224 = (*uv_2);
            param_18 = _e224;
            param_19 = _e223;
            let _e225 = (*tile_2);
            param_20 = _e225;
            let _e226 = (*range_2);
            param_21 = _e226;
            let _e227 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_18), (&param_19), (&param_20), (&param_21));
            stored_1 = _e227;
            let _e228 = stored_1;
            let _e229 = (*range_2);
            if (_e228 >= (_e229 * 0.999f)) {
                continue;
            }
            let _e232 = stored_1;
            let _e233 = (*receiver_1);
            if (_e232 >= _e233) {
                continue;
            }
            let _e235 = stored_1;
            let _e236 = sum;
            sum = (_e236 + _e235);
            let _e238 = count;
            count = (_e238 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e240 = i_2;
            i_2 = (_e240 + 1i);
        }
    }
    let _e242 = count;
    if (_e242 < 0.5f) {
        return -1f;
    }
    let _e244 = sum;
    let _e245 = count;
    blocker = max((_e244 / _e245), 0.0001f);
    let _e248 = blocker;
    (*blockerOut) = _e248;
    let _e249 = lightRadius;
    let _e250 = (*receiver_1);
    let _e251 = blocker;
    let _e255 = blocker;
    world = ((_e249 * max((_e250 - _e251), 0f)) / _e255);
    let _e257 = world;
    let _e258 = (*receiver_1);
    let _e260 = (*tanHalf);
    let _e263 = minRadius;
    let _e264 = maxRadius;
    return clamp((_e257 / ((2f * _e258) * _e260)), _e263, _e264);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_4: vec2<f32>;

    let _e174 = (*rows);
    if (_e174 > 0f) {
        let _e177 = gl_FragCoord_1[0u];
        let _e178 = (*rows);
        let _e180 = gl_FragCoord_1[1u];
        local_4 = vec2<f32>(_e177, (_e178 - _e180));
    } else {
        let _e183 = gl_FragCoord_1;
        local_4 = _e183.xy;
    }
    let _e185 = local_4;
    return _e185;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_3: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_22: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_23: vec2<f32>;
    var param_24: vec2<f32>;
    var param_25: f32;
    var param_26: f32;
    var param_27: f32;
    var param_28: f32;
    var param_29: f32;
    var param_30: f32;
    var local_5: vec3<f32>;
    var lit: f32;
    var param_31: vec2<f32>;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var i_3: i32;
    var param_36: i32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var phi_2528_: bool;
    var phi_2589_: bool;

    let _e226 = (*lightIndex);
    let _e230 = point_shadow.slots[_e226][0u];
    slot = i32((_e230 + 0.5f));
    let _e233 = (*lightIndex);
    let _e237 = point_shadow.slots[_e233][0u];
    if (_e237 < 0f) {
        return 1f;
    }
    let _e241 = point_shadow.params[2u];
    strength = _e241;
    let _e242 = strength;
    if (_e242 <= 0f) {
        return 1f;
    }
    let _e244 = slot;
    let _e247 = point_shadow.lights[_e244];
    let _e249 = (*world_1);
    toLight = (_e247.xyz - _e249);
    let _e251 = toLight;
    toLightLength = max(length(_e251), 0.000001f);
    let _e254 = (*normal);
    let _e255 = toLight;
    let _e256 = toLightLength;
    nDotL = max(dot(_e254, (_e255 / vec3(_e256))), 0.15f);
    let _e261 = nDotL;
    let _e262 = nDotL;
    let _e267 = nDotL;
    let _e268 = nDotL;
    slope = min((sqrt(max((1f - (_e261 * _e262)), 0f)) / (_e267 * _e268)), 8f);
    let _e272 = toLightLength;
    let _e274 = (*lightIndex);
    let _e278 = point_shadow.slots[_e274][2u];
    let _e283 = point_shadow.params3_[1u];
    texel = (((2f * _e272) * max(_e278, 0.0001f)) * _e283);
    let _e285 = (*world_1);
    let _e286 = (*normal);
    let _e287 = texel;
    let _e291 = point_shadow.params[3u];
    let _e293 = slope;
    origin = (_e285 + (((_e286 * _e287) * _e291) * (1f + _e293)));
    let _e297 = origin;
    let _e298 = slot;
    let _e301 = point_shadow.lights[_e298];
    toFragment = (_e297 - _e301.xyz);
    let _e304 = toFragment;
    distance_ = length(_e304);
    let _e306 = slot;
    let _e310 = point_shadow.lights[_e306][3u];
    range_3 = max(_e310, 0.0001f);
    let _e312 = distance_;
    let _e313 = range_3;
    if (_e312 >= _e313) {
        return 1f;
    }
    face = 0i;
    let _e315 = (*lightIndex);
    let _e319 = point_shadow.slots[_e315][1u];
    if (_e319 < 0.5f) {
        let _e321 = toFragment;
        a = abs(_e321);
        let _e324 = a[0u];
        let _e326 = a[1u];
        let _e327 = (_e324 >= _e326);
        phi_2528_ = _e327;
        if _e327 {
            let _e329 = a[0u];
            let _e331 = a[2u];
            phi_2528_ = (_e329 >= _e331);
        }
        let _e334 = phi_2528_;
        if _e334 {
            let _e336 = toFragment[0u];
            face = select(1i, 0i, (_e336 > 0f));
        } else {
            let _e340 = a[1u];
            let _e342 = a[2u];
            if (_e340 >= _e342) {
                let _e345 = toFragment[1u];
                face = select(3i, 2i, (_e345 > 0f));
            } else {
                let _e349 = toFragment[2u];
                face = select(5i, 4i, (_e349 > 0f));
            }
        }
    }
    let _e352 = slot;
    let _e354 = face;
    let _e358 = point_shadow.faces[((_e352 * 6i) + _e354)];
    let _e359 = origin;
    clip = (_e358 * vec4<f32>(_e359.x, _e359.y, _e359.z, 1f));
    let _e366 = clip[3u];
    if (_e366 <= 0f) {
        return 1f;
    }
    let _e368 = clip;
    let _e371 = clip[3u];
    ndc = (_e368.xy / vec2(_e371));
    let _e375 = ndc[0u];
    let _e377 = (abs(_e375) > 1f);
    phi_2589_ = _e377;
    if !(_e377) {
        let _e380 = ndc[1u];
        phi_2589_ = (abs(_e380) > 1f);
    }
    let _e384 = phi_2589_;
    if _e384 {
        return 1f;
    }
    let _e386 = ndc[0u];
    let _e390 = ndc[1u];
    uv_3 = vec2<f32>(((_e386 * 0.5f) + 0.5f), (0.5f - (_e390 * 0.5f)));
    let _e394 = face;
    let _e396 = slot;
    tile_3 = vec2<f32>(f32(_e394), f32(_e396));
    let _e399 = distance_;
    let _e402 = point_shadow.params[1u];
    receiver_2 = (_e399 - _e402);
    let _e406 = frag_info.target_origin[0u];
    param_22 = _e406;
    let _e407 = FragCoordFromTop_u0028_f1_u003b((&param_22));
    noise = fract((52.982918f * fract(dot(_e407, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e412 = noise;
    angle = (_e412 * 6.2831855f);
    let _e414 = angle;
    ca_2 = cos(_e414);
    let _e416 = angle;
    sa_2 = sin(_e416);
    let _e418 = (*lightIndex);
    let _e422 = point_shadow.slots[_e418][2u];
    tanHalf_1 = max(_e422, 0.0001f);
    blocker_1 = -1f;
    let _e424 = uv_3;
    param_23 = _e424;
    let _e425 = tile_3;
    param_24 = _e425;
    let _e426 = range_3;
    param_25 = _e426;
    let _e427 = receiver_2;
    param_26 = _e427;
    let _e428 = ca_2;
    param_27 = _e428;
    let _e429 = sa_2;
    param_28 = _e429;
    let _e430 = tanHalf_1;
    param_29 = _e430;
    let _e431 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26), (&param_27), (&param_28), (&param_29), (&param_30));
    let _e432 = param_30;
    blocker_1 = _e432;
    radius_1 = _e431;
    let _e435 = point_shadow.params2_[3u];
    if (_e435 > 0.5f) {
        g_debug_surface_on = true;
        let _e437 = radius_1;
        if (_e437 < 0f) {
            local_5 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e439 = radius_1;
            let _e442 = point_shadow.params2_[2u];
            let _e446 = blocker_1;
            let _e447 = range_3;
            local_5 = vec3<f32>(clamp((_e439 / max(_e442, 0.000001f)), 0f, 1f), clamp((_e446 / _e447), 0f, 1f), 0f);
        }
        let _e451 = local_5;
        g_debug_surface = _e451;
    }
    let _e452 = radius_1;
    if (_e452 < 0f) {
        return 1f;
    }
    let _e454 = uv_3;
    param_31 = _e454;
    param_32 = vec2<f32>(0f, 0f);
    let _e455 = tile_3;
    param_33 = _e455;
    let _e456 = range_3;
    param_34 = _e456;
    let _e457 = receiver_2;
    param_35 = _e457;
    let _e458 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_31), (&param_32), (&param_33), (&param_34), (&param_35));
    lit = _e458;
    let _e459 = radius_1;
    if (_e459 > 0f) {
        i_3 = 0i;
        loop {
            let _e461 = i_3;
            if (_e461 < 8i) {
                let _e463 = i_3;
                param_36 = _e463;
                let _e464 = ca_2;
                param_37 = _e464;
                let _e465 = sa_2;
                param_38 = _e465;
                let _e466 = radius_1;
                param_39 = _e466;
                let _e467 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_36), (&param_37), (&param_38), (&param_39));
                let _e468 = uv_3;
                param_40 = _e468;
                param_41 = _e467;
                let _e469 = tile_3;
                param_42 = _e469;
                let _e470 = range_3;
                param_43 = _e470;
                let _e471 = receiver_2;
                param_44 = _e471;
                let _e472 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
                let _e473 = lit;
                lit = (_e473 + _e472);
                continue;
            } else {
                break;
            }
            continuing {
                let _e475 = i_3;
                i_3 = (_e475 + 1i);
            }
        }
        let _e477 = lit;
        lit = (_e477 * 0.11111111f);
    }
    let _e479 = lit;
    let _e480 = strength;
    return mix(1f, _e479, clamp(_e480, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e177 = (*i_4);
    let _e180 = (*n_1);
    r = sqrt(((f32(_e177) + 0.5f) / f32(_e180)));
    let _e184 = (*i_4);
    let _e187 = (*turn);
    theta = ((f32(_e184) * 2.3999631f) + _e187);
    let _e189 = r;
    let _e190 = theta;
    let _e192 = theta;
    return (vec2<f32>(cos(_e190), sin(_e192)) * _e189);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_45: f32;

    let _e176 = frag_info.target_origin[0u];
    param_45 = _e176;
    let _e177 = FragCoordFromTop_u0028_f1_u003b((&param_45));
    let _e180 = frag_info.target_origin[3u];
    at = (_e177 + vec2((5.588238f * max(_e180, 0f))));
    let _e185 = at;
    return fract((52.982918f * fract(dot(_e185, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_6: f32;

    let _e175 = (*mode_1);
    if (_e175 > 0.5f) {
        let _e177 = (*stored_2);
        local_6 = (1f - _e177);
    } else {
        let _e179 = (*stored_2);
        local_6 = _e179;
    }
    let _e180 = local_6;
    return _e180;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e181 = (*moments)[1u];
    let _e183 = (*moments)[0u];
    let _e185 = (*moments)[0u];
    let _e188 = (*minVariance);
    variance = max((_e181 - (_e183 * _e185)), _e188);
    let _e190 = (*t);
    let _e192 = (*moments)[0u];
    d_1 = (_e190 - _e192);
    let _e194 = variance;
    let _e195 = variance;
    let _e196 = d_1;
    let _e197 = d_1;
    pMax = (_e194 / (_e195 + (_e196 * _e197)));
    let _e201 = pMax;
    let _e202 = (*bleed);
    let _e204 = (*bleed);
    reduced = clamp(((_e201 - _e202) / max((1f - _e204), 0.0001f)), 0f, 1f);
    let _e209 = (*t);
    let _e211 = (*moments)[0u];
    let _e213 = reduced;
    return select(_e213, 1f, (_e209 <= _e211));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e174 = (*depth);
    d_2 = ((2f * clamp(_e174, 0f, 1f)) - 1f);
    let _e178 = d_2;
    let _e181 = d_2;
    return vec2<f32>(exp((40f * _e178)), -(exp((-5f * _e181))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_46: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_47: vec2<f32>;
    var param_48: f32;
    var param_49: f32;
    var param_50: f32;
    var negative: f32;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var param_54: f32;

    let _e188 = (*depth_1);
    param_46 = _e188;
    let _e189 = EvsmWarp_u0028_f1_u003b((&param_46));
    warped = _e189;
    let _e190 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e190);
    let _e193 = scale[0u];
    let _e195 = scale[0u];
    let _e197 = (*moments_1);
    param_47 = _e197.xy;
    let _e200 = warped[0u];
    param_48 = _e200;
    param_49 = (_e193 * _e195);
    let _e201 = (*bleed_1);
    param_50 = _e201;
    let _e202 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_47), (&param_48), (&param_49), (&param_50));
    positive = _e202;
    let _e204 = scale[1u];
    let _e206 = scale[1u];
    let _e208 = (*moments_1);
    param_51 = _e208.zw;
    let _e211 = warped[1u];
    param_52 = _e211;
    param_53 = (_e204 * _e206);
    let _e212 = (*bleed_1);
    param_54 = _e212;
    let _e213 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_51), (&param_52), (&param_53), (&param_54));
    negative = _e213;
    let _e214 = positive;
    let _e215 = negative;
    return min(_e214, _e215);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e174 = (*depth_2);
    stored_3 = max((1f - _e174), 0.000061035156f);
    let _e177 = stored_3;
    return exp2((floor(log2(_e177)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_1: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_7: f32;
    var cascade: i32;
    var uv_4: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_8: mat4x4<f32>;
    var local_9: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_10: f32;
    var local_11: f32;
    var storage_: f32;
    var param_55: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_1: f32;
    var moments_2: vec4<f32>;
    var param_56: vec4<f32>;
    var param_57: f32;
    var param_58: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_59: f32;
    var param_60: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_61: i32;
    var param_62: i32;
    var param_63: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_64: f32;
    var param_65: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_66: i32;
    var param_67: i32;
    var param_68: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_69: f32;
    var param_70: f32;
    var phi_2918_: bool;
    var phi_2929_: bool;
    var phi_3090_: bool;
    var phi_3097_: bool;
    var phi_3104_: bool;

    let _e253 = frag_info.shadow_params[3u];
    strength_1 = _e253;
    let _e254 = strength_1;
    if (_e254 <= 0f) {
        return 1f;
    }
    let _e256 = (*lightIndex_1);
    let _e259 = frag_info.frame_params[2u];
    if (_e256 != i32(floor((_e259 + 0.5f)))) {
        return 1f;
    }
    let _e266 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e266 + 0.5f));
    let _e269 = Orthographic_u0028_();
    if _e269 {
        let _e270 = ViewDepth_u0028_();
        local_7 = _e270;
    } else {
        let _e271 = v_world_position_1;
        let _e273 = frag_info.camera_position;
        local_7 = length((_e271 - _e273.xyz));
    }
    let _e277 = local_7;
    viewDistance = _e277;
    cascade = 0i;
    let _e278 = cascadeCount;
    let _e279 = (_e278 > 1i);
    phi_2918_ = _e279;
    if _e279 {
        let _e280 = viewDistance;
        let _e283 = frag_info.shadow_cascades[0u];
        phi_2918_ = (_e280 > _e283);
    }
    let _e286 = phi_2918_;
    if _e286 {
        cascade = 1i;
    }
    let _e287 = cascadeCount;
    let _e288 = (_e287 > 2i);
    phi_2929_ = _e288;
    if _e288 {
        let _e289 = viewDistance;
        let _e292 = frag_info.shadow_cascades[1u];
        phi_2929_ = (_e289 > _e292);
    }
    let _e295 = phi_2929_;
    if _e295 {
        cascade = 2i;
    }
    uv_4 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e296 = attempt;
        if (_e296 < 3i) {
            let _e298 = cascade;
            let _e299 = attempt;
            which = (_e298 + _e299);
            let _e301 = which;
            let _e302 = cascadeCount;
            if (_e301 >= _e302) {
                break;
            }
            let _e304 = which;
            if (_e304 == 0i) {
                let _e307 = frag_info.shadow_matrix;
                local_8 = _e307;
            } else {
                let _e308 = which;
                if (_e308 == 1i) {
                    let _e311 = frag_info.shadow_matrix_far;
                    local_9 = _e311;
                } else {
                    let _e313 = frag_info.shadow_matrix_farthest;
                    local_9 = _e313;
                }
                let _e314 = local_9;
                local_8 = _e314;
            }
            let _e315 = local_8;
            matrix = _e315;
            let _e318 = matrix[0][0u];
            let _e321 = matrix[1][0u];
            let _e324 = matrix[2][0u];
            axisX = vec3<f32>(_e318, _e321, _e324);
            let _e328 = matrix[0][1u];
            let _e331 = matrix[1][1u];
            let _e334 = matrix[2][1u];
            axisY = vec3<f32>(_e328, _e331, _e334);
            let _e336 = axisX;
            rowX = max(length(_e336), 0.000001f);
            let _e339 = axisY;
            rowY = max(length(_e339), 0.000001f);
            let _e344 = frag_info.shadow_cascades[3u];
            let _e346 = rowX;
            texelMetres = ((2f * _e344) / _e346);
            let _e350 = frag_info.shadow_cascades[3u];
            let _e353 = (*s_1).n;
            let _e354 = axisX;
            let _e357 = rowX;
            let _e358 = rowX;
            let _e362 = (*s_1).n;
            let _e363 = axisY;
            let _e366 = rowY;
            let _e367 = rowY;
            reach = ((3f * _e350) * ((abs(dot(_e353, _e354)) / (_e357 * _e358)) + (abs(dot(_e362, _e363)) / (_e366 * _e367))));
            let _e374 = frag_info.shadow_params[2u];
            let _e375 = texelMetres;
            flatOffset = min(_e374, _e375);
            let _e377 = v_world_position_1;
            let _e379 = (*s_1).n;
            let _e380 = flatOffset;
            let _e381 = reach;
            origin_1 = (_e377 + (_e379 * (_e380 + _e381)));
            let _e385 = matrix;
            let _e386 = origin_1;
            lightSpace = (_e385 * vec4<f32>(_e386.x, _e386.y, _e386.z, 1f));
            let _e393 = lightSpace[3u];
            if (_e393 <= 0f) {
                continue;
            }
            let _e395 = lightSpace;
            let _e398 = lightSpace[3u];
            candidate = (_e395.xyz / vec3(_e398));
            let _e402 = candidate[0u];
            let _e406 = candidate[1u];
            inTile = vec2<f32>(((_e402 * 0.5f) + 0.5f), (0.5f - (_e406 * 0.5f)));
            let _e411 = inTile[0u];
            let _e412 = (_e411 < 0f);
            phi_3090_ = _e412;
            if !(_e412) {
                let _e415 = inTile[0u];
                phi_3090_ = (_e415 > 1f);
            }
            let _e418 = phi_3090_;
            phi_3097_ = _e418;
            if !(_e418) {
                let _e421 = inTile[1u];
                phi_3097_ = (_e421 < 0f);
            }
            let _e424 = phi_3097_;
            phi_3104_ = _e424;
            if !(_e424) {
                let _e427 = inTile[1u];
                phi_3104_ = (_e427 > 1f);
            }
            let _e430 = phi_3104_;
            if _e430 {
                continue;
            }
            let _e432 = candidate[2u];
            if (_e432 > 1f) {
                let _e434 = which;
                let _e435 = cascadeCount;
                if (_e434 < (_e435 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e440 = inTile[0u];
            let _e441 = which;
            let _e444 = cascadeCount;
            let _e448 = inTile[1u];
            uv_4 = vec2<f32>(((_e440 + f32(_e441)) / f32(_e444)), _e448);
            let _e450 = candidate;
            projected = _e450;
            let _e451 = which;
            cascade = _e451;
            let _e452 = texelMetres;
            cascadeTexel = _e452;
            let _e455 = matrix[0][2u];
            let _e458 = matrix[1][2u];
            let _e461 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e455, _e458, _e461)), 0.000001f));
            let _e467 = (*s_1).n;
            let _e470 = matrix[0][2u];
            let _e473 = matrix[1][2u];
            let _e476 = matrix[2][2u];
            let _e480 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e467, vec3<f32>(_e470, _e473, _e476))) * _e480), 0.1f, 1f);
            let _e483 = texelMetres;
            let _e484 = cosSlope;
            let _e485 = cosSlope;
            let _e491 = cosSlope;
            let _e493 = cascadeDepth;
            receiverSlope = (((_e483 * sqrt(max((1f - (_e484 * _e485)), 0f))) / _e491) / _e493);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e495 = attempt;
            attempt = (_e495 + 1i);
        }
    }
    let _e497 = found;
    if !(_e497) {
        return 1f;
    }
    let _e499 = cascade;
    if (_e499 == 0i) {
        let _e503 = frag_info.shadow_bias[0u];
        local_10 = _e503;
    } else {
        let _e504 = cascade;
        if (_e504 == 1i) {
            let _e508 = frag_info.shadow_bias[1u];
            local_11 = _e508;
        } else {
            let _e511 = frag_info.shadow_bias[2u];
            local_11 = _e511;
        }
        let _e512 = local_11;
        local_10 = _e512;
    }
    let _e513 = local_10;
    bias = _e513;
    let _e516 = frag_info.shadow_params[1u];
    storage_ = _e516;
    let _e517 = storage_;
    let _e519 = storage_;
    if ((_e517 > 0.5f) && (_e519 < 1.5f)) {
        let _e522 = bias;
        let _e524 = projected[2u];
        param_55 = _e524;
        let _e525 = ShadowStoredStep_u0028_f1_u003b((&param_55));
        bias = max(_e522, _e525);
    }
    let _e529 = frag_info.shadow_params[0u];
    let _e532 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e529, _e532);
    let _e534 = cascade;
    let _e536 = cascadeCount;
    let _e540 = texel_1;
    tileLo = (vec2<f32>((f32(_e534) / f32(_e536)), 0f) + (_e540 * 0.5f));
    let _e543 = cascade;
    let _e546 = cascadeCount;
    let _e550 = texel_1;
    tileHi = (vec2<f32>((f32((_e543 + 1i)) / f32(_e546)), 1f) - (_e550 * 0.5f));
    let _e555 = frag_info.shadow_bias[3u];
    if (_e555 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e557 = y;
            if (_e557 <= 1i) {
                x = -1i;
                loop {
                    let _e559 = x;
                    if (_e559 <= 1i) {
                        let _e561 = uv_4;
                        let _e562 = x;
                        let _e564 = y;
                        let _e567 = texel_1;
                        let _e570 = tileLo;
                        let _e571 = tileHi;
                        let _e573 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e561 + (vec2<f32>(f32(_e562), f32(_e564)) * _e567)), _e570, _e571), 0f);
                        let _e574 = stored_4;
                        stored_4 = (_e574 + _e573);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e576 = x;
                        x = (_e576 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e578 = y;
                y = (_e578 + 1i);
            }
        }
        let _e580 = stored_4;
        stored_4 = (_e580 * 0.11111111f);
        let _e583 = stored_4[1u];
        let _e586 = stored_4[2u];
        let _e589 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e583), (1f - _e586), _e589), vec3(0f), vec3(4f));
        let _e594 = through;
        let _e595 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e594, vec3(clamp(_e595, 0f, 1f)));
    }
    let _e601 = frag_info.ambient_ground[3u];
    softness = _e601;
    lit_1 = 0f;
    let _e602 = softness;
    if (_e602 < 0f) {
        let _e604 = uv_4;
        let _e605 = tileLo;
        let _e606 = tileHi;
        let _e608 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e604, _e605, _e606), 0f);
        moments_2 = _e608;
        let _e610 = projected[2u];
        let _e611 = bias;
        let _e613 = softness;
        let _e617 = moments_2;
        param_56 = _e617;
        param_57 = (_e610 - _e611);
        param_58 = clamp((-(_e613) - 1f), 0f, 0.95f);
        let _e618 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58));
        lit_1 = _e618;
    } else {
        let _e619 = softness;
        if (_e619 <= 0f) {
            y_1 = -1i;
            loop {
                let _e621 = y_1;
                if (_e621 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e623 = x_1;
                        if (_e623 <= 1i) {
                            let _e625 = uv_4;
                            let _e626 = x_1;
                            let _e628 = y_1;
                            let _e631 = texel_1;
                            let _e634 = tileLo;
                            let _e635 = tileHi;
                            let _e637 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e625 + (vec2<f32>(f32(_e626), f32(_e628)) * _e631)), _e634, _e635), 0f);
                            param_59 = _e637.x;
                            let _e639 = storage_;
                            param_60 = _e639;
                            let _e640 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_59), (&param_60));
                            occluder = _e640;
                            let _e642 = projected[2u];
                            let _e643 = bias;
                            let _e645 = occluder;
                            let _e648 = lit_1;
                            lit_1 = (_e648 + select(1f, 0f, ((_e642 - _e643) > _e645)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e650 = x_1;
                            x_1 = (_e650 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e652 = y_1;
                    y_1 = (_e652 + 1i);
                }
            }
            let _e654 = lit_1;
            lit_1 = (_e654 * 0.11111111f);
        } else {
            let _e656 = softness;
            spread = tan(min(_e656, 0.5f));
            let _e659 = ShadowNoise_u0028_();
            turn_1 = (_e659 * 6.2831855f);
            let _e661 = spread;
            let _e663 = projected[2u];
            let _e665 = cascadeDepth;
            let _e667 = cascadeTexel;
            searchRadius = clamp((((_e661 * _e663) * _e665) / _e667), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e670 = i_5;
                if (_e670 < 16i) {
                    let _e672 = i_5;
                    param_61 = _e672;
                    param_62 = 16i;
                    let _e673 = turn_1;
                    param_63 = _e673;
                    let _e674 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
                    disc = _e674;
                    let _e675 = bias;
                    let _e676 = disc;
                    let _e678 = searchRadius;
                    let _e682 = receiverSlope;
                    tapBias = (_e675 + (max(((length(_e676) * _e678) - 1.5f), 0f) * _e682));
                    let _e685 = uv_4;
                    let _e686 = disc;
                    let _e687 = texel_1;
                    let _e689 = searchRadius;
                    let _e692 = tileLo;
                    let _e693 = tileHi;
                    let _e695 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e685 + ((_e686 * _e687) * _e689)), _e692, _e693), 0f);
                    param_64 = _e695.x;
                    let _e697 = storage_;
                    param_65 = _e697;
                    let _e698 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_64), (&param_65));
                    occluder_1 = _e698;
                    let _e700 = projected[2u];
                    let _e701 = tapBias;
                    let _e703 = occluder_1;
                    if ((_e700 - _e701) > _e703) {
                        let _e705 = occluder_1;
                        let _e706 = blockerSum;
                        blockerSum = (_e706 + _e705);
                        let _e708 = blockerCount;
                        blockerCount = (_e708 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e710 = i_5;
                    i_5 = (_e710 + 1i);
                }
            }
            let _e712 = blockerCount;
            if (_e712 <= 0f) {
                return 1f;
            }
            let _e715 = projected[2u];
            let _e716 = blockerSum;
            let _e717 = blockerCount;
            let _e721 = cascadeDepth;
            gap = (max((_e715 - (_e716 / _e717)), 0f) * _e721);
            let _e723 = spread;
            let _e724 = gap;
            let _e726 = cascadeTexel;
            radius_2 = clamp(((_e723 * _e724) / _e726), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e729 = i_6;
                if (_e729 < 16i) {
                    let _e731 = turn_1;
                    let _e733 = i_6;
                    param_66 = _e733;
                    param_67 = 16i;
                    param_68 = (_e731 + 1f);
                    let _e734 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_66), (&param_67), (&param_68));
                    disc_1 = _e734;
                    let _e735 = bias;
                    let _e736 = disc_1;
                    let _e738 = radius_2;
                    let _e742 = receiverSlope;
                    tapBias_1 = (_e735 + (max(((length(_e736) * _e738) - 1.5f), 0f) * _e742));
                    let _e745 = uv_4;
                    let _e746 = disc_1;
                    let _e747 = texel_1;
                    let _e749 = radius_2;
                    let _e752 = tileLo;
                    let _e753 = tileHi;
                    let _e755 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e745 + ((_e746 * _e747) * _e749)), _e752, _e753), 0f);
                    param_69 = _e755.x;
                    let _e757 = storage_;
                    param_70 = _e757;
                    let _e758 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_69), (&param_70));
                    occluder_2 = _e758;
                    let _e760 = projected[2u];
                    let _e761 = tapBias_1;
                    let _e763 = occluder_2;
                    let _e766 = lit_1;
                    lit_1 = (_e766 + select(1f, 0f, ((_e760 - _e761) > _e763)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e768 = i_6;
                    i_6 = (_e768 + 1i);
                }
            }
            let _e770 = lit_1;
            lit_1 = (_e770 * 0.0625f);
        }
    }
    let _e772 = lit_1;
    let _e773 = strength_1;
    return mix(1f, _e772, clamp(_e773, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_71: Surface;
    var param_72: LightSample;
    var param_73: i32;

    let _e178 = (*s_2);
    param_71 = _e178;
    let _e179 = (*light_2);
    param_72 = _e179;
    let _e180 = (*index);
    param_73 = _e180;
    let _e181 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_71), (&param_72), (&param_73));
    return _e181;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e173 = (*index_1);
    return (_e173 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e177 = (*distance_1);
    let _e178 = (*distance_1);
    attenuation = (1f / max((_e177 * _e178), 0.0001f));
    let _e182 = (*range_4);
    if (_e182 > 0f) {
        let _e184 = (*distance_1);
        let _e185 = (*range_4);
        ratio = (_e184 / _e185);
        let _e187 = ratio;
        let _e188 = ratio;
        let _e190 = ratio;
        let _e192 = ratio;
        window = clamp((1f - (((_e187 * _e188) * _e190) * _e192)), 0f, 1f);
        let _e196 = window;
        let _e197 = window;
        let _e199 = attenuation;
        attenuation = (_e199 * (_e196 * _e197));
    }
    let _e201 = attenuation;
    return _e201;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_12: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e189 = (*halfWidth);
    let _e190 = (*halfHeight);
    n_2 = cross(_e189, _e190);
    let _e192 = n_2;
    nLen = length(_e192);
    let _e194 = nLen;
    if (_e194 < 0.000000000001f) {
        let _e196 = (*centre);
        return _e196;
    }
    let _e197 = nLen;
    let _e198 = n_2;
    n_2 = (_e198 / vec3(_e197));
    let _e201 = (*centre);
    let _e202 = (*world_2);
    toPlane = (_e201 - _e202);
    let _e204 = (*mirror);
    let _e205 = n_2;
    denom = dot(_e204, _e205);
    let _e207 = denom;
    if (abs(_e207) < 0.00001f) {
        let _e210 = toPlane;
        let _e211 = n_2;
        let _e212 = toPlane;
        let _e213 = n_2;
        onPlane = (_e210 - (_e211 * dot(_e212, _e213)));
    } else {
        let _e217 = toPlane;
        let _e218 = n_2;
        let _e220 = denom;
        t_1 = (dot(_e217, _e218) / _e220);
        let _e222 = t_1;
        if (_e222 > 0f) {
            let _e224 = (*mirror);
            let _e225 = t_1;
            local_12 = (_e224 * _e225);
        } else {
            let _e227 = toPlane;
            let _e228 = n_2;
            let _e229 = toPlane;
            let _e230 = n_2;
            local_12 = (_e227 - (_e228 * dot(_e229, _e230)));
        }
        let _e234 = local_12;
        onPlane = _e234;
    }
    let _e235 = onPlane;
    let _e236 = toPlane;
    offset_2 = (_e235 - _e236);
    let _e238 = (*halfWidth);
    let _e239 = (*halfWidth);
    wLen2_ = max(dot(_e238, _e239), 0.000000000001f);
    let _e242 = (*halfHeight);
    let _e243 = (*halfHeight);
    hLen2_ = max(dot(_e242, _e243), 0.000000000001f);
    let _e246 = offset_2;
    let _e247 = (*halfWidth);
    let _e249 = wLen2_;
    u = clamp((dot(_e246, _e247) / _e249), -1f, 1f);
    let _e252 = offset_2;
    let _e253 = (*halfHeight);
    let _e255 = hLen2_;
    v = clamp((dot(_e252, _e253) / _e255), -1f, 1f);
    let _e258 = (*centre);
    let _e259 = (*halfWidth);
    let _e260 = u;
    let _e263 = (*halfHeight);
    let _e264 = v;
    return ((_e258 + (_e259 * _e260)) + (_e263 * _e264));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_13: f32;

    let _e181 = (*a_1);
    let _e182 = (*a_1);
    ua = (_e181 / vec3(max(length(_e182), 0.000000000001f)));
    let _e187 = (*b);
    let _e188 = (*b);
    ub = (_e187 / vec3(max(length(_e188), 0.000000000001f)));
    let _e193 = ua;
    let _e194 = ub;
    angle_1 = acos(clamp(dot(_e193, _e194), -1f, 1f));
    let _e198 = ua;
    let _e199 = ub;
    axis = cross(_e198, _e199);
    let _e201 = axis;
    len = length(_e201);
    let _e203 = len;
    if (_e203 > 0.000001f) {
        let _e205 = angle_1;
        let _e206 = axis;
        let _e207 = (*n_3);
        let _e210 = len;
        local_13 = ((_e205 * dot(_e206, _e207)) / _e210);
    } else {
        local_13 = 0f;
    }
    let _e212 = local_13;
    return _e212;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_14: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_15: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_16: f32;
    var param_74: vec3<f32>;
    var param_75: vec3<f32>;
    var param_76: vec3<f32>;
    var param_77: vec3<f32>;
    var param_78: vec3<f32>;
    var param_79: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e195 = i_7;
        if (_e195 < 4i) {
            let _e197 = i_7;
            let _e199 = (*corners)[_e197];
            a_2 = _e199;
            let _e200 = i_7;
            if (_e200 == 3i) {
                local_14 = 0i;
            } else {
                let _e202 = i_7;
                local_14 = (_e202 + 1i);
            }
            let _e204 = local_14;
            let _e206 = (*corners)[_e204];
            b_1 = _e206;
            let _e207 = a_2;
            let _e208 = (*n_4);
            ha = dot(_e207, _e208);
            let _e210 = b_1;
            let _e211 = (*n_4);
            hb = dot(_e210, _e211);
            let _e213 = ha;
            let _e214 = hb;
            d_3 = (_e213 - _e214);
            let _e216 = a_2;
            let _e217 = b_1;
            let _e218 = a_2;
            let _e220 = d_3;
            if (abs(_e220) > 0.000000000001f) {
                let _e223 = ha;
                let _e224 = d_3;
                local_15 = (_e223 / _e224);
            } else {
                local_15 = 0f;
            }
            let _e226 = local_15;
            q = (_e216 + ((_e217 - _e218) * _e226));
            let _e229 = ha;
            aAbove = (_e229 > 0f);
            let _e231 = hb;
            bAbove = (_e231 > 0f);
            let _e233 = aAbove;
            let _e234 = bAbove;
            if (_e233 || _e234) {
                let _e236 = aAbove;
                let _e237 = a_2;
                let _e238 = q;
                let _e241 = bAbove;
                let _e242 = b_1;
                let _e243 = q;
                param_74 = select(_e238, _e237, vec3(_e236));
                param_75 = select(_e243, _e242, vec3(_e241));
                let _e246 = (*n_4);
                param_76 = _e246;
                let _e247 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_74), (&param_75), (&param_76));
                local_16 = _e247;
            } else {
                local_16 = 0f;
            }
            let _e248 = local_16;
            let _e249 = total;
            total = (_e249 + _e248);
            let _e251 = aAbove;
            let _e252 = bAbove;
            let _e255 = q;
            let _e256 = exit;
            exit = select(_e256, _e255, vec3((_e251 && !(_e252))));
            let _e259 = aAbove;
            let _e261 = bAbove;
            let _e263 = q;
            let _e264 = entry;
            entry = select(_e264, _e263, vec3((!(_e259) && _e261)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e267 = i_7;
            i_7 = (_e267 + 1i);
        }
    }
    let _e269 = exit;
    param_77 = _e269;
    let _e270 = entry;
    param_78 = _e270;
    let _e271 = (*n_4);
    param_79 = _e271;
    let _e272 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_77), (&param_78), (&param_79));
    let _e273 = total;
    total = (_e273 + _e272);
    let _e275 = total;
    return max((-(_e275) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_17: f32;
    var local_18: f32;
    var local_19: f32;

    let _e178 = (*slot_1);
    let _e179 = (*slot_1);
    lane = (_e178 - ((_e179 / 4i) * 4i));
    let _e183 = lane;
    if (_e183 == 0i) {
        let _e186 = (*four)[0u];
        local_17 = _e186;
    } else {
        let _e187 = lane;
        if (_e187 == 1i) {
            let _e190 = (*four)[1u];
            local_18 = _e190;
        } else {
            let _e191 = lane;
            if (_e191 == 2i) {
                let _e194 = (*four)[2u];
                local_19 = _e194;
            } else {
                let _e196 = (*four)[3u];
                local_19 = _e196;
            }
            let _e197 = local_19;
            local_18 = _e197;
        }
        let _e198 = local_18;
        local_17 = _e198;
    }
    let _e199 = local_17;
    return _e199;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_80: vec4<f32>;
    var param_81: i32;

    let _e175 = (*slot_2);
    let _e179 = light_list_info.scales[(_e175 / 4i)];
    param_80 = _e179;
    let _e180 = (*slot_2);
    param_81 = _e180;
    let _e181 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_80), (&param_81));
    return _e181;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e177 = light_list_info.slot_rows[0i];
    let _e178 = (*row);
    a_3 = abs((_e177 - vec4(_e178)));
    let _e184 = light_list_info.slot_rows[1i];
    let _e185 = (*row);
    b_2 = abs((_e184 - vec4(_e185)));
    let _e190 = a_3[0u];
    let _e192 = a_3[1u];
    let _e195 = a_3[2u];
    let _e197 = a_3[3u];
    let _e201 = b_2[0u];
    let _e203 = b_2[1u];
    let _e206 = b_2[2u];
    let _e208 = b_2[3u];
    return (min(min(min(_e190, _e192), min(_e195, _e197)), min(min(_e201, _e203), min(_e206, _e208))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_82: vec4<f32>;
    var param_83: i32;

    let _e175 = (*slot_3);
    let _e179 = light_list_info.indices[(_e175 / 4i)];
    param_82 = _e179;
    let _e180 = (*slot_3);
    param_83 = _e180;
    let _e181 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_82), (&param_83));
    return _e181;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e174 = (*texel_2);
    let _e178 = light_list_info.list[1u];
    let _e180 = (*row_1);
    let _e184 = light_list_info.list[2u];
    let _e187 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e174 + 0.5f) * _e178), ((_e180 + 0.5f) * _e184)), 0f);
    return _e187;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_84: f32;
    var param_85: f32;
    var param_86: vec4<f32>;
    var param_87: i32;

    let _e182 = g_cluster_offset;
    let _e183 = (*slot_4);
    entry_1 = (_e182 + f32(_e183));
    let _e186 = entry_1;
    row_2 = floor((_e186 / 16f));
    let _e189 = entry_1;
    let _e190 = row_2;
    within = (_e189 - (_e190 * 16f));
    let _e193 = within;
    texel_3 = floor((_e193 / 4f));
    let _e198 = light_list_info.cluster_depth[3u];
    let _e199 = row_2;
    let _e201 = texel_3;
    param_84 = _e201;
    param_85 = (_e198 + _e199);
    let _e202 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_84), (&param_85));
    four_1 = _e202;
    let _e203 = within;
    let _e204 = texel_3;
    let _e209 = four_1;
    param_86 = _e209;
    param_87 = i32(((_e203 - (_e204 * 4f)) + 0.5f));
    let _e210 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_86), (&param_87));
    return _e210;
}

fn Clustered_u0028_() -> bool {
    let _e174 = light_list_info.cluster_grid[3u];
    return (_e174 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_3: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_20: f32;
    var param_88: i32;
    var param_89: i32;
    var v_1: f32;
    var u_1: f32;
    var local_21: f32;
    var param_90: f32;
    var param_91: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_22: f32;
    var param_92: array<vec3<f32>, 4>;
    var param_93: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_23: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_94: vec3<f32>;
    var param_95: vec3<f32>;
    var param_96: vec3<f32>;
    var param_97: vec3<f32>;
    var param_98: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_24: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_99: f32;
    var param_100: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e226 = (*index_2);
    if (_e226 < 8i) {
        let _e228 = (*index_2);
        let _e231 = frag_info.light_position[_e228];
        position = _e231;
        let _e232 = (*index_2);
        let _e235 = frag_info.light_color[_e232];
        color_1 = _e235;
        let _e236 = (*index_2);
        let _e239 = frag_info.light_direction[_e236];
        direction = _e239;
        let _e240 = (*index_2);
        let _e243 = frag_info.light_cone[_e240];
        cone = _e243;
    } else {
        let _e244 = (*index_2);
        slot_5 = (_e244 - 8i);
        let _e246 = Clustered_u0028_();
        clustered = _e246;
        let _e247 = clustered;
        if _e247 {
            let _e248 = slot_5;
            param_88 = _e248;
            let _e249 = ClusterRow_u0028_i1_u003b((&param_88));
            local_20 = _e249;
        } else {
            let _e250 = slot_5;
            param_89 = _e250;
            let _e251 = LightListRow_u0028_i1_u003b((&param_89));
            local_20 = _e251;
        }
        let _e252 = local_20;
        listRow = _e252;
        let _e253 = listRow;
        let _e257 = light_list_info.list[2u];
        v_1 = ((_e253 + 0.5f) * _e257);
        let _e261 = light_list_info.list[1u];
        u_1 = _e261;
        let _e262 = u_1;
        let _e264 = v_1;
        let _e266 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e262), _e264), 0f);
        position = _e266;
        let _e267 = u_1;
        let _e269 = v_1;
        let _e271 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e267), _e269), 0f);
        color_1 = _e271;
        let _e272 = u_1;
        let _e274 = v_1;
        let _e276 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e272), _e274), 0f);
        direction = _e276;
        let _e277 = u_1;
        let _e279 = v_1;
        let _e281 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e277), _e279), 0f);
        cone = _e281;
        let _e282 = clustered;
        if _e282 {
            let _e283 = listRow;
            param_90 = _e283;
            let _e284 = InSlots_u0028_f1_u003b((&param_90));
            local_21 = select(1f, 0f, _e284);
        } else {
            let _e286 = slot_5;
            param_91 = _e286;
            let _e287 = LightListScale_u0028_i1_u003b((&param_91));
            local_21 = _e287;
        }
        let _e288 = local_21;
        let _e290 = color_1[3u];
        color_1[3u] = (_e290 * _e288);
    }
    let _e294 = position[3u];
    type_39 = _e294;
    let _e295 = type_39;
    if (_e295 > 15.5f) {
        let _e298 = (*s_3).n;
        light_3.l = _e298;
        let _e301 = (*s_3).n;
        light_3.h = _e301;
        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 _e307 = light_3;
        return _e307;
    }
    let _e308 = type_39;
    if (_e308 > 2.5f) {
        let _e310 = direction;
        halfWidth_1 = _e310.xyz;
        let _e312 = cone;
        halfHeight_1 = _e312.xyz;
        let _e314 = position;
        let _e316 = v_world_position_1;
        toCentre = (_e314.xyz - _e316);
        let _e318 = toCentre;
        let _e319 = halfWidth_1;
        let _e321 = halfHeight_1;
        corners_1[0i] = ((_e318 - _e319) - _e321);
        let _e324 = toCentre;
        let _e325 = halfWidth_1;
        let _e327 = halfHeight_1;
        corners_1[1i] = ((_e324 + _e325) - _e327);
        let _e330 = toCentre;
        let _e331 = halfWidth_1;
        let _e333 = halfHeight_1;
        corners_1[2i] = ((_e330 + _e331) + _e333);
        let _e336 = toCentre;
        let _e337 = halfWidth_1;
        let _e339 = halfHeight_1;
        corners_1[3i] = ((_e336 - _e337) + _e339);
        let _e342 = toCentre;
        let _e343 = halfWidth_1;
        let _e344 = halfHeight_1;
        behind = (dot(_e342, cross(_e343, _e344)) >= 0f);
        let _e348 = behind;
        if _e348 {
            local_22 = 0f;
        } else {
            let _e349 = corners_1;
            param_92 = _e349;
            let _e351 = (*s_3).n;
            param_93 = _e351;
            let _e352 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_92), (&param_93));
            local_22 = _e352;
        }
        let _e353 = local_22;
        formFactor = _e353;
        let _e354 = halfWidth_1;
        let _e355 = halfHeight_1;
        area = (length(cross(_e354, _e355)) * 4f);
        let _e359 = area;
        if (_e359 > 0.000000001f) {
            let _e361 = area;
            local_23 = (1f / _e361);
        } else {
            local_23 = 0f;
        }
        let _e363 = local_23;
        radiance = _e363;
        let _e364 = toCentre;
        distance_2 = length(_e364);
        let _e367 = direction[3u];
        if (_e367 > 0f) {
            let _e369 = distance_2;
            let _e371 = direction[3u];
            ratio_1 = (_e369 / _e371);
            let _e373 = ratio_1;
            let _e374 = ratio_1;
            let _e376 = ratio_1;
            let _e378 = ratio_1;
            window_1 = clamp((1f - (((_e373 * _e374) * _e376) * _e378)), 0f, 1f);
            let _e382 = window_1;
            let _e383 = window_1;
            let _e385 = radiance;
            radiance = (_e385 * (_e382 * _e383));
        }
        let _e388 = (*s_3).v;
        let _e391 = (*s_3).n;
        mirror_1 = reflect(-(_e388), _e391);
        let _e393 = position;
        param_94 = _e393.xyz;
        let _e395 = halfWidth_1;
        param_95 = _e395;
        let _e396 = halfHeight_1;
        param_96 = _e396;
        let _e397 = v_world_position_1;
        param_97 = _e397;
        let _e398 = mirror_1;
        param_98 = _e398;
        let _e399 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_94), (&param_95), (&param_96), (&param_97), (&param_98));
        representative = _e399;
        let _e400 = representative;
        let _e401 = v_world_position_1;
        toPoint = (_e400 - _e401);
        let _e403 = toPoint;
        pointDistance = length(_e403);
        let _e405 = pointDistance;
        if (_e405 > 0.000001f) {
            let _e407 = toPoint;
            let _e408 = pointDistance;
            local_24 = (_e407 / vec3(_e408));
        } else {
            let _e412 = (*s_3).n;
            local_24 = _e412;
        }
        let _e413 = local_24;
        light_3.l = _e413;
        let _e416 = light_3.l;
        let _e418 = (*s_3).v;
        light_3.h = normalize((_e416 + _e418));
        let _e422 = formFactor;
        light_3.n_dot_l = _e422;
        let _e425 = (*s_3).n;
        let _e427 = light_3.h;
        light_3.n_dot_h = max(dot(_e425, _e427), 0f);
        let _e432 = (*s_3).v;
        let _e434 = light_3.h;
        light_3.v_dot_h = max(dot(_e432, _e434), 0f);
        let _e438 = color_1;
        let _e441 = color_1[3u];
        let _e443 = radiance;
        light_3.radiance = ((_e438.xyz * _e441) * _e443);
        let _e446 = light_3;
        return _e446;
    }
    let _e447 = direction;
    aim = normalize(_e447.xyz);
    attenuation_1 = 1f;
    let _e450 = type_39;
    if (_e450 < 0.5f) {
        let _e452 = aim;
        light_3.l = -(_e452);
    } else {
        let _e455 = position;
        let _e457 = v_world_position_1;
        toLight_1 = (_e455.xyz - _e457);
        let _e459 = toLight_1;
        distance_3 = length(_e459);
        let _e461 = distance_3;
        if (_e461 < 0.000001f) {
            let _e464 = (*s_3).n;
            light_3.l = _e464;
            let _e467 = (*s_3).n;
            light_3.h = _e467;
            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 _e473 = light_3;
            return _e473;
        }
        let _e474 = toLight_1;
        let _e475 = distance_3;
        light_3.l = (_e474 / vec3(_e475));
        let _e479 = distance_3;
        param_99 = _e479;
        let _e481 = direction[3u];
        param_100 = _e481;
        let _e482 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_99), (&param_100));
        attenuation_1 = _e482;
        let _e483 = type_39;
        if (_e483 > 1.5f) {
            let _e485 = aim;
            let _e487 = light_3.l;
            cosAngle = dot(_e485, -(_e487));
            let _e490 = cosAngle;
            let _e492 = cone[1u];
            let _e495 = cone[0u];
            let _e497 = cone[1u];
            ramp = clamp(((_e490 - _e492) / (_e495 - _e497)), 0f, 1f);
            let _e501 = ramp;
            let _e502 = ramp;
            let _e504 = attenuation_1;
            attenuation_1 = (_e504 * (_e501 * _e502));
        }
    }
    let _e507 = light_3.l;
    let _e509 = (*s_3).v;
    light_3.h = normalize((_e507 + _e509));
    let _e514 = (*s_3).n;
    let _e516 = light_3.l;
    light_3.n_dot_l = max(dot(_e514, _e516), 0f);
    let _e521 = (*s_3).n;
    let _e523 = light_3.h;
    light_3.n_dot_h = max(dot(_e521, _e523), 0f);
    let _e528 = (*s_3).v;
    let _e530 = light_3.h;
    light_3.v_dot_h = max(dot(_e528, _e530), 0f);
    let _e534 = color_1;
    let _e537 = color_1[3u];
    let _e539 = attenuation_1;
    light_3.radiance = ((_e534.xyz * _e537) * _e539);
    let _e542 = light_3;
    return _e542;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_25: f32;
    var cell: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_101: f32;
    var param_102: f32;

    let _e187 = light_list_info.cluster_view_projection;
    let _e188 = (*world_3);
    clip_1 = (_e187 * vec4<f32>(_e188.x, _e188.y, _e188.z, 1f));
    let _e194 = clip_1;
    let _e197 = clip_1[3u];
    ndc_1 = (_e194.xy / vec2(max(_e197, 0.000001f)));
    let _e202 = light_list_info.cluster_grid;
    grid = _e202.xyz;
    let _e206 = light_list_info.cluster_depth[0u];
    near_1 = _e206;
    let _e208 = ndc_1[0u];
    let _e212 = grid[0u];
    let _e216 = grid[0u];
    tx = clamp(floor((((_e208 * 0.5f) + 0.5f) * _e212)), 0f, (_e216 - 1f));
    let _e220 = ndc_1[1u];
    let _e224 = grid[1u];
    let _e228 = grid[1u];
    ty = clamp(floor((((_e220 * 0.5f) + 0.5f) * _e224)), 0f, (_e228 - 1f));
    let _e232 = clip_1[3u];
    let _e233 = near_1;
    if (_e232 <= _e233) {
        local_25 = 0f;
    } else {
        let _e236 = clip_1[3u];
        let _e237 = near_1;
        let _e242 = light_list_info.cluster_depth[1u];
        let _e246 = grid[2u];
        local_25 = clamp(floor((log((_e236 / _e237)) * _e242)), 0f, (_e246 - 1f));
    }
    let _e249 = local_25;
    tz = _e249;
    let _e250 = tx;
    let _e251 = ty;
    let _e253 = grid[0u];
    let _e256 = tz;
    let _e258 = grid[0u];
    let _e261 = grid[1u];
    cell = ((_e250 + (_e251 * _e253)) + ((_e256 * _e258) * _e261));
    let _e264 = cell;
    row_3 = floor((_e264 / 4f));
    let _e267 = cell;
    let _e268 = row_3;
    let _e273 = light_list_info.cluster_depth[2u];
    let _e274 = row_3;
    param_101 = (_e267 - (_e268 * 4f));
    param_102 = (_e273 + _e274);
    let _e276 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_101), (&param_102));
    header = _e276;
    let _e278 = header[0u];
    g_cluster_offset = _e278;
    let _e280 = header[1u];
    g_cluster_count = _e280;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_103: vec3<f32>;

    let _e176 = light_list_info.list[0u];
    tail = _e176;
    let _e177 = Clustered_u0028_();
    if _e177 {
        let _e178 = v_world_position_1;
        param_103 = _e178;
        FindCluster_u0028_vf3_u003b((&param_103));
        let _e179 = g_cluster_count;
        tail = _e179;
    }
    let _e182 = frag_info.frame_params[1u];
    let _e186 = tail;
    return (clamp(i32((_e182 + 0.5f)), 0i, 8i) + clamp(i32((_e186 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_4: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_104: i32;
    var param_105: Surface;
    var visibility: f32;
    var param_106: i32;
    var local_26: f32;
    var param_107: Surface;
    var param_108: LightSample;
    var param_109: i32;
    var param_110: vec3<f32>;
    var param_111: vec3<f32>;
    var param_112: i32;
    var param_113: Surface;
    var param_114: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e190 = LightCount_u0028_();
    count_1 = _e190;
    i_8 = 0i;
    loop {
        let _e191 = i_8;
        if (_e191 < 32i) {
            let _e193 = i_8;
            let _e194 = count_1;
            if (_e193 >= _e194) {
                break;
            }
            let _e196 = i_8;
            param_104 = _e196;
            let _e197 = (*s_4);
            param_105 = _e197;
            let _e198 = 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((&param_104), (&param_105));
            light_4 = _e198;
            let _e200 = light_4.n_dot_l;
            if (_e200 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e202 = i_8;
            param_106 = _e202;
            let _e203 = LightHasShadow_u0028_i1_u003b((&param_106));
            if _e203 {
                let _e204 = (*s_4);
                param_107 = _e204;
                let _e205 = light_4;
                param_108 = _e205;
                let _e206 = i_8;
                param_109 = _e206;
                let _e207 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_107), (&param_108), (&param_109));
                let _e208 = v_world_position_1;
                param_110 = _e208;
                let _e210 = (*s_4).n;
                param_111 = _e210;
                let _e211 = i_8;
                param_112 = _e211;
                let _e212 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_110), (&param_111), (&param_112));
                local_26 = (_e207 * _e212);
            } else {
                local_26 = 1f;
            }
            let _e214 = local_26;
            visibility = _e214;
            let _e215 = visibility;
            if (_e215 <= 0f) {
                continue;
            }
            let _e217 = (*s_4);
            param_113 = _e217;
            let _e218 = light_4;
            param_114 = _e218;
            let _e219 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_113), (&param_114));
            let _e221 = light_4.radiance;
            let _e224 = light_4.n_dot_l;
            let _e226 = visibility;
            let _e228 = light_transmittance;
            let _e230 = total_1;
            total_1 = (_e230 + ((((_e219 * _e221) * _e224) * _e226) * _e228));
            continue;
        } else {
            break;
        }
        continuing {
            let _e232 = i_8;
            i_8 = (_e232 + 1i);
        }
    }
    let _e234 = total_1;
    return _e234;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e173 = (*srgb);
    let _e176 = (*srgb);
    let _e181 = (*srgb);
    return mix((_e173 / vec3(12.92f)), pow(((_e176 + 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), _e181));
}

fn ImpostorRight_u0028_vf3_u003b(d_4: ptr<function, vec3<f32>>) -> vec3<f32> {
    var up: vec3<f32>;

    let _e175 = (*d_4)[1u];
    up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e175) > 0.999f)));
    let _e180 = up;
    let _e181 = (*d_4);
    return normalize(cross(_e180, _e181));
}

fn ImpostorDecode_u0028_vf2_u003b(uv_5: ptr<function, vec2<f32>>) -> vec3<f32> {
    var p_1: vec2<f32>;
    var y_2: f32;
    var s_5: vec2<f32>;
    var folded: vec2<f32>;
    var xz: vec2<f32>;

    let _e178 = (*uv_5);
    p_1 = ((_e178 * 2f) - vec2<f32>(1f, 1f));
    let _e182 = p_1[0u];
    let _e186 = p_1[1u];
    y_2 = ((1f - abs(_e182)) - abs(_e186));
    let _e190 = p_1[0u];
    let _e194 = p_1[1u];
    s_5 = vec2<f32>(select(-1f, 1f, (_e190 >= 0f)), select(-1f, 1f, (_e194 >= 0f)));
    let _e198 = p_1;
    let _e202 = s_5;
    folded = ((vec2<f32>(1f, 1f) - abs(_e198.yx)) * _e202);
    let _e204 = y_2;
    let _e206 = p_1;
    let _e207 = folded;
    xz = select(_e207, _e206, vec2((_e204 >= 0f)));
    let _e211 = xz[0u];
    let _e212 = y_2;
    let _e214 = xz[1u];
    return normalize(vec3<f32>(_e211, _e212, _e214));
}

fn ImpostorViewUv_u0028_vf2_u003b_vf3_u003b(cell_1: ptr<function, vec2<f32>>, offset_3: ptr<function, vec3<f32>>) -> vec2<f32> {
    var d_5: vec3<f32>;
    var param_115: vec2<f32>;
    var right: vec3<f32>;
    var param_116: vec3<f32>;
    var up_1: vec3<f32>;
    var local_27: vec2<f32>;

    let _e180 = (*cell_1);
    param_115 = (_e180 / vec2(7f));
    let _e183 = ImpostorDecode_u0028_vf2_u003b((&param_115));
    d_5 = _e183;
    let _e184 = d_5;
    param_116 = _e184;
    let _e185 = ImpostorRight_u0028_vf3_u003b((&param_116));
    right = _e185;
    let _e186 = d_5;
    let _e187 = right;
    up_1 = cross(_e186, _e187);
    let _e189 = (*offset_3);
    let _e190 = right;
    let _e194 = (*offset_3);
    let _e195 = up_1;
    local_27 = vec2<f32>(((dot(_e189, _e190) * 0.5f) + 0.5f), (0.5f - (dot(_e194, _e195) * 0.5f)));
    let _e200 = (*cell_1);
    let _e201 = local_27;
    return ((_e200 + clamp(_e201, vec2<f32>(0f, 0f), vec2<f32>(1f, 1f))) / vec2(8f));
}

fn ImpostorEncode_u0028_vf3_u003b(d_6: ptr<function, vec3<f32>>) -> vec2<f32> {
    var a_4: vec3<f32>;
    var p_2: vec2<f32>;
    var s_6: vec2<f32>;
    var folded_1: vec2<f32>;

    let _e177 = (*d_6);
    a_4 = abs(_e177);
    let _e179 = (*d_6);
    let _e182 = a_4[0u];
    let _e184 = a_4[1u];
    let _e187 = a_4[2u];
    p_2 = (_e179.xz / vec2(max(((_e182 + _e184) + _e187), 0.00000001f)));
    let _e193 = p_2[0u];
    let _e197 = p_2[1u];
    s_6 = vec2<f32>(select(-1f, 1f, (_e193 >= 0f)), select(-1f, 1f, (_e197 >= 0f)));
    let _e201 = p_2;
    let _e205 = s_6;
    folded_1 = ((vec2<f32>(1f, 1f) - abs(_e201.yx)) * _e205);
    let _e208 = (*d_6)[1u];
    let _e210 = p_2;
    let _e211 = folded_1;
    return ((select(_e211, _e210, vec2((_e208 >= 0f))) * 0.5f) + vec2<f32>(0.5f, 0.5f));
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_28: vec3<f32>;

    let _e173 = Orthographic_u0028_();
    if _e173 {
        let _e175 = fog_info.forward;
        local_28 = -(_e175.xyz);
    } else {
        let _e179 = fog_info.eye;
        let _e181 = v_world_position_1;
        local_28 = normalize((_e179.xyz - _e181));
    }
    let _e184 = local_28;
    return _e184;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key: f32;
    var origin_2: vec3<f32>;
    var cell_2: vec3<f32>;
    var p3_: vec3<f32>;

    let _e178 = (*cutoff);
    key = (-2f - _e178);
    let _e180 = key;
    let _e183 = key;
    let _e185 = floor((_e183 / 128f));
    let _e190 = key;
    origin_2 = vec3<f32>(floor((_e180 / 16384f)), (_e185 - (floor((_e185 / 128f)) * 128f)), (_e190 - (floor((_e190 / 128f)) * 128f)));
    let _e196 = (*scenePosition);
    let _e199 = origin_2;
    let _e200 = (floor((_e196 * 16f)) + _e199);
    let _e201 = vec3(128f);
    cell_2 = (_e200 - (floor((_e200 / _e201)) * _e201));
    let _e206 = cell_2;
    p3_ = fract((_e206 * 0.1031f));
    let _e209 = p3_;
    let _e210 = p3_;
    let _e215 = p3_;
    p3_ = (_e215 + vec3(dot(_e209, (_e210.zyx + vec3(31.32f)))));
    let _e219 = p3_[0u];
    let _e221 = p3_[1u];
    let _e224 = p3_[2u];
    return fract(((_e219 + _e221) * _e224));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e174 = frag_info.target_origin[1u];
    return _e174;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_4: vec4<f32>;
    var s_7: Surface;
    var param_117: vec3<f32>;
    var param_118: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_119: vec3<f32>;
    var param_120: f32;

    let _e180 = v_texcoord_1;
    let _e181 = MaterialLodBias_u0028_();
    let _e182 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e180, _e181);
    texel_4 = _e182;
    let _e183 = texel_4;
    param_117 = _e183.xyz;
    let _e185 = SrgbToLinear_u0028_vf3_u003b((&param_117));
    let _e187 = frag_info.base_color;
    param_118 = _e187.xyz;
    let _e189 = SrgbToLinear_u0028_vf3_u003b((&param_118));
    let _e191 = v_color_1;
    s_7.albedo = ((_e185 * _e189) * _e191.xyz);
    let _e196 = texel_4[3u];
    let _e199 = frag_info.base_color[3u];
    let _e202 = v_color_1[3u];
    s_7.alpha = ((_e196 * _e199) * _e202);
    let _e206 = s_7.albedo;
    g_albedo = _e206;
    let _e209 = frag_info.material2_[0u];
    cutoff_1 = _e209;
    let _e210 = cutoff_1;
    if (_e210 > 1f) {
        let _e212 = cutoff_1;
        edge = (_e212 - 1f);
        let _e215 = s_7.alpha;
        let _e216 = edge;
        let _e219 = s_7.alpha;
        let _e220 = fwidth(_e219);
        s_7.alpha = clamp((((_e215 - _e216) / max(_e220, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e226 = cutoff_1;
        if (_e226 >= 0f) {
            let _e229 = s_7.alpha;
            let _e230 = cutoff_1;
            if (_e229 < _e230) {
                discard;
            }
            s_7.alpha = 1f;
        } else {
            let _e233 = cutoff_1;
            if (_e233 < -1.5f) {
                let _e236 = s_7.alpha;
                let _e237 = v_world_position_1;
                param_119 = _e237;
                let _e238 = cutoff_1;
                param_120 = _e238;
                let _e239 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_119), (&param_120));
                if (_e236 < _e239) {
                    discard;
                }
            }
        }
    }
    let _e241 = cutoff_1;
    let _e243 = cutoff_1;
    g_premultiply = ((_e241 < 0f) && (_e243 > -0.75f));
    let _e246 = v_normal_1;
    s_7.n = normalize(_e246);
    let _e249 = gl_FrontFacing_1;
    if !(_e249) {
        let _e252 = s_7.n;
        s_7.n = -(_e252);
    }
    let _e255 = TowardsEye_u0028_();
    s_7.v = _e255;
    let _e258 = s_7.n;
    let _e260 = s_7.v;
    s_7.n_dot_v = max(dot(_e258, _e260), 0.0001f);
    let _e266 = frag_info.material[0u];
    s_7.metallic = clamp(_e266, 0f, 1f);
    let _e271 = frag_info.material[1u];
    s_7.roughness = clamp(_e271, 0.02f, 1f);
    let _e275 = frag_info.ambient_ground;
    let _e278 = frag_info.ambient_sky;
    let _e282 = s_7.n[1u];
    let _e289 = frag_info.material[2u];
    s_7.ambient = (mix(_e275.xyz, _e278.xyz, vec3(((_e282 * 0.5f) + 0.5f))) * _e289);
    let _e294 = frag_info.frame_params[0u];
    s_7.exposure = max(_e294, 0f);
    s_7.occlusion = 1f;
    s_7.emissive = vec3<f32>(0f, 0f, 0f);
    let _e299 = s_7;
    return _e299;
}

fn main_1() {
    var s_8: Surface;
    var d_7: vec3<f32>;
    var right_1: vec3<f32>;
    var param_121: vec3<f32>;
    var up_2: vec3<f32>;
    var offset_4: vec3<f32>;
    var g: vec2<f32>;
    var param_122: vec3<f32>;
    var base: vec2<f32>;
    var f: vec2<f32>;
    var lower: bool;
    var c0_: vec2<f32>;
    var local_29: vec2<f32>;
    var c1_: vec2<f32>;
    var c2_: vec2<f32>;
    var w: vec3<f32>;
    var local_30: vec3<f32>;
    var uv0_: vec2<f32>;
    var param_123: vec2<f32>;
    var param_124: vec3<f32>;
    var uv1_: vec2<f32>;
    var param_125: vec2<f32>;
    var param_126: vec3<f32>;
    var uv2_: vec2<f32>;
    var param_127: vec2<f32>;
    var param_128: vec3<f32>;
    var a0_: vec4<f32>;
    var a1_: vec4<f32>;
    var a2_: vec4<f32>;
    var n0_: vec4<f32>;
    var n1_: vec4<f32>;
    var n2_: vec4<f32>;
    var wa: vec3<f32>;
    var alpha_3: f32;
    var srgb_1: vec3<f32>;
    var local_31: vec3<f32>;
    var worldRight: vec3<f32>;
    var worldFacing: vec3<f32>;
    var worldUp: vec3<f32>;
    var param_129: vec3<f32>;
    var param_130: vec3<f32>;
    var ambient: vec3<f32>;
    var lit_2: vec3<f32>;
    var param_131: Surface;
    var param_132: vec3<f32>;
    var param_133: f32;
    var param_134: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e219 = ReadSurface_u0028_();
    s_8 = _e219;
    let _e220 = v_color_1;
    d_7 = normalize(_e220.xyz);
    let _e223 = d_7;
    param_121 = _e223;
    let _e224 = ImpostorRight_u0028_vf3_u003b((&param_121));
    right_1 = _e224;
    let _e225 = d_7;
    let _e226 = right_1;
    up_2 = cross(_e225, _e226);
    let _e228 = right_1;
    let _e230 = v_texcoord_1[0u];
    let _e234 = up_2;
    let _e236 = v_texcoord_1[1u];
    offset_4 = ((_e228 * ((_e230 * 2f) - 1f)) + (_e234 * (1f - (_e236 * 2f))));
    let _e241 = d_7;
    param_122 = _e241;
    let _e242 = ImpostorEncode_u0028_vf3_u003b((&param_122));
    g = (_e242 * 7f);
    let _e244 = g;
    base = clamp(floor(_e244), vec2<f32>(0f, 0f), vec2<f32>(6f, 6f));
    let _e247 = g;
    let _e248 = base;
    f = (_e247 - _e248);
    let _e251 = f[0u];
    let _e253 = f[1u];
    lower = ((_e251 + _e253) < 1f);
    let _e256 = lower;
    if _e256 {
        let _e257 = base;
        local_29 = _e257;
    } else {
        let _e258 = base;
        local_29 = (_e258 + vec2<f32>(1f, 1f));
    }
    let _e260 = local_29;
    c0_ = _e260;
    let _e261 = base;
    c1_ = (_e261 + vec2<f32>(1f, 0f));
    let _e263 = base;
    c2_ = (_e263 + vec2<f32>(0f, 1f));
    let _e265 = lower;
    if _e265 {
        let _e267 = f[0u];
        let _e270 = f[1u];
        let _e273 = f[0u];
        let _e275 = f[1u];
        local_30 = vec3<f32>(((1f - _e267) - _e270), _e273, _e275);
    } else {
        let _e278 = f[0u];
        let _e280 = f[1u];
        let _e284 = f[1u];
        let _e287 = f[0u];
        local_30 = vec3<f32>(((_e278 + _e280) - 1f), (1f - _e284), (1f - _e287));
    }
    let _e290 = local_30;
    w = _e290;
    let _e291 = c0_;
    param_123 = _e291;
    let _e292 = offset_4;
    param_124 = _e292;
    let _e293 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_123), (&param_124));
    uv0_ = _e293;
    let _e294 = c1_;
    param_125 = _e294;
    let _e295 = offset_4;
    param_126 = _e295;
    let _e296 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_125), (&param_126));
    uv1_ = _e296;
    let _e297 = c2_;
    param_127 = _e297;
    let _e298 = offset_4;
    param_128 = _e298;
    let _e299 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_127), (&param_128));
    uv2_ = _e299;
    let _e300 = uv0_;
    let _e301 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e300, 0f);
    a0_ = _e301;
    let _e302 = uv1_;
    let _e303 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e302, 0f);
    a1_ = _e303;
    let _e304 = uv2_;
    let _e305 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e304, 0f);
    a2_ = _e305;
    let _e306 = uv0_;
    let _e307 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e306, 0f);
    n0_ = _e307;
    let _e308 = uv1_;
    let _e309 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e308, 0f);
    n1_ = _e309;
    let _e310 = uv2_;
    let _e311 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e310, 0f);
    n2_ = _e311;
    let _e312 = w;
    let _e314 = a0_[3u];
    let _e316 = a1_[3u];
    let _e318 = a2_[3u];
    wa = (_e312 * vec3<f32>(_e314, _e316, _e318));
    let _e322 = wa[0u];
    let _e324 = wa[1u];
    let _e327 = wa[2u];
    alpha_3 = ((_e322 + _e324) + _e327);
    let _e329 = alpha_3;
    if (_e329 < 0.5f) {
        discard;
    }
    let _e331 = a0_;
    let _e334 = wa[0u];
    let _e336 = a1_;
    let _e339 = wa[1u];
    let _e342 = a2_;
    let _e345 = wa[2u];
    let _e348 = alpha_3;
    srgb_1 = ((((_e331.xyz * _e334) + (_e336.xyz * _e339)) + (_e342.xyz * _e345)) / vec3(_e348));
    let _e351 = n0_;
    let _e356 = wa[0u];
    let _e358 = n1_;
    let _e363 = wa[1u];
    let _e366 = n2_;
    let _e371 = wa[2u];
    local_31 = (((((_e351.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e356) + (((_e358.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e363)) + (((_e366.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e371));
    let _e374 = local_31;
    let _e375 = local_31;
    let _e378 = local_31;
    let _e379 = d_7;
    local_31 = normalize(select(_e379, _e378, vec3((dot(_e374, _e375) > 0.000000000001f))));
    let _e383 = v_tangent_1;
    worldRight = normalize(_e383.xyz);
    let _e386 = v_normal_1;
    worldFacing = normalize(_e386);
    let _e388 = worldFacing;
    let _e389 = worldRight;
    worldUp = cross(_e388, _e389);
    let _e391 = worldRight;
    let _e392 = local_31;
    let _e393 = right_1;
    let _e396 = worldUp;
    let _e397 = local_31;
    let _e398 = up_2;
    let _e402 = worldFacing;
    let _e403 = local_31;
    let _e404 = d_7;
    s_8.n = normalize((((_e391 * dot(_e392, _e393)) + (_e396 * dot(_e397, _e398))) + (_e402 * dot(_e403, _e404))));
    let _e411 = s_8.n;
    let _e413 = s_8.v;
    s_8.n_dot_v = max(dot(_e411, _e413), 0.0001f);
    let _e417 = srgb_1;
    param_129 = _e417;
    let _e418 = SrgbToLinear_u0028_vf3_u003b((&param_129));
    let _e420 = frag_info.base_color;
    param_130 = _e420.xyz;
    let _e422 = SrgbToLinear_u0028_vf3_u003b((&param_130));
    s_8.albedo = (_e418 * _e422);
    s_8.alpha = 1f;
    let _e427 = s_8.albedo;
    g_albedo = _e427;
    let _e429 = frag_info.ambient_ground;
    let _e432 = frag_info.ambient_sky;
    let _e436 = s_8.n[1u];
    let _e443 = frag_info.material[2u];
    s_8.ambient = (mix(_e429.xyz, _e432.xyz, vec3(((_e436 * 0.5f) + 0.5f))) * _e443);
    let _e447 = s_8.albedo;
    let _e449 = s_8.ambient;
    ambient = (_e447 * _e449);
    let _e451 = s_8;
    param_131 = _e451;
    let _e452 = 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((&param_131));
    let _e453 = ambient;
    lit_2 = (_e452 + _e453);
    let _e455 = lit_2;
    param_132 = _e455;
    param_133 = 1f;
    param_134 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_132), (&param_133), (&param_134));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 3,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
    'ImpostorDebug': WebGpuStage(
      wgsl: r'''
struct Surface {
    albedo: vec3<f32>,
    alpha: f32,
    n: vec3<f32>,
    v: vec3<f32>,
    n_dot_v: f32,
    metallic: f32,
    roughness: f32,
    occlusion: f32,
    emissive: vec3<f32>,
    ambient: vec3<f32>,
    exposure: f32,
}

struct LightSample {
    l: vec3<f32>,
    h: vec3<f32>,
    radiance: vec3<f32>,
    n_dot_l: f32,
    n_dot_h: f32,
    v_dot_h: f32,
    integrated: f32,
    ltc: vec3<f32>,
}

struct FogInfo {
    fog: vec4<f32>,
    eye: vec4<f32>,
    forward: vec4<f32>,
    projection: vec4<f32>,
}

struct LightListInfo {
    list: vec4<f32>,
    indices: array<vec4<f32>, 6>,
    scales: array<vec4<f32>, 6>,
    cluster_view_projection: mat4x4<f32>,
    cluster_grid: vec4<f32>,
    cluster_depth: vec4<f32>,
    slot_rows: array<vec4<f32>, 2>,
}

struct FragInfo {
    light_position: array<vec4<f32>, 8>,
    light_color: array<vec4<f32>, 8>,
    light_direction: array<vec4<f32>, 8>,
    light_cone: array<vec4<f32>, 8>,
    base_color: vec4<f32>,
    emissive: vec4<f32>,
    camera_position: vec4<f32>,
    material: vec4<f32>,
    material2_: vec4<f32>,
    frame_params: vec4<f32>,
    shadow_params: vec4<f32>,
    shadow_matrix: mat4x4<f32>,
    shadow_matrix_far: mat4x4<f32>,
    shadow_matrix_farthest: mat4x4<f32>,
    shadow_cascades: vec4<f32>,
    ambient_sky: vec4<f32>,
    ambient_ground: vec4<f32>,
    shadow_bias: vec4<f32>,
    target_origin: vec4<f32>,
    debug_view: vec4<f32>,
}

struct PointShadow {
    faces: array<mat4x4<f32>, 36>,
    lights: array<vec4<f32>, 6>,
    slots: array<vec4<f32>, 8>,
    params: vec4<f32>,
    params2_: vec4<f32>,
    params3_: vec4<f32>,
}

struct FragmentOutput {
    @location(2) member: vec4<f32>,
    @location(1) member_1: vec4<f32>,
    @location(0) member_2: vec4<f32>,
}

var<private> g_albedo: vec3<f32>;
var<private> g_debug_surface: vec3<f32>;
var<private> g_debug_surface_on: bool;
var<private> g_premultiply: bool;
var<private> g_pass_through: f32;
var<private> g_cluster_offset: f32;
var<private> g_cluster_count: f32;
var<private> light_transmittance: vec3<f32>;
@group(1) @binding(0)
var<uniform> fog_info: FogInfo;
var<private> v_world_position_1: vec3<f32>;
var<private> frag_albedo: vec4<f32>;
var<private> frag_surface: vec4<f32>;
var<private> v_normal_1: vec3<f32>;
var<private> gl_FrontFacing_1: bool;
var<private> frag_color: vec4<f32>;
var<private> gl_FragCoord_1: vec4<f32>;
@group(1) @binding(2)
var<uniform> light_list_info: LightListInfo;
@group(1) @binding(6)
var light_list_texture_tex: texture_2d<f32>;
@group(1) @binding(7)
var light_list_texture_smp: sampler;
@group(1) @binding(1)
var<uniform> frag_info: FragInfo;
@group(1) @binding(4)
var base_color_texture_tex: texture_2d<f32>;
@group(1) @binding(5)
var base_color_texture_smp: sampler;
var<private> v_texcoord_1: vec2<f32>;
var<private> v_color_1: vec4<f32>;
@group(1) @binding(3)
var<uniform> point_shadow: PointShadow;
@group(1) @binding(12)
var point_shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(13)
var point_shadow_texture_smp: sampler;
@group(1) @binding(10)
var point_shadow_static_texture_tex: texture_2d<f32>;
@group(1) @binding(11)
var point_shadow_static_texture_smp: sampler;
var<private> v_tangent_1: vec4<f32>;
@group(1) @binding(14)
var shadow_texture_tex: texture_2d<f32>;
@group(1) @binding(15)
var shadow_texture_smp: sampler;
@group(1) @binding(8)
var normal_texture_tex: texture_2d<f32>;
@group(1) @binding(9)
var normal_texture_smp: sampler;
var<private> v_lightmap_uv_1: vec2<f32>;

fn ViewDepth_u0028_() -> f32 {
    let _e210 = v_world_position_1;
    let _e212 = fog_info.eye;
    let _e216 = fog_info.forward;
    return dot((_e210 - _e212.xyz), _e216.xyz);
}

fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
    var z: f32;
    var near: f32;
    var far: f32;
    var far3_: f32;

    let _e215 = ViewDepth_u0028_();
    z = abs(_e215);
    let _e217 = z;
    near = (_e217 / 5f);
    let _e219 = z;
    far = (_e219 / 200f);
    let _e221 = far;
    let _e222 = far;
    let _e224 = far;
    far3_ = ((_e221 * _e222) * _e224);
    let _e226 = (*alpha);
    let _e227 = near;
    let _e228 = near;
    let _e231 = far3_;
    let _e232 = far3_;
    return (_e226 * clamp((10f / ((0.00001f + (_e227 * _e228)) + (_e231 * _e232))), 0.01f, 3000f));
}

fn WriteWeightedBlended_u0028_() {
    var mode: f32;
    var alpha_1: f32;
    var weight: f32;
    var param: f32;
    var accumulate: vec4<f32>;
    var revealage: bool;
    var local: vec4<f32>;

    let _e219 = fog_info.forward[3u];
    mode = _e219;
    let _e220 = mode;
    if (_e220 > 0.5f) {
        let _e223 = frag_color[3u];
        alpha_1 = _e223;
        let _e224 = alpha_1;
        param = _e224;
        let _e225 = WeightedBlendedWeight_u0028_f1_u003b((&param));
        weight = _e225;
        let _e226 = frag_color;
        let _e228 = weight;
        let _e229 = (_e226.xyz * _e228);
        let _e230 = alpha_1;
        let _e231 = weight;
        accumulate = vec4<f32>(_e229.x, _e229.y, _e229.z, (_e230 * _e231));
        let _e237 = mode;
        let _e239 = mode;
        revealage = ((_e237 > 1.5f) && (_e239 < 2.5f));
        let _e242 = revealage;
        if _e242 {
            let _e243 = alpha_1;
            local = vec4(_e243);
        } else {
            let _e245 = accumulate;
            local = _e245;
        }
        let _e246 = local;
        frag_color = _e246;
        let _e247 = mode;
        if (_e247 > 2.5f) {
            let _e249 = alpha_1;
            frag_surface = vec4(_e249);
        }
    }
    return;
}

fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
    var e: vec2<f32>;

    let _e213 = (*n)[0u];
    let _e216 = (*n)[1u];
    let _e220 = (*n)[2u];
    let _e223 = (*n);
    (*n) = (_e223 / vec3(((abs(_e213) + abs(_e216)) + abs(_e220))));
    let _e226 = (*n);
    e = _e226.xy;
    let _e229 = (*n)[2u];
    if (_e229 < 0f) {
        let _e231 = (*n);
        let _e237 = (*n)[0u];
        let _e241 = (*n)[1u];
        e = ((vec2(1f) - abs(_e231.yx)) * vec2<f32>(select(-1f, 1f, (_e237 >= 0f)), select(-1f, 1f, (_e241 >= 0f))));
    }
    let _e246 = e;
    return ((_e246 * 0.5f) + vec2(0.5f));
}

fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e211 = (*linear);
    let _e213 = (*linear);
    let _e217 = (*linear);
    return mix((_e211 * 12.92f), ((pow(_e213, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e217));
}

fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
    var param_1: vec3<f32>;
    var geometric: vec3<f32>;
    var param_2: vec3<f32>;

    let _e214 = g_albedo;
    param_1 = clamp(_e214, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
    let _e216 = LinearToSrgb_u0028_vf3_u003b((&param_1));
    frag_albedo = vec4<f32>(_e216.x, _e216.y, _e216.z, 1f);
    let _e221 = g_debug_surface_on;
    if _e221 {
        let _e222 = g_debug_surface;
        let _e223 = ViewDepth_u0028_();
        frag_surface = vec4<f32>(_e222.x, _e222.y, _e222.z, _e223);
        return;
    }
    let _e228 = v_normal_1;
    geometric = normalize(_e228);
    let _e230 = gl_FrontFacing_1;
    if !(_e230) {
        let _e232 = geometric;
        geometric = -(_e232);
    }
    let _e234 = geometric;
    param_2 = _e234;
    let _e235 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
    let _e236 = (*roughness);
    let _e238 = ViewDepth_u0028_();
    frag_surface = vec4<f32>(_e235.x, _e235.y, clamp(_e236, 0f, 1f), _e238);
    return;
}

fn Orthographic_u0028_() -> bool {
    let _e212 = fog_info.projection[0u];
    return (_e212 > 0.5f);
}

fn EyeDistance_u0028_() -> f32 {
    var local_1: f32;

    let _e211 = Orthographic_u0028_();
    if _e211 {
        let _e212 = ViewDepth_u0028_();
        local_1 = max(_e212, 0f);
    } else {
        let _e214 = v_world_position_1;
        let _e216 = fog_info.eye;
        local_1 = distance(_e214, _e216.xyz);
    }
    let _e219 = local_1;
    return _e219;
}

fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
    var density: f32;
    var d: f32;
    var falloff: f32;
    var k: f32;
    var local_2: f32;

    let _e218 = fog_info.fog[3u];
    density = _e218;
    let _e219 = density;
    if (_e219 <= 0f) {
        let _e221 = (*color);
        return _e221;
    }
    let _e222 = EyeDistance_u0028_();
    d = _e222;
    let _e225 = fog_info.eye[3u];
    falloff = _e225;
    let _e226 = falloff;
    if (_e226 > 0f) {
        let _e228 = falloff;
        let _e230 = v_world_position_1[1u];
        let _e233 = fog_info.eye[1u];
        k = (_e228 * (_e230 - _e233));
        let _e236 = k;
        if (abs(_e236) > 0.001f) {
            let _e239 = k;
            let _e243 = k;
            local_2 = ((1f - exp(-(_e239))) / _e243);
        } else {
            let _e245 = k;
            local_2 = (1f - (0.5f * _e245));
        }
        let _e248 = local_2;
        let _e249 = density;
        density = (_e249 * _e248);
    }
    let _e252 = fog_info.fog;
    let _e254 = (*color);
    let _e255 = density;
    let _e257 = d;
    return mix(_e252.xyz, _e254, vec3(clamp(exp((-(_e255) * _e257)), 0f, 1f)));
}

fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
    var weight_1: f32;
    var param_3: vec3<f32>;
    var param_4: f32;

    let _e216 = g_premultiply;
    let _e217 = (*alpha_2);
    weight_1 = select(1f, _e217, _e216);
    let _e219 = (*linearColor);
    param_3 = _e219;
    let _e220 = ApplyFog_u0028_vf3_u003b((&param_3));
    let _e221 = weight_1;
    let _e222 = (_e220 * _e221);
    let _e223 = (*alpha_2);
    let _e224 = g_pass_through;
    frag_color = vec4<f32>(_e222.x, _e222.y, _e222.z, (_e223 * (1f - _e224)));
    let _e231 = (*roughness_1);
    param_4 = _e231;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
    WriteWeightedBlended_u0028_();
    return;
}

fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
    let _e211 = (*srgb);
    let _e214 = (*srgb);
    let _e219 = (*srgb);
    return mix((_e211 / vec3(12.92f)), pow(((_e214 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e219));
}

fn DebugIdentityColour_u0028_f1_u003b(key: ptr<function, f32>) -> vec3<f32> {
    var hue: f32;
    var k_1: vec3<f32>;

    let _e213 = (*key);
    hue = fract(((_e213 * 0.618034f) + 0.13f));
    let _e217 = hue;
    k_1 = clamp((abs(((fract((vec3(_e217) + vec3<f32>(0f, 0.6666667f, 0.33333334f))) * 6f) - vec3(3f))) - vec3(1f)), vec3(0f), vec3(1f));
    let _e230 = k_1;
    return (mix(vec3<f32>(1f, 1f, 1f), _e230, vec3(0.7f)) * 0.95f);
}

fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
    var phi_2854_: bool;

    let _e211 = (*c);
    let _e212 = (*c);
    let _e214 = any((_e211 != _e212));
    phi_2854_ = _e214;
    if !(_e214) {
        let _e216 = (*c);
        phi_2854_ = any((abs(_e216) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
    }
    let _e221 = phi_2854_;
    return _e221;
}

fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
    var view: f32;
    var local_3: f32;
    var code: i32;
    var shown: vec3<f32>;
    var geometric_n: vec3<f32>;
    var tangent: vec3<f32>;
    var tangent_usable: bool;
    var identity: f32;
    var identity_object: f32;
    var identity_rest: f32;
    var identity_material: f32;
    var normal_mapped: bool;
    var param_5: vec3<f32>;
    var param_6: vec3<f32>;
    var grey: f32;
    var param_7: vec3<f32>;
    var param_8: vec3<f32>;
    var local_4: vec3<f32>;
    var local_5: vec3<f32>;
    var uv: vec2<f32>;
    var cell: vec2<f32>;
    var odd: f32;
    var within: vec2<f32>;
    var param_9: vec3<f32>;
    var key_1: f32;
    var param_10: f32;
    var srgb_1: vec3<f32>;
    var param_11: vec3<f32>;
    var luma: f32;
    var metal: bool;
    var local_6: vec3<f32>;
    var local_7: vec3<f32>;
    var local_8: vec3<f32>;
    var m: f32;
    var local_9: vec3<f32>;
    var local_10: vec3<f32>;
    var weight_2: f32;
    var local_11: f32;
    var param_12: vec3<f32>;
    var param_13: f32;
    var phi_2944_: bool;
    var phi_3212_: bool;

    let _e253 = gl_FragCoord_1[0u];
    let _e256 = frag_info.debug_view[1u];
    if (_e253 < _e256) {
        let _e260 = frag_info.debug_view[2u];
        local_3 = _e260;
    } else {
        let _e263 = frag_info.debug_view[0u];
        local_3 = _e263;
    }
    let _e264 = local_3;
    view = _e264;
    let _e265 = view;
    if (_e265 < 0.5f) {
        return false;
    }
    let _e267 = view;
    code = i32((_e267 + 0.5f));
    shown = vec3<f32>(0f, 0f, 0f);
    let _e270 = v_normal_1;
    geometric_n = normalize(_e270);
    let _e272 = v_tangent_1;
    let _e274 = geometric_n;
    let _e275 = geometric_n;
    let _e276 = v_tangent_1;
    tangent = (_e272.xyz - (_e274 * dot(_e275, _e276.xyz)));
    let _e281 = tangent;
    let _e282 = tangent;
    let _e284 = (dot(_e281, _e282) > 0.000000000001f);
    phi_2944_ = _e284;
    if _e284 {
        let _e286 = v_tangent_1[3u];
        phi_2944_ = (abs((abs(_e286) - 1f)) < 0.01f);
    }
    let _e292 = phi_2944_;
    tangent_usable = _e292;
    let _e295 = frag_info.debug_view[3u];
    identity = _e295;
    let _e296 = identity;
    identity_object = floor((_e296 / 8192f));
    let _e299 = identity;
    let _e300 = identity_object;
    identity_rest = (_e299 - (_e300 * 8192f));
    let _e303 = identity_rest;
    identity_material = floor((_e303 / 2f));
    let _e306 = identity_rest;
    let _e307 = identity_material;
    normal_mapped = ((_e306 - (_e307 * 2f)) > 0.5f);
    let _e311 = code;
    if (_e311 == 1i) {
        let _e314 = (*s).albedo;
        param_5 = clamp(_e314, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
        let _e316 = LinearToSrgb_u0028_vf3_u003b((&param_5));
        shown = _e316;
    } else {
        let _e317 = code;
        if (_e317 == 2i) {
            let _e320 = (*s).n;
            shown = ((_e320 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
        } else {
            let _e323 = code;
            if (_e323 == 3i) {
                let _e326 = (*s).roughness;
                shown = vec3(clamp(_e326, 0f, 1f));
            } else {
                let _e329 = code;
                if (_e329 == 4i) {
                    let _e332 = (*s).metallic;
                    shown = vec3(clamp(_e332, 0f, 1f));
                } else {
                    let _e335 = code;
                    if (_e335 == 5i) {
                        let _e338 = (*s).occlusion;
                        shown = vec3(clamp(_e338, 0f, 1f));
                    } else {
                        let _e341 = code;
                        if (_e341 == 6i) {
                            let _e344 = (*s).emissive;
                            param_6 = clamp(_e344, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                            let _e346 = LinearToSrgb_u0028_vf3_u003b((&param_6));
                            shown = _e346;
                        } else {
                            let _e347 = code;
                            if (_e347 == 7i) {
                                let _e349 = v_texcoord_1;
                                let _e350 = fract(_e349);
                                shown = vec3<f32>(_e350.x, _e350.y, 0f);
                            } else {
                                let _e354 = code;
                                if (_e354 == 8i) {
                                    let _e356 = (*lit);
                                    param_7 = clamp(_e356, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                    let _e358 = LinearToSrgb_u0028_vf3_u003b((&param_7));
                                    grey = dot(_e358, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                    let _e360 = (*lit);
                                    param_8 = _e360;
                                    let _e361 = NonFinite_u0028_vf3_u003b((&param_8));
                                    if _e361 {
                                        local_4 = vec3<f32>(1f, 0f, 1f);
                                    } else {
                                        let _e362 = grey;
                                        local_4 = vec3((_e362 * 0.5f));
                                    }
                                    let _e365 = local_4;
                                    shown = _e365;
                                } else {
                                    let _e366 = code;
                                    if (_e366 == 9i) {
                                        let _e368 = tangent_usable;
                                        if _e368 {
                                            let _e369 = tangent;
                                            local_5 = ((normalize(_e369) * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
                                        } else {
                                            local_5 = vec3<f32>(0f, 0f, 0f);
                                        }
                                        let _e373 = local_5;
                                        shown = _e373;
                                    } else {
                                        let _e374 = code;
                                        if (_e374 == 10i) {
                                            let _e376 = v_texcoord_1;
                                            uv = _e376;
                                            let _e377 = uv;
                                            cell = floor((_e377 * 8f));
                                            let _e381 = cell[0u];
                                            let _e383 = cell[1u];
                                            odd = (fract(((_e381 + _e383) * 0.5f)) * 2f);
                                            let _e388 = uv;
                                            within = fract(_e388);
                                            let _e390 = odd;
                                            let _e394 = within[0u];
                                            let _e398 = within[1u];
                                            shown = (mix(vec3<f32>(0.22f, 0.22f, 0.22f), vec3<f32>(0.92f, 0.92f, 0.92f), vec3(_e390)) * vec3<f32>((0.55f + (0.45f * _e394)), (0.55f + (0.45f * _e398)), 0.85f));
                                        } else {
                                            let _e403 = code;
                                            if (_e403 == 11i) {
                                                let _e405 = gl_FrontFacing_1;
                                                shown = select(vec3<f32>(0.95f, 0.15f, 0.15f), vec3<f32>(0.2f, 0.35f, 0.95f), vec3(_e405));
                                            } else {
                                                let _e408 = code;
                                                if (_e408 == 12i) {
                                                    let _e410 = v_color_1;
                                                    param_9 = clamp(_e410.xyz, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                    let _e413 = LinearToSrgb_u0028_vf3_u003b((&param_9));
                                                    shown = _e413;
                                                } else {
                                                    let _e414 = code;
                                                    let _e416 = code;
                                                    if ((_e414 == 13i) || (_e416 == 14i)) {
                                                        let _e419 = code;
                                                        let _e421 = identity_object;
                                                        let _e422 = identity_material;
                                                        key_1 = select(_e422, _e421, (_e419 == 13i));
                                                        let _e424 = key_1;
                                                        param_10 = _e424;
                                                        let _e425 = DebugIdentityColour_u0028_f1_u003b((&param_10));
                                                        let _e427 = (*s).n_dot_v;
                                                        shown = (_e425 * (0.55f + (0.45f * _e427)));
                                                    } else {
                                                        let _e431 = code;
                                                        if (_e431 == 15i) {
                                                            let _e434 = (*s).albedo;
                                                            param_11 = clamp(_e434, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
                                                            let _e436 = LinearToSrgb_u0028_vf3_u003b((&param_11));
                                                            srgb_1 = _e436;
                                                            let _e437 = srgb_1;
                                                            luma = dot(_e437, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
                                                            let _e440 = (*s).metallic;
                                                            metal = (_e440 > 0.5f);
                                                            let _e442 = metal;
                                                            let _e444 = luma;
                                                            if (!(_e442) && (_e444 < 0.11764706f)) {
                                                                local_6 = vec3<f32>(0.1f, 0.3f, 1f);
                                                            } else {
                                                                let _e447 = metal;
                                                                let _e448 = !(_e447);
                                                                phi_3212_ = _e448;
                                                                if _e448 {
                                                                    let _e450 = srgb_1[0u];
                                                                    let _e452 = srgb_1[1u];
                                                                    let _e454 = srgb_1[2u];
                                                                    phi_3212_ = (max(_e450, max(_e452, _e454)) > 0.9411765f);
                                                                }
                                                                let _e459 = phi_3212_;
                                                                if _e459 {
                                                                    local_7 = vec3<f32>(1f, 0.1f, 0.1f);
                                                                } else {
                                                                    let _e460 = metal;
                                                                    let _e461 = luma;
                                                                    if (_e460 && (_e461 < 0.7058824f)) {
                                                                        local_8 = vec3<f32>(1f, 0.85f, 0.1f);
                                                                    } else {
                                                                        let _e464 = luma;
                                                                        local_8 = vec3(_e464);
                                                                    }
                                                                    let _e466 = local_8;
                                                                    local_7 = _e466;
                                                                }
                                                                let _e467 = local_7;
                                                                local_6 = _e467;
                                                            }
                                                            let _e468 = local_6;
                                                            shown = _e468;
                                                        } else {
                                                            let _e469 = code;
                                                            if (_e469 == 16i) {
                                                                let _e472 = (*s).metallic;
                                                                m = _e472;
                                                                let _e473 = m;
                                                                let _e475 = m;
                                                                if ((_e473 > 0.05f) && (_e475 < 0.95f)) {
                                                                    local_9 = vec3<f32>(1f, 0.5f, 0f);
                                                                } else {
                                                                    let _e478 = m;
                                                                    local_9 = vec3(select(0.15f, 1f, (_e478 > 0.5f)));
                                                                }
                                                                let _e482 = local_9;
                                                                shown = _e482;
                                                            } else {
                                                                let _e483 = code;
                                                                if (_e483 == 17i) {
                                                                    let _e485 = normal_mapped;
                                                                    if !(_e485) {
                                                                        local_10 = vec3<f32>(0.5f, 0.5f, 0.5f);
                                                                    } else {
                                                                        let _e487 = tangent_usable;
                                                                        local_10 = select(vec3<f32>(1f, 0.1f, 0.1f), vec3<f32>(0.2f, 0.8f, 0.3f), vec3(_e487));
                                                                    }
                                                                    let _e490 = local_10;
                                                                    shown = _e490;
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let _e491 = g_premultiply;
    if _e491 {
        let _e493 = (*s).alpha;
        local_11 = _e493;
    } else {
        local_11 = 1f;
    }
    let _e494 = local_11;
    weight_2 = _e494;
    let _e495 = shown;
    param_12 = _e495;
    let _e496 = SrgbToLinear_u0028_vf3_u003b((&param_12));
    let _e497 = weight_2;
    let _e498 = (_e496 * _e497);
    let _e500 = (*s).alpha;
    frag_color = vec4<f32>(_e498.x, _e498.y, _e498.z, _e500);
    let _e506 = (*s).roughness;
    param_13 = _e506;
    WriteSurfaceGeometry_u0028_f1_u003b((&param_13));
    WriteWeightedBlended_u0028_();
    return true;
}

fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
    let _e213 = (*s_1).albedo;
    return _e213;
}

fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
    let _e211 = (*i);
    if (_e211 == 0i) {
        return vec2<f32>(-0.94201624f, -0.39906216f);
    }
    let _e213 = (*i);
    if (_e213 == 1i) {
        return vec2<f32>(0.9455861f, -0.76890725f);
    }
    let _e215 = (*i);
    if (_e215 == 2i) {
        return vec2<f32>(-0.0941841f, -0.9293887f);
    }
    let _e217 = (*i);
    if (_e217 == 3i) {
        return vec2<f32>(0.34495938f, 0.2938776f);
    }
    let _e219 = (*i);
    if (_e219 == 4i) {
        return vec2<f32>(-0.9158858f, 0.45771432f);
    }
    let _e221 = (*i);
    if (_e221 == 5i) {
        return vec2<f32>(-0.8154423f, -0.87912464f);
    }
    let _e223 = (*i);
    if (_e223 == 6i) {
        return vec2<f32>(-0.38277543f, 0.27676845f);
    }
    return vec2<f32>(0.974844f, 0.7564838f);
}

fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function, i32>, ca: ptr<function, f32>, sa: ptr<function, f32>, radius: ptr<function, f32>) -> vec2<f32> {
    var p: vec2<f32>;
    var param_14: i32;

    let _e216 = (*i_1);
    param_14 = _e216;
    let _e217 = PointShadowDiskTap_u0028_i1_u003b((&param_14));
    p = _e217;
    let _e219 = p[0u];
    let _e220 = (*ca);
    let _e223 = p[1u];
    let _e224 = (*sa);
    let _e228 = p[0u];
    let _e229 = (*sa);
    let _e232 = p[1u];
    let _e233 = (*ca);
    let _e237 = (*radius);
    return (vec2<f32>(((_e219 * _e220) - (_e223 * _e224)), ((_e228 * _e229) + (_e232 * _e233))) * _e237);
}

fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
    var inset: f32;
    var local_12: vec2<f32>;
    var atlas: vec2<f32>;

    let _e219 = point_shadow.params[0u];
    inset = _e219;
    let _e220 = (*uv_1);
    let _e221 = (*offset);
    let _e223 = inset;
    let _e224 = inset;
    local_12 = clamp((_e220 + _e221), vec2(_e223), vec2((1f - _e224)));
    let _e229 = local_12;
    let _e230 = (*tile);
    atlas = ((_e229 + _e230) * vec2<f32>(0.16666667f, 0.16666667f));
    let _e235 = point_shadow.params3_[0u];
    if (_e235 > 0.5f) {
        let _e238 = atlas[1u];
        atlas[1u] = (1f - _e238);
    }
    let _e241 = atlas;
    let _e242 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e241, 0f);
    let _e244 = atlas;
    let _e245 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e244, 0f);
    let _e248 = (*range);
    return (min(_e242.x, _e245.x) * _e248);
}

fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
    var stored: f32;
    var param_15: vec2<f32>;
    var param_16: vec2<f32>;
    var param_17: vec2<f32>;
    var param_18: f32;

    let _e220 = (*uv_2);
    param_15 = _e220;
    let _e221 = (*offset_1);
    param_16 = _e221;
    let _e222 = (*tile_1);
    param_17 = _e222;
    let _e223 = (*range_1);
    param_18 = _e223;
    let _e224 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_15), (&param_16), (&param_17), (&param_18));
    stored = _e224;
    let _e225 = stored;
    let _e226 = (*range_1);
    if (_e225 >= (_e226 * 0.999f)) {
        return 1f;
    }
    let _e229 = (*receiver);
    let _e230 = stored;
    return select(1f, 0f, (_e229 > _e230));
}

fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
    var lightRadius: f32;
    var minRadius: f32;
    var maxRadius: f32;
    var param_19: vec2<f32>;
    var param_20: vec2<f32>;
    var param_21: vec2<f32>;
    var param_22: f32;
    var sum: f32;
    var count: f32;
    var i_2: i32;
    var stored_1: f32;
    var param_23: i32;
    var param_24: f32;
    var param_25: f32;
    var param_26: f32;
    var param_27: vec2<f32>;
    var param_28: vec2<f32>;
    var param_29: vec2<f32>;
    var param_30: f32;
    var blocker: f32;
    var world: f32;

    (*blockerOut) = -1f;
    let _e241 = point_shadow.params2_[1u];
    lightRadius = _e241;
    let _e244 = point_shadow.params2_[0u];
    minRadius = _e244;
    let _e247 = point_shadow.params2_[2u];
    maxRadius = _e247;
    let _e248 = lightRadius;
    if (_e248 <= 0f) {
        let _e250 = (*uv_3);
        param_19 = _e250;
        param_20 = vec2<f32>(0f, 0f);
        let _e251 = (*tile_2);
        param_21 = _e251;
        let _e252 = (*range_2);
        param_22 = _e252;
        let _e253 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_19), (&param_20), (&param_21), (&param_22));
        (*blockerOut) = _e253;
        let _e254 = minRadius;
        return _e254;
    }
    sum = 0f;
    count = 0f;
    i_2 = 0i;
    loop {
        let _e255 = i_2;
        if (_e255 < 8i) {
            let _e257 = i_2;
            param_23 = _e257;
            let _e258 = (*ca_1);
            param_24 = _e258;
            let _e259 = (*sa_1);
            param_25 = _e259;
            let _e260 = maxRadius;
            param_26 = _e260;
            let _e261 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_23), (&param_24), (&param_25), (&param_26));
            let _e262 = (*uv_3);
            param_27 = _e262;
            param_28 = _e261;
            let _e263 = (*tile_2);
            param_29 = _e263;
            let _e264 = (*range_2);
            param_30 = _e264;
            let _e265 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_27), (&param_28), (&param_29), (&param_30));
            stored_1 = _e265;
            let _e266 = stored_1;
            let _e267 = (*range_2);
            if (_e266 >= (_e267 * 0.999f)) {
                continue;
            }
            let _e270 = stored_1;
            let _e271 = (*receiver_1);
            if (_e270 >= _e271) {
                continue;
            }
            let _e273 = stored_1;
            let _e274 = sum;
            sum = (_e274 + _e273);
            let _e276 = count;
            count = (_e276 + 1f);
            continue;
        } else {
            break;
        }
        continuing {
            let _e278 = i_2;
            i_2 = (_e278 + 1i);
        }
    }
    let _e280 = count;
    if (_e280 < 0.5f) {
        return -1f;
    }
    let _e282 = sum;
    let _e283 = count;
    blocker = max((_e282 / _e283), 0.0001f);
    let _e286 = blocker;
    (*blockerOut) = _e286;
    let _e287 = lightRadius;
    let _e288 = (*receiver_1);
    let _e289 = blocker;
    let _e293 = blocker;
    world = ((_e287 * max((_e288 - _e289), 0f)) / _e293);
    let _e295 = world;
    let _e296 = (*receiver_1);
    let _e298 = (*tanHalf);
    let _e301 = minRadius;
    let _e302 = maxRadius;
    return clamp((_e295 / ((2f * _e296) * _e298)), _e301, _e302);
}

fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
    var local_13: vec2<f32>;

    let _e212 = (*rows);
    if (_e212 > 0f) {
        let _e215 = gl_FragCoord_1[0u];
        let _e216 = (*rows);
        let _e218 = gl_FragCoord_1[1u];
        local_13 = vec2<f32>(_e215, (_e216 - _e218));
    } else {
        let _e221 = gl_FragCoord_1;
        local_13 = _e221.xy;
    }
    let _e223 = local_13;
    return _e223;
}

fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
    var slot: i32;
    var strength: f32;
    var toLight: vec3<f32>;
    var toLightLength: f32;
    var nDotL: f32;
    var slope: f32;
    var texel: f32;
    var origin: vec3<f32>;
    var toFragment: vec3<f32>;
    var distance_: f32;
    var range_3: f32;
    var face: i32;
    var a: vec3<f32>;
    var clip: vec4<f32>;
    var ndc: vec2<f32>;
    var uv_4: vec2<f32>;
    var tile_3: vec2<f32>;
    var receiver_2: f32;
    var noise: f32;
    var param_31: f32;
    var angle: f32;
    var ca_2: f32;
    var sa_2: f32;
    var tanHalf_1: f32;
    var blocker_1: f32;
    var radius_1: f32;
    var param_32: vec2<f32>;
    var param_33: vec2<f32>;
    var param_34: f32;
    var param_35: f32;
    var param_36: f32;
    var param_37: f32;
    var param_38: f32;
    var param_39: f32;
    var local_14: vec3<f32>;
    var lit_1: f32;
    var param_40: vec2<f32>;
    var param_41: vec2<f32>;
    var param_42: vec2<f32>;
    var param_43: f32;
    var param_44: f32;
    var i_3: i32;
    var param_45: i32;
    var param_46: f32;
    var param_47: f32;
    var param_48: f32;
    var param_49: vec2<f32>;
    var param_50: vec2<f32>;
    var param_51: vec2<f32>;
    var param_52: f32;
    var param_53: f32;
    var phi_2541_: bool;
    var phi_2602_: bool;

    let _e264 = (*lightIndex);
    let _e268 = point_shadow.slots[_e264][0u];
    slot = i32((_e268 + 0.5f));
    let _e271 = (*lightIndex);
    let _e275 = point_shadow.slots[_e271][0u];
    if (_e275 < 0f) {
        return 1f;
    }
    let _e279 = point_shadow.params[2u];
    strength = _e279;
    let _e280 = strength;
    if (_e280 <= 0f) {
        return 1f;
    }
    let _e282 = slot;
    let _e285 = point_shadow.lights[_e282];
    let _e287 = (*world_1);
    toLight = (_e285.xyz - _e287);
    let _e289 = toLight;
    toLightLength = max(length(_e289), 0.000001f);
    let _e292 = (*normal);
    let _e293 = toLight;
    let _e294 = toLightLength;
    nDotL = max(dot(_e292, (_e293 / vec3(_e294))), 0.15f);
    let _e299 = nDotL;
    let _e300 = nDotL;
    let _e305 = nDotL;
    let _e306 = nDotL;
    slope = min((sqrt(max((1f - (_e299 * _e300)), 0f)) / (_e305 * _e306)), 8f);
    let _e310 = toLightLength;
    let _e312 = (*lightIndex);
    let _e316 = point_shadow.slots[_e312][2u];
    let _e321 = point_shadow.params3_[1u];
    texel = (((2f * _e310) * max(_e316, 0.0001f)) * _e321);
    let _e323 = (*world_1);
    let _e324 = (*normal);
    let _e325 = texel;
    let _e329 = point_shadow.params[3u];
    let _e331 = slope;
    origin = (_e323 + (((_e324 * _e325) * _e329) * (1f + _e331)));
    let _e335 = origin;
    let _e336 = slot;
    let _e339 = point_shadow.lights[_e336];
    toFragment = (_e335 - _e339.xyz);
    let _e342 = toFragment;
    distance_ = length(_e342);
    let _e344 = slot;
    let _e348 = point_shadow.lights[_e344][3u];
    range_3 = max(_e348, 0.0001f);
    let _e350 = distance_;
    let _e351 = range_3;
    if (_e350 >= _e351) {
        return 1f;
    }
    face = 0i;
    let _e353 = (*lightIndex);
    let _e357 = point_shadow.slots[_e353][1u];
    if (_e357 < 0.5f) {
        let _e359 = toFragment;
        a = abs(_e359);
        let _e362 = a[0u];
        let _e364 = a[1u];
        let _e365 = (_e362 >= _e364);
        phi_2541_ = _e365;
        if _e365 {
            let _e367 = a[0u];
            let _e369 = a[2u];
            phi_2541_ = (_e367 >= _e369);
        }
        let _e372 = phi_2541_;
        if _e372 {
            let _e374 = toFragment[0u];
            face = select(1i, 0i, (_e374 > 0f));
        } else {
            let _e378 = a[1u];
            let _e380 = a[2u];
            if (_e378 >= _e380) {
                let _e383 = toFragment[1u];
                face = select(3i, 2i, (_e383 > 0f));
            } else {
                let _e387 = toFragment[2u];
                face = select(5i, 4i, (_e387 > 0f));
            }
        }
    }
    let _e390 = slot;
    let _e392 = face;
    let _e396 = point_shadow.faces[((_e390 * 6i) + _e392)];
    let _e397 = origin;
    clip = (_e396 * vec4<f32>(_e397.x, _e397.y, _e397.z, 1f));
    let _e404 = clip[3u];
    if (_e404 <= 0f) {
        return 1f;
    }
    let _e406 = clip;
    let _e409 = clip[3u];
    ndc = (_e406.xy / vec2(_e409));
    let _e413 = ndc[0u];
    let _e415 = (abs(_e413) > 1f);
    phi_2602_ = _e415;
    if !(_e415) {
        let _e418 = ndc[1u];
        phi_2602_ = (abs(_e418) > 1f);
    }
    let _e422 = phi_2602_;
    if _e422 {
        return 1f;
    }
    let _e424 = ndc[0u];
    let _e428 = ndc[1u];
    uv_4 = vec2<f32>(((_e424 * 0.5f) + 0.5f), (0.5f - (_e428 * 0.5f)));
    let _e432 = face;
    let _e434 = slot;
    tile_3 = vec2<f32>(f32(_e432), f32(_e434));
    let _e437 = distance_;
    let _e440 = point_shadow.params[1u];
    receiver_2 = (_e437 - _e440);
    let _e444 = frag_info.target_origin[0u];
    param_31 = _e444;
    let _e445 = FragCoordFromTop_u0028_f1_u003b((&param_31));
    noise = fract((52.982918f * fract(dot(_e445, vec2<f32>(0.06711056f, 0.00583715f)))));
    let _e450 = noise;
    angle = (_e450 * 6.2831855f);
    let _e452 = angle;
    ca_2 = cos(_e452);
    let _e454 = angle;
    sa_2 = sin(_e454);
    let _e456 = (*lightIndex);
    let _e460 = point_shadow.slots[_e456][2u];
    tanHalf_1 = max(_e460, 0.0001f);
    blocker_1 = -1f;
    let _e462 = uv_4;
    param_32 = _e462;
    let _e463 = tile_3;
    param_33 = _e463;
    let _e464 = range_3;
    param_34 = _e464;
    let _e465 = receiver_2;
    param_35 = _e465;
    let _e466 = ca_2;
    param_36 = _e466;
    let _e467 = sa_2;
    param_37 = _e467;
    let _e468 = tanHalf_1;
    param_38 = _e468;
    let _e469 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36), (&param_37), (&param_38), (&param_39));
    let _e470 = param_39;
    blocker_1 = _e470;
    radius_1 = _e469;
    let _e473 = point_shadow.params2_[3u];
    if (_e473 > 0.5f) {
        g_debug_surface_on = true;
        let _e475 = radius_1;
        if (_e475 < 0f) {
            local_14 = vec3<f32>(0f, 0f, 1f);
        } else {
            let _e477 = radius_1;
            let _e480 = point_shadow.params2_[2u];
            let _e484 = blocker_1;
            let _e485 = range_3;
            local_14 = vec3<f32>(clamp((_e477 / max(_e480, 0.000001f)), 0f, 1f), clamp((_e484 / _e485), 0f, 1f), 0f);
        }
        let _e489 = local_14;
        g_debug_surface = _e489;
    }
    let _e490 = radius_1;
    if (_e490 < 0f) {
        return 1f;
    }
    let _e492 = uv_4;
    param_40 = _e492;
    param_41 = vec2<f32>(0f, 0f);
    let _e493 = tile_3;
    param_42 = _e493;
    let _e494 = range_3;
    param_43 = _e494;
    let _e495 = receiver_2;
    param_44 = _e495;
    let _e496 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_40), (&param_41), (&param_42), (&param_43), (&param_44));
    lit_1 = _e496;
    let _e497 = radius_1;
    if (_e497 > 0f) {
        i_3 = 0i;
        loop {
            let _e499 = i_3;
            if (_e499 < 8i) {
                let _e501 = i_3;
                param_45 = _e501;
                let _e502 = ca_2;
                param_46 = _e502;
                let _e503 = sa_2;
                param_47 = _e503;
                let _e504 = radius_1;
                param_48 = _e504;
                let _e505 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47), (&param_48));
                let _e506 = uv_4;
                param_49 = _e506;
                param_50 = _e505;
                let _e507 = tile_3;
                param_51 = _e507;
                let _e508 = range_3;
                param_52 = _e508;
                let _e509 = receiver_2;
                param_53 = _e509;
                let _e510 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_49), (&param_50), (&param_51), (&param_52), (&param_53));
                let _e511 = lit_1;
                lit_1 = (_e511 + _e510);
                continue;
            } else {
                break;
            }
            continuing {
                let _e513 = i_3;
                i_3 = (_e513 + 1i);
            }
        }
        let _e515 = lit_1;
        lit_1 = (_e515 * 0.11111111f);
    }
    let _e517 = lit_1;
    let _e518 = strength;
    return mix(1f, _e517, clamp(_e518, 0f, 1f));
}

fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
    var r: f32;
    var theta: f32;

    let _e215 = (*i_4);
    let _e218 = (*n_1);
    r = sqrt(((f32(_e215) + 0.5f) / f32(_e218)));
    let _e222 = (*i_4);
    let _e225 = (*turn);
    theta = ((f32(_e222) * 2.3999631f) + _e225);
    let _e227 = r;
    let _e228 = theta;
    let _e230 = theta;
    return (vec2<f32>(cos(_e228), sin(_e230)) * _e227);
}

fn ShadowNoise_u0028_() -> f32 {
    var at: vec2<f32>;
    var param_54: f32;

    let _e214 = frag_info.target_origin[0u];
    param_54 = _e214;
    let _e215 = FragCoordFromTop_u0028_f1_u003b((&param_54));
    let _e218 = frag_info.target_origin[3u];
    at = (_e215 + vec2((5.588238f * max(_e218, 0f))));
    let _e223 = at;
    return fract((52.982918f * fract(dot(_e223, vec2<f32>(0.06711056f, 0.00583715f)))));
}

fn ShadowStored_u0028_f1_u003b_f1_u003b(stored_2: ptr<function, f32>, mode_1: ptr<function, f32>) -> f32 {
    var local_15: f32;

    let _e213 = (*mode_1);
    if (_e213 > 0.5f) {
        let _e215 = (*stored_2);
        local_15 = (1f - _e215);
    } else {
        let _e217 = (*stored_2);
        local_15 = _e217;
    }
    let _e218 = local_15;
    return _e218;
}

fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
    var variance: f32;
    var d_1: f32;
    var pMax: f32;
    var reduced: f32;

    let _e219 = (*moments)[1u];
    let _e221 = (*moments)[0u];
    let _e223 = (*moments)[0u];
    let _e226 = (*minVariance);
    variance = max((_e219 - (_e221 * _e223)), _e226);
    let _e228 = (*t);
    let _e230 = (*moments)[0u];
    d_1 = (_e228 - _e230);
    let _e232 = variance;
    let _e233 = variance;
    let _e234 = d_1;
    let _e235 = d_1;
    pMax = (_e232 / (_e233 + (_e234 * _e235)));
    let _e239 = pMax;
    let _e240 = (*bleed);
    let _e242 = (*bleed);
    reduced = clamp(((_e239 - _e240) / max((1f - _e242), 0.0001f)), 0f, 1f);
    let _e247 = (*t);
    let _e249 = (*moments)[0u];
    let _e251 = reduced;
    return select(_e251, 1f, (_e247 <= _e249));
}

fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
    var d_2: f32;

    let _e212 = (*depth);
    d_2 = ((2f * clamp(_e212, 0f, 1f)) - 1f);
    let _e216 = d_2;
    let _e219 = d_2;
    return vec2<f32>(exp((40f * _e216)), -(exp((-5f * _e219))));
}

fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
    var warped: vec2<f32>;
    var param_55: f32;
    var scale: vec2<f32>;
    var positive: f32;
    var param_56: vec2<f32>;
    var param_57: f32;
    var param_58: f32;
    var param_59: f32;
    var negative: f32;
    var param_60: vec2<f32>;
    var param_61: f32;
    var param_62: f32;
    var param_63: f32;

    let _e226 = (*depth_1);
    param_55 = _e226;
    let _e227 = EvsmWarp_u0028_f1_u003b((&param_55));
    warped = _e227;
    let _e228 = warped;
    scale = (vec2<f32>(0.004f, 0.0005f) * _e228);
    let _e231 = scale[0u];
    let _e233 = scale[0u];
    let _e235 = (*moments_1);
    param_56 = _e235.xy;
    let _e238 = warped[0u];
    param_57 = _e238;
    param_58 = (_e231 * _e233);
    let _e239 = (*bleed_1);
    param_59 = _e239;
    let _e240 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_56), (&param_57), (&param_58), (&param_59));
    positive = _e240;
    let _e242 = scale[1u];
    let _e244 = scale[1u];
    let _e246 = (*moments_1);
    param_60 = _e246.zw;
    let _e249 = warped[1u];
    param_61 = _e249;
    param_62 = (_e242 * _e244);
    let _e250 = (*bleed_1);
    param_63 = _e250;
    let _e251 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63));
    negative = _e251;
    let _e252 = positive;
    let _e253 = negative;
    return min(_e252, _e253);
}

fn ShadowStoredStep_u0028_f1_u003b(depth_2: ptr<function, f32>) -> f32 {
    var stored_3: f32;

    let _e212 = (*depth_2);
    stored_3 = max((1f - _e212), 0.000061035156f);
    let _e215 = stored_3;
    return exp2((floor(log2(_e215)) - 10f));
}

fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
    var strength_1: f32;
    var cascadeCount: i32;
    var viewDistance: f32;
    var local_16: f32;
    var cascade: i32;
    var uv_5: vec2<f32>;
    var projected: vec3<f32>;
    var found: bool;
    var cascadeTexel: f32;
    var cascadeDepth: f32;
    var receiverSlope: f32;
    var attempt: i32;
    var which: i32;
    var matrix: mat4x4<f32>;
    var local_17: mat4x4<f32>;
    var local_18: mat4x4<f32>;
    var axisX: vec3<f32>;
    var axisY: vec3<f32>;
    var rowX: f32;
    var rowY: f32;
    var texelMetres: f32;
    var reach: f32;
    var flatOffset: f32;
    var origin_1: vec3<f32>;
    var lightSpace: vec4<f32>;
    var candidate: vec3<f32>;
    var inTile: vec2<f32>;
    var cosSlope: f32;
    var bias: f32;
    var local_19: f32;
    var local_20: f32;
    var storage_: f32;
    var param_64: f32;
    var texel_1: vec2<f32>;
    var tileLo: vec2<f32>;
    var tileHi: vec2<f32>;
    var stored_4: vec4<f32>;
    var y: i32;
    var x: i32;
    var through: vec3<f32>;
    var softness: f32;
    var lit_2: f32;
    var moments_2: vec4<f32>;
    var param_65: vec4<f32>;
    var param_66: f32;
    var param_67: f32;
    var y_1: i32;
    var x_1: i32;
    var occluder: f32;
    var param_68: f32;
    var param_69: f32;
    var spread: f32;
    var turn_1: f32;
    var searchRadius: f32;
    var blockerSum: f32;
    var blockerCount: f32;
    var i_5: i32;
    var disc: vec2<f32>;
    var param_70: i32;
    var param_71: i32;
    var param_72: f32;
    var tapBias: f32;
    var occluder_1: f32;
    var param_73: f32;
    var param_74: f32;
    var gap: f32;
    var radius_2: f32;
    var i_6: i32;
    var disc_1: vec2<f32>;
    var param_75: i32;
    var param_76: i32;
    var param_77: f32;
    var tapBias_1: f32;
    var occluder_2: f32;
    var param_78: f32;
    var param_79: f32;
    var phi_3391_: bool;
    var phi_3402_: bool;
    var phi_3559_: bool;
    var phi_3566_: bool;
    var phi_3573_: bool;

    let _e291 = frag_info.shadow_params[3u];
    strength_1 = _e291;
    let _e292 = strength_1;
    if (_e292 <= 0f) {
        return 1f;
    }
    let _e294 = (*lightIndex_1);
    let _e297 = frag_info.frame_params[2u];
    if (_e294 != i32(floor((_e297 + 0.5f)))) {
        return 1f;
    }
    let _e304 = frag_info.shadow_cascades[2u];
    cascadeCount = i32((_e304 + 0.5f));
    let _e307 = Orthographic_u0028_();
    if _e307 {
        let _e308 = ViewDepth_u0028_();
        local_16 = _e308;
    } else {
        let _e309 = v_world_position_1;
        let _e311 = frag_info.camera_position;
        local_16 = length((_e309 - _e311.xyz));
    }
    let _e315 = local_16;
    viewDistance = _e315;
    cascade = 0i;
    let _e316 = cascadeCount;
    let _e317 = (_e316 > 1i);
    phi_3391_ = _e317;
    if _e317 {
        let _e318 = viewDistance;
        let _e321 = frag_info.shadow_cascades[0u];
        phi_3391_ = (_e318 > _e321);
    }
    let _e324 = phi_3391_;
    if _e324 {
        cascade = 1i;
    }
    let _e325 = cascadeCount;
    let _e326 = (_e325 > 2i);
    phi_3402_ = _e326;
    if _e326 {
        let _e327 = viewDistance;
        let _e330 = frag_info.shadow_cascades[1u];
        phi_3402_ = (_e327 > _e330);
    }
    let _e333 = phi_3402_;
    if _e333 {
        cascade = 2i;
    }
    uv_5 = vec2<f32>(0f, 0f);
    projected = vec3<f32>(0f, 0f, 0f);
    found = false;
    cascadeTexel = 1f;
    cascadeDepth = 1f;
    receiverSlope = 0f;
    attempt = 0i;
    loop {
        let _e334 = attempt;
        if (_e334 < 3i) {
            let _e336 = cascade;
            let _e337 = attempt;
            which = (_e336 + _e337);
            let _e339 = which;
            let _e340 = cascadeCount;
            if (_e339 >= _e340) {
                break;
            }
            let _e342 = which;
            if (_e342 == 0i) {
                let _e345 = frag_info.shadow_matrix;
                local_17 = _e345;
            } else {
                let _e346 = which;
                if (_e346 == 1i) {
                    let _e349 = frag_info.shadow_matrix_far;
                    local_18 = _e349;
                } else {
                    let _e351 = frag_info.shadow_matrix_farthest;
                    local_18 = _e351;
                }
                let _e352 = local_18;
                local_17 = _e352;
            }
            let _e353 = local_17;
            matrix = _e353;
            let _e356 = matrix[0][0u];
            let _e359 = matrix[1][0u];
            let _e362 = matrix[2][0u];
            axisX = vec3<f32>(_e356, _e359, _e362);
            let _e366 = matrix[0][1u];
            let _e369 = matrix[1][1u];
            let _e372 = matrix[2][1u];
            axisY = vec3<f32>(_e366, _e369, _e372);
            let _e374 = axisX;
            rowX = max(length(_e374), 0.000001f);
            let _e377 = axisY;
            rowY = max(length(_e377), 0.000001f);
            let _e382 = frag_info.shadow_cascades[3u];
            let _e384 = rowX;
            texelMetres = ((2f * _e382) / _e384);
            let _e388 = frag_info.shadow_cascades[3u];
            let _e391 = (*s_2).n;
            let _e392 = axisX;
            let _e395 = rowX;
            let _e396 = rowX;
            let _e400 = (*s_2).n;
            let _e401 = axisY;
            let _e404 = rowY;
            let _e405 = rowY;
            reach = ((3f * _e388) * ((abs(dot(_e391, _e392)) / (_e395 * _e396)) + (abs(dot(_e400, _e401)) / (_e404 * _e405))));
            let _e412 = frag_info.shadow_params[2u];
            let _e413 = texelMetres;
            flatOffset = min(_e412, _e413);
            let _e415 = v_world_position_1;
            let _e417 = (*s_2).n;
            let _e418 = flatOffset;
            let _e419 = reach;
            origin_1 = (_e415 + (_e417 * (_e418 + _e419)));
            let _e423 = matrix;
            let _e424 = origin_1;
            lightSpace = (_e423 * vec4<f32>(_e424.x, _e424.y, _e424.z, 1f));
            let _e431 = lightSpace[3u];
            if (_e431 <= 0f) {
                continue;
            }
            let _e433 = lightSpace;
            let _e436 = lightSpace[3u];
            candidate = (_e433.xyz / vec3(_e436));
            let _e440 = candidate[0u];
            let _e444 = candidate[1u];
            inTile = vec2<f32>(((_e440 * 0.5f) + 0.5f), (0.5f - (_e444 * 0.5f)));
            let _e449 = inTile[0u];
            let _e450 = (_e449 < 0f);
            phi_3559_ = _e450;
            if !(_e450) {
                let _e453 = inTile[0u];
                phi_3559_ = (_e453 > 1f);
            }
            let _e456 = phi_3559_;
            phi_3566_ = _e456;
            if !(_e456) {
                let _e459 = inTile[1u];
                phi_3566_ = (_e459 < 0f);
            }
            let _e462 = phi_3566_;
            phi_3573_ = _e462;
            if !(_e462) {
                let _e465 = inTile[1u];
                phi_3573_ = (_e465 > 1f);
            }
            let _e468 = phi_3573_;
            if _e468 {
                continue;
            }
            let _e470 = candidate[2u];
            if (_e470 > 1f) {
                let _e472 = which;
                let _e473 = cascadeCount;
                if (_e472 < (_e473 - 1i)) {
                    continue;
                }
                candidate[2u] = 1f;
            }
            let _e478 = inTile[0u];
            let _e479 = which;
            let _e482 = cascadeCount;
            let _e486 = inTile[1u];
            uv_5 = vec2<f32>(((_e478 + f32(_e479)) / f32(_e482)), _e486);
            let _e488 = candidate;
            projected = _e488;
            let _e489 = which;
            cascade = _e489;
            let _e490 = texelMetres;
            cascadeTexel = _e490;
            let _e493 = matrix[0][2u];
            let _e496 = matrix[1][2u];
            let _e499 = matrix[2][2u];
            cascadeDepth = (1f / max(length(vec3<f32>(_e493, _e496, _e499)), 0.000001f));
            let _e505 = (*s_2).n;
            let _e508 = matrix[0][2u];
            let _e511 = matrix[1][2u];
            let _e514 = matrix[2][2u];
            let _e518 = cascadeDepth;
            cosSlope = clamp((abs(dot(_e505, vec3<f32>(_e508, _e511, _e514))) * _e518), 0.1f, 1f);
            let _e521 = texelMetres;
            let _e522 = cosSlope;
            let _e523 = cosSlope;
            let _e529 = cosSlope;
            let _e531 = cascadeDepth;
            receiverSlope = (((_e521 * sqrt(max((1f - (_e522 * _e523)), 0f))) / _e529) / _e531);
            found = true;
            break;
        } else {
            break;
        }
        continuing {
            let _e533 = attempt;
            attempt = (_e533 + 1i);
        }
    }
    let _e535 = found;
    if !(_e535) {
        return 1f;
    }
    let _e537 = cascade;
    if (_e537 == 0i) {
        let _e541 = frag_info.shadow_bias[0u];
        local_19 = _e541;
    } else {
        let _e542 = cascade;
        if (_e542 == 1i) {
            let _e546 = frag_info.shadow_bias[1u];
            local_20 = _e546;
        } else {
            let _e549 = frag_info.shadow_bias[2u];
            local_20 = _e549;
        }
        let _e550 = local_20;
        local_19 = _e550;
    }
    let _e551 = local_19;
    bias = _e551;
    let _e554 = frag_info.shadow_params[1u];
    storage_ = _e554;
    let _e555 = storage_;
    let _e557 = storage_;
    if ((_e555 > 0.5f) && (_e557 < 1.5f)) {
        let _e560 = bias;
        let _e562 = projected[2u];
        param_64 = _e562;
        let _e563 = ShadowStoredStep_u0028_f1_u003b((&param_64));
        bias = max(_e560, _e563);
    }
    let _e567 = frag_info.shadow_params[0u];
    let _e570 = frag_info.shadow_cascades[3u];
    texel_1 = vec2<f32>(_e567, _e570);
    let _e572 = cascade;
    let _e574 = cascadeCount;
    let _e578 = texel_1;
    tileLo = (vec2<f32>((f32(_e572) / f32(_e574)), 0f) + (_e578 * 0.5f));
    let _e581 = cascade;
    let _e584 = cascadeCount;
    let _e588 = texel_1;
    tileHi = (vec2<f32>((f32((_e581 + 1i)) / f32(_e584)), 1f) - (_e588 * 0.5f));
    let _e593 = frag_info.shadow_bias[3u];
    if (_e593 > 0.5f) {
        stored_4 = vec4<f32>(0f, 0f, 0f, 0f);
        y = -1i;
        loop {
            let _e595 = y;
            if (_e595 <= 1i) {
                x = -1i;
                loop {
                    let _e597 = x;
                    if (_e597 <= 1i) {
                        let _e599 = uv_5;
                        let _e600 = x;
                        let _e602 = y;
                        let _e605 = texel_1;
                        let _e608 = tileLo;
                        let _e609 = tileHi;
                        let _e611 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e599 + (vec2<f32>(f32(_e600), f32(_e602)) * _e605)), _e608, _e609), 0f);
                        let _e612 = stored_4;
                        stored_4 = (_e612 + _e611);
                        continue;
                    } else {
                        break;
                    }
                    continuing {
                        let _e614 = x;
                        x = (_e614 + 1i);
                    }
                }
                continue;
            } else {
                break;
            }
            continuing {
                let _e616 = y;
                y = (_e616 + 1i);
            }
        }
        let _e618 = stored_4;
        stored_4 = (_e618 * 0.11111111f);
        let _e621 = stored_4[1u];
        let _e624 = stored_4[2u];
        let _e627 = stored_4[3u];
        through = clamp(vec3<f32>((1f - _e621), (1f - _e624), _e627), vec3(0f), vec3(4f));
        let _e632 = through;
        let _e633 = strength_1;
        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e632, vec3(clamp(_e633, 0f, 1f)));
    }
    let _e639 = frag_info.ambient_ground[3u];
    softness = _e639;
    lit_2 = 0f;
    let _e640 = softness;
    if (_e640 < 0f) {
        let _e642 = uv_5;
        let _e643 = tileLo;
        let _e644 = tileHi;
        let _e646 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e642, _e643, _e644), 0f);
        moments_2 = _e646;
        let _e648 = projected[2u];
        let _e649 = bias;
        let _e651 = softness;
        let _e655 = moments_2;
        param_65 = _e655;
        param_66 = (_e648 - _e649);
        param_67 = clamp((-(_e651) - 1f), 0f, 0.95f);
        let _e656 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_65), (&param_66), (&param_67));
        lit_2 = _e656;
    } else {
        let _e657 = softness;
        if (_e657 <= 0f) {
            y_1 = -1i;
            loop {
                let _e659 = y_1;
                if (_e659 <= 1i) {
                    x_1 = -1i;
                    loop {
                        let _e661 = x_1;
                        if (_e661 <= 1i) {
                            let _e663 = uv_5;
                            let _e664 = x_1;
                            let _e666 = y_1;
                            let _e669 = texel_1;
                            let _e672 = tileLo;
                            let _e673 = tileHi;
                            let _e675 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e663 + (vec2<f32>(f32(_e664), f32(_e666)) * _e669)), _e672, _e673), 0f);
                            param_68 = _e675.x;
                            let _e677 = storage_;
                            param_69 = _e677;
                            let _e678 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_68), (&param_69));
                            occluder = _e678;
                            let _e680 = projected[2u];
                            let _e681 = bias;
                            let _e683 = occluder;
                            let _e686 = lit_2;
                            lit_2 = (_e686 + select(1f, 0f, ((_e680 - _e681) > _e683)));
                            continue;
                        } else {
                            break;
                        }
                        continuing {
                            let _e688 = x_1;
                            x_1 = (_e688 + 1i);
                        }
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e690 = y_1;
                    y_1 = (_e690 + 1i);
                }
            }
            let _e692 = lit_2;
            lit_2 = (_e692 * 0.11111111f);
        } else {
            let _e694 = softness;
            spread = tan(min(_e694, 0.5f));
            let _e697 = ShadowNoise_u0028_();
            turn_1 = (_e697 * 6.2831855f);
            let _e699 = spread;
            let _e701 = projected[2u];
            let _e703 = cascadeDepth;
            let _e705 = cascadeTexel;
            searchRadius = clamp((((_e699 * _e701) * _e703) / _e705), 1f, 16f);
            blockerSum = 0f;
            blockerCount = 0f;
            i_5 = 0i;
            loop {
                let _e708 = i_5;
                if (_e708 < 16i) {
                    let _e710 = i_5;
                    param_70 = _e710;
                    param_71 = 16i;
                    let _e711 = turn_1;
                    param_72 = _e711;
                    let _e712 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_70), (&param_71), (&param_72));
                    disc = _e712;
                    let _e713 = bias;
                    let _e714 = disc;
                    let _e716 = searchRadius;
                    let _e720 = receiverSlope;
                    tapBias = (_e713 + (max(((length(_e714) * _e716) - 1.5f), 0f) * _e720));
                    let _e723 = uv_5;
                    let _e724 = disc;
                    let _e725 = texel_1;
                    let _e727 = searchRadius;
                    let _e730 = tileLo;
                    let _e731 = tileHi;
                    let _e733 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e723 + ((_e724 * _e725) * _e727)), _e730, _e731), 0f);
                    param_73 = _e733.x;
                    let _e735 = storage_;
                    param_74 = _e735;
                    let _e736 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_73), (&param_74));
                    occluder_1 = _e736;
                    let _e738 = projected[2u];
                    let _e739 = tapBias;
                    let _e741 = occluder_1;
                    if ((_e738 - _e739) > _e741) {
                        let _e743 = occluder_1;
                        let _e744 = blockerSum;
                        blockerSum = (_e744 + _e743);
                        let _e746 = blockerCount;
                        blockerCount = (_e746 + 1f);
                    }
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e748 = i_5;
                    i_5 = (_e748 + 1i);
                }
            }
            let _e750 = blockerCount;
            if (_e750 <= 0f) {
                return 1f;
            }
            let _e753 = projected[2u];
            let _e754 = blockerSum;
            let _e755 = blockerCount;
            let _e759 = cascadeDepth;
            gap = (max((_e753 - (_e754 / _e755)), 0f) * _e759);
            let _e761 = spread;
            let _e762 = gap;
            let _e764 = cascadeTexel;
            radius_2 = clamp(((_e761 * _e762) / _e764), 1f, 16f);
            i_6 = 0i;
            loop {
                let _e767 = i_6;
                if (_e767 < 16i) {
                    let _e769 = turn_1;
                    let _e771 = i_6;
                    param_75 = _e771;
                    param_76 = 16i;
                    param_77 = (_e769 + 1f);
                    let _e772 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_75), (&param_76), (&param_77));
                    disc_1 = _e772;
                    let _e773 = bias;
                    let _e774 = disc_1;
                    let _e776 = radius_2;
                    let _e780 = receiverSlope;
                    tapBias_1 = (_e773 + (max(((length(_e774) * _e776) - 1.5f), 0f) * _e780));
                    let _e783 = uv_5;
                    let _e784 = disc_1;
                    let _e785 = texel_1;
                    let _e787 = radius_2;
                    let _e790 = tileLo;
                    let _e791 = tileHi;
                    let _e793 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e783 + ((_e784 * _e785) * _e787)), _e790, _e791), 0f);
                    param_78 = _e793.x;
                    let _e795 = storage_;
                    param_79 = _e795;
                    let _e796 = ShadowStored_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
                    occluder_2 = _e796;
                    let _e798 = projected[2u];
                    let _e799 = tapBias_1;
                    let _e801 = occluder_2;
                    let _e804 = lit_2;
                    lit_2 = (_e804 + select(1f, 0f, ((_e798 - _e799) > _e801)));
                    continue;
                } else {
                    break;
                }
                continuing {
                    let _e806 = i_6;
                    i_6 = (_e806 + 1i);
                }
            }
            let _e808 = lit_2;
            lit_2 = (_e808 * 0.0625f);
        }
    }
    let _e810 = lit_2;
    let _e811 = strength_1;
    return mix(1f, _e810, clamp(_e811, 0f, 1f));
}

fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
    var param_80: Surface;
    var param_81: LightSample;
    var param_82: i32;

    let _e216 = (*s_3);
    param_80 = _e216;
    let _e217 = (*light_2);
    param_81 = _e217;
    let _e218 = (*index);
    param_82 = _e218;
    let _e219 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_80), (&param_81), (&param_82));
    return _e219;
}

fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
    let _e211 = (*index_1);
    return (_e211 < 8i);
}

fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
    var attenuation: f32;
    var ratio: f32;
    var window: f32;

    let _e215 = (*distance_1);
    let _e216 = (*distance_1);
    attenuation = (1f / max((_e215 * _e216), 0.0001f));
    let _e220 = (*range_4);
    if (_e220 > 0f) {
        let _e222 = (*distance_1);
        let _e223 = (*range_4);
        ratio = (_e222 / _e223);
        let _e225 = ratio;
        let _e226 = ratio;
        let _e228 = ratio;
        let _e230 = ratio;
        window = clamp((1f - (((_e225 * _e226) * _e228) * _e230)), 0f, 1f);
        let _e234 = window;
        let _e235 = window;
        let _e237 = attenuation;
        attenuation = (_e237 * (_e234 * _e235));
    }
    let _e239 = attenuation;
    return _e239;
}

fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
    var n_2: vec3<f32>;
    var nLen: f32;
    var toPlane: vec3<f32>;
    var denom: f32;
    var onPlane: vec3<f32>;
    var t_1: f32;
    var local_21: vec3<f32>;
    var offset_2: vec3<f32>;
    var wLen2_: f32;
    var hLen2_: f32;
    var u: f32;
    var v: f32;

    let _e227 = (*halfWidth);
    let _e228 = (*halfHeight);
    n_2 = cross(_e227, _e228);
    let _e230 = n_2;
    nLen = length(_e230);
    let _e232 = nLen;
    if (_e232 < 0.000000000001f) {
        let _e234 = (*centre);
        return _e234;
    }
    let _e235 = nLen;
    let _e236 = n_2;
    n_2 = (_e236 / vec3(_e235));
    let _e239 = (*centre);
    let _e240 = (*world_2);
    toPlane = (_e239 - _e240);
    let _e242 = (*mirror);
    let _e243 = n_2;
    denom = dot(_e242, _e243);
    let _e245 = denom;
    if (abs(_e245) < 0.00001f) {
        let _e248 = toPlane;
        let _e249 = n_2;
        let _e250 = toPlane;
        let _e251 = n_2;
        onPlane = (_e248 - (_e249 * dot(_e250, _e251)));
    } else {
        let _e255 = toPlane;
        let _e256 = n_2;
        let _e258 = denom;
        t_1 = (dot(_e255, _e256) / _e258);
        let _e260 = t_1;
        if (_e260 > 0f) {
            let _e262 = (*mirror);
            let _e263 = t_1;
            local_21 = (_e262 * _e263);
        } else {
            let _e265 = toPlane;
            let _e266 = n_2;
            let _e267 = toPlane;
            let _e268 = n_2;
            local_21 = (_e265 - (_e266 * dot(_e267, _e268)));
        }
        let _e272 = local_21;
        onPlane = _e272;
    }
    let _e273 = onPlane;
    let _e274 = toPlane;
    offset_2 = (_e273 - _e274);
    let _e276 = (*halfWidth);
    let _e277 = (*halfWidth);
    wLen2_ = max(dot(_e276, _e277), 0.000000000001f);
    let _e280 = (*halfHeight);
    let _e281 = (*halfHeight);
    hLen2_ = max(dot(_e280, _e281), 0.000000000001f);
    let _e284 = offset_2;
    let _e285 = (*halfWidth);
    let _e287 = wLen2_;
    u = clamp((dot(_e284, _e285) / _e287), -1f, 1f);
    let _e290 = offset_2;
    let _e291 = (*halfHeight);
    let _e293 = hLen2_;
    v = clamp((dot(_e290, _e291) / _e293), -1f, 1f);
    let _e296 = (*centre);
    let _e297 = (*halfWidth);
    let _e298 = u;
    let _e301 = (*halfHeight);
    let _e302 = v;
    return ((_e296 + (_e297 * _e298)) + (_e301 * _e302));
}

fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
    var ua: vec3<f32>;
    var ub: vec3<f32>;
    var angle_1: f32;
    var axis: vec3<f32>;
    var len: f32;
    var local_22: f32;

    let _e219 = (*a_1);
    let _e220 = (*a_1);
    ua = (_e219 / vec3(max(length(_e220), 0.000000000001f)));
    let _e225 = (*b);
    let _e226 = (*b);
    ub = (_e225 / vec3(max(length(_e226), 0.000000000001f)));
    let _e231 = ua;
    let _e232 = ub;
    angle_1 = acos(clamp(dot(_e231, _e232), -1f, 1f));
    let _e236 = ua;
    let _e237 = ub;
    axis = cross(_e236, _e237);
    let _e239 = axis;
    len = length(_e239);
    let _e241 = len;
    if (_e241 > 0.000001f) {
        let _e243 = angle_1;
        let _e244 = axis;
        let _e245 = (*n_3);
        let _e248 = len;
        local_22 = ((_e243 * dot(_e244, _e245)) / _e248);
    } else {
        local_22 = 0f;
    }
    let _e250 = local_22;
    return _e250;
}

fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
    var total: f32;
    var exit: vec3<f32>;
    var entry: vec3<f32>;
    var i_7: i32;
    var a_2: vec3<f32>;
    var b_1: vec3<f32>;
    var local_23: i32;
    var ha: f32;
    var hb: f32;
    var d_3: f32;
    var q: vec3<f32>;
    var local_24: f32;
    var aAbove: bool;
    var bAbove: bool;
    var local_25: f32;
    var param_83: vec3<f32>;
    var param_84: vec3<f32>;
    var param_85: vec3<f32>;
    var param_86: vec3<f32>;
    var param_87: vec3<f32>;
    var param_88: vec3<f32>;

    total = 0f;
    exit = vec3<f32>(0f, 0f, 0f);
    entry = vec3<f32>(0f, 0f, 0f);
    i_7 = 0i;
    loop {
        let _e233 = i_7;
        if (_e233 < 4i) {
            let _e235 = i_7;
            let _e237 = (*corners)[_e235];
            a_2 = _e237;
            let _e238 = i_7;
            if (_e238 == 3i) {
                local_23 = 0i;
            } else {
                let _e240 = i_7;
                local_23 = (_e240 + 1i);
            }
            let _e242 = local_23;
            let _e244 = (*corners)[_e242];
            b_1 = _e244;
            let _e245 = a_2;
            let _e246 = (*n_4);
            ha = dot(_e245, _e246);
            let _e248 = b_1;
            let _e249 = (*n_4);
            hb = dot(_e248, _e249);
            let _e251 = ha;
            let _e252 = hb;
            d_3 = (_e251 - _e252);
            let _e254 = a_2;
            let _e255 = b_1;
            let _e256 = a_2;
            let _e258 = d_3;
            if (abs(_e258) > 0.000000000001f) {
                let _e261 = ha;
                let _e262 = d_3;
                local_24 = (_e261 / _e262);
            } else {
                local_24 = 0f;
            }
            let _e264 = local_24;
            q = (_e254 + ((_e255 - _e256) * _e264));
            let _e267 = ha;
            aAbove = (_e267 > 0f);
            let _e269 = hb;
            bAbove = (_e269 > 0f);
            let _e271 = aAbove;
            let _e272 = bAbove;
            if (_e271 || _e272) {
                let _e274 = aAbove;
                let _e275 = a_2;
                let _e276 = q;
                let _e279 = bAbove;
                let _e280 = b_1;
                let _e281 = q;
                param_83 = select(_e276, _e275, vec3(_e274));
                param_84 = select(_e281, _e280, vec3(_e279));
                let _e284 = (*n_4);
                param_85 = _e284;
                let _e285 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_83), (&param_84), (&param_85));
                local_25 = _e285;
            } else {
                local_25 = 0f;
            }
            let _e286 = local_25;
            let _e287 = total;
            total = (_e287 + _e286);
            let _e289 = aAbove;
            let _e290 = bAbove;
            let _e293 = q;
            let _e294 = exit;
            exit = select(_e294, _e293, vec3((_e289 && !(_e290))));
            let _e297 = aAbove;
            let _e299 = bAbove;
            let _e301 = q;
            let _e302 = entry;
            entry = select(_e302, _e301, vec3((!(_e297) && _e299)));
            continue;
        } else {
            break;
        }
        continuing {
            let _e305 = i_7;
            i_7 = (_e305 + 1i);
        }
    }
    let _e307 = exit;
    param_86 = _e307;
    let _e308 = entry;
    param_87 = _e308;
    let _e309 = (*n_4);
    param_88 = _e309;
    let _e310 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_86), (&param_87), (&param_88));
    let _e311 = total;
    total = (_e311 + _e310);
    let _e313 = total;
    return max((-(_e313) * 0.5f), 0f);
}

fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
    var lane: i32;
    var local_26: f32;
    var local_27: f32;
    var local_28: f32;

    let _e216 = (*slot_1);
    let _e217 = (*slot_1);
    lane = (_e216 - ((_e217 / 4i) * 4i));
    let _e221 = lane;
    if (_e221 == 0i) {
        let _e224 = (*four)[0u];
        local_26 = _e224;
    } else {
        let _e225 = lane;
        if (_e225 == 1i) {
            let _e228 = (*four)[1u];
            local_27 = _e228;
        } else {
            let _e229 = lane;
            if (_e229 == 2i) {
                let _e232 = (*four)[2u];
                local_28 = _e232;
            } else {
                let _e234 = (*four)[3u];
                local_28 = _e234;
            }
            let _e235 = local_28;
            local_27 = _e235;
        }
        let _e236 = local_27;
        local_26 = _e236;
    }
    let _e237 = local_26;
    return _e237;
}

fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
    var param_89: vec4<f32>;
    var param_90: i32;

    let _e213 = (*slot_2);
    let _e217 = light_list_info.scales[(_e213 / 4i)];
    param_89 = _e217;
    let _e218 = (*slot_2);
    param_90 = _e218;
    let _e219 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_89), (&param_90));
    return _e219;
}

fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
    var a_3: vec4<f32>;
    var b_2: vec4<f32>;

    let _e215 = light_list_info.slot_rows[0i];
    let _e216 = (*row);
    a_3 = abs((_e215 - vec4(_e216)));
    let _e222 = light_list_info.slot_rows[1i];
    let _e223 = (*row);
    b_2 = abs((_e222 - vec4(_e223)));
    let _e228 = a_3[0u];
    let _e230 = a_3[1u];
    let _e233 = a_3[2u];
    let _e235 = a_3[3u];
    let _e239 = b_2[0u];
    let _e241 = b_2[1u];
    let _e244 = b_2[2u];
    let _e246 = b_2[3u];
    return (min(min(min(_e228, _e230), min(_e233, _e235)), min(min(_e239, _e241), min(_e244, _e246))) < 0.5f);
}

fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
    var param_91: vec4<f32>;
    var param_92: i32;

    let _e213 = (*slot_3);
    let _e217 = light_list_info.indices[(_e213 / 4i)];
    param_91 = _e217;
    let _e218 = (*slot_3);
    param_92 = _e218;
    let _e219 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_91), (&param_92));
    return _e219;
}

fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
    let _e212 = (*texel_2);
    let _e216 = light_list_info.list[1u];
    let _e218 = (*row_1);
    let _e222 = light_list_info.list[2u];
    let _e225 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e212 + 0.5f) * _e216), ((_e218 + 0.5f) * _e222)), 0f);
    return _e225;
}

fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
    var entry_1: f32;
    var row_2: f32;
    var within_1: f32;
    var texel_3: f32;
    var four_1: vec4<f32>;
    var param_93: f32;
    var param_94: f32;
    var param_95: vec4<f32>;
    var param_96: i32;

    let _e220 = g_cluster_offset;
    let _e221 = (*slot_4);
    entry_1 = (_e220 + f32(_e221));
    let _e224 = entry_1;
    row_2 = floor((_e224 / 16f));
    let _e227 = entry_1;
    let _e228 = row_2;
    within_1 = (_e227 - (_e228 * 16f));
    let _e231 = within_1;
    texel_3 = floor((_e231 / 4f));
    let _e236 = light_list_info.cluster_depth[3u];
    let _e237 = row_2;
    let _e239 = texel_3;
    param_93 = _e239;
    param_94 = (_e236 + _e237);
    let _e240 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_93), (&param_94));
    four_1 = _e240;
    let _e241 = within_1;
    let _e242 = texel_3;
    let _e247 = four_1;
    param_95 = _e247;
    param_96 = i32(((_e241 - (_e242 * 4f)) + 0.5f));
    let _e248 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_95), (&param_96));
    return _e248;
}

fn Clustered_u0028_() -> bool {
    let _e212 = light_list_info.cluster_grid[3u];
    return (_e212 > 0.5f);
}

fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
    var light_3: LightSample;
    var position: vec4<f32>;
    var color_1: vec4<f32>;
    var direction: vec4<f32>;
    var cone: vec4<f32>;
    var slot_5: i32;
    var clustered: bool;
    var listRow: f32;
    var local_29: f32;
    var param_97: i32;
    var param_98: i32;
    var v_1: f32;
    var u_1: f32;
    var local_30: f32;
    var param_99: f32;
    var param_100: i32;
    var type_39: f32;
    var halfWidth_1: vec3<f32>;
    var halfHeight_1: vec3<f32>;
    var toCentre: vec3<f32>;
    var corners_1: array<vec3<f32>, 4>;
    var behind: bool;
    var formFactor: f32;
    var local_31: f32;
    var param_101: array<vec3<f32>, 4>;
    var param_102: vec3<f32>;
    var area: f32;
    var radiance: f32;
    var local_32: f32;
    var distance_2: f32;
    var ratio_1: f32;
    var window_1: f32;
    var mirror_1: vec3<f32>;
    var representative: vec3<f32>;
    var param_103: vec3<f32>;
    var param_104: vec3<f32>;
    var param_105: vec3<f32>;
    var param_106: vec3<f32>;
    var param_107: vec3<f32>;
    var toPoint: vec3<f32>;
    var pointDistance: f32;
    var local_33: vec3<f32>;
    var aim: vec3<f32>;
    var attenuation_1: f32;
    var toLight_1: vec3<f32>;
    var distance_3: f32;
    var param_108: f32;
    var param_109: f32;
    var cosAngle: f32;
    var ramp: f32;

    light_3.integrated = 0f;
    light_3.ltc = vec3<f32>(0f, 0f, 0f);
    let _e264 = (*index_2);
    if (_e264 < 8i) {
        let _e266 = (*index_2);
        let _e269 = frag_info.light_position[_e266];
        position = _e269;
        let _e270 = (*index_2);
        let _e273 = frag_info.light_color[_e270];
        color_1 = _e273;
        let _e274 = (*index_2);
        let _e277 = frag_info.light_direction[_e274];
        direction = _e277;
        let _e278 = (*index_2);
        let _e281 = frag_info.light_cone[_e278];
        cone = _e281;
    } else {
        let _e282 = (*index_2);
        slot_5 = (_e282 - 8i);
        let _e284 = Clustered_u0028_();
        clustered = _e284;
        let _e285 = clustered;
        if _e285 {
            let _e286 = slot_5;
            param_97 = _e286;
            let _e287 = ClusterRow_u0028_i1_u003b((&param_97));
            local_29 = _e287;
        } else {
            let _e288 = slot_5;
            param_98 = _e288;
            let _e289 = LightListRow_u0028_i1_u003b((&param_98));
            local_29 = _e289;
        }
        let _e290 = local_29;
        listRow = _e290;
        let _e291 = listRow;
        let _e295 = light_list_info.list[2u];
        v_1 = ((_e291 + 0.5f) * _e295);
        let _e299 = light_list_info.list[1u];
        u_1 = _e299;
        let _e300 = u_1;
        let _e302 = v_1;
        let _e304 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e300), _e302), 0f);
        position = _e304;
        let _e305 = u_1;
        let _e307 = v_1;
        let _e309 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e305), _e307), 0f);
        color_1 = _e309;
        let _e310 = u_1;
        let _e312 = v_1;
        let _e314 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e310), _e312), 0f);
        direction = _e314;
        let _e315 = u_1;
        let _e317 = v_1;
        let _e319 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e315), _e317), 0f);
        cone = _e319;
        let _e320 = clustered;
        if _e320 {
            let _e321 = listRow;
            param_99 = _e321;
            let _e322 = InSlots_u0028_f1_u003b((&param_99));
            local_30 = select(1f, 0f, _e322);
        } else {
            let _e324 = slot_5;
            param_100 = _e324;
            let _e325 = LightListScale_u0028_i1_u003b((&param_100));
            local_30 = _e325;
        }
        let _e326 = local_30;
        let _e328 = color_1[3u];
        color_1[3u] = (_e328 * _e326);
    }
    let _e332 = position[3u];
    type_39 = _e332;
    let _e333 = type_39;
    if (_e333 > 15.5f) {
        let _e336 = (*s_4).n;
        light_3.l = _e336;
        let _e339 = (*s_4).n;
        light_3.h = _e339;
        light_3.radiance = vec3<f32>(0f, 0f, 0f);
        light_3.n_dot_l = 0f;
        light_3.n_dot_h = 0f;
        light_3.v_dot_h = 0f;
        let _e345 = light_3;
        return _e345;
    }
    let _e346 = type_39;
    if (_e346 > 2.5f) {
        let _e348 = direction;
        halfWidth_1 = _e348.xyz;
        let _e350 = cone;
        halfHeight_1 = _e350.xyz;
        let _e352 = position;
        let _e354 = v_world_position_1;
        toCentre = (_e352.xyz - _e354);
        let _e356 = toCentre;
        let _e357 = halfWidth_1;
        let _e359 = halfHeight_1;
        corners_1[0i] = ((_e356 - _e357) - _e359);
        let _e362 = toCentre;
        let _e363 = halfWidth_1;
        let _e365 = halfHeight_1;
        corners_1[1i] = ((_e362 + _e363) - _e365);
        let _e368 = toCentre;
        let _e369 = halfWidth_1;
        let _e371 = halfHeight_1;
        corners_1[2i] = ((_e368 + _e369) + _e371);
        let _e374 = toCentre;
        let _e375 = halfWidth_1;
        let _e377 = halfHeight_1;
        corners_1[3i] = ((_e374 - _e375) + _e377);
        let _e380 = toCentre;
        let _e381 = halfWidth_1;
        let _e382 = halfHeight_1;
        behind = (dot(_e380, cross(_e381, _e382)) >= 0f);
        let _e386 = behind;
        if _e386 {
            local_31 = 0f;
        } else {
            let _e387 = corners_1;
            param_101 = _e387;
            let _e389 = (*s_4).n;
            param_102 = _e389;
            let _e390 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_101), (&param_102));
            local_31 = _e390;
        }
        let _e391 = local_31;
        formFactor = _e391;
        let _e392 = halfWidth_1;
        let _e393 = halfHeight_1;
        area = (length(cross(_e392, _e393)) * 4f);
        let _e397 = area;
        if (_e397 > 0.000000001f) {
            let _e399 = area;
            local_32 = (1f / _e399);
        } else {
            local_32 = 0f;
        }
        let _e401 = local_32;
        radiance = _e401;
        let _e402 = toCentre;
        distance_2 = length(_e402);
        let _e405 = direction[3u];
        if (_e405 > 0f) {
            let _e407 = distance_2;
            let _e409 = direction[3u];
            ratio_1 = (_e407 / _e409);
            let _e411 = ratio_1;
            let _e412 = ratio_1;
            let _e414 = ratio_1;
            let _e416 = ratio_1;
            window_1 = clamp((1f - (((_e411 * _e412) * _e414) * _e416)), 0f, 1f);
            let _e420 = window_1;
            let _e421 = window_1;
            let _e423 = radiance;
            radiance = (_e423 * (_e420 * _e421));
        }
        let _e426 = (*s_4).v;
        let _e429 = (*s_4).n;
        mirror_1 = reflect(-(_e426), _e429);
        let _e431 = position;
        param_103 = _e431.xyz;
        let _e433 = halfWidth_1;
        param_104 = _e433;
        let _e434 = halfHeight_1;
        param_105 = _e434;
        let _e435 = v_world_position_1;
        param_106 = _e435;
        let _e436 = mirror_1;
        param_107 = _e436;
        let _e437 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_103), (&param_104), (&param_105), (&param_106), (&param_107));
        representative = _e437;
        let _e438 = representative;
        let _e439 = v_world_position_1;
        toPoint = (_e438 - _e439);
        let _e441 = toPoint;
        pointDistance = length(_e441);
        let _e443 = pointDistance;
        if (_e443 > 0.000001f) {
            let _e445 = toPoint;
            let _e446 = pointDistance;
            local_33 = (_e445 / vec3(_e446));
        } else {
            let _e450 = (*s_4).n;
            local_33 = _e450;
        }
        let _e451 = local_33;
        light_3.l = _e451;
        let _e454 = light_3.l;
        let _e456 = (*s_4).v;
        light_3.h = normalize((_e454 + _e456));
        let _e460 = formFactor;
        light_3.n_dot_l = _e460;
        let _e463 = (*s_4).n;
        let _e465 = light_3.h;
        light_3.n_dot_h = max(dot(_e463, _e465), 0f);
        let _e470 = (*s_4).v;
        let _e472 = light_3.h;
        light_3.v_dot_h = max(dot(_e470, _e472), 0f);
        let _e476 = color_1;
        let _e479 = color_1[3u];
        let _e481 = radiance;
        light_3.radiance = ((_e476.xyz * _e479) * _e481);
        let _e484 = light_3;
        return _e484;
    }
    let _e485 = direction;
    aim = normalize(_e485.xyz);
    attenuation_1 = 1f;
    let _e488 = type_39;
    if (_e488 < 0.5f) {
        let _e490 = aim;
        light_3.l = -(_e490);
    } else {
        let _e493 = position;
        let _e495 = v_world_position_1;
        toLight_1 = (_e493.xyz - _e495);
        let _e497 = toLight_1;
        distance_3 = length(_e497);
        let _e499 = distance_3;
        if (_e499 < 0.000001f) {
            let _e502 = (*s_4).n;
            light_3.l = _e502;
            let _e505 = (*s_4).n;
            light_3.h = _e505;
            light_3.radiance = vec3<f32>(0f, 0f, 0f);
            light_3.n_dot_l = 0f;
            light_3.n_dot_h = 0f;
            light_3.v_dot_h = 0f;
            let _e511 = light_3;
            return _e511;
        }
        let _e512 = toLight_1;
        let _e513 = distance_3;
        light_3.l = (_e512 / vec3(_e513));
        let _e517 = distance_3;
        param_108 = _e517;
        let _e519 = direction[3u];
        param_109 = _e519;
        let _e520 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_108), (&param_109));
        attenuation_1 = _e520;
        let _e521 = type_39;
        if (_e521 > 1.5f) {
            let _e523 = aim;
            let _e525 = light_3.l;
            cosAngle = dot(_e523, -(_e525));
            let _e528 = cosAngle;
            let _e530 = cone[1u];
            let _e533 = cone[0u];
            let _e535 = cone[1u];
            ramp = clamp(((_e528 - _e530) / (_e533 - _e535)), 0f, 1f);
            let _e539 = ramp;
            let _e540 = ramp;
            let _e542 = attenuation_1;
            attenuation_1 = (_e542 * (_e539 * _e540));
        }
    }
    let _e545 = light_3.l;
    let _e547 = (*s_4).v;
    light_3.h = normalize((_e545 + _e547));
    let _e552 = (*s_4).n;
    let _e554 = light_3.l;
    light_3.n_dot_l = max(dot(_e552, _e554), 0f);
    let _e559 = (*s_4).n;
    let _e561 = light_3.h;
    light_3.n_dot_h = max(dot(_e559, _e561), 0f);
    let _e566 = (*s_4).v;
    let _e568 = light_3.h;
    light_3.v_dot_h = max(dot(_e566, _e568), 0f);
    let _e572 = color_1;
    let _e575 = color_1[3u];
    let _e577 = attenuation_1;
    light_3.radiance = ((_e572.xyz * _e575) * _e577);
    let _e580 = light_3;
    return _e580;
}

fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
    var clip_1: vec4<f32>;
    var ndc_1: vec2<f32>;
    var grid: vec3<f32>;
    var near_1: f32;
    var tx: f32;
    var ty: f32;
    var tz: f32;
    var local_34: f32;
    var cell_1: f32;
    var row_3: f32;
    var header: vec4<f32>;
    var param_110: f32;
    var param_111: f32;

    let _e225 = light_list_info.cluster_view_projection;
    let _e226 = (*world_3);
    clip_1 = (_e225 * vec4<f32>(_e226.x, _e226.y, _e226.z, 1f));
    let _e232 = clip_1;
    let _e235 = clip_1[3u];
    ndc_1 = (_e232.xy / vec2(max(_e235, 0.000001f)));
    let _e240 = light_list_info.cluster_grid;
    grid = _e240.xyz;
    let _e244 = light_list_info.cluster_depth[0u];
    near_1 = _e244;
    let _e246 = ndc_1[0u];
    let _e250 = grid[0u];
    let _e254 = grid[0u];
    tx = clamp(floor((((_e246 * 0.5f) + 0.5f) * _e250)), 0f, (_e254 - 1f));
    let _e258 = ndc_1[1u];
    let _e262 = grid[1u];
    let _e266 = grid[1u];
    ty = clamp(floor((((_e258 * 0.5f) + 0.5f) * _e262)), 0f, (_e266 - 1f));
    let _e270 = clip_1[3u];
    let _e271 = near_1;
    if (_e270 <= _e271) {
        local_34 = 0f;
    } else {
        let _e274 = clip_1[3u];
        let _e275 = near_1;
        let _e280 = light_list_info.cluster_depth[1u];
        let _e284 = grid[2u];
        local_34 = clamp(floor((log((_e274 / _e275)) * _e280)), 0f, (_e284 - 1f));
    }
    let _e287 = local_34;
    tz = _e287;
    let _e288 = tx;
    let _e289 = ty;
    let _e291 = grid[0u];
    let _e294 = tz;
    let _e296 = grid[0u];
    let _e299 = grid[1u];
    cell_1 = ((_e288 + (_e289 * _e291)) + ((_e294 * _e296) * _e299));
    let _e302 = cell_1;
    row_3 = floor((_e302 / 4f));
    let _e305 = cell_1;
    let _e306 = row_3;
    let _e311 = light_list_info.cluster_depth[2u];
    let _e312 = row_3;
    param_110 = (_e305 - (_e306 * 4f));
    param_111 = (_e311 + _e312);
    let _e314 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_110), (&param_111));
    header = _e314;
    let _e316 = header[0u];
    g_cluster_offset = _e316;
    let _e318 = header[1u];
    g_cluster_count = _e318;
    return;
}

fn LightCount_u0028_() -> i32 {
    var tail: f32;
    var param_112: vec3<f32>;

    let _e214 = light_list_info.list[0u];
    tail = _e214;
    let _e215 = Clustered_u0028_();
    if _e215 {
        let _e216 = v_world_position_1;
        param_112 = _e216;
        FindCluster_u0028_vf3_u003b((&param_112));
        let _e217 = g_cluster_count;
        tail = _e217;
    }
    let _e220 = frag_info.frame_params[1u];
    let _e224 = tail;
    return (clamp(i32((_e220 + 0.5f)), 0i, 8i) + clamp(i32((_e224 + 0.5f)), 0i, 24i));
}

fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
    var total_1: vec3<f32>;
    var count_1: i32;
    var i_8: i32;
    var light_4: LightSample;
    var param_113: i32;
    var param_114: Surface;
    var visibility: f32;
    var param_115: i32;
    var local_35: f32;
    var param_116: Surface;
    var param_117: LightSample;
    var param_118: i32;
    var param_119: vec3<f32>;
    var param_120: vec3<f32>;
    var param_121: i32;
    var param_122: Surface;
    var param_123: LightSample;

    total_1 = vec3<f32>(0f, 0f, 0f);
    let _e228 = LightCount_u0028_();
    count_1 = _e228;
    i_8 = 0i;
    loop {
        let _e229 = i_8;
        if (_e229 < 32i) {
            let _e231 = i_8;
            let _e232 = count_1;
            if (_e231 >= _e232) {
                break;
            }
            let _e234 = i_8;
            param_113 = _e234;
            let _e235 = (*s_5);
            param_114 = _e235;
            let _e236 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_113), (&param_114));
            light_4 = _e236;
            let _e238 = light_4.n_dot_l;
            if (_e238 <= 0f) {
                continue;
            }
            light_transmittance = vec3<f32>(1f, 1f, 1f);
            let _e240 = i_8;
            param_115 = _e240;
            let _e241 = LightHasShadow_u0028_i1_u003b((&param_115));
            if _e241 {
                let _e242 = (*s_5);
                param_116 = _e242;
                let _e243 = light_4;
                param_117 = _e243;
                let _e244 = i_8;
                param_118 = _e244;
                let _e245 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_116), (&param_117), (&param_118));
                let _e246 = v_world_position_1;
                param_119 = _e246;
                let _e248 = (*s_5).n;
                param_120 = _e248;
                let _e249 = i_8;
                param_121 = _e249;
                let _e250 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_119), (&param_120), (&param_121));
                local_35 = (_e245 * _e250);
            } else {
                local_35 = 1f;
            }
            let _e252 = local_35;
            visibility = _e252;
            let _e253 = visibility;
            if (_e253 <= 0f) {
                continue;
            }
            let _e255 = (*s_5);
            param_122 = _e255;
            let _e256 = light_4;
            param_123 = _e256;
            let _e257 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_122), (&param_123));
            let _e259 = light_4.radiance;
            let _e262 = light_4.n_dot_l;
            let _e264 = visibility;
            let _e266 = light_transmittance;
            let _e268 = total_1;
            total_1 = (_e268 + ((((_e257 * _e259) * _e262) * _e264) * _e266));
            continue;
        } else {
            break;
        }
        continuing {
            let _e270 = i_8;
            i_8 = (_e270 + 1i);
        }
    }
    let _e272 = total_1;
    return _e272;
}

fn ImpostorRight_u0028_vf3_u003b(d_4: ptr<function, vec3<f32>>) -> vec3<f32> {
    var up: vec3<f32>;

    let _e213 = (*d_4)[1u];
    up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e213) > 0.999f)));
    let _e218 = up;
    let _e219 = (*d_4);
    return normalize(cross(_e218, _e219));
}

fn ImpostorDecode_u0028_vf2_u003b(uv_6: ptr<function, vec2<f32>>) -> vec3<f32> {
    var p_1: vec2<f32>;
    var y_2: f32;
    var s_6: vec2<f32>;
    var folded: vec2<f32>;
    var xz: vec2<f32>;

    let _e216 = (*uv_6);
    p_1 = ((_e216 * 2f) - vec2<f32>(1f, 1f));
    let _e220 = p_1[0u];
    let _e224 = p_1[1u];
    y_2 = ((1f - abs(_e220)) - abs(_e224));
    let _e228 = p_1[0u];
    let _e232 = p_1[1u];
    s_6 = vec2<f32>(select(-1f, 1f, (_e228 >= 0f)), select(-1f, 1f, (_e232 >= 0f)));
    let _e236 = p_1;
    let _e240 = s_6;
    folded = ((vec2<f32>(1f, 1f) - abs(_e236.yx)) * _e240);
    let _e242 = y_2;
    let _e244 = p_1;
    let _e245 = folded;
    xz = select(_e245, _e244, vec2((_e242 >= 0f)));
    let _e249 = xz[0u];
    let _e250 = y_2;
    let _e252 = xz[1u];
    return normalize(vec3<f32>(_e249, _e250, _e252));
}

fn ImpostorViewUv_u0028_vf2_u003b_vf3_u003b(cell_2: ptr<function, vec2<f32>>, offset_3: ptr<function, vec3<f32>>) -> vec2<f32> {
    var d_5: vec3<f32>;
    var param_124: vec2<f32>;
    var right: vec3<f32>;
    var param_125: vec3<f32>;
    var up_1: vec3<f32>;
    var local_36: vec2<f32>;

    let _e218 = (*cell_2);
    param_124 = (_e218 / vec2(7f));
    let _e221 = ImpostorDecode_u0028_vf2_u003b((&param_124));
    d_5 = _e221;
    let _e222 = d_5;
    param_125 = _e222;
    let _e223 = ImpostorRight_u0028_vf3_u003b((&param_125));
    right = _e223;
    let _e224 = d_5;
    let _e225 = right;
    up_1 = cross(_e224, _e225);
    let _e227 = (*offset_3);
    let _e228 = right;
    let _e232 = (*offset_3);
    let _e233 = up_1;
    local_36 = vec2<f32>(((dot(_e227, _e228) * 0.5f) + 0.5f), (0.5f - (dot(_e232, _e233) * 0.5f)));
    let _e238 = (*cell_2);
    let _e239 = local_36;
    return ((_e238 + clamp(_e239, vec2<f32>(0f, 0f), vec2<f32>(1f, 1f))) / vec2(8f));
}

fn ImpostorEncode_u0028_vf3_u003b(d_6: ptr<function, vec3<f32>>) -> vec2<f32> {
    var a_4: vec3<f32>;
    var p_2: vec2<f32>;
    var s_7: vec2<f32>;
    var folded_1: vec2<f32>;

    let _e215 = (*d_6);
    a_4 = abs(_e215);
    let _e217 = (*d_6);
    let _e220 = a_4[0u];
    let _e222 = a_4[1u];
    let _e225 = a_4[2u];
    p_2 = (_e217.xz / vec2(max(((_e220 + _e222) + _e225), 0.00000001f)));
    let _e231 = p_2[0u];
    let _e235 = p_2[1u];
    s_7 = vec2<f32>(select(-1f, 1f, (_e231 >= 0f)), select(-1f, 1f, (_e235 >= 0f)));
    let _e239 = p_2;
    let _e243 = s_7;
    folded_1 = ((vec2<f32>(1f, 1f) - abs(_e239.yx)) * _e243);
    let _e246 = (*d_6)[1u];
    let _e248 = p_2;
    let _e249 = folded_1;
    return ((select(_e249, _e248, vec2((_e246 >= 0f))) * 0.5f) + vec2<f32>(0.5f, 0.5f));
}

fn TowardsEye_u0028_() -> vec3<f32> {
    var local_37: vec3<f32>;

    let _e211 = Orthographic_u0028_();
    if _e211 {
        let _e213 = fog_info.forward;
        local_37 = -(_e213.xyz);
    } else {
        let _e217 = fog_info.eye;
        let _e219 = v_world_position_1;
        local_37 = normalize((_e217.xyz - _e219));
    }
    let _e222 = local_37;
    return _e222;
}

fn HashedAlphaNoise_u0028_vf3_u003b_f1_u003b(scenePosition: ptr<function, vec3<f32>>, cutoff: ptr<function, f32>) -> f32 {
    var key_2: f32;
    var origin_2: vec3<f32>;
    var cell_3: vec3<f32>;
    var p3_: vec3<f32>;

    let _e216 = (*cutoff);
    key_2 = (-2f - _e216);
    let _e218 = key_2;
    let _e221 = key_2;
    let _e223 = floor((_e221 / 128f));
    let _e228 = key_2;
    origin_2 = vec3<f32>(floor((_e218 / 16384f)), (_e223 - (floor((_e223 / 128f)) * 128f)), (_e228 - (floor((_e228 / 128f)) * 128f)));
    let _e234 = (*scenePosition);
    let _e237 = origin_2;
    let _e238 = (floor((_e234 * 16f)) + _e237);
    let _e239 = vec3(128f);
    cell_3 = (_e238 - (floor((_e238 / _e239)) * _e239));
    let _e244 = cell_3;
    p3_ = fract((_e244 * 0.1031f));
    let _e247 = p3_;
    let _e248 = p3_;
    let _e253 = p3_;
    p3_ = (_e253 + vec3(dot(_e247, (_e248.zyx + vec3(31.32f)))));
    let _e257 = p3_[0u];
    let _e259 = p3_[1u];
    let _e262 = p3_[2u];
    return fract(((_e257 + _e259) * _e262));
}

fn MaterialLodBias_u0028_() -> f32 {
    let _e212 = frag_info.target_origin[1u];
    return _e212;
}

fn ReadSurface_u0028_() -> Surface {
    var texel_4: vec4<f32>;
    var s_8: Surface;
    var param_126: vec3<f32>;
    var param_127: vec3<f32>;
    var cutoff_1: f32;
    var edge: f32;
    var param_128: vec3<f32>;
    var param_129: f32;

    let _e218 = v_texcoord_1;
    let _e219 = MaterialLodBias_u0028_();
    let _e220 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e218, _e219);
    texel_4 = _e220;
    let _e221 = texel_4;
    param_126 = _e221.xyz;
    let _e223 = SrgbToLinear_u0028_vf3_u003b((&param_126));
    let _e225 = frag_info.base_color;
    param_127 = _e225.xyz;
    let _e227 = SrgbToLinear_u0028_vf3_u003b((&param_127));
    let _e229 = v_color_1;
    s_8.albedo = ((_e223 * _e227) * _e229.xyz);
    let _e234 = texel_4[3u];
    let _e237 = frag_info.base_color[3u];
    let _e240 = v_color_1[3u];
    s_8.alpha = ((_e234 * _e237) * _e240);
    let _e244 = s_8.albedo;
    g_albedo = _e244;
    let _e247 = frag_info.material2_[0u];
    cutoff_1 = _e247;
    let _e248 = cutoff_1;
    if (_e248 > 1f) {
        let _e250 = cutoff_1;
        edge = (_e250 - 1f);
        let _e253 = s_8.alpha;
        let _e254 = edge;
        let _e257 = s_8.alpha;
        let _e258 = fwidth(_e257);
        s_8.alpha = clamp((((_e253 - _e254) / max(_e258, 0.0001f)) + 0.5f), 0f, 1f);
    } else {
        let _e264 = cutoff_1;
        if (_e264 >= 0f) {
            let _e267 = s_8.alpha;
            let _e268 = cutoff_1;
            if (_e267 < _e268) {
                discard;
            }
            s_8.alpha = 1f;
        } else {
            let _e271 = cutoff_1;
            if (_e271 < -1.5f) {
                let _e274 = s_8.alpha;
                let _e275 = v_world_position_1;
                param_128 = _e275;
                let _e276 = cutoff_1;
                param_129 = _e276;
                let _e277 = HashedAlphaNoise_u0028_vf3_u003b_f1_u003b((&param_128), (&param_129));
                if (_e274 < _e277) {
                    discard;
                }
            }
        }
    }
    let _e279 = cutoff_1;
    let _e281 = cutoff_1;
    g_premultiply = ((_e279 < 0f) && (_e281 > -0.75f));
    let _e284 = v_normal_1;
    s_8.n = normalize(_e284);
    let _e287 = gl_FrontFacing_1;
    if !(_e287) {
        let _e290 = s_8.n;
        s_8.n = -(_e290);
    }
    let _e293 = TowardsEye_u0028_();
    s_8.v = _e293;
    let _e296 = s_8.n;
    let _e298 = s_8.v;
    s_8.n_dot_v = max(dot(_e296, _e298), 0.0001f);
    let _e304 = frag_info.material[0u];
    s_8.metallic = clamp(_e304, 0f, 1f);
    let _e309 = frag_info.material[1u];
    s_8.roughness = clamp(_e309, 0.02f, 1f);
    let _e313 = frag_info.ambient_ground;
    let _e316 = frag_info.ambient_sky;
    let _e320 = s_8.n[1u];
    let _e327 = frag_info.material[2u];
    s_8.ambient = (mix(_e313.xyz, _e316.xyz, vec3(((_e320 * 0.5f) + 0.5f))) * _e327);
    let _e332 = frag_info.frame_params[0u];
    s_8.exposure = max(_e332, 0f);
    s_8.occlusion = 1f;
    s_8.emissive = vec3<f32>(0f, 0f, 0f);
    let _e337 = s_8;
    return _e337;
}

fn main_1() {
    var s_9: Surface;
    var d_7: vec3<f32>;
    var right_1: vec3<f32>;
    var param_130: vec3<f32>;
    var up_2: vec3<f32>;
    var offset_4: vec3<f32>;
    var g: vec2<f32>;
    var param_131: vec3<f32>;
    var base: vec2<f32>;
    var f: vec2<f32>;
    var lower: bool;
    var c0_: vec2<f32>;
    var local_38: vec2<f32>;
    var c1_: vec2<f32>;
    var c2_: vec2<f32>;
    var w: vec3<f32>;
    var local_39: vec3<f32>;
    var uv0_: vec2<f32>;
    var param_132: vec2<f32>;
    var param_133: vec3<f32>;
    var uv1_: vec2<f32>;
    var param_134: vec2<f32>;
    var param_135: vec3<f32>;
    var uv2_: vec2<f32>;
    var param_136: vec2<f32>;
    var param_137: vec3<f32>;
    var a0_: vec4<f32>;
    var a1_: vec4<f32>;
    var a2_: vec4<f32>;
    var n0_: vec4<f32>;
    var n1_: vec4<f32>;
    var n2_: vec4<f32>;
    var wa: vec3<f32>;
    var alpha_3: f32;
    var srgb_2: vec3<f32>;
    var local_40: vec3<f32>;
    var worldRight: vec3<f32>;
    var worldFacing: vec3<f32>;
    var worldUp: vec3<f32>;
    var param_138: vec3<f32>;
    var param_139: vec3<f32>;
    var ambient: vec3<f32>;
    var lit_3: vec3<f32>;
    var param_140: Surface;
    var param_141: Surface;
    var param_142: vec3<f32>;
    var param_143: vec3<f32>;
    var param_144: f32;
    var param_145: f32;

    g_albedo = vec3<f32>(0f, 0f, 0f);
    g_debug_surface = vec3<f32>(0f, 0f, 0f);
    g_debug_surface_on = false;
    g_premultiply = false;
    g_pass_through = 0f;
    g_cluster_offset = 0f;
    g_cluster_count = 0f;
    light_transmittance = vec3<f32>(1f, 1f, 1f);
    let _e259 = ReadSurface_u0028_();
    s_9 = _e259;
    let _e260 = v_color_1;
    d_7 = normalize(_e260.xyz);
    let _e263 = d_7;
    param_130 = _e263;
    let _e264 = ImpostorRight_u0028_vf3_u003b((&param_130));
    right_1 = _e264;
    let _e265 = d_7;
    let _e266 = right_1;
    up_2 = cross(_e265, _e266);
    let _e268 = right_1;
    let _e270 = v_texcoord_1[0u];
    let _e274 = up_2;
    let _e276 = v_texcoord_1[1u];
    offset_4 = ((_e268 * ((_e270 * 2f) - 1f)) + (_e274 * (1f - (_e276 * 2f))));
    let _e281 = d_7;
    param_131 = _e281;
    let _e282 = ImpostorEncode_u0028_vf3_u003b((&param_131));
    g = (_e282 * 7f);
    let _e284 = g;
    base = clamp(floor(_e284), vec2<f32>(0f, 0f), vec2<f32>(6f, 6f));
    let _e287 = g;
    let _e288 = base;
    f = (_e287 - _e288);
    let _e291 = f[0u];
    let _e293 = f[1u];
    lower = ((_e291 + _e293) < 1f);
    let _e296 = lower;
    if _e296 {
        let _e297 = base;
        local_38 = _e297;
    } else {
        let _e298 = base;
        local_38 = (_e298 + vec2<f32>(1f, 1f));
    }
    let _e300 = local_38;
    c0_ = _e300;
    let _e301 = base;
    c1_ = (_e301 + vec2<f32>(1f, 0f));
    let _e303 = base;
    c2_ = (_e303 + vec2<f32>(0f, 1f));
    let _e305 = lower;
    if _e305 {
        let _e307 = f[0u];
        let _e310 = f[1u];
        let _e313 = f[0u];
        let _e315 = f[1u];
        local_39 = vec3<f32>(((1f - _e307) - _e310), _e313, _e315);
    } else {
        let _e318 = f[0u];
        let _e320 = f[1u];
        let _e324 = f[1u];
        let _e327 = f[0u];
        local_39 = vec3<f32>(((_e318 + _e320) - 1f), (1f - _e324), (1f - _e327));
    }
    let _e330 = local_39;
    w = _e330;
    let _e331 = c0_;
    param_132 = _e331;
    let _e332 = offset_4;
    param_133 = _e332;
    let _e333 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_132), (&param_133));
    uv0_ = _e333;
    let _e334 = c1_;
    param_134 = _e334;
    let _e335 = offset_4;
    param_135 = _e335;
    let _e336 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_134), (&param_135));
    uv1_ = _e336;
    let _e337 = c2_;
    param_136 = _e337;
    let _e338 = offset_4;
    param_137 = _e338;
    let _e339 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_136), (&param_137));
    uv2_ = _e339;
    let _e340 = uv0_;
    let _e341 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e340, 0f);
    a0_ = _e341;
    let _e342 = uv1_;
    let _e343 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e342, 0f);
    a1_ = _e343;
    let _e344 = uv2_;
    let _e345 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e344, 0f);
    a2_ = _e345;
    let _e346 = uv0_;
    let _e347 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e346, 0f);
    n0_ = _e347;
    let _e348 = uv1_;
    let _e349 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e348, 0f);
    n1_ = _e349;
    let _e350 = uv2_;
    let _e351 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e350, 0f);
    n2_ = _e351;
    let _e352 = w;
    let _e354 = a0_[3u];
    let _e356 = a1_[3u];
    let _e358 = a2_[3u];
    wa = (_e352 * vec3<f32>(_e354, _e356, _e358));
    let _e362 = wa[0u];
    let _e364 = wa[1u];
    let _e367 = wa[2u];
    alpha_3 = ((_e362 + _e364) + _e367);
    let _e369 = alpha_3;
    if (_e369 < 0.5f) {
        discard;
    }
    let _e371 = a0_;
    let _e374 = wa[0u];
    let _e376 = a1_;
    let _e379 = wa[1u];
    let _e382 = a2_;
    let _e385 = wa[2u];
    let _e388 = alpha_3;
    srgb_2 = ((((_e371.xyz * _e374) + (_e376.xyz * _e379)) + (_e382.xyz * _e385)) / vec3(_e388));
    let _e391 = n0_;
    let _e396 = wa[0u];
    let _e398 = n1_;
    let _e403 = wa[1u];
    let _e406 = n2_;
    let _e411 = wa[2u];
    local_40 = (((((_e391.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e396) + (((_e398.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e403)) + (((_e406.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e411));
    let _e414 = local_40;
    let _e415 = local_40;
    let _e418 = local_40;
    let _e419 = d_7;
    local_40 = normalize(select(_e419, _e418, vec3((dot(_e414, _e415) > 0.000000000001f))));
    let _e423 = v_tangent_1;
    worldRight = normalize(_e423.xyz);
    let _e426 = v_normal_1;
    worldFacing = normalize(_e426);
    let _e428 = worldFacing;
    let _e429 = worldRight;
    worldUp = cross(_e428, _e429);
    let _e431 = worldRight;
    let _e432 = local_40;
    let _e433 = right_1;
    let _e436 = worldUp;
    let _e437 = local_40;
    let _e438 = up_2;
    let _e442 = worldFacing;
    let _e443 = local_40;
    let _e444 = d_7;
    s_9.n = normalize((((_e431 * dot(_e432, _e433)) + (_e436 * dot(_e437, _e438))) + (_e442 * dot(_e443, _e444))));
    let _e451 = s_9.n;
    let _e453 = s_9.v;
    s_9.n_dot_v = max(dot(_e451, _e453), 0.0001f);
    let _e457 = srgb_2;
    param_138 = _e457;
    let _e458 = SrgbToLinear_u0028_vf3_u003b((&param_138));
    let _e460 = frag_info.base_color;
    param_139 = _e460.xyz;
    let _e462 = SrgbToLinear_u0028_vf3_u003b((&param_139));
    s_9.albedo = (_e458 * _e462);
    s_9.alpha = 1f;
    let _e467 = s_9.albedo;
    g_albedo = _e467;
    let _e469 = frag_info.ambient_ground;
    let _e472 = frag_info.ambient_sky;
    let _e476 = s_9.n[1u];
    let _e483 = frag_info.material[2u];
    s_9.ambient = (mix(_e469.xyz, _e472.xyz, vec3(((_e476 * 0.5f) + 0.5f))) * _e483);
    let _e487 = s_9.albedo;
    let _e489 = s_9.ambient;
    ambient = (_e487 * _e489);
    let _e491 = s_9;
    param_140 = _e491;
    let _e492 = 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((&param_140));
    let _e493 = ambient;
    lit_3 = (_e492 + _e493);
    let _e495 = s_9;
    param_141 = _e495;
    let _e496 = lit_3;
    param_142 = _e496;
    let _e497 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_141), (&param_142));
    if _e497 {
        return;
    }
    let _e498 = lit_3;
    param_143 = _e498;
    param_144 = 1f;
    param_145 = 1f;
    WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_143), (&param_144), (&param_145));
    return;
}

@fragment
fn main(@location(7) v_world_position: vec3<f32>, @location(3) v_normal: vec3<f32>, @builtin(front_facing) gl_FrontFacing: bool, @builtin(position) gl_FragCoord: vec4<f32>, @location(5) v_texcoord: vec2<f32>, @location(0) v_color: vec4<f32>, @location(4) v_tangent: vec4<f32>, @location(2) v_lightmap_uv: vec2<f32>) -> FragmentOutput {
    v_world_position_1 = v_world_position;
    v_normal_1 = v_normal;
    gl_FrontFacing_1 = gl_FrontFacing;
    gl_FragCoord_1 = gl_FragCoord;
    v_texcoord_1 = v_texcoord;
    v_color_1 = v_color;
    v_tangent_1 = v_tangent;
    v_lightmap_uv_1 = v_lightmap_uv;
    main_1();
    let _e19 = frag_albedo;
    let _e20 = frag_surface;
    let _e21 = frag_color;
    return FragmentOutput(_e19, _e20, _e21);
}
''',
      attributes: <WebGpuAttribute>[],
      blocks: <WebGpuBlock>[
        WebGpuBlock(
          name: 'FogInfo',
          group: 1,
          binding: 0,
          sizeInBytes: 64,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'fog', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(name: 'eye', offsetInBytes: 16, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'forward',
              offsetInBytes: 32,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'projection',
              offsetInBytes: 48,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'FragInfo',
          group: 1,
          binding: 1,
          sizeInBytes: 912,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'light_position',
              offsetInBytes: 0,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_color',
              offsetInBytes: 128,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_direction',
              offsetInBytes: 256,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'light_cone',
              offsetInBytes: 384,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'base_color',
              offsetInBytes: 512,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'emissive',
              offsetInBytes: 528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'camera_position',
              offsetInBytes: 544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material',
              offsetInBytes: 560,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'material2',
              offsetInBytes: 576,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'frame_params',
              offsetInBytes: 592,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_params',
              offsetInBytes: 608,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix',
              offsetInBytes: 624,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_far',
              offsetInBytes: 688,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_matrix_farthest',
              offsetInBytes: 752,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'shadow_cascades',
              offsetInBytes: 816,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_sky',
              offsetInBytes: 832,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'ambient_ground',
              offsetInBytes: 848,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'shadow_bias',
              offsetInBytes: 864,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'target_origin',
              offsetInBytes: 880,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'debug_view',
              offsetInBytes: 896,
              sizeInBytes: 16,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'LightListInfo',
          group: 1,
          binding: 2,
          sizeInBytes: 336,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(name: 'list', offsetInBytes: 0, sizeInBytes: 16),
            WebGpuBlockMember(
              name: 'indices',
              offsetInBytes: 16,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'scales',
              offsetInBytes: 112,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'cluster_view_projection',
              offsetInBytes: 208,
              sizeInBytes: 64,
            ),
            WebGpuBlockMember(
              name: 'cluster_grid',
              offsetInBytes: 272,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'cluster_depth',
              offsetInBytes: 288,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'slot_rows',
              offsetInBytes: 304,
              sizeInBytes: 32,
            ),
          ],
        ),
        WebGpuBlock(
          name: 'PointShadow',
          group: 1,
          binding: 3,
          sizeInBytes: 2576,
          members: <WebGpuBlockMember>[
            WebGpuBlockMember(
              name: 'faces',
              offsetInBytes: 0,
              sizeInBytes: 2304,
            ),
            WebGpuBlockMember(
              name: 'lights',
              offsetInBytes: 2304,
              sizeInBytes: 96,
            ),
            WebGpuBlockMember(
              name: 'slots',
              offsetInBytes: 2400,
              sizeInBytes: 128,
            ),
            WebGpuBlockMember(
              name: 'params',
              offsetInBytes: 2528,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params2',
              offsetInBytes: 2544,
              sizeInBytes: 16,
            ),
            WebGpuBlockMember(
              name: 'params3',
              offsetInBytes: 2560,
              sizeInBytes: 16,
            ),
          ],
        ),
      ],
      samplers: <WebGpuSampler>[
        WebGpuSampler(
          name: 'base_color_texture',
          group: 1,
          textureBinding: 4,
          samplerBinding: 5,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'light_list_texture',
          group: 1,
          textureBinding: 6,
          samplerBinding: 7,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'normal_texture',
          group: 1,
          textureBinding: 8,
          samplerBinding: 9,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_static_texture',
          group: 1,
          textureBinding: 10,
          samplerBinding: 11,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'point_shadow_texture',
          group: 1,
          textureBinding: 12,
          samplerBinding: 13,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
        WebGpuSampler(
          name: 'shadow_texture',
          group: 1,
          textureBinding: 14,
          samplerBinding: 15,
          dimension: WebGpuTextureDimension.twoDimensional,
        ),
      ],
    ),
  },
);