| SKIP: FAILED |
| |
| ../../src/tint/lang/msl/writer/printer/printer.cc:500 internal compiler error: Camera = struct @align(16) { |
| projection:mat4x4<f32> @offset(0) |
| inverseProjection:mat4x4<f32> @offset(64) |
| view:mat4x4<f32> @offset(128) |
| position:vec3<f32> @offset(192) |
| time:f32 @offset(204) |
| outputSize:vec2<f32> @offset(208) |
| zNear:f32 @offset(216) |
| zFar:f32 @offset(220) |
| } |
| |
| ClusterLights = struct @align(4) { |
| offset:u32 @offset(0) |
| count:u32 @offset(4) |
| } |
| |
| ClusterLightGroup = struct @align(4) { |
| offset:u32 @offset(0) |
| lights:array<ClusterLights, 27648> @offset(4) |
| indices:array<u32, 1769472> @offset(221188) |
| } |
| |
| Light = struct @align(16) { |
| position:vec3<f32> @offset(0) |
| range:f32 @offset(12) |
| color:vec3<f32> @offset(16) |
| intensity:f32 @offset(28) |
| } |
| |
| GlobalLights = struct @align(16) { |
| ambient:vec3<f32> @offset(0) |
| dirColor:vec3<f32> @offset(16) |
| dirIntensity:f32 @offset(28) |
| dirDirection:vec3<f32> @offset(32) |
| lightCount:u32 @offset(44) |
| lights:array<Light> @offset(48) |
| } |
| |
| LightShadowTable = struct @align(4) { |
| light:array<i32> @offset(0) |
| } |
| |
| ShadowProperties = struct @align(16) { |
| viewport:vec4<f32> @offset(0) |
| viewProj:mat4x4<f32> @offset(16) |
| } |
| |
| LightShadows = struct @align(16) { |
| properties:array<ShadowProperties> @offset(0) |
| } |
| |
| Material = struct @align(16) { |
| baseColorFactor:vec4<f32> @offset(0) |
| emissiveFactor:vec3<f32> @offset(16) |
| occlusionStrength:f32 @offset(28) |
| metallicRoughnessFactor:vec2<f32> @offset(32) |
| alphaCutoff:f32 @offset(40) |
| } |
| |
| SurfaceInfo = struct @align(16) { |
| baseColor:vec4<f32> @offset(0) |
| albedo:vec3<f32> @offset(16) |
| metallic:f32 @offset(28) |
| roughness:f32 @offset(32) |
| normal:vec3<f32> @offset(48) |
| f0:vec3<f32> @offset(64) |
| ao:f32 @offset(76) |
| emissive:vec3<f32> @offset(80) |
| v:vec3<f32> @offset(96) |
| } |
| |
| VertexOutput = struct @align(16) { |
| position:vec4<f32> @offset(0), @builtin(position) |
| worldPos:vec3<f32> @offset(16), @location(0) |
| view:vec3<f32> @offset(32), @location(1) |
| texcoord:vec2<f32> @offset(48), @location(2) |
| texcoord2:vec2<f32> @offset(56), @location(3) |
| color:vec4<f32> @offset(64), @location(4) |
| instanceColor:vec4<f32> @offset(80), @location(5) |
| normal:vec3<f32> @offset(96), @location(6) |
| tangent:vec3<f32> @offset(112), @location(7) |
| bitangent:vec3<f32> @offset(128), @location(8) |
| } |
| |
| PuctualLight = struct @align(16) { |
| lightType:u32 @offset(0) |
| pointToLight:vec3<f32> @offset(16) |
| range:f32 @offset(28) |
| color:vec3<f32> @offset(32) |
| intensity:f32 @offset(44) |
| } |
| |
| FragmentOutput = struct @align(16) { |
| color:vec4<f32> @offset(0), @location(0) |
| emissive:vec4<f32> @offset(16), @location(1) |
| } |
| |
| $B1: { # root |
| %camera:ptr<uniform, Camera, read> = var @binding_point(0, 0) |
| %clusterLights:ptr<storage, ClusterLightGroup, read> = var @binding_point(0, 1) |
| %globalLights:ptr<storage, GlobalLights, read> = var @binding_point(0, 2) |
| %defaultSampler:ptr<handle, sampler, read> = var @binding_point(0, 3) |
| %shadowTexture:ptr<handle, texture_depth_2d, read> = var @binding_point(0, 4) |
| %shadowSampler:ptr<handle, sampler_comparison, read> = var @binding_point(0, 5) |
| %lightShadowTable:ptr<storage, LightShadowTable, read> = var @binding_point(0, 6) |
| %shadowSampleOffsets:ptr<private, array<vec2<f32>, 16>, read_write> = var, array<vec2<f32>, 16>(vec2<f32>(-1.5f), vec2<f32>(-1.5f, -0.5f), vec2<f32>(-1.5f, 0.5f), vec2<f32>(-1.5f, 1.5f), vec2<f32>(-0.5f, -1.5f), vec2<f32>(-0.5f), vec2<f32>(-0.5f, 0.5f), vec2<f32>(-0.5f, 1.5f), vec2<f32>(0.5f, -1.5f), vec2<f32>(0.5f, -0.5f), vec2<f32>(0.5f), vec2<f32>(0.5f, 1.5f), vec2<f32>(1.5f, -1.5f), vec2<f32>(1.5f, -0.5f), vec2<f32>(1.5f, 0.5f), vec2<f32>(1.5f)) |
| %shadow:ptr<storage, LightShadows, read> = var @binding_point(0, 7) |
| %material:ptr<uniform, Material, read> = var @binding_point(0, 8) |
| %baseColorTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 9) |
| %baseColorSampler:ptr<handle, sampler, read> = var @binding_point(0, 10) |
| %normalTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 11) |
| %normalSampler:ptr<handle, sampler, read> = var @binding_point(0, 12) |
| %metallicRoughnessTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 13) |
| %metallicRoughnessSampler:ptr<handle, sampler, read> = var @binding_point(0, 14) |
| %occlusionTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 15) |
| %occlusionSampler:ptr<handle, sampler, read> = var @binding_point(0, 16) |
| %emissiveTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 17) |
| %emissiveSampler:ptr<handle, sampler, read> = var @binding_point(0, 18) |
| %ssaoTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 19) |
| } |
| |
| %linearTosRGB = func(%linear:vec3<f32>):vec3<f32> { |
| $B2: { |
| %INV_GAMMA:f32 = let 0.45454543828964233398f |
| %25:vec3<f32> = construct %INV_GAMMA |
| %26:vec3<f32> = pow %linear, %25 |
| ret %26 |
| } |
| } |
| %sRGBToLinear = func(%srgb:vec3<f32>):vec3<f32> { |
| $B3: { |
| %29:vec3<f32> = pow %srgb, vec3<f32>(2.20000004768371582031f) |
| ret %29 |
| } |
| } |
| %linearDepth = func(%depthSample:f32):f32 { |
| $B4: { |
| %32:ptr<uniform, f32, read> = access %camera, 7u |
| %33:f32 = load %32 |
| %34:ptr<uniform, f32, read> = access %camera, 6u |
| %35:f32 = load %34 |
| %36:f32 = mul %33, %35 |
| %37:f32 = let %36 |
| %38:ptr<uniform, f32, read> = access %camera, 6u |
| %39:f32 = load %38 |
| %40:ptr<uniform, f32, read> = access %camera, 7u |
| %41:f32 = load %40 |
| %42:f32 = sub %39, %41 |
| %43:ptr<uniform, f32, read> = access %camera, 7u |
| %44:f32 = load %43 |
| %45:f32 = fma %depthSample, %42, %44 |
| %46:f32 = div %37, %45 |
| ret %46 |
| } |
| } |
| %getTile = func(%fragCoord:vec4<f32>):vec3<u32> { |
| $B5: { |
| %49:ptr<uniform, f32, read> = access %camera, 7u |
| %50:f32 = load %49 |
| %51:ptr<uniform, f32, read> = access %camera, 6u |
| %52:f32 = load %51 |
| %53:f32 = div %50, %52 |
| %54:f32 = log2 %53 |
| %55:f32 = div 48.0f, %54 |
| %sliceScale:f32 = let %55 |
| %57:ptr<uniform, f32, read> = access %camera, 6u |
| %58:f32 = load %57 |
| %59:f32 = log2 %58 |
| %60:f32 = mul 48.0f, %59 |
| %61:f32 = let %60 |
| %62:ptr<uniform, f32, read> = access %camera, 7u |
| %63:f32 = load %62 |
| %64:ptr<uniform, f32, read> = access %camera, 6u |
| %65:f32 = load %64 |
| %66:f32 = div %63, %65 |
| %67:f32 = log2 %66 |
| %68:f32 = div %61, %67 |
| %69:f32 = negation %68 |
| %sliceBias:f32 = let %69 |
| %71:f32 = access %fragCoord, 2u |
| %72:f32 = call %linearDepth, %71 |
| %73:f32 = log2 %72 |
| %74:f32 = mul %73, %sliceScale |
| %75:f32 = add %74, %sliceBias |
| %76:f32 = max %75, 0.0f |
| %77:u32 = call %tint_f32_to_u32, %76 |
| %zTile:u32 = let %77 |
| %80:f32 = access %fragCoord, 0u |
| %81:ptr<uniform, vec2<f32>, read> = access %camera, 5u |
| %82:f32 = load_vector_element %81, 0u |
| %83:f32 = div %82, 32.0f |
| %84:f32 = div %80, %83 |
| %85:u32 = call %tint_f32_to_u32, %84 |
| %86:u32 = let %85 |
| %87:f32 = access %fragCoord, 1u |
| %88:ptr<uniform, vec2<f32>, read> = access %camera, 5u |
| %89:f32 = load_vector_element %88, 1u |
| %90:f32 = div %89, 18.0f |
| %91:f32 = div %87, %90 |
| %92:u32 = call %tint_f32_to_u32, %91 |
| %93:vec3<u32> = construct %86, %92, %zTile |
| ret %93 |
| } |
| } |
| %getClusterIndex = func(%fragCoord_1:vec4<f32>):u32 { # %fragCoord_1: 'fragCoord' |
| $B6: { |
| %96:vec3<u32> = call %getTile, %fragCoord_1 |
| %tile:vec3<u32> = let %96 |
| %98:u32 = access %tile, 0u |
| %99:u32 = access %tile, 1u |
| %100:u32 = mul %99, 32u |
| %101:u32 = add %98, %100 |
| %102:u32 = access %tile, 2u |
| %103:u32 = mul %102, 32u |
| %104:u32 = mul %103, 18u |
| %105:u32 = add %101, %104 |
| ret %105 |
| } |
| } |
| %dirLightVisibility = func(%worldPos:vec3<f32>):f32 { |
| $B7: { |
| %108:ptr<storage, i32, read> = access %lightShadowTable, 0u, 0u |
| %109:i32 = load %108 |
| %shadowIndex:i32 = let %109 |
| %111:bool = eq %shadowIndex, -1i |
| if %111 [t: $B8] { # if_1 |
| $B8: { # true |
| ret 1.0f |
| } |
| } |
| %112:ptr<storage, vec4<f32>, read> = access %shadow, 0u, %shadowIndex, 0u |
| %113:vec4<f32> = load %112 |
| %viewport:vec4<f32> = let %113 |
| %115:ptr<storage, mat4x4<f32>, read> = access %shadow, 0u, %shadowIndex, 1u |
| %116:mat4x4<f32> = load %115 |
| %117:mat4x4<f32> = let %116 |
| %118:vec4<f32> = construct %worldPos, 1.0f |
| %119:vec4<f32> = mul %117, %118 |
| %lightPos:vec4<f32> = let %119 |
| %121:vec2<f32> = swizzle %lightPos, xy |
| %122:f32 = access %lightPos, 3u |
| %123:vec2<f32> = div %121, %122 |
| %124:vec2<f32> = mul %123, vec2<f32>(0.5f, -0.5f) |
| %125:vec2<f32> = add %124, vec2<f32>(0.5f) |
| %126:f32 = access %lightPos, 2u |
| %127:f32 = access %lightPos, 3u |
| %128:f32 = div %126, %127 |
| %129:vec3<f32> = construct %125, %128 |
| %shadowPos:vec3<f32> = let %129 |
| %131:vec2<f32> = swizzle %viewport, xy |
| %132:vec2<f32> = swizzle %shadowPos, xy |
| %133:vec2<f32> = swizzle %viewport, zw |
| %134:vec2<f32> = mul %132, %133 |
| %135:vec2<f32> = add %131, %134 |
| %136:vec2<f32> = construct %135 |
| %viewportPos:vec2<f32> = let %136 |
| %138:texture_depth_2d = load %shadowTexture |
| %139:vec2<u32> = textureDimensions %138, 0i |
| %140:vec2<f32> = convert %139 |
| %141:vec2<f32> = div 1.0f, %140 |
| %texelSize:vec2<f32> = let %141 |
| %143:vec2<f32> = swizzle %viewport, xy |
| %144:vec2<f32> = sub %143, %texelSize |
| %145:vec2<f32> = swizzle %viewport, xy |
| %146:vec2<f32> = swizzle %viewport, zw |
| %147:vec2<f32> = add %145, %146 |
| %148:vec2<f32> = add %147, %texelSize |
| %149:vec4<f32> = construct %144, %148 |
| %clampRect:vec4<f32> = let %149 |
| %visibility:ptr<function, f32, read_write> = var, 0.0f |
| loop [i: $B9, b: $B10, c: $B11] { # loop_1 |
| $B9: { # initializer |
| %i:ptr<function, u32, read_write> = var, 0u |
| next_iteration # -> $B10 |
| } |
| $B10: { # body |
| %153:u32 = load %i |
| %154:bool = lt %153, 16u |
| if %154 [t: $B12, f: $B13] { # if_2 |
| $B12: { # true |
| exit_if # if_2 |
| } |
| $B13: { # false |
| exit_loop # loop_1 |
| } |
| } |
| %155:f32 = load %visibility |
| %156:f32 = let %155 |
| %157:texture_depth_2d = load %shadowTexture |
| %158:texture_depth_2d = let %157 |
| %159:sampler_comparison = load %shadowSampler |
| %160:sampler_comparison = let %159 |
| %161:u32 = load %i |
| %162:ptr<private, vec2<f32>, read_write> = access %shadowSampleOffsets, %161 |
| %163:vec2<f32> = load %162 |
| %164:vec2<f32> = mul %163, %texelSize |
| %165:vec2<f32> = add %viewportPos, %164 |
| %166:vec2<f32> = swizzle %clampRect, xy |
| %167:vec2<f32> = swizzle %clampRect, zw |
| %168:vec2<f32> = clamp %165, %166, %167 |
| %169:f32 = access %shadowPos, 2u |
| %170:f32 = sub %169, 0.00300000002607703209f |
| %171:f32 = textureSampleCompareLevel %158, %160, %168, %170 |
| %172:f32 = add %156, %171 |
| store %visibility, %172 |
| continue # -> $B11 |
| } |
| $B11: { # continuing |
| %173:u32 = load %i |
| %174:u32 = add %173, 1u |
| store %i, %174 |
| next_iteration # -> $B10 |
| } |
| } |
| %175:f32 = load %visibility |
| %176:f32 = div %175, 16.0f |
| ret %176 |
| } |
| } |
| %getCubeFace = func(%v:vec3<f32>):i32 { |
| $B14: { |
| %179:vec3<f32> = abs %v |
| %vAbs:vec3<f32> = let %179 |
| %181:f32 = access %vAbs, 2u |
| %182:f32 = access %vAbs, 0u |
| %183:bool = gte %181, %182 |
| %184:bool = if %183 [t: $B15, f: $B16] { # if_3 |
| $B15: { # true |
| %185:f32 = access %vAbs, 2u |
| %186:f32 = access %vAbs, 1u |
| %187:bool = gte %185, %186 |
| exit_if %187 # if_3 |
| } |
| $B16: { # false |
| exit_if false # if_3 |
| } |
| } |
| if %184 [t: $B17] { # if_4 |
| $B17: { # true |
| %188:f32 = access %v, 2u |
| %189:bool = lt %188, 0.0f |
| if %189 [t: $B18] { # if_5 |
| $B18: { # true |
| ret 5i |
| } |
| } |
| ret 4i |
| } |
| } |
| %190:f32 = access %vAbs, 1u |
| %191:f32 = access %vAbs, 0u |
| %192:bool = gte %190, %191 |
| if %192 [t: $B19] { # if_6 |
| $B19: { # true |
| %193:f32 = access %v, 1u |
| %194:bool = lt %193, 0.0f |
| if %194 [t: $B20] { # if_7 |
| $B20: { # true |
| ret 3i |
| } |
| } |
| ret 2i |
| } |
| } |
| %195:f32 = access %v, 0u |
| %196:bool = lt %195, 0.0f |
| if %196 [t: $B21] { # if_8 |
| $B21: { # true |
| ret 1i |
| } |
| } |
| ret 0i |
| } |
| } |
| %pointLightVisibility = func(%lightIndex:u32, %worldPos_1:vec3<f32>, %pointToLight:vec3<f32>):f32 { # %worldPos_1: 'worldPos' |
| $B22: { |
| %201:u32 = add %lightIndex, 1u |
| %202:ptr<storage, i32, read> = access %lightShadowTable, 0u, %201 |
| %203:i32 = load %202 |
| %shadowIndex_1:ptr<function, i32, read_write> = var, %203 # %shadowIndex_1: 'shadowIndex' |
| %205:i32 = load %shadowIndex_1 |
| %206:bool = eq %205, -1i |
| if %206 [t: $B23] { # if_9 |
| $B23: { # true |
| ret 1.0f |
| } |
| } |
| %207:i32 = load %shadowIndex_1 |
| %208:i32 = let %207 |
| %209:vec3<f32> = mul %pointToLight, -1.0f |
| %210:i32 = call %getCubeFace, %209 |
| %211:i32 = add %208, %210 |
| store %shadowIndex_1, %211 |
| %212:i32 = load %shadowIndex_1 |
| %213:ptr<storage, vec4<f32>, read> = access %shadow, 0u, %212, 0u |
| %214:vec4<f32> = load %213 |
| %viewport_1:vec4<f32> = let %214 # %viewport_1: 'viewport' |
| %216:i32 = load %shadowIndex_1 |
| %217:ptr<storage, mat4x4<f32>, read> = access %shadow, 0u, %216, 1u |
| %218:mat4x4<f32> = load %217 |
| %219:mat4x4<f32> = let %218 |
| %220:vec4<f32> = construct %worldPos_1, 1.0f |
| %221:vec4<f32> = mul %219, %220 |
| %lightPos_1:vec4<f32> = let %221 # %lightPos_1: 'lightPos' |
| %223:vec2<f32> = swizzle %lightPos_1, xy |
| %224:f32 = access %lightPos_1, 3u |
| %225:vec2<f32> = div %223, %224 |
| %226:vec2<f32> = mul %225, vec2<f32>(0.5f, -0.5f) |
| %227:vec2<f32> = add %226, vec2<f32>(0.5f) |
| %228:f32 = access %lightPos_1, 2u |
| %229:f32 = access %lightPos_1, 3u |
| %230:f32 = div %228, %229 |
| %231:vec3<f32> = construct %227, %230 |
| %shadowPos_1:vec3<f32> = let %231 # %shadowPos_1: 'shadowPos' |
| %233:vec2<f32> = swizzle %viewport_1, xy |
| %234:vec2<f32> = swizzle %shadowPos_1, xy |
| %235:vec2<f32> = swizzle %viewport_1, zw |
| %236:vec2<f32> = mul %234, %235 |
| %237:vec2<f32> = add %233, %236 |
| %238:vec2<f32> = construct %237 |
| %viewportPos_1:vec2<f32> = let %238 # %viewportPos_1: 'viewportPos' |
| %240:texture_depth_2d = load %shadowTexture |
| %241:vec2<u32> = textureDimensions %240, 0i |
| %242:vec2<f32> = convert %241 |
| %243:vec2<f32> = div 1.0f, %242 |
| %texelSize_1:vec2<f32> = let %243 # %texelSize_1: 'texelSize' |
| %245:vec2<f32> = swizzle %viewport_1, xy |
| %246:vec2<f32> = swizzle %viewport_1, xy |
| %247:vec2<f32> = swizzle %viewport_1, zw |
| %248:vec2<f32> = add %246, %247 |
| %249:vec4<f32> = construct %245, %248 |
| %clampRect_1:vec4<f32> = let %249 # %clampRect_1: 'clampRect' |
| %visibility_1:ptr<function, f32, read_write> = var, 0.0f # %visibility_1: 'visibility' |
| loop [i: $B24, b: $B25, c: $B26] { # loop_2 |
| $B24: { # initializer |
| %i_1:ptr<function, u32, read_write> = var, 0u # %i_1: 'i' |
| next_iteration # -> $B25 |
| } |
| $B25: { # body |
| %253:u32 = load %i_1 |
| %254:bool = lt %253, 16u |
| if %254 [t: $B27, f: $B28] { # if_10 |
| $B27: { # true |
| exit_if # if_10 |
| } |
| $B28: { # false |
| exit_loop # loop_2 |
| } |
| } |
| %255:f32 = load %visibility_1 |
| %256:f32 = let %255 |
| %257:texture_depth_2d = load %shadowTexture |
| %258:texture_depth_2d = let %257 |
| %259:sampler_comparison = load %shadowSampler |
| %260:sampler_comparison = let %259 |
| %261:u32 = load %i_1 |
| %262:ptr<private, vec2<f32>, read_write> = access %shadowSampleOffsets, %261 |
| %263:vec2<f32> = load %262 |
| %264:vec2<f32> = mul %263, %texelSize_1 |
| %265:vec2<f32> = add %viewportPos_1, %264 |
| %266:vec2<f32> = swizzle %clampRect_1, xy |
| %267:vec2<f32> = swizzle %clampRect_1, zw |
| %268:vec2<f32> = clamp %265, %266, %267 |
| %269:f32 = access %shadowPos_1, 2u |
| %270:f32 = sub %269, 0.00999999977648258209f |
| %271:f32 = textureSampleCompareLevel %258, %260, %268, %270 |
| %272:f32 = add %256, %271 |
| store %visibility_1, %272 |
| continue # -> $B26 |
| } |
| $B26: { # continuing |
| %273:u32 = load %i_1 |
| %274:u32 = add %273, 1u |
| store %i_1, %274 |
| next_iteration # -> $B25 |
| } |
| } |
| %275:f32 = load %visibility_1 |
| %276:f32 = div %275, 16.0f |
| ret %276 |
| } |
| } |
| %GetSurfaceInfo = func(%input:VertexOutput):SurfaceInfo { |
| $B29: { |
| %surface:ptr<function, SurfaceInfo, read_write> = var |
| %280:ptr<function, vec3<f32>, read_write> = access %surface, 8u |
| %281:vec3<f32> = access %input, 2u |
| %282:vec3<f32> = normalize %281 |
| store %280, %282 |
| %283:vec3<f32> = access %input, 8u |
| %284:vec3<f32> = access %input, 9u |
| %285:vec3<f32> = access %input, 7u |
| %286:mat3x3<f32> = construct %283, %284, %285 |
| %tbn:mat3x3<f32> = let %286 |
| %288:texture_2d<f32> = load %normalTexture |
| %289:sampler = load %normalSampler |
| %290:vec2<f32> = access %input, 3u |
| %291:vec4<f32> = textureSample %288, %289, %290 |
| %292:vec3<f32> = swizzle %291, xyz |
| %normalMap:vec3<f32> = let %292 |
| %294:ptr<function, vec3<f32>, read_write> = access %surface, 4u |
| %295:vec3<f32> = mul 2.0f, %normalMap |
| %296:vec3<f32> = sub %295, vec3<f32>(1.0f) |
| %297:vec3<f32> = mul %tbn, %296 |
| %298:vec3<f32> = normalize %297 |
| store %294, %298 |
| %299:texture_2d<f32> = load %baseColorTexture |
| %300:sampler = load %baseColorSampler |
| %301:vec2<f32> = access %input, 3u |
| %302:vec4<f32> = textureSample %299, %300, %301 |
| %baseColorMap:vec4<f32> = let %302 |
| %304:ptr<function, vec4<f32>, read_write> = access %surface, 0u |
| %305:vec4<f32> = access %input, 5u |
| %306:ptr<uniform, vec4<f32>, read> = access %material, 0u |
| %307:vec4<f32> = load %306 |
| %308:vec4<f32> = mul %305, %307 |
| %309:vec4<f32> = mul %308, %baseColorMap |
| store %304, %309 |
| %310:ptr<function, vec4<f32>, read_write> = access %surface, 0u |
| %311:f32 = load_vector_element %310, 3u |
| %312:ptr<uniform, f32, read> = access %material, 4u |
| %313:f32 = load %312 |
| %314:bool = lt %311, %313 |
| if %314 [t: $B30] { # if_11 |
| $B30: { # true |
| exit_if # if_11 |
| } |
| } |
| %315:ptr<function, vec3<f32>, read_write> = access %surface, 1u |
| %316:ptr<function, vec4<f32>, read_write> = access %surface, 0u |
| %317:vec4<f32> = load %316 |
| %318:vec3<f32> = swizzle %317, xyz |
| store %315, %318 |
| %319:texture_2d<f32> = load %metallicRoughnessTexture |
| %320:sampler = load %metallicRoughnessSampler |
| %321:vec2<f32> = access %input, 3u |
| %322:vec4<f32> = textureSample %319, %320, %321 |
| %metallicRoughnessMap:vec4<f32> = let %322 |
| %324:ptr<function, f32, read_write> = access %surface, 2u |
| %325:ptr<uniform, vec2<f32>, read> = access %material, 3u |
| %326:f32 = load_vector_element %325, 0u |
| %327:f32 = access %metallicRoughnessMap, 2u |
| %328:f32 = mul %326, %327 |
| store %324, %328 |
| %329:ptr<function, f32, read_write> = access %surface, 3u |
| %330:ptr<uniform, vec2<f32>, read> = access %material, 3u |
| %331:f32 = load_vector_element %330, 1u |
| %332:f32 = access %metallicRoughnessMap, 1u |
| %333:f32 = mul %331, %332 |
| store %329, %333 |
| %dielectricSpec:vec3<f32> = let vec3<f32>(0.03999999910593032837f) |
| %335:ptr<function, vec3<f32>, read_write> = access %surface, 5u |
| %336:ptr<function, vec3<f32>, read_write> = access %surface, 1u |
| %337:vec3<f32> = load %336 |
| %338:vec3<f32> = let %337 |
| %339:ptr<function, f32, read_write> = access %surface, 2u |
| %340:f32 = load %339 |
| %341:vec3<f32> = construct %340 |
| %342:vec3<f32> = mix %dielectricSpec, %338, %341 |
| store %335, %342 |
| %343:texture_2d<f32> = load %occlusionTexture |
| %344:sampler = load %occlusionSampler |
| %345:vec2<f32> = access %input, 3u |
| %346:vec4<f32> = textureSample %343, %344, %345 |
| %occlusionMap:vec4<f32> = let %346 |
| %348:ptr<function, f32, read_write> = access %surface, 6u |
| %349:ptr<uniform, f32, read> = access %material, 2u |
| %350:f32 = load %349 |
| %351:f32 = access %occlusionMap, 0u |
| %352:f32 = mul %350, %351 |
| store %348, %352 |
| %353:texture_2d<f32> = load %emissiveTexture |
| %354:sampler = load %emissiveSampler |
| %355:vec2<f32> = access %input, 3u |
| %356:vec4<f32> = textureSample %353, %354, %355 |
| %emissiveMap:vec4<f32> = let %356 |
| %358:ptr<function, vec3<f32>, read_write> = access %surface, 7u |
| %359:ptr<uniform, vec3<f32>, read> = access %material, 1u |
| %360:vec3<f32> = load %359 |
| %361:vec3<f32> = swizzle %emissiveMap, xyz |
| %362:vec3<f32> = mul %360, %361 |
| store %358, %362 |
| %363:f32 = access %input, 6u, 3u |
| %364:bool = eq %363, 0.0f |
| if %364 [t: $B31, f: $B32] { # if_12 |
| $B31: { # true |
| %365:ptr<function, vec3<f32>, read_write> = access %surface, 1u |
| %366:ptr<function, vec3<f32>, read_write> = access %surface, 1u |
| %367:vec3<f32> = load %366 |
| %368:vec4<f32> = access %input, 6u |
| %369:vec3<f32> = swizzle %368, xyz |
| %370:vec3<f32> = add %367, %369 |
| store %365, %370 |
| exit_if # if_12 |
| } |
| $B32: { # false |
| %371:ptr<function, vec3<f32>, read_write> = access %surface, 1u |
| %372:ptr<function, vec3<f32>, read_write> = access %surface, 1u |
| %373:vec3<f32> = load %372 |
| %374:vec4<f32> = access %input, 6u |
| %375:vec3<f32> = swizzle %374, xyz |
| %376:vec3<f32> = mul %373, %375 |
| store %371, %376 |
| exit_if # if_12 |
| } |
| } |
| %377:SurfaceInfo = load %surface |
| ret %377 |
| } |
| } |
| %FresnelSchlick = func(%cosTheta:f32, %F0:vec3<f32>):vec3<f32> { |
| $B33: { |
| %381:vec3<f32> = sub vec3<f32>(1.0f), %F0 |
| %382:f32 = sub 1.0f, %cosTheta |
| %383:f32 = pow %382, 5.0f |
| %384:vec3<f32> = mul %381, %383 |
| %385:vec3<f32> = add %F0, %384 |
| ret %385 |
| } |
| } |
| %DistributionGGX = func(%N:vec3<f32>, %H:vec3<f32>, %roughness:f32):f32 { |
| $B34: { |
| %390:f32 = mul %roughness, %roughness |
| %a:f32 = let %390 |
| %392:f32 = mul %a, %a |
| %a2:f32 = let %392 |
| %394:f32 = dot %N, %H |
| %395:f32 = max %394, 0.0f |
| %NdotH:f32 = let %395 |
| %397:f32 = mul %NdotH, %NdotH |
| %NdotH2:f32 = let %397 |
| %num:f32 = let %a2 |
| %400:f32 = sub %a2, 1.0f |
| %401:f32 = mul %NdotH2, %400 |
| %402:f32 = add %401, 1.0f |
| %denom:f32 = let %402 |
| %404:f32 = mul 3.14159274101257324219f, %denom |
| %405:f32 = mul %404, %denom |
| %406:f32 = div %num, %405 |
| ret %406 |
| } |
| } |
| %GeometrySchlickGGX = func(%NdotV:f32, %roughness_1:f32):f32 { # %roughness_1: 'roughness' |
| $B35: { |
| %410:f32 = add %roughness_1, 1.0f |
| %r:f32 = let %410 |
| %412:f32 = mul %r, %r |
| %413:f32 = div %412, 8.0f |
| %k:f32 = let %413 |
| %num_1:f32 = let %NdotV # %num_1: 'num' |
| %416:f32 = sub 1.0f, %k |
| %417:f32 = mul %NdotV, %416 |
| %418:f32 = add %417, %k |
| %denom_1:f32 = let %418 # %denom_1: 'denom' |
| %420:f32 = div %num_1, %denom_1 |
| ret %420 |
| } |
| } |
| %GeometrySmith = func(%N_1:vec3<f32>, %V:vec3<f32>, %L:vec3<f32>, %roughness_2:f32):f32 { # %N_1: 'N', %roughness_2: 'roughness' |
| $B36: { |
| %426:f32 = dot %N_1, %V |
| %427:f32 = max %426, 0.0f |
| %NdotV_1:f32 = let %427 # %NdotV_1: 'NdotV' |
| %429:f32 = dot %N_1, %L |
| %430:f32 = max %429, 0.0f |
| %NdotL:f32 = let %430 |
| %432:f32 = call %GeometrySchlickGGX, %NdotV_1, %roughness_2 |
| %ggx2:f32 = let %432 |
| %434:f32 = call %GeometrySchlickGGX, %NdotL, %roughness_2 |
| %ggx1:f32 = let %434 |
| %436:f32 = mul %ggx1, %ggx2 |
| ret %436 |
| } |
| } |
| %lightAttenuation = func(%light:PuctualLight):f32 { |
| $B37: { |
| %439:u32 = access %light, 0u |
| %440:bool = eq %439, 2u |
| if %440 [t: $B38] { # if_13 |
| $B38: { # true |
| ret 1.0f |
| } |
| } |
| %441:vec3<f32> = access %light, 1u |
| %442:f32 = length %441 |
| %distance:f32 = let %442 |
| %444:f32 = access %light, 2u |
| %445:bool = lte %444, 0.0f |
| if %445 [t: $B39] { # if_14 |
| $B39: { # true |
| %446:f32 = pow %distance, 2.0f |
| %447:f32 = div 1.0f, %446 |
| ret %447 |
| } |
| } |
| %448:f32 = access %light, 2u |
| %449:f32 = div %distance, %448 |
| %450:f32 = pow %449, 4.0f |
| %451:f32 = sub 1.0f, %450 |
| %452:f32 = clamp %451, 0.0f, 1.0f |
| %453:f32 = let %452 |
| %454:f32 = pow %distance, 2.0f |
| %455:f32 = div %453, %454 |
| ret %455 |
| } |
| } |
| %lightRadiance = func(%light_1:PuctualLight, %surface_1:SurfaceInfo):vec3<f32> { # %light_1: 'light', %surface_1: 'surface' |
| $B40: { |
| %459:vec3<f32> = access %light_1, 1u |
| %460:vec3<f32> = normalize %459 |
| %L_1:vec3<f32> = let %460 # %L_1: 'L' |
| %462:vec3<f32> = access %surface_1, 8u |
| %463:vec3<f32> = add %462, %L_1 |
| %464:vec3<f32> = normalize %463 |
| %H_1:vec3<f32> = let %464 # %H_1: 'H' |
| %466:vec3<f32> = access %surface_1, 4u |
| %467:f32 = access %surface_1, 3u |
| %468:f32 = call %DistributionGGX, %466, %H_1, %467 |
| %NDF:f32 = let %468 |
| %470:vec3<f32> = access %surface_1, 4u |
| %471:vec3<f32> = access %surface_1, 8u |
| %472:f32 = access %surface_1, 3u |
| %473:f32 = call %GeometrySmith, %470, %471, %L_1, %472 |
| %G:f32 = let %473 |
| %475:vec3<f32> = access %surface_1, 8u |
| %476:f32 = dot %H_1, %475 |
| %477:f32 = max %476, 0.0f |
| %478:vec3<f32> = access %surface_1, 5u |
| %479:vec3<f32> = call %FresnelSchlick, %477, %478 |
| %F:vec3<f32> = let %479 |
| %481:vec3<f32> = sub vec3<f32>(1.0f), %F |
| %482:f32 = access %surface_1, 2u |
| %483:f32 = sub 1.0f, %482 |
| %484:vec3<f32> = mul %481, %483 |
| %kD:vec3<f32> = let %484 |
| %486:vec3<f32> = access %surface_1, 4u |
| %487:f32 = dot %486, %L_1 |
| %488:f32 = max %487, 0.0f |
| %NdotL_1:f32 = let %488 # %NdotL_1: 'NdotL' |
| %490:f32 = mul %NDF, %G |
| %491:vec3<f32> = mul %490, %F |
| %numerator:vec3<f32> = let %491 |
| %493:vec3<f32> = access %surface_1, 4u |
| %494:vec3<f32> = access %surface_1, 8u |
| %495:f32 = dot %493, %494 |
| %496:f32 = max %495, 0.0f |
| %497:f32 = mul 4.0f, %496 |
| %498:f32 = mul %497, %NdotL_1 |
| %499:f32 = max %498, 0.00100000004749745131f |
| %denominator:f32 = let %499 |
| %501:vec3<f32> = construct %denominator |
| %502:vec3<f32> = div %numerator, %501 |
| %specular:vec3<f32> = let %502 |
| %504:vec3<f32> = access %light_1, 3u |
| %505:f32 = access %light_1, 4u |
| %506:vec3<f32> = mul %504, %505 |
| %507:f32 = call %lightAttenuation, %light_1 |
| %508:vec3<f32> = mul %506, %507 |
| %radiance:vec3<f32> = let %508 |
| %510:vec3<f32> = access %surface_1, 1u |
| %511:vec3<f32> = mul %kD, %510 |
| %512:vec3<f32> = div %511, vec3<f32>(3.14159274101257324219f) |
| %513:vec3<f32> = add %512, %specular |
| %514:vec3<f32> = mul %513, %radiance |
| %515:vec3<f32> = mul %514, %NdotL_1 |
| ret %515 |
| } |
| } |
| %fragmentMain = @fragment func(%input_1:VertexOutput):FragmentOutput { # %input_1: 'input' |
| $B41: { |
| %518:SurfaceInfo = call %GetSurfaceInfo, %input_1 |
| %surface_2:SurfaceInfo = let %518 # %surface_2: 'surface' |
| %Lo:ptr<function, vec3<f32>, read_write> = var, vec3<f32>(0.0f) |
| %521:ptr<storage, f32, read> = access %globalLights, 2u |
| %522:f32 = load %521 |
| %523:bool = gt %522, 0.0f |
| if %523 [t: $B42] { # if_15 |
| $B42: { # true |
| %light_2:ptr<function, PuctualLight, read_write> = var # %light_2: 'light' |
| %525:ptr<function, u32, read_write> = access %light_2, 0u |
| store %525, 2u |
| %526:ptr<function, vec3<f32>, read_write> = access %light_2, 1u |
| %527:ptr<storage, vec3<f32>, read> = access %globalLights, 3u |
| %528:vec3<f32> = load %527 |
| store %526, %528 |
| %529:ptr<function, vec3<f32>, read_write> = access %light_2, 3u |
| %530:ptr<storage, vec3<f32>, read> = access %globalLights, 1u |
| %531:vec3<f32> = load %530 |
| store %529, %531 |
| %532:ptr<function, f32, read_write> = access %light_2, 4u |
| %533:ptr<storage, f32, read> = access %globalLights, 2u |
| %534:f32 = load %533 |
| store %532, %534 |
| %535:vec3<f32> = access %input_1, 1u |
| %536:f32 = call %dirLightVisibility, %535 |
| %lightVis:f32 = let %536 |
| %538:vec3<f32> = load %Lo |
| %539:vec3<f32> = let %538 |
| %540:PuctualLight = load %light_2 |
| %541:vec3<f32> = call %lightRadiance, %540, %surface_2 |
| %542:vec3<f32> = mul %541, %lightVis |
| %543:vec3<f32> = add %539, %542 |
| store %Lo, %543 |
| exit_if # if_15 |
| } |
| } |
| %544:vec4<f32> = access %input_1, 0u |
| %545:u32 = call %getClusterIndex, %544 |
| %clusterIndex:u32 = let %545 |
| %547:ptr<storage, u32, read> = access %clusterLights, 1u, %clusterIndex, 0u |
| %548:u32 = load %547 |
| %lightOffset:u32 = let %548 |
| %550:ptr<storage, u32, read> = access %clusterLights, 1u, %clusterIndex, 1u |
| %551:u32 = load %550 |
| %lightCount:u32 = let %551 |
| loop [i: $B43, b: $B44, c: $B45] { # loop_3 |
| $B43: { # initializer |
| %lightIndex_1:ptr<function, u32, read_write> = var, 0u # %lightIndex_1: 'lightIndex' |
| next_iteration # -> $B44 |
| } |
| $B44: { # body |
| %554:u32 = load %lightIndex_1 |
| %555:bool = lt %554, %lightCount |
| if %555 [t: $B46, f: $B47] { # if_16 |
| $B46: { # true |
| exit_if # if_16 |
| } |
| $B47: { # false |
| exit_loop # loop_3 |
| } |
| } |
| %556:u32 = load %lightIndex_1 |
| %557:u32 = add %lightOffset, %556 |
| %558:ptr<storage, u32, read> = access %clusterLights, 2u, %557 |
| %559:u32 = load %558 |
| %i_2:u32 = let %559 # %i_2: 'i' |
| %light_3:ptr<function, PuctualLight, read_write> = var # %light_3: 'light' |
| %562:ptr<function, u32, read_write> = access %light_3, 0u |
| store %562, 0u |
| %563:ptr<function, vec3<f32>, read_write> = access %light_3, 1u |
| %564:ptr<storage, vec3<f32>, read> = access %globalLights, 5u, %i_2, 0u |
| %565:vec3<f32> = load %564 |
| %566:vec3<f32> = swizzle %565, xyz |
| %567:vec3<f32> = access %input_1, 1u |
| %568:vec3<f32> = sub %566, %567 |
| store %563, %568 |
| %569:ptr<function, f32, read_write> = access %light_3, 2u |
| %570:ptr<storage, f32, read> = access %globalLights, 5u, %i_2, 1u |
| %571:f32 = load %570 |
| store %569, %571 |
| %572:ptr<function, vec3<f32>, read_write> = access %light_3, 3u |
| %573:ptr<storage, vec3<f32>, read> = access %globalLights, 5u, %i_2, 2u |
| %574:vec3<f32> = load %573 |
| store %572, %574 |
| %575:ptr<function, f32, read_write> = access %light_3, 4u |
| %576:ptr<storage, f32, read> = access %globalLights, 5u, %i_2, 3u |
| %577:f32 = load %576 |
| store %575, %577 |
| %578:vec3<f32> = access %input_1, 1u |
| %579:ptr<function, vec3<f32>, read_write> = access %light_3, 1u |
| %580:vec3<f32> = load %579 |
| %581:f32 = call %pointLightVisibility, %i_2, %578, %580 |
| %lightVis_1:f32 = let %581 # %lightVis_1: 'lightVis' |
| %583:vec3<f32> = load %Lo |
| %584:vec3<f32> = let %583 |
| %585:PuctualLight = load %light_3 |
| %586:vec3<f32> = call %lightRadiance, %585, %surface_2 |
| %587:vec3<f32> = mul %586, %lightVis_1 |
| %588:vec3<f32> = add %584, %587 |
| store %Lo, %588 |
| continue # -> $B45 |
| } |
| $B45: { # continuing |
| %589:u32 = load %lightIndex_1 |
| %590:u32 = add %589, 1u |
| store %lightIndex_1, %590 |
| next_iteration # -> $B44 |
| } |
| } |
| %591:vec4<f32> = access %input_1, 0u |
| %592:vec2<f32> = swizzle %591, xy |
| %593:texture_2d<f32> = load %ssaoTexture |
| %594:vec2<u32> = textureDimensions %593 |
| %595:vec2<u32> = swizzle %594, xy |
| %596:vec2<f32> = convert %595 |
| %597:vec2<f32> = div %592, %596 |
| %ssaoCoord:vec2<f32> = let %597 |
| %599:texture_2d<f32> = load %ssaoTexture |
| %600:sampler = load %defaultSampler |
| %601:vec4<f32> = textureSample %599, %600, %ssaoCoord |
| %602:f32 = access %601, 0u |
| %ssaoFactor:f32 = let %602 |
| %604:ptr<storage, vec3<f32>, read> = access %globalLights, 0u |
| %605:vec3<f32> = load %604 |
| %606:vec3<f32> = access %surface_2, 1u |
| %607:vec3<f32> = mul %605, %606 |
| %608:f32 = access %surface_2, 6u |
| %609:vec3<f32> = mul %607, %608 |
| %610:vec3<f32> = mul %609, %ssaoFactor |
| %ambient:vec3<f32> = let %610 |
| %612:vec3<f32> = load %Lo |
| %613:vec3<f32> = add %612, %ambient |
| %614:vec3<f32> = access %surface_2, 7u |
| %615:vec3<f32> = add %613, %614 |
| %616:vec3<f32> = call %linearTosRGB, %615 |
| %color:vec3<f32> = let %616 |
| %out:ptr<function, FragmentOutput, read_write> = var |
| %619:ptr<function, vec4<f32>, read_write> = access %out, 0u |
| %620:f32 = access %surface_2, 0u, 3u |
| %621:vec4<f32> = construct %color, %620 |
| store %619, %621 |
| %622:ptr<function, vec4<f32>, read_write> = access %out, 1u |
| %623:vec3<f32> = access %surface_2, 7u |
| %624:f32 = access %surface_2, 0u, 3u |
| %625:vec4<f32> = construct %623, %624 |
| store %622, %625 |
| %626:FragmentOutput = load %out |
| ret %626 |
| } |
| } |
| %tint_f32_to_u32 = func(%value:f32):u32 { |
| $B48: { |
| %628:u32 = convert %value |
| %629:bool = gte %value, 0.0f |
| %630:u32 = select 0u, %628, %629 |
| %631:bool = lte %value, 4294967040.0f |
| %632:u32 = select 4294967295u, %630, %631 |
| ret %632 |
| } |
| } |
| |
| unhandled variable address space |
| ******************************************************************** |
| * The tint shader compiler has encountered an unexpected error. * |
| * * |
| * Please help us fix this issue by submitting a bug report at * |
| * crbug.com/tint with the source program that triggered the bug. * |
| ******************************************************************** |
