dawn-cmake/test/benchmark/skinned-shadowed-pbr-fragment.wgsl.expected.glsl

SKIP: FAILED

benchmark/skinned-shadowed-pbr-fragment.wgsl:51:13 warning: use of deprecated language feature: the @stride attribute is deprecated; use a larger type if necessary
  lights : @stride(32) array<Light>;
            ^^^^^^

#version 310 es
precision mediump float;

layout(location = 0) in vec3 worldPos_1;
layout(location = 1) in vec3 view_1;
layout(location = 2) in vec2 texcoord_1;
layout(location = 3) in vec2 texcoord2_1;
layout(location = 4) in vec4 color_1;
layout(location = 5) in vec4 instanceColor_1;
layout(location = 6) in vec3 normal_1;
layout(location = 7) in vec3 tangent_1;
layout(location = 8) in vec3 bitangent_1;
layout(location = 0) out vec4 color_2;
layout(location = 1) out vec4 emissive_1;
const float GAMMA = 2.200000048f;
vec3 linearTosRGB(vec3 linear) {
  float INV_GAMMA = (1.0f / GAMMA);
  return pow(linear, vec3(INV_GAMMA));
}

struct Camera {
  mat4 projection;
  mat4 inverseProjection;
  mat4 view;
  vec3 position;
  float time;
  vec2 outputSize;
  float zNear;
  float zFar;
};

layout(binding = 0) uniform Camera_1 {
  mat4 projection;
  mat4 inverseProjection;
  mat4 view;
  vec3 position;
  float time;
  vec2 outputSize;
  float zNear;
  float zFar;
} camera;

struct ClusterLights {
  uint offset;
  uint count;
};

struct ClusterLightGroup {
  uint offset;
  ClusterLights lights[27648];
  uint indices[1769472];
};

layout(binding = 1, std430) buffer ClusterLightGroup_1 {
  uint offset;
  ClusterLights lights[27648];
  uint indices[1769472];
} clusterLights;
struct Light {
  vec3 position;
  float range;
  vec3 color;
  float intensity;
};

layout(binding = 2, std430) buffer GlobalLights_1 {
  vec3 ambient;
  vec3 dirColor;
  float dirIntensity;
  vec3 dirDirection;
  uint lightCount;
  Light lights[];
} globalLights;
const uvec3 tileCount = uvec3(32u, 18u, 48u);
float linearDepth(float depthSample) {
  return ((camera.zFar * camera.zNear) / mad(depthSample, (camera.zNear - camera.zFar), camera.zFar));
}

uvec3 getTile(vec4 fragCoord) {
  float sliceScale = (float(tileCount.z) / log2((camera.zFar / camera.zNear)));
  float sliceBias = -(((float(tileCount.z) * log2(camera.zNear)) / log2((camera.zFar / camera.zNear))));
  uint zTile = uint(max(((log2(linearDepth(fragCoord.z)) * sliceScale) + sliceBias), 0.0f));
  return uvec3(uint((fragCoord.x / (camera.outputSize.x / float(tileCount.x)))), uint((fragCoord.y / (camera.outputSize.y / float(tileCount.y)))), zTile);
}

uint getClusterIndex(vec4 fragCoord) {
  uvec3 tile = getTile(fragCoord);
  return ((tile.x + (tile.y * tileCount.x)) + ((tile.z * tileCount.x) * tileCount.y));
}

layout(binding = 6, std430) buffer LightShadowTable_1 {
  int light[];
} lightShadowTable;
vec2 shadowSampleOffsets[16] = vec2[16](vec2(-1.5f, -1.5f), vec2(-1.5f, -0.5f), vec2(-1.5f, 0.5f), vec2(-1.5f, 1.5f), vec2(-0.5f, -1.5f), vec2(-0.5f, -0.5f), vec2(-0.5f, 0.5f), vec2(-0.5f, 1.5f), vec2(0.5f, -1.5f), vec2(0.5f, -0.5f), vec2(0.5f, 0.5f), vec2(0.5f, 1.5f), vec2(1.5f, -1.5f), vec2(1.5f, -0.5f), vec2(1.5f, 0.5f), vec2(1.5f, 1.5f));
const uint shadowSampleCount = 16u;
struct ShadowProperties {
  vec4 viewport;
  mat4 viewProj;
};

layout(binding = 7, std430) buffer LightShadows_1 {
  ShadowProperties properties[];
} shadow;
uniform highp sampler2D shadowTexture_1;
uniform highp sampler2DShadow shadowTexture_shadowSampler;

float dirLightVisibility(vec3 worldPos) {
  int shadowIndex = lightShadowTable.light[0u];
  if ((shadowIndex == -1)) {
    return 1.0f;
  }
  vec4 viewport = shadow.properties[shadowIndex].viewport;
  vec4 lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0f));
  vec3 shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5f, -0.5f)) + vec2(0.5f, 0.5f)), (lightPos.z / lightPos.w));
  vec2 viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
  vec2 texelSize = (1.0f / vec2(textureSize(shadowTexture_1, 0)));
  vec4 clampRect = vec4((viewport.xy - texelSize), ((viewport.xy + viewport.zw) + texelSize));
  float visibility = 0.0f;
  {
    for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
      visibility = (visibility + texture(shadowTexture_shadowSampler, vec3(clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.003f))));
    }
  }
  return (visibility / float(shadowSampleCount));
}

int getCubeFace(vec3 v) {
  vec3 vAbs = abs(v);
  bool tint_tmp = (vAbs.z >= vAbs.x);
  if (tint_tmp) {
    tint_tmp = (vAbs.z >= vAbs.y);
  }
  if ((tint_tmp)) {
    if ((v.z < 0.0f)) {
      return 5;
    }
    return 4;
  }
  if ((vAbs.y >= vAbs.x)) {
    if ((v.y < 0.0f)) {
      return 3;
    }
    return 2;
  }
  if ((v.x < 0.0f)) {
    return 1;
  }
  return 0;
}

float pointLightVisibility(uint lightIndex, vec3 worldPos, vec3 pointToLight) {
  int shadowIndex = lightShadowTable.light[(lightIndex + 1u)];
  if ((shadowIndex == -1)) {
    return 1.0f;
  }
  shadowIndex = (shadowIndex + getCubeFace((pointToLight * -1.0f)));
  vec4 viewport = shadow.properties[shadowIndex].viewport;
  vec4 lightPos = (shadow.properties[shadowIndex].viewProj * vec4(worldPos, 1.0f));
  vec3 shadowPos = vec3((((lightPos.xy / lightPos.w) * vec2(0.5f, -0.5f)) + vec2(0.5f, 0.5f)), (lightPos.z / lightPos.w));
  vec2 viewportPos = vec2((viewport.xy + (shadowPos.xy * viewport.zw)));
  vec2 texelSize = (1.0f / vec2(textureSize(shadowTexture_1, 0)));
  vec4 clampRect = vec4(viewport.xy, (viewport.xy + viewport.zw));
  float visibility = 0.0f;
  {
    for(uint i = 0u; (i < shadowSampleCount); i = (i + 1u)) {
      visibility = (visibility + texture(shadowTexture_shadowSampler, vec3(clamp((viewportPos + (shadowSampleOffsets[i] * texelSize)), clampRect.xy, clampRect.zw), (shadowPos.z - 0.01f))));
    }
  }
  return (visibility / float(shadowSampleCount));
}

struct VertexOutput {
  vec4 position;
  vec3 worldPos;
  vec3 view;
  vec2 texcoord;
  vec2 texcoord2;
  vec4 color;
  vec4 instanceColor;
  vec3 normal;
  vec3 tangent;
  vec3 bitangent;
};

struct Material {
  vec4 baseColorFactor;
  vec3 emissiveFactor;
  float occlusionStrength;
  vec2 metallicRoughnessFactor;
  float alphaCutoff;
};

layout(binding = 8) uniform Material_1 {
  vec4 baseColorFactor;
  vec3 emissiveFactor;
  float occlusionStrength;
  vec2 metallicRoughnessFactor;
  float alphaCutoff;
} material;

struct SurfaceInfo {
  vec4 baseColor;
  vec3 albedo;
  float metallic;
  float roughness;
  vec3 normal;
  vec3 f0;
  float ao;
  vec3 emissive;
  vec3 v;
};

uniform highp sampler2D normalTexture_normalSampler;
uniform highp sampler2D baseColorTexture_baseColorSampler;
uniform highp sampler2D metallicRoughnessTexture_metallicRoughnessSampler;
uniform highp sampler2D occlusionTexture_occlusionSampler;
uniform highp sampler2D emissiveTexture_emissiveSampler;

SurfaceInfo GetSurfaceInfo(VertexOutput tint_symbol) {
  SurfaceInfo surface = SurfaceInfo(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), 0.0f, 0.0f, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f), 0.0f, vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 0.0f));
  surface.v = normalize(tint_symbol.view);
  mat3 tbn = mat3(tint_symbol.tangent, tint_symbol.bitangent, tint_symbol.normal);
  vec3 normalMap = texture(normalTexture_normalSampler, tint_symbol.texcoord).rgb;
  surface.normal = normalize((tbn * ((2.0f * normalMap) - vec3(1.0f))));
  vec4 baseColorMap = texture(baseColorTexture_baseColorSampler, tint_symbol.texcoord);
  surface.baseColor = ((tint_symbol.color * material.baseColorFactor) * baseColorMap);
  if ((surface.baseColor.a < material.alphaCutoff)) {
    discard;
  }
  surface.albedo = surface.baseColor.rgb;
  vec4 metallicRoughnessMap = texture(metallicRoughnessTexture_metallicRoughnessSampler, tint_symbol.texcoord);
  surface.metallic = (material.metallicRoughnessFactor.x * metallicRoughnessMap.b);
  surface.roughness = (material.metallicRoughnessFactor.y * metallicRoughnessMap.g);
  vec3 dielectricSpec = vec3(0.039999999f);
  surface.f0 = mix(dielectricSpec, surface.albedo, vec3(surface.metallic));
  vec4 occlusionMap = texture(occlusionTexture_occlusionSampler, tint_symbol.texcoord);
  surface.ao = (material.occlusionStrength * occlusionMap.r);
  vec4 emissiveMap = texture(emissiveTexture_emissiveSampler, tint_symbol.texcoord);
  surface.emissive = (material.emissiveFactor * emissiveMap.rgb);
  if ((tint_symbol.instanceColor.a == 0.0f)) {
    surface.albedo = (surface.albedo + tint_symbol.instanceColor.rgb);
  } else {
    surface.albedo = (surface.albedo * tint_symbol.instanceColor.rgb);
  }
  return surface;
}

const float PI = 3.141592741f;
const uint LightType_Point = 0u;
const uint LightType_Directional = 2u;
struct PuctualLight {
  uint lightType;
  vec3 pointToLight;
  float range;
  vec3 color;
  float intensity;
};

vec3 FresnelSchlick(float cosTheta, vec3 F0) {
  return (F0 + ((vec3(1.0f) - F0) * pow((1.0f - cosTheta), 5.0f)));
}

float DistributionGGX(vec3 N, vec3 H, float roughness) {
  float a_1 = (roughness * roughness);
  float a2 = (a_1 * a_1);
  float NdotH = max(dot(N, H), 0.0f);
  float NdotH2 = (NdotH * NdotH);
  float num = a2;
  float denom = ((NdotH2 * (a2 - 1.0f)) + 1.0f);
  return (num / ((PI * denom) * denom));
}

float GeometrySchlickGGX(float NdotV, float roughness) {
  float r_1 = (roughness + 1.0f);
  float k = ((r_1 * r_1) / 8.0f);
  float num = NdotV;
  float denom = ((NdotV * (1.0f - k)) + k);
  return (num / denom);
}

float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness) {
  float NdotV = max(dot(N, V), 0.0f);
  float NdotL = max(dot(N, L), 0.0f);
  float ggx2 = GeometrySchlickGGX(NdotV, roughness);
  float ggx1 = GeometrySchlickGGX(NdotL, roughness);
  return (ggx1 * ggx2);
}

float lightAttenuation(PuctualLight light) {
  if ((light.lightType == LightType_Directional)) {
    return 1.0f;
  }
  float tint_symbol_1 = length(light.pointToLight);
  if ((light.range <= 0.0f)) {
    return (1.0f / pow(tint_symbol_1, 2.0f));
  }
  return (clamp((1.0f - pow((tint_symbol_1 / light.range), 4.0f)), 0.0f, 1.0f) / pow(tint_symbol_1, 2.0f));
}

vec3 lightRadiance(PuctualLight light, SurfaceInfo surface) {
  vec3 L = normalize(light.pointToLight);
  vec3 H = normalize((surface.v + L));
  float NDF = DistributionGGX(surface.normal, H, surface.roughness);
  float G = GeometrySmith(surface.normal, surface.v, L, surface.roughness);
  vec3 F = FresnelSchlick(max(dot(H, surface.v), 0.0f), surface.f0);
  vec3 kD = ((vec3(1.0f) - F) * (1.0f - surface.metallic));
  float NdotL = max(dot(surface.normal, L), 0.0f);
  vec3 numerator = ((NDF * G) * F);
  float denominator = max(((4.0f * max(dot(surface.normal, surface.v), 0.0f)) * NdotL), 0.001f);
  vec3 specular = (numerator / vec3(denominator));
  vec3 radiance = ((light.color * light.intensity) * lightAttenuation(light));
  return (((((kD * surface.albedo) / vec3(PI)) + specular) * radiance) * NdotL);
}

struct FragmentOutput {
  vec4 color;
  vec4 emissive;
};

uniform highp sampler2D ssaoTexture_1;
uniform highp sampler2D ssaoTexture_defaultSampler;
FragmentOutput fragmentMain(VertexOutput tint_symbol) {
  SurfaceInfo surface = GetSurfaceInfo(tint_symbol);
  vec3 Lo = vec3(0.0f, 0.0f, 0.0f);
  if ((globalLights.dirIntensity > 0.0f)) {
    PuctualLight light = PuctualLight(0u, vec3(0.0f, 0.0f, 0.0f), 0.0f, vec3(0.0f, 0.0f, 0.0f), 0.0f);
    light.lightType = LightType_Directional;
    light.pointToLight = globalLights.dirDirection;
    light.color = globalLights.dirColor;
    light.intensity = globalLights.dirIntensity;
    float lightVis = dirLightVisibility(tint_symbol.worldPos);
    Lo = (Lo + (lightRadiance(light, surface) * lightVis));
  }
  uint clusterIndex = getClusterIndex(tint_symbol.position);
  uint lightOffset = clusterLights.lights[clusterIndex].offset;
  uint lightCount = clusterLights.lights[clusterIndex].count;
  {
    for(uint lightIndex = 0u; (lightIndex < lightCount); lightIndex = (lightIndex + 1u)) {
      uint i = clusterLights.indices[(lightOffset + lightIndex)];
      PuctualLight light = PuctualLight(0u, vec3(0.0f, 0.0f, 0.0f), 0.0f, vec3(0.0f, 0.0f, 0.0f), 0.0f);
      light.lightType = LightType_Point;
      light.pointToLight = (globalLights.lights[i].position.xyz - tint_symbol.worldPos);
      light.range = globalLights.lights[i].range;
      light.color = globalLights.lights[i].color;
      light.intensity = globalLights.lights[i].intensity;
      float lightVis = pointLightVisibility(i, tint_symbol.worldPos, light.pointToLight);
      Lo = (Lo + (lightRadiance(light, surface) * lightVis));
    }
  }
  vec2 ssaoCoord = (tint_symbol.position.xy / vec2(textureSize(ssaoTexture_1, 0).xy));
  float ssaoFactor = texture(ssaoTexture_defaultSampler, ssaoCoord).r;
  vec3 ambient = (((globalLights.ambient * surface.albedo) * surface.ao) * ssaoFactor);
  vec3 color = linearTosRGB(((Lo + ambient) + surface.emissive));
  FragmentOutput tint_symbol_2 = FragmentOutput(vec4(0.0f, 0.0f, 0.0f, 0.0f), vec4(0.0f, 0.0f, 0.0f, 0.0f));
  tint_symbol_2.color = vec4(color, surface.baseColor.a);
  tint_symbol_2.emissive = vec4(surface.emissive, surface.baseColor.a);
  return tint_symbol_2;
}

void main() {
  VertexOutput tint_symbol_3 = VertexOutput(gl_FragCoord, worldPos_1, view_1, texcoord_1, texcoord2_1, color_1, instanceColor_1, normal_1, tangent_1, bitangent_1);
  FragmentOutput inner_result = fragmentMain(tint_symbol_3);
  color_2 = inner_result.color;
  emissive_1 = inner_result.emissive;
  return;
}
Error parsing GLSL shader:
ERROR: 0:76: 'mad' : no matching overloaded function found 
ERROR: 0:76: '' : compilation terminated 
ERROR: 2 compilation errors.  No code generated.