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

QOpenGLShader::compile errors

    XMLWordPrintable

Details

    • Bug
    • Resolution: Duplicate
    • P1: Critical
    • None
    • 5.15.0 RC2, 5.15.1
    • Qt3D
    • Windows 10, x64
    • All

    Description

      Setup:

      • Qt3D/QML Scene3D in QQuickWidget
      • Scenegraph (but not the framegraph) is being manipulated from C++
      • Notable used Qt3D objects: QPerVertexColorMaterial, QPhongAlphaMaterial, QPlaneMesh, QMesh,  QTextureMaterial, QExtrudedTextMesh, QPaintedTextureImage
      • MSVC 2019 x64

      At the start of the application, the following error is reported via application output:

      
      

      QOpenGLShaderPrivate::compile: QOpenGLShader::compile(Fragment): ERROR: 4:2: 'add' : syntax error syntax error

      QOpenGLShaderPrivate::compile: *** Problematic Fragment shader source code ***
      #version 110
      #ifdef GL_KHR_blend_equation_advanced
      #extension GL_ARB_fragment_coord_conventions : enable
      #extension GL_KHR_blend_equation_advanced : enable
      #endif
      #define lowp
      #define mediump
      #define highp
      #line 1

      add-input varying vec3 worldPosition
      add-input varying vec3 worldNormal
      add-input uniform vec4 ka
      add-input uniform vec4 kd
      add-input uniform vec4 ks
      add-input uniform float 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$
          **
          ****************************************************************************/

      layout(std140, binding = auto) uniform qt3d_render_view_uniforms

      { mat4 viewMatrix; mat4 projectionMatrix; mat4 viewProjectionMatrix; mat4 inverseViewMatrix; mat4 inverseProjectionMatrix; mat4 inverseViewProjectionMatrix; mat4 viewportMatrix; mat4 inverseViewportMatrix; vec4 textureTransformMatrix; vec3 eyePosition; float aspectRatio; float gamma; float exposure; float time; }

      ;

      layout(std140, binding = auto) uniform qt3d_command_uniforms

      { mat4 modelMatrix; mat4 inverseModelMatrix; mat4 modelViewMatrix; mat3 modelNormalMatrix; mat4 inverseModelViewMatrix; mat4 mvp; mat4 inverseModelViewProjectionMatrix; }

      ;

      layout(std140, binding = auto) uniform qt3d_extras_uniforms

      { float texCoordScale; }

      ;

      #line 2

      const int MAX_LIGHTS = 8;
      const int TYPE_POINT = 0;
      const int TYPE_DIRECTIONAL = 1;
      const int TYPE_SPOT = 2;

      struct Light

      { vec3 position; float intensity; vec3 color; float constantAttenuation; vec3 direction; float linearAttenuation; float quadraticAttenuation; float cutOffAngle; int type; }

      ;

      layout(std140, binding = auto) uniform qt3d_light_uniforms

      { Light lights[MAX_LIGHTS]; int lightCount; int envLightCount; }

      ;

      // Pre-convolved environment maps
      layout(binding = auto) uniform samplerCube envLight_irradiance; // For diffuse contribution
      layout(binding = auto) uniform samplerCube envLight_specular; // For specular contribution

      #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 10
      layout(location = 0) out vec4 fragColor;

      void main()

      { fragColor = (((((((phongFunction(ka, kd, ks, shininess, worldPosition, normalize(((eyePosition - worldPosition))), normalize(worldNormal))))))))); }

      ***

      
      

      Additionally, the 3D view is blank until the camera is moved. Then the view appears and everything seems to be as it should be.

      None of this is present when compiled with Qt 5.14.2.

      Attachments

        Issue Links

          No reviews matched the request. Check your Options in the drop-down menu of this sections header.

          Activity

            People

              seanharmer Sean Harmer
              isikorska Iwona Sikorska
              Votes:
              2 Vote for this issue
              Watchers:
              7 Start watching this issue

              Dates

                Created:
                Updated:
                Resolved:

                Gerrit Reviews

                  There are no open Gerrit changes