From c73277a4aa107dc4fce6eec565dfcb91d33c5ac4 Mon Sep 17 00:00:00 2001 From: Jeremy HU Date: Tue, 9 Jul 2019 18:16:04 +0930 Subject: [PATCH] Fix shader error on Raspberry PI 3 Model B+ --- shaders/pbr-qt.frag | 138 ++++++++++++++++++++++---------------------- 1 file changed, 69 insertions(+), 69 deletions(-) diff --git a/shaders/pbr-qt.frag b/shaders/pbr-qt.frag index 839a8e92..3c6c0017 100644 --- a/shaders/pbr-qt.frag +++ b/shaders/pbr-qt.frag @@ -52,9 +52,9 @@ // https://github.com/qt/qt3d/blob/5.11/src/extras/shaders/gl3/metalrough.inc.frag // Exposure correction -float exposure; +highp float exposure; // Gamma correction -float gamma; +highp float gamma; varying highp vec3 vert; varying highp vec3 vertNormal; @@ -63,9 +63,9 @@ varying highp vec2 vertTexCoord; varying highp float vertMetalness; varying highp float vertRoughness; varying highp vec3 cameraPos; -varying vec3 firstLightPos; -varying vec3 secondLightPos; -varying vec3 thirdLightPos; +varying highp vec3 firstLightPos; +varying highp vec3 secondLightPos; +varying highp vec3 thirdLightPos; uniform highp vec3 lightPos; uniform highp sampler2D textureId; uniform highp int textureEnabled; @@ -94,39 +94,39 @@ struct Light { int lightCount; Light lights[MAX_LIGHTS]; -float remapRoughness(const in float roughness) +highp float remapRoughness(const in highp float roughness) { // As per page 14 of // http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf // we remap the roughness to give a more perceptually linear response // of "bluriness" as a function of the roughness specified by the user. // r = roughness^2 - float maxSpecPower; - float minRoughness; + highp float maxSpecPower; + highp float minRoughness; maxSpecPower = 999999.0; minRoughness = sqrt(2.0 / (maxSpecPower + 2.0)); return max(roughness * roughness, minRoughness); } -float normalDistribution(const in vec3 n, const in vec3 h, const in float alpha) +highp float normalDistribution(const in highp vec3 n, const in highp vec3 h, const in highp float alpha) { // Blinn-Phong approximation - see // http://graphicrants.blogspot.co.uk/2013/08/specular-brdf-reference.html - float specPower = 2.0 / (alpha * alpha) - 2.0; + highp float specPower = 2.0 / (alpha * alpha) - 2.0; return (specPower + 2.0) / (2.0 * 3.14159) * pow(max(dot(n, h), 0.0), specPower); } -vec3 fresnelFactor(const in vec3 color, const in float cosineFactor) +highp vec3 fresnelFactor(const in highp vec3 color, const in highp float cosineFactor) { // Calculate the Fresnel effect value - vec3 f = color; - vec3 F = f + (1.0 - f) * pow(1.0 - cosineFactor, 5.0); + highp vec3 f = color; + highp vec3 F = f + (1.0 - f) * pow(1.0 - cosineFactor, 5.0); return clamp(F, f, vec3(1.0)); } -float geometricModel(const in float lDotN, - const in float vDotN, - const in vec3 h) +highp float geometricModel(const in highp float lDotN, + const in highp float vDotN, + const in highp vec3 h) { // Implicit geometric model (equal to denominator in specular model). // This currently assumes that there is no attenuation by geometric shadowing or @@ -134,50 +134,50 @@ float geometricModel(const in float lDotN, return lDotN * vDotN; } -vec3 specularModel(const in vec3 F0, - const in float sDotH, - const in float sDotN, - const in float vDotN, - const in vec3 n, - const in vec3 h) +highp vec3 specularModel(const in highp vec3 F0, + const in highp float sDotH, + const in highp float sDotN, + const in highp float vDotN, + const in highp vec3 n, + const in highp vec3 h) { // Clamp sDotN and vDotN to small positive value to prevent the // denominator in the reflection equation going to infinity. Balance this // by using the clamped values in the geometric factor function to // avoid ugly seams in the specular lighting. - float sDotNPrime = max(sDotN, 0.001); - float vDotNPrime = max(vDotN, 0.001); + highp float sDotNPrime = max(sDotN, 0.001); + highp float vDotNPrime = max(vDotN, 0.001); - vec3 F = fresnelFactor(F0, sDotH); - float G = geometricModel(sDotNPrime, vDotNPrime, h); + highp vec3 F = fresnelFactor(F0, sDotH); + highp float G = geometricModel(sDotNPrime, vDotNPrime, h); - vec3 cSpec = F * G / (4.0 * sDotNPrime * vDotNPrime); + highp vec3 cSpec = F * G / (4.0 * sDotNPrime * vDotNPrime); return clamp(cSpec, vec3(0.0), vec3(1.0)); } -vec3 pbrModel(const in int lightIndex, - const in vec3 wPosition, - const in vec3 wNormal, - const in vec3 wView, - const in vec3 baseColor, - const in float metalness, - const in float alpha, - const in float ambientOcclusion) +highp vec3 pbrModel(const in int lightIndex, + const in highp vec3 wPosition, + const in highp vec3 wNormal, + const in highp vec3 wView, + const in highp vec3 baseColor, + const in highp float metalness, + const in highp float alpha, + const in highp float ambientOcclusion) { // Calculate some useful quantities - vec3 n = wNormal; - vec3 s = vec3(0.0); - vec3 v = wView; - vec3 h = vec3(0.0); + highp vec3 n = wNormal; + highp vec3 s = vec3(0.0); + highp vec3 v = wView; + highp vec3 h = vec3(0.0); - float vDotN = dot(v, n); - float sDotN = 0.0; - float sDotH = 0.0; - float att = 1.0; + highp float vDotN = dot(v, n); + highp float sDotN = 0.0; + highp float sDotH = 0.0; + highp float att = 1.0; if (lights[lightIndex].type != TYPE_DIRECTIONAL) { // Point and Spot lights - vec3 sUnnormalized = vec3(lights[lightIndex].position) - wPosition; + highp vec3 sUnnormalized = vec3(lights[lightIndex].position) - wPosition; s = normalize(sUnnormalized); // Calculate the attenuation factor @@ -186,7 +186,7 @@ vec3 pbrModel(const in int lightIndex, if (lights[lightIndex].constantAttenuation != 0.0 || lights[lightIndex].linearAttenuation != 0.0 || lights[lightIndex].quadraticAttenuation != 0.0) { - float dist = length(sUnnormalized); + highp float dist = length(sUnnormalized); att = 1.0 / (lights[lightIndex].constantAttenuation + lights[lightIndex].linearAttenuation * dist + lights[lightIndex].quadraticAttenuation * dist * dist); @@ -210,22 +210,22 @@ vec3 pbrModel(const in int lightIndex, sDotH = dot(s, h); // Calculate diffuse component - vec3 diffuseColor = (1.0 - metalness) * baseColor * lights[lightIndex].color; - vec3 diffuse = diffuseColor * max(sDotN, 0.0) / 3.14159; + highp vec3 diffuseColor = (1.0 - metalness) * baseColor * lights[lightIndex].color; + highp vec3 diffuse = diffuseColor * max(sDotN, 0.0) / 3.14159; // Calculate specular component - vec3 dielectricColor = vec3(0.04); - vec3 F0 = mix(dielectricColor, baseColor, metalness); - vec3 specularFactor = vec3(0.0); + highp vec3 dielectricColor = vec3(0.04); + highp vec3 F0 = mix(dielectricColor, baseColor, metalness); + highp vec3 specularFactor = vec3(0.0); if (sDotN > 0.0) { specularFactor = specularModel(F0, sDotH, sDotN, vDotN, n, h); specularFactor *= normalDistribution(n, h, alpha); } - vec3 specularColor = lights[lightIndex].color; - vec3 specular = specularColor * specularFactor; + highp vec3 specularColor = lights[lightIndex].color; + highp vec3 specular = specularColor * specularFactor; // Blend between diffuse and specular to conserver energy - vec3 color = att * lights[lightIndex].intensity * (specular + diffuse * (vec3(1.0) - specular)); + highp vec3 color = att * lights[lightIndex].intensity * (specular + diffuse * (vec3(1.0) - specular)); // Reduce by ambient occlusion amount color *= ambientOcclusion; @@ -233,28 +233,28 @@ vec3 pbrModel(const in int lightIndex, return color; } -vec3 toneMap(const in vec3 c) +highp vec3 toneMap(const in highp vec3 c) { return c / (c + vec3(1.0)); } -vec3 gammaCorrect(const in vec3 color) +highp vec3 gammaCorrect(const in highp vec3 color) { return pow(color, vec3(1.0 / gamma)); } -vec4 metalRoughFunction(const in vec4 baseColor, - const in float metalness, - const in float roughness, - const in float ambientOcclusion, - const in vec3 worldPosition, - const in vec3 worldView, - const in vec3 worldNormal) +highp vec4 metalRoughFunction(const in highp vec4 baseColor, + const in highp float metalness, + const in highp float roughness, + const in highp float ambientOcclusion, + const in highp vec3 worldPosition, + const in highp vec3 worldView, + const in highp vec3 worldNormal) { - vec3 cLinear = vec3(0.0); + highp vec3 cLinear = vec3(0.0); // Remap roughness for a perceptually more linear correspondence - float alpha = remapRoughness(roughness); + highp float alpha = remapRoughness(roughness); for (int i = 0; i < lightCount; ++i) { cLinear += pbrModel(i, @@ -271,10 +271,10 @@ vec4 metalRoughFunction(const in vec4 baseColor, cLinear *= pow(2.0, exposure); // Apply simple (Reinhard) tonemap transform to get into LDR range [0, 1] - vec3 cToneMapped = toneMap(cLinear); + highp vec3 cToneMapped = toneMap(cLinear); // Apply gamma correction prior to display - vec3 cGamma = gammaCorrect(cToneMapped); + highp vec3 cGamma = gammaCorrect(cToneMapped); return vec4(cGamma, 1.0); } @@ -332,17 +332,17 @@ void main() // Green: Roughness // Blue: Metallic - float metalness = vertMetalness; + highp float metalness = vertMetalness; if (metalnessMapEnabled == 1) { metalness = texture2D(metalnessRoughnessAmbientOcclusionMapId, vertTexCoord).b; } - float roughness = vertRoughness; + highp float roughness = vertRoughness; if (roughnessMapEnabled == 1) { roughness = texture2D(metalnessRoughnessAmbientOcclusionMapId, vertTexCoord).g; } - float ambientOcclusion = 1.0; + highp float ambientOcclusion = 1.0; if (ambientOcclusionMapEnabled == 1) { ambientOcclusion = texture2D(metalnessRoughnessAmbientOcclusionMapId, vertTexCoord).r; }