Uploaded image for project: 'Qt'
  1. Qt
  2. QTBUG-64365

Extras shaders do not work in static builds

    XMLWordPrintable

    Details

    • Type: Bug
    • Status: Closed
    • Priority: P1: Critical
    • Resolution: Done
    • Affects Version/s: 5.10.0 Beta 3
    • Fix Version/s: 5.10.0 RC
    • Component/s: Qt3D
    • Labels:
      None
    • Commits:
      932a834c253c02291c32a1f21ff5ad19dfef762d

      Description

      Build the 5.10.0 branch from git while configured with -static, with https://codereview.qt-project.org/#/c/210622 on top.

      Unlike in the default non-static builds, the shader builder generates invalid shader code. For instance, simple-qml results in:

      
      
      Starting E:\qt3d_510\examples\qt3d\simple-qml\debug\simple-qml.exe...
      QOpenGLShader::compile(Fragment): Fragment shader failed to compile with the following errors:
      ERROR: 3:2: error(#132) Syntax error: "worldPosition" parse error
      ERROR: error(#273) 1 compilation errors.  No code generated
      
      
      *** Problematic Fragment shader source code ***
      #version 140
      #define lowp
      #define mediump
      #define highp
      #line 1
      
        worldPosition;
      uniform vec3 eyePosition;
        worldNormal;
        ka;
        kd;
        ks;
        shininess;
      /****************************************************************************
      **
      ** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the Qt3D module of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** Commercial License Usage
      ** Licensees holding valid commercial Qt licenses may use this file in
      ** accordance with the commercial license agreement provided with the
      ** Software or, alternatively, in accordance with the terms contained in
      ** a written agreement between you and The Qt Company. For licensing terms
      ** and conditions see https://www.qt.io/terms-conditions. For further
      ** information use the contact form at https://www.qt.io/contact-us.
      **
      ** BSD License Usage
      ** Alternatively, you may use this file under the terms of the BSD license
      ** as follows:
      **
      ** "Redistribution and use in source and binary forms, with or without
      ** modification, are permitted provided that the following conditions are
      ** met:
      **   * Redistributions of source code must retain the above copyright
      **     notice, this list of conditions and the following disclaimer.
      **   * Redistributions in binary form must reproduce the above copyright
      **     notice, this list of conditions and the following disclaimer in
      **     the documentation and/or other materials provided with the
      **     distribution.
      **   * Neither the name of The Qt Company Ltd nor the names of its
      **     contributors may be used to endorse or promote products derived
      **     from this software without specific prior written permission.
      **
      **
      ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
      **
      ** $QT_END_LICENSE$
      **
      ****************************************************************************/
      
      const int MAX_LIGHTS = 8;
      const int TYPE_POINT = 0;
      const int TYPE_DIRECTIONAL = 1;
      const int TYPE_SPOT = 2;
      struct Light {
          int type;
          vec3 position;
          vec3 color;
          float intensity;
          vec3 direction;
          float constantAttenuation;
          float linearAttenuation;
          float quadraticAttenuation;
          float cutOffAngle;
      };
      uniform Light lights[MAX_LIGHTS];
      uniform int lightCount;
      
      // Pre-convolved environment maps
      struct EnvironmentLight {
          samplerCube irradiance; // For diffuse contribution
          samplerCube specular; // For specular contribution
      };
      uniform EnvironmentLight envLight;
      uniform int envLightCount = 0;
      
      #line 52
      
      void adsModel(const in vec3 worldPos,
                    const in vec3 worldNormal,
                    const in vec3 worldView,
                    const in float shininess,
                    out vec3 diffuseColor,
                    out vec3 specularColor)
      {
          diffuseColor = vec3(0.0);
          specularColor = vec3(0.0);
      
          // We perform all work in world space
          vec3 n = normalize(worldNormal);
          vec3 s = vec3(0.0);
      
          for (int i = 0; i < lightCount; ++i) {
              float att = 1.0;
              float sDotN = 0.0;
      
              if (lights[i].type != TYPE_DIRECTIONAL) {
                  // Point and Spot lights
      
                  // Light position is already in world space
                  vec3 sUnnormalized = lights[i].position - worldPos;
                  s = normalize(sUnnormalized); // Light direction
      
                  // Calculate the attenuation factor
                  sDotN = dot(s, n);
                  if (sDotN > 0.0) {
                      if (lights[i].constantAttenuation != 0.0
                       || lights[i].linearAttenuation != 0.0
                       || lights[i].quadraticAttenuation != 0.0) {
                          float dist = length(sUnnormalized);
                          att = 1.0 / (lights[i].constantAttenuation +
                                       lights[i].linearAttenuation * dist +
                                       lights[i].quadraticAttenuation * dist * dist);
                      }
      
                      // The light direction is in world space already
                      if (lights[i].type == TYPE_SPOT) {
                          // Check if fragment is inside or outside of the spot light cone
                          if (degrees(acos(dot(-s, lights[i].direction))) > lights[i].cutOffAngle)
                              sDotN = 0.0;
                      }
                  }
              } else {
                  // Directional lights
                  // The light direction is in world space already
                  s = normalize(-lights[i].direction);
                  sDotN = dot(s, n);
              }
      
              // Calculate the diffuse factor
              float diffuse = max(sDotN, 0.0);
      
              // Calculate the specular factor
              float specular = 0.0;
              if (diffuse > 0.0 && shininess > 0.0) {
                  float normFactor = (shininess + 2.0) / 2.0;
                  vec3 r = reflect(-s, n);   // Reflection direction in world space
                  specular = normFactor * pow(max(dot(r, worldView), 0.0), shininess);
              }
      
              // Accumulate the diffuse and specular contributions
              diffuseColor += att * lights[i].intensity * diffuse * lights[i].color;
              specularColor += att * lights[i].intensity * specular * lights[i].color;
          }
      }
      
      vec4 phongFunction(const in vec4 ambient,
                         const in vec4 diffuse,
                         const in vec4 specular,
                         const in float shininess,
                         const in vec3 worldPosition,
                         const in vec3 worldView,
                         const in vec3 worldNormal)
      {
          // Calculate the lighting model, keeping the specular component separate
          vec3 diffuseColor, specularColor;
          adsModel(worldPosition, worldNormal, worldView, shininess, diffuseColor, specularColor);
      
          // Combine spec with ambient+diffuse for final fragment color
          vec3 color = (ambient.rgb + diffuseColor) * diffuse.rgb
                     + specularColor * specular.rgb;
      
          return vec4(color, diffuse.a);
      }
      
      #line 11
      out vec4 fragColor;
      
      void main()
      {
          vec3 v1 = eyePosition;
           v0 = worldPosition;
           v2 = worldNormal;
           v7 = v1 - v0;
           v6 = shininess;
           v5 = ks;
           v4 = kd;
           v3 = ka;
           v9 = normalize(v2);
           v8 = normalize(v7);
          vec4 v12 = phongFunction(v3, v4, v5, v6, v0, v8, v9);
          fragColor = v12;
      }
      
      ***
      QOpenGLShader::compile(Fragment): Fragment shader failed to compile with the following errors:
      ERROR: 3:2: error(#132) Syntax error: "worldPosition" parse error
      ERROR: error(#273) 1 compilation errors.  No code generated
      
      
      *** Problematic Fragment shader source code ***
      #version 140
      #define lowp
      #define mediump
      #define highp
      #line 1
      
        worldPosition;
      uniform vec3 eyePosition;
        worldNormal;
        ka;
        kd;
        ks;
        shininess;
      /****************************************************************************
      **
      ** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the Qt3D module of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** Commercial License Usage
      ** Licensees holding valid commercial Qt licenses may use this file in
      ** accordance with the commercial license agreement provided with the
      ** Software or, alternatively, in accordance with the terms contained in
      ** a written agreement between you and The Qt Company. For licensing terms
      ** and conditions see https://www.qt.io/terms-conditions. For further
      ** information use the contact form at https://www.qt.io/contact-us.
      **
      ** BSD License Usage
      ** Alternatively, you may use this file under the terms of the BSD license
      ** as follows:
      **
      ** "Redistribution and use in source and binary forms, with or without
      ** modification, are permitted provided that the following conditions are
      ** met:
      **   * Redistributions of source code must retain the above copyright
      **     notice, this list of conditions and the following disclaimer.
      **   * Redistributions in binary form must reproduce the above copyright
      **     notice, this list of conditions and the following disclaimer in
      **     the documentation and/or other materials provided with the
      **     distribution.
      **   * Neither the name of The Qt Company Ltd nor the names of its
      **     contributors may be used to endorse or promote products derived
      **     from this software without specific prior written permission.
      **
      **
      ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
      **
      ** $QT_END_LICENSE$
      **
      ****************************************************************************/
      
      const int MAX_LIGHTS = 8;
      const int TYPE_POINT = 0;
      const int TYPE_DIRECTIONAL = 1;
      const int TYPE_SPOT = 2;
      struct Light {
          int type;
          vec3 position;
          vec3 color;
          float intensity;
          vec3 direction;
          float constantAttenuation;
          float linearAttenuation;
          float quadraticAttenuation;
          float cutOffAngle;
      };
      uniform Light lights[MAX_LIGHTS];
      uniform int lightCount;
      
      // Pre-convolved environment maps
      struct EnvironmentLight {
          samplerCube irradiance; // For diffuse contribution
          samplerCube specular; // For specular contribution
      };
      uniform EnvironmentLight envLight;
      uniform int envLightCount = 0;
      
      #line 52
      
      void adsModel(const in vec3 worldPos,
                    const in vec3 worldNormal,
                    const in vec3 worldView,
                    const in float shininess,
                    out vec3 diffuseColor,
                    out vec3 specularColor)
      {
          diffuseColor = vec3(0.0);
          specularColor = vec3(0.0);
      
          // We perform all work in world space
          vec3 n = normalize(worldNormal);
          vec3 s = vec3(0.0);
      
          for (int i = 0; i < lightCount; ++i) {
              float att = 1.0;
              float sDotN = 0.0;
      
              if (lights[i].type != TYPE_DIRECTIONAL) {
                  // Point and Spot lights
      
                  // Light position is already in world space
                  vec3 sUnnormalized = lights[i].position - worldPos;
                  s = normalize(sUnnormalized); // Light direction
      
                  // Calculate the attenuation factor
                  sDotN = dot(s, n);
                  if (sDotN > 0.0) {
                      if (lights[i].constantAttenuation != 0.0
                       || lights[i].linearAttenuation != 0.0
                       || lights[i].quadraticAttenuation != 0.0) {
                          float dist = length(sUnnormalized);
                          att = 1.0 / (lights[i].constantAttenuation +
                                       lights[i].linearAttenuation * dist +
                                       lights[i].quadraticAttenuation * dist * dist);
                      }
      
                      // The light direction is in world space already
                      if (lights[i].type == TYPE_SPOT) {
                          // Check if fragment is inside or outside of the spot light cone
                          if (degrees(acos(dot(-s, lights[i].direction))) > lights[i].cutOffAngle)
                              sDotN = 0.0;
                      }
                  }
              } else {
                  // Directional lights
                  // The light direction is in world space already
                  s = normalize(-lights[i].direction);
                  sDotN = dot(s, n);
              }
      
              // Calculate the diffuse factor
              float diffuse = max(sDotN, 0.0);
      
              // Calculate the specular factor
              float specular = 0.0;
              if (diffuse > 0.0 && shininess > 0.0) {
                  float normFactor = (shininess + 2.0) / 2.0;
                  vec3 r = reflect(-s, n);   // Reflection direction in world space
                  specular = normFactor * pow(max(dot(r, worldView), 0.0), shininess);
              }
      
              // Accumulate the diffuse and specular contributions
              diffuseColor += att * lights[i].intensity * diffuse * lights[i].color;
              specularColor += att * lights[i].intensity * specular * lights[i].color;
          }
      }
      
      vec4 phongFunction(const in vec4 ambient,
                         const in vec4 diffuse,
                         const in vec4 specular,
                         const in float shininess,
                         const in vec3 worldPosition,
                         const in vec3 worldView,
                         const in vec3 worldNormal)
      {
          // Calculate the lighting model, keeping the specular component separate
          vec3 diffuseColor, specularColor;
          adsModel(worldPosition, worldNormal, worldView, shininess, diffuseColor, specularColor);
      
          // Combine spec with ambient+diffuse for final fragment color
          vec3 color = (ambient.rgb + diffuseColor) * diffuse.rgb
                     + specularColor * specular.rgb;
      
          return vec4(color, diffuse.a);
      }
      
      #line 11
      out vec4 fragColor;
      
      void main()
      {
          vec3 v1 = eyePosition;
           v0 = worldPosition;
           v2 = worldNormal;
           v7 = v1 - v0;
           v6 = shininess;
           v5 = ks;
           v4 = kd;
           v3 = ka;
           v9 = normalize(v2);
           v8 = normalize(v7);
          vec4 v12 = phongFunction(v3, v4, v5, v6, v0, v8, v9);
          fragColor = v12;
      }
      
      ***
      ASSERT: "!m_programHash.contains(dna)" in file e:\qt3d_510\src\render\materialsystem\shadercache.cpp, line 87
      E:\qt3d_510\examples\qt3d\simple-qml\debug\simple-qml.exe exited with code 3
      

      This can be critical for platforms like INTEGRITY where static builds are the only option.

        Attachments

          Issue Links

          For Gerrit Dashboard: QTBUG-64365
          # Subject Branch Project Status CR V

            Activity

              People

              • Assignee:
                lagocs Laszlo Agocs
                Reporter:
                lagocs Laszlo Agocs
              • Votes:
                0 Vote for this issue
                Watchers:
                1 Start watching this issue

                Dates

                • Created:
                  Updated:
                  Resolved:

                  Gerrit Reviews

                  There are no open Gerrit changes