| SKIP: FAILED |
| |
| <dawn>/src/tint/lang/msl/writer/printer/printer.cc:355 internal compiler error: LeftOver = struct @align(16) { |
| u_World:mat4x4<f32> @offset(0) |
| u_ViewProjection:mat4x4<f32> @offset(64) |
| u_bumpStrength:f32 @offset(128) |
| padding:u32 @offset(132) |
| u_cameraPosition:vec3<f32> @offset(144) |
| u_parallaxScale:f32 @offset(156) |
| textureInfoName:f32 @offset(160) |
| padding_1:u32 @offset(164) |
| tangentSpaceParameter0:vec2<f32> @offset(168) |
| } |
| |
| Light0 = struct @align(16) { |
| vLightData:vec4<f32> @offset(0) |
| vLightDiffuse:vec4<f32> @offset(16) |
| vLightSpecular:vec4<f32> @offset(32) |
| vLightGround:vec3<f32> @offset(48) |
| padding_2:u32 @offset(60) |
| shadowsInfo:vec4<f32> @offset(64) |
| depthValues:vec2<f32> @offset(80) |
| } |
| |
| lightingInfo = struct @align(16) { |
| diffuse:vec3<f32> @offset(0) |
| specular:vec3<f32> @offset(16) |
| } |
| |
| main_out = struct @align(16) { |
| glFragColor_1:vec4<f32> @offset(0), @location(0) |
| } |
| |
| %b1 = block { # root |
| %u_Float:ptr<private, f32, read_write> = var |
| %u_Color:ptr<private, vec3<f32>, read_write> = var |
| %TextureSamplerTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(2, 1) |
| %TextureSamplerSampler:ptr<handle, sampler, read> = var @binding_point(2, 0) |
| %vMainuv:ptr<private, vec2<f32>, read_write> = var |
| %x_269:ptr<uniform, LeftOver, read> = var @binding_point(2, 6) |
| %v_output1:ptr<private, vec4<f32>, read_write> = var |
| %gl_FrontFacing:ptr<private, bool, read_write> = var |
| %v_uv:ptr<private, vec2<f32>, read_write> = var |
| %v_output2:ptr<private, vec4<f32>, read_write> = var |
| %TextureSampler1Texture:ptr<handle, texture_2d<f32>, read> = var @binding_point(2, 3) |
| %TextureSampler1Sampler:ptr<handle, sampler, read> = var @binding_point(2, 2) |
| %light0:ptr<uniform, Light0, read> = var @binding_point(0, 5) |
| %glFragColor:ptr<private, vec4<f32>, read_write> = var |
| %bumpSamplerSampler:ptr<handle, sampler, read> = var @binding_point(2, 4) |
| %bumpSamplerTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(2, 5) |
| } |
| |
| %cotangent_frame_vf3_vf3_vf2_vf2_ = func(%normal_1:ptr<function, vec3<f32>, read_write>, %p:ptr<function, vec3<f32>, read_write>, %uv:ptr<function, vec2<f32>, read_write>, %tangentSpaceParams:ptr<function, vec2<f32>, read_write>):mat3x3<f32> -> %b2 { |
| %b2 = block { |
| %dp1:ptr<function, vec3<f32>, read_write> = var |
| %dp2:ptr<function, vec3<f32>, read_write> = var |
| %duv1:ptr<function, vec2<f32>, read_write> = var |
| %duv2:ptr<function, vec2<f32>, read_write> = var |
| %dp2perp:ptr<function, vec3<f32>, read_write> = var |
| %dp1perp:ptr<function, vec3<f32>, read_write> = var |
| %tangent:ptr<function, vec3<f32>, read_write> = var |
| %bitangent:ptr<function, vec3<f32>, read_write> = var |
| %invmax:ptr<function, f32, read_write> = var |
| %x_133:vec3<f32> = load %p |
| %32:vec3<f32> = dpdx %x_133 |
| store %dp1, %32 |
| %x_136:vec3<f32> = load %p |
| %34:vec3<f32> = dpdy %x_136 |
| store %dp2, %34 |
| %x_139:vec2<f32> = load %uv |
| %36:vec2<f32> = dpdx %x_139 |
| store %duv1, %36 |
| %x_142:vec2<f32> = load %uv |
| %38:vec2<f32> = dpdy %x_142 |
| store %duv2, %38 |
| %x_145:vec3<f32> = load %dp2 |
| %x_146:vec3<f32> = load %normal_1 |
| %41:vec3<f32> = cross %x_145, %x_146 |
| store %dp2perp, %41 |
| %x_149:vec3<f32> = load %normal_1 |
| %x_150:vec3<f32> = load %dp1 |
| %44:vec3<f32> = cross %x_149, %x_150 |
| store %dp1perp, %44 |
| %x_153:vec3<f32> = load %dp2perp |
| %x_155:f32 = load_vector_element %duv1, 0u |
| %x_157:vec3<f32> = load %dp1perp |
| %x_159:f32 = load_vector_element %duv2, 0u |
| %49:vec3<f32> = mul %x_153, %x_155 |
| %50:vec3<f32> = mul %x_157, %x_159 |
| %51:vec3<f32> = add %49, %50 |
| store %tangent, %51 |
| %x_163:vec3<f32> = load %dp2perp |
| %x_165:f32 = load_vector_element %duv1, 1u |
| %x_167:vec3<f32> = load %dp1perp |
| %x_169:f32 = load_vector_element %duv2, 1u |
| %56:vec3<f32> = mul %x_163, %x_165 |
| %57:vec3<f32> = mul %x_167, %x_169 |
| %58:vec3<f32> = add %56, %57 |
| store %bitangent, %58 |
| %x_173:f32 = load_vector_element %tangentSpaceParams, 0u |
| %x_174:vec3<f32> = load %tangent |
| %61:vec3<f32> = mul %x_174, %x_173 |
| store %tangent, %61 |
| %x_177:f32 = load_vector_element %tangentSpaceParams, 1u |
| %x_178:vec3<f32> = load %bitangent |
| %64:vec3<f32> = mul %x_178, %x_177 |
| store %bitangent, %64 |
| %x_181:vec3<f32> = load %tangent |
| %x_182:vec3<f32> = load %tangent |
| %x_184:vec3<f32> = load %bitangent |
| %x_185:vec3<f32> = load %bitangent |
| %69:f32 = dot %x_181, %x_182 |
| %70:f32 = dot %x_184, %x_185 |
| %71:f32 = max %69, %70 |
| %72:f32 = inverseSqrt %71 |
| store %invmax, %72 |
| %x_189:vec3<f32> = load %tangent |
| %x_190:f32 = load %invmax |
| %x_191:vec3<f32> = mul %x_189, %x_190 |
| %x_192:vec3<f32> = load %bitangent |
| %x_193:f32 = load %invmax |
| %x_194:vec3<f32> = mul %x_192, %x_193 |
| %x_195:vec3<f32> = load %normal_1 |
| %80:f32 = access %x_191, 0u |
| %81:f32 = access %x_191, 1u |
| %82:f32 = access %x_191, 2u |
| %83:vec3<f32> = construct %80, %81, %82 |
| %84:f32 = access %x_194, 0u |
| %85:f32 = access %x_194, 1u |
| %86:f32 = access %x_194, 2u |
| %87:vec3<f32> = construct %84, %85, %86 |
| %88:f32 = access %x_195, 0u |
| %89:f32 = access %x_195, 1u |
| %90:f32 = access %x_195, 2u |
| %91:vec3<f32> = construct %88, %89, %90 |
| %92:mat3x3<f32> = construct %83, %87, %91 |
| ret %92 |
| } |
| } |
| %transposeMat3_mf33_ = func(%inMatrix:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> -> %b3 { |
| %b3 = block { |
| %i0:ptr<function, vec3<f32>, read_write> = var |
| %i1:ptr<function, vec3<f32>, read_write> = var |
| %i2:ptr<function, vec3<f32>, read_write> = var |
| %outMatrix:ptr<function, mat3x3<f32>, read_write> = var |
| %99:ptr<function, vec3<f32>, read_write> = access %inMatrix, 0i |
| %x_60:vec3<f32> = load %99 |
| store %i0, %x_60 |
| %101:ptr<function, vec3<f32>, read_write> = access %inMatrix, 1i |
| %x_64:vec3<f32> = load %101 |
| store %i1, %x_64 |
| %103:ptr<function, vec3<f32>, read_write> = access %inMatrix, 2i |
| %x_68:vec3<f32> = load %103 |
| store %i2, %x_68 |
| %x_73:f32 = load_vector_element %i0, 0u |
| %x_75:f32 = load_vector_element %i1, 0u |
| %x_77:f32 = load_vector_element %i2, 0u |
| %x_78:vec3<f32> = construct %x_73, %x_75, %x_77 |
| %x_81:f32 = load_vector_element %i0, 1u |
| %x_83:f32 = load_vector_element %i1, 1u |
| %x_85:f32 = load_vector_element %i2, 1u |
| %x_86:vec3<f32> = construct %x_81, %x_83, %x_85 |
| %x_89:f32 = load_vector_element %i0, 2u |
| %x_91:f32 = load_vector_element %i1, 2u |
| %x_93:f32 = load_vector_element %i2, 2u |
| %x_94:vec3<f32> = construct %x_89, %x_91, %x_93 |
| %117:f32 = access %x_78, 0u |
| %118:f32 = access %x_78, 1u |
| %119:f32 = access %x_78, 2u |
| %120:vec3<f32> = construct %117, %118, %119 |
| %121:f32 = access %x_86, 0u |
| %122:f32 = access %x_86, 1u |
| %123:f32 = access %x_86, 2u |
| %124:vec3<f32> = construct %121, %122, %123 |
| %125:f32 = access %x_94, 0u |
| %126:f32 = access %x_94, 1u |
| %127:f32 = access %x_94, 2u |
| %128:vec3<f32> = construct %125, %126, %127 |
| %129:mat3x3<f32> = construct %120, %124, %128 |
| store %outMatrix, %129 |
| %x_110:mat3x3<f32> = load %outMatrix |
| ret %x_110 |
| } |
| } |
| %perturbNormalBase_mf33_vf3_f1_ = func(%cotangentFrame:ptr<function, mat3x3<f32>, read_write>, %normal:ptr<function, vec3<f32>, read_write>, %scale:ptr<function, f32, read_write>):vec3<f32> -> %b4 { |
| %b4 = block { |
| %x_113:mat3x3<f32> = load %cotangentFrame |
| %x_114:vec3<f32> = load %normal |
| %137:vec3<f32> = mul %x_113, %x_114 |
| %138:vec3<f32> = normalize %137 |
| ret %138 |
| } |
| } |
| %perturbNormal_mf33_vf3_f1_ = func(%cotangentFrame_1:ptr<function, mat3x3<f32>, read_write>, %textureSample:ptr<function, vec3<f32>, read_write>, %scale_1:ptr<function, f32, read_write>):vec3<f32> -> %b5 { |
| %b5 = block { |
| %param:ptr<function, mat3x3<f32>, read_write> = var |
| %param_1:ptr<function, vec3<f32>, read_write> = var |
| %param_2:ptr<function, f32, read_write> = var |
| %x_119:vec3<f32> = load %textureSample |
| %x_125:mat3x3<f32> = load %cotangentFrame_1 |
| store %param, %x_125 |
| %148:vec3<f32> = mul %x_119, 2.0f |
| %149:vec3<f32> = sub %148, vec3<f32>(1.0f) |
| store %param_1, %149 |
| %x_128:f32 = load %scale_1 |
| store %param_2, %x_128 |
| %x_129:vec3<f32> = call %perturbNormalBase_mf33_vf3_f1_, %param, %param_1, %param_2 |
| ret %x_129 |
| } |
| } |
| %computeHemisphericLighting_vf3_vf3_vf4_vf3_vf3_vf3_f1_ = func(%viewDirectionW:ptr<function, vec3<f32>, read_write>, %vNormal:ptr<function, vec3<f32>, read_write>, %lightData:ptr<function, vec4<f32>, read_write>, %diffuseColor:ptr<function, vec3<f32>, read_write>, %specularColor:ptr<function, vec3<f32>, read_write>, %groundColor:ptr<function, vec3<f32>, read_write>, %glossiness:ptr<function, f32, read_write>):lightingInfo -> %b6 { |
| %b6 = block { |
| %ndl:ptr<function, f32, read_write> = var |
| %result:ptr<function, lightingInfo, read_write> = var |
| %angleW:ptr<function, vec3<f32>, read_write> = var |
| %specComp:ptr<function, f32, read_write> = var |
| %x_212:vec3<f32> = load %vNormal |
| %x_213:vec4<f32> = load %lightData |
| %166:f32 = access %x_213, 0u |
| %167:f32 = access %x_213, 1u |
| %168:f32 = access %x_213, 2u |
| %169:vec3<f32> = construct %166, %167, %168 |
| %170:f32 = dot %x_212, %169 |
| %171:f32 = mul %170, 0.5f |
| %172:f32 = add %171, 0.5f |
| store %ndl, %172 |
| %x_220:vec3<f32> = load %groundColor |
| %x_221:vec3<f32> = load %diffuseColor |
| %x_222:f32 = load %ndl |
| %176:ptr<function, vec3<f32>, read_write> = access %result, 0u |
| %177:vec3<f32> = construct %x_222, %x_222, %x_222 |
| %178:vec3<f32> = mix %x_220, %x_221, %177 |
| store %176, %178 |
| %x_227:vec3<f32> = load %viewDirectionW |
| %x_228:vec4<f32> = load %lightData |
| %181:f32 = access %x_228, 0u |
| %182:f32 = access %x_228, 1u |
| %183:f32 = access %x_228, 2u |
| %184:vec3<f32> = construct %181, %182, %183 |
| %185:vec3<f32> = add %x_227, %184 |
| %186:vec3<f32> = normalize %185 |
| store %angleW, %186 |
| %x_233:vec3<f32> = load %vNormal |
| %x_234:vec3<f32> = load %angleW |
| %189:f32 = dot %x_233, %x_234 |
| %190:f32 = max 0.0f, %189 |
| store %specComp, %190 |
| %x_237:f32 = load %specComp |
| %x_238:f32 = load %glossiness |
| %193:f32 = max 1.0f, %x_238 |
| %194:f32 = pow %x_237, %193 |
| store %specComp, %194 |
| %x_241:f32 = load %specComp |
| %x_242:vec3<f32> = load %specularColor |
| %197:ptr<function, vec3<f32>, read_write> = access %result, 1u |
| %198:vec3<f32> = mul %x_242, %x_241 |
| store %197, %198 |
| %x_245:lightingInfo = load %result |
| ret %x_245 |
| } |
| } |
| %main_1 = func():void -> %b7 { |
| %b7 = block { |
| %tempTextureRead:ptr<function, vec4<f32>, read_write> = var |
| %rgb:ptr<function, vec3<f32>, read_write> = var |
| %output5:ptr<function, vec3<f32>, read_write> = var |
| %output4:ptr<function, vec4<f32>, read_write> = var |
| %uvOffset:ptr<function, vec2<f32>, read_write> = var |
| %normalScale:ptr<function, f32, read_write> = var |
| %TBNUV:ptr<function, vec2<f32>, read_write> = var |
| %x_299:ptr<function, vec2<f32>, read_write> = var |
| %TBN:ptr<function, mat3x3<f32>, read_write> = var |
| %param_3:ptr<function, vec3<f32>, read_write> = var |
| %param_4:ptr<function, vec3<f32>, read_write> = var |
| %param_5:ptr<function, vec2<f32>, read_write> = var |
| %param_6:ptr<function, vec2<f32>, read_write> = var |
| %invTBN:ptr<function, mat3x3<f32>, read_write> = var |
| %param_7:ptr<function, mat3x3<f32>, read_write> = var |
| %parallaxLimit:ptr<function, f32, read_write> = var |
| %vOffsetDir:ptr<function, vec2<f32>, read_write> = var |
| %vMaxOffset:ptr<function, vec2<f32>, read_write> = var |
| %numSamples:ptr<function, f32, read_write> = var |
| %stepSize:ptr<function, f32, read_write> = var |
| %currRayHeight:ptr<function, f32, read_write> = var |
| %vCurrOffset:ptr<function, vec2<f32>, read_write> = var |
| %vLastOffset:ptr<function, vec2<f32>, read_write> = var |
| %lastSampledHeight:ptr<function, f32, read_write> = var |
| %currSampledHeight:ptr<function, f32, read_write> = var |
| %i:ptr<function, i32, read_write> = var |
| %delta1:ptr<function, f32, read_write> = var |
| %delta2:ptr<function, f32, read_write> = var |
| %ratio:ptr<function, f32, read_write> = var |
| %parallaxOcclusion_0:ptr<function, vec2<f32>, read_write> = var |
| %param_8:ptr<function, mat3x3<f32>, read_write> = var |
| %param_9:ptr<function, vec3<f32>, read_write> = var |
| %param_10:ptr<function, f32, read_write> = var |
| %output6:ptr<function, vec2<f32>, read_write> = var |
| %tempTextureRead1:ptr<function, vec4<f32>, read_write> = var |
| %rgb1:ptr<function, vec3<f32>, read_write> = var |
| %viewDirectionW_1:ptr<function, vec3<f32>, read_write> = var |
| %shadow:ptr<function, f32, read_write> = var |
| %glossiness_1:ptr<function, f32, read_write> = var |
| %diffuseBase:ptr<function, vec3<f32>, read_write> = var |
| %specularBase:ptr<function, vec3<f32>, read_write> = var |
| %normalW:ptr<function, vec3<f32>, read_write> = var |
| %info:ptr<function, lightingInfo, read_write> = var |
| %param_11:ptr<function, vec3<f32>, read_write> = var |
| %param_12:ptr<function, vec3<f32>, read_write> = var |
| %param_13:ptr<function, vec4<f32>, read_write> = var |
| %param_14:ptr<function, vec3<f32>, read_write> = var |
| %param_15:ptr<function, vec3<f32>, read_write> = var |
| %param_16:ptr<function, vec3<f32>, read_write> = var |
| %param_17:ptr<function, f32, read_write> = var |
| %diffuseOutput:ptr<function, vec3<f32>, read_write> = var |
| %specularOutput:ptr<function, vec3<f32>, read_write> = var |
| %output3:ptr<function, vec3<f32>, read_write> = var |
| store %u_Float, 100.0f |
| store %u_Color, vec3<f32>(0.5f) |
| %x_261:vec2<f32> = load %vMainuv |
| %255:texture_2d<f32> = load %TextureSamplerTexture |
| %256:sampler = load %TextureSamplerSampler |
| %x_262:vec4<f32> = textureSample %255, %256, %x_261 |
| store %tempTextureRead, %x_262 |
| %x_264:vec4<f32> = load %tempTextureRead |
| %259:ptr<uniform, f32, read> = access %x_269, 6u |
| %x_273:f32 = load %259 |
| %261:f32 = access %x_264, 0u |
| %262:f32 = access %x_264, 1u |
| %263:f32 = access %x_264, 2u |
| %264:vec3<f32> = construct %261, %262, %263 |
| %265:vec3<f32> = mul %264, %x_273 |
| store %rgb, %265 |
| %266:ptr<uniform, vec3<f32>, read> = access %x_269, 4u |
| %x_279:vec3<f32> = load %266 |
| %x_282:vec4<f32> = load %v_output1 |
| %269:f32 = access %x_282, 0u |
| %270:f32 = access %x_282, 1u |
| %271:f32 = access %x_282, 2u |
| %272:vec3<f32> = construct %269, %270, %271 |
| %273:vec3<f32> = sub %x_279, %272 |
| %274:vec3<f32> = normalize %273 |
| store %output5, %274 |
| store %output4, vec4<f32>(0.0f) |
| store %uvOffset, vec2<f32>(0.0f) |
| %275:ptr<uniform, f32, read> = access %x_269, 2u |
| %x_292:f32 = load %275 |
| %277:f32 = div 1.0f, %x_292 |
| store %normalScale, %277 |
| %x_298:bool = load %gl_FrontFacing |
| if %x_298 [t: %b8, f: %b9] { # if_1 |
| %b8 = block { # true |
| %x_303:vec2<f32> = load %v_uv |
| store %x_299, %x_303 |
| exit_if # if_1 |
| } |
| %b9 = block { # false |
| %x_305:vec2<f32> = load %v_uv |
| %281:vec2<f32> = negation %x_305 |
| store %x_299, %281 |
| exit_if # if_1 |
| } |
| } |
| %x_307:vec2<f32> = load %x_299 |
| store %TBNUV, %x_307 |
| %x_310:vec4<f32> = load %v_output2 |
| %x_312:f32 = load %normalScale |
| %285:f32 = access %x_310, 0u |
| %286:f32 = access %x_310, 1u |
| %287:f32 = access %x_310, 2u |
| %288:vec3<f32> = construct %285, %286, %287 |
| %289:vec3<f32> = mul %288, %x_312 |
| store %param_3, %289 |
| %x_317:vec4<f32> = load %v_output1 |
| %291:f32 = access %x_317, 0u |
| %292:f32 = access %x_317, 1u |
| %293:f32 = access %x_317, 2u |
| %294:vec3<f32> = construct %291, %292, %293 |
| store %param_4, %294 |
| %x_320:vec2<f32> = load %TBNUV |
| store %param_5, %x_320 |
| %296:ptr<uniform, vec2<f32>, read> = access %x_269, 8u |
| %x_324:vec2<f32> = load %296 |
| store %param_6, %x_324 |
| %x_325:mat3x3<f32> = call %cotangent_frame_vf3_vf3_vf2_vf2_, %param_3, %param_4, %param_5, %param_6 |
| store %TBN, %x_325 |
| %x_328:mat3x3<f32> = load %TBN |
| store %param_7, %x_328 |
| %x_329:mat3x3<f32> = call %transposeMat3_mf33_, %param_7 |
| store %invTBN, %x_329 |
| %x_331:mat3x3<f32> = load %invTBN |
| %x_332:vec3<f32> = load %output5 |
| %303:vec3<f32> = negation %x_332 |
| %x_334:vec3<f32> = mul %x_331, %303 |
| %x_337:mat3x3<f32> = load %invTBN |
| %x_338:vec3<f32> = load %output5 |
| %307:f32 = access %x_334, 0u |
| %308:f32 = access %x_334, 1u |
| %309:vec2<f32> = construct %307, %308 |
| %310:f32 = length %309 |
| %311:vec3<f32> = negation %x_338 |
| %312:vec3<f32> = mul %x_337, %311 |
| %313:f32 = access %312, 2u |
| %314:f32 = div %310, %313 |
| store %parallaxLimit, %314 |
| %315:ptr<uniform, f32, read> = access %x_269, 5u |
| %x_345:f32 = load %315 |
| %x_346:f32 = load %parallaxLimit |
| %318:f32 = mul %x_346, %x_345 |
| store %parallaxLimit, %318 |
| %x_349:mat3x3<f32> = load %invTBN |
| %x_350:vec3<f32> = load %output5 |
| %321:vec3<f32> = negation %x_350 |
| %x_352:vec3<f32> = mul %x_349, %321 |
| %323:f32 = access %x_352, 0u |
| %324:f32 = access %x_352, 1u |
| %325:vec2<f32> = construct %323, %324 |
| %326:vec2<f32> = normalize %325 |
| store %vOffsetDir, %326 |
| %x_356:vec2<f32> = load %vOffsetDir |
| %x_357:f32 = load %parallaxLimit |
| %329:vec2<f32> = mul %x_356, %x_357 |
| store %vMaxOffset, %329 |
| %x_361:mat3x3<f32> = load %invTBN |
| %x_362:vec3<f32> = load %output5 |
| %x_365:mat3x3<f32> = load %invTBN |
| %x_366:vec4<f32> = load %v_output2 |
| %334:vec3<f32> = negation %x_362 |
| %335:vec3<f32> = mul %x_361, %334 |
| %336:f32 = access %x_366, 0u |
| %337:f32 = access %x_366, 1u |
| %338:f32 = access %x_366, 2u |
| %339:vec3<f32> = construct %336, %337, %338 |
| %340:vec3<f32> = mul %x_365, %339 |
| %341:f32 = dot %335, %340 |
| %342:f32 = mul %341, -11.0f |
| %343:f32 = add 15.0f, %342 |
| store %numSamples, %343 |
| %x_374:f32 = load %numSamples |
| %345:f32 = div 1.0f, %x_374 |
| store %stepSize, %345 |
| store %currRayHeight, 1.0f |
| store %vCurrOffset, vec2<f32>(0.0f) |
| store %vLastOffset, vec2<f32>(0.0f) |
| store %lastSampledHeight, 1.0f |
| store %currSampledHeight, 1.0f |
| store %i, 0i |
| loop [b: %b10, c: %b11] { # loop_1 |
| %b10 = block { # body |
| %x_388:i32 = load %i |
| %347:bool = lt %x_388, 15i |
| if %347 [t: %b12, f: %b13] { # if_2 |
| %b12 = block { # true |
| exit_if # if_2 |
| } |
| %b13 = block { # false |
| exit_loop # loop_1 |
| } |
| } |
| %x_394:vec2<f32> = load %v_uv |
| %x_395:vec2<f32> = load %vCurrOffset |
| %x_397:vec4<f32> = let vec4<f32>(0.0f) |
| %351:f32 = access %x_397, 3u |
| store %currSampledHeight, %351 |
| %x_400:f32 = load %currSampledHeight |
| %x_401:f32 = load %currRayHeight |
| %354:bool = gt %x_400, %x_401 |
| if %354 [t: %b14, f: %b15] { # if_3 |
| %b14 = block { # true |
| %x_406:f32 = load %currSampledHeight |
| %x_407:f32 = load %currRayHeight |
| %357:f32 = sub %x_406, %x_407 |
| store %delta1, %357 |
| %x_410:f32 = load %currRayHeight |
| %x_411:f32 = load %stepSize |
| %x_413:f32 = load %lastSampledHeight |
| %361:f32 = add %x_410, %x_411 |
| %362:f32 = sub %361, %x_413 |
| store %delta2, %362 |
| %x_416:f32 = load %delta1 |
| %x_417:f32 = load %delta1 |
| %x_418:f32 = load %delta2 |
| %366:f32 = add %x_417, %x_418 |
| %367:f32 = div %x_416, %366 |
| store %ratio, %367 |
| %x_421:f32 = load %ratio |
| %x_422:vec2<f32> = load %vLastOffset |
| %x_424:f32 = load %ratio |
| %x_426:vec2<f32> = load %vCurrOffset |
| %372:vec2<f32> = mul %x_422, %x_421 |
| %373:f32 = sub 1.0f, %x_424 |
| %374:vec2<f32> = mul %x_426, %373 |
| %375:vec2<f32> = add %372, %374 |
| store %vCurrOffset, %375 |
| exit_loop # loop_1 |
| } |
| %b15 = block { # false |
| %x_431:f32 = load %stepSize |
| %x_432:f32 = load %currRayHeight |
| %378:f32 = sub %x_432, %x_431 |
| store %currRayHeight, %378 |
| %x_434:vec2<f32> = load %vCurrOffset |
| store %vLastOffset, %x_434 |
| %x_435:f32 = load %stepSize |
| %x_436:vec2<f32> = load %vMaxOffset |
| %x_438:vec2<f32> = load %vCurrOffset |
| %383:vec2<f32> = mul %x_436, %x_435 |
| %384:vec2<f32> = add %x_438, %383 |
| store %vCurrOffset, %384 |
| %x_440:f32 = load %currSampledHeight |
| store %lastSampledHeight, %x_440 |
| exit_if # if_3 |
| } |
| } |
| continue %b11 |
| } |
| %b11 = block { # continuing |
| %x_441:i32 = load %i |
| %387:i32 = add %x_441, 1i |
| store %i, %387 |
| next_iteration %b10 |
| } |
| } |
| %x_444:vec2<f32> = load %vCurrOffset |
| store %parallaxOcclusion_0, %x_444 |
| %x_445:vec2<f32> = load %parallaxOcclusion_0 |
| store %uvOffset, %x_445 |
| %x_449:vec2<f32> = load %v_uv |
| %x_450:vec2<f32> = load %uvOffset |
| %392:texture_2d<f32> = load %TextureSamplerTexture |
| %393:sampler = load %TextureSamplerSampler |
| %394:vec2<f32> = add %x_449, %x_450 |
| %x_452:vec4<f32> = textureSample %392, %393, %394 |
| %396:ptr<uniform, f32, read> = access %x_269, 2u |
| %x_454:f32 = load %396 |
| %x_457:mat3x3<f32> = load %TBN |
| store %param_8, %x_457 |
| %399:f32 = access %x_452, 0u |
| %400:f32 = access %x_452, 1u |
| %401:f32 = access %x_452, 2u |
| %402:vec3<f32> = construct %399, %400, %401 |
| store %param_9, %402 |
| %403:f32 = div 1.0f, %x_454 |
| store %param_10, %403 |
| %x_461:vec3<f32> = call %perturbNormal_mf33_vf3_f1_, %param_8, %param_9, %param_10 |
| %x_462:vec4<f32> = load %output4 |
| %406:f32 = access %x_461, 0u |
| %407:f32 = access %x_461, 1u |
| %408:f32 = access %x_461, 2u |
| %409:f32 = access %x_462, 3u |
| %410:vec4<f32> = construct %406, %407, %408, %409 |
| store %output4, %410 |
| %x_465:vec2<f32> = load %v_uv |
| %x_466:vec2<f32> = load %uvOffset |
| %413:vec2<f32> = add %x_465, %x_466 |
| store %output6, %413 |
| %x_474:vec2<f32> = load %output6 |
| %415:texture_2d<f32> = load %TextureSampler1Texture |
| %416:sampler = load %TextureSampler1Sampler |
| %x_475:vec4<f32> = textureSample %415, %416, %x_474 |
| store %tempTextureRead1, %x_475 |
| %x_477:vec4<f32> = load %tempTextureRead1 |
| %419:f32 = access %x_477, 0u |
| %420:f32 = access %x_477, 1u |
| %421:f32 = access %x_477, 2u |
| %422:vec3<f32> = construct %419, %420, %421 |
| store %rgb1, %422 |
| %423:ptr<uniform, vec3<f32>, read> = access %x_269, 4u |
| %x_481:vec3<f32> = load %423 |
| %x_482:vec4<f32> = load %v_output1 |
| %426:f32 = access %x_482, 0u |
| %427:f32 = access %x_482, 1u |
| %428:f32 = access %x_482, 2u |
| %429:vec3<f32> = construct %426, %427, %428 |
| %430:vec3<f32> = sub %x_481, %429 |
| %431:vec3<f32> = normalize %430 |
| store %viewDirectionW_1, %431 |
| store %shadow, 1.0f |
| %x_488:f32 = load %u_Float |
| %433:f32 = mul 1.0f, %x_488 |
| store %glossiness_1, %433 |
| store %diffuseBase, vec3<f32>(0.0f) |
| store %specularBase, vec3<f32>(0.0f) |
| %x_494:vec4<f32> = load %output4 |
| %435:f32 = access %x_494, 0u |
| %436:f32 = access %x_494, 1u |
| %437:f32 = access %x_494, 2u |
| %438:vec3<f32> = construct %435, %436, %437 |
| store %normalW, %438 |
| %x_501:vec3<f32> = load %viewDirectionW_1 |
| store %param_11, %x_501 |
| %x_503:vec3<f32> = load %normalW |
| store %param_12, %x_503 |
| %441:ptr<uniform, vec4<f32>, read> = access %light0, 0u |
| %x_507:vec4<f32> = load %441 |
| store %param_13, %x_507 |
| %443:ptr<uniform, vec4<f32>, read> = access %light0, 1u |
| %x_510:vec4<f32> = load %443 |
| %445:f32 = access %x_510, 0u |
| %446:f32 = access %x_510, 1u |
| %447:f32 = access %x_510, 2u |
| %448:vec3<f32> = construct %445, %446, %447 |
| store %param_14, %448 |
| %449:ptr<uniform, vec4<f32>, read> = access %light0, 2u |
| %x_514:vec4<f32> = load %449 |
| %451:f32 = access %x_514, 0u |
| %452:f32 = access %x_514, 1u |
| %453:f32 = access %x_514, 2u |
| %454:vec3<f32> = construct %451, %452, %453 |
| store %param_15, %454 |
| %455:ptr<uniform, vec3<f32>, read> = access %light0, 3u |
| %x_518:vec3<f32> = load %455 |
| store %param_16, %x_518 |
| %x_520:f32 = load %glossiness_1 |
| store %param_17, %x_520 |
| %x_521:lightingInfo = call %computeHemisphericLighting_vf3_vf3_vf4_vf3_vf3_vf3_f1_, %param_11, %param_12, %param_13, %param_14, %param_15, %param_16, %param_17 |
| store %info, %x_521 |
| store %shadow, 1.0f |
| %459:ptr<function, vec3<f32>, read_write> = access %info, 0u |
| %x_523:vec3<f32> = load %459 |
| %x_524:f32 = load %shadow |
| %x_526:vec3<f32> = load %diffuseBase |
| %463:vec3<f32> = mul %x_523, %x_524 |
| %464:vec3<f32> = add %x_526, %463 |
| store %diffuseBase, %464 |
| %465:ptr<function, vec3<f32>, read_write> = access %info, 1u |
| %x_529:vec3<f32> = load %465 |
| %x_530:f32 = load %shadow |
| %x_532:vec3<f32> = load %specularBase |
| %469:vec3<f32> = mul %x_529, %x_530 |
| %470:vec3<f32> = add %x_532, %469 |
| store %specularBase, %470 |
| %x_535:vec3<f32> = load %diffuseBase |
| %x_536:vec3<f32> = load %rgb1 |
| %473:vec3<f32> = mul %x_535, %x_536 |
| store %diffuseOutput, %473 |
| %x_539:vec3<f32> = load %specularBase |
| %x_540:vec3<f32> = load %u_Color |
| %476:vec3<f32> = mul %x_539, %x_540 |
| store %specularOutput, %476 |
| %x_543:vec3<f32> = load %diffuseOutput |
| %x_544:vec3<f32> = load %specularOutput |
| %479:vec3<f32> = add %x_543, %x_544 |
| store %output3, %479 |
| %x_548:vec3<f32> = load %output3 |
| %481:f32 = access %x_548, 0u |
| %482:f32 = access %x_548, 1u |
| %483:f32 = access %x_548, 2u |
| %484:vec4<f32> = construct %481, %482, %483, 1.0f |
| store %glFragColor, %484 |
| ret |
| } |
| } |
| %tint_symbol = @fragment func(%vMainuv_param:vec2<f32> [@location(1)], %v_output1_param:vec4<f32> [@location(0)], %gl_FrontFacing_param:bool [@front_facing], %v_uv_param:vec2<f32> [@location(3)], %v_output2_param:vec4<f32> [@location(2)]):main_out -> %b16 { |
| %b16 = block { |
| store %vMainuv, %vMainuv_param |
| store %v_output1, %v_output1_param |
| store %gl_FrontFacing, %gl_FrontFacing_param |
| store %v_uv, %v_uv_param |
| store %v_output2, %v_output2_param |
| %491:void = call %main_1 |
| %492:vec4<f32> = load %glFragColor |
| %493:main_out = construct %492 |
| ret %493 |
| } |
| } |
| |
| 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. * |
| ******************************************************************** |
