Shader errors if there are multiple windows

QObject::connect(QOpenGLContext, Unknown): invalid nullptr parameter
QObject::connect(QOpenGLContext, Unknown): invalid nullptr parameter
QString::arg: Argument missing: "  Max Work Group Size: 1536, 1024, 64\n  Max Work Group Count: 2147483647, 65535, 65535\n  Max Invocations: 65535\n  Max Shared Memory Size: 1536\n" , 49152
QOpenGLShader::compile(Fragment): 0(3) : error C0000: syntax error, unexpected '-', expecting "::" at token "-"
0(74) : error C0000: syntax error, unexpected '}' at token "}"
0(76) : error C1154: non constant expression in layout value
0(84) : error C7566: uniform blocks require #version 140 or later
0(84) : error C0000: ... or #extension GL_ARB_gpu_shader5 : enable
0(84) : error C0000: ... or #extension GL_ARB_uniform_buffer_object : enable
0(84) : error C7532: layout qualifier 'binding' requires "#version 420" or later
0(84) : error C0000: ... or #extension GL_ARB_shading_language_420pack : enable
0(86) : error C1154: non constant expression in layout value
0(88) : error C7566: uniform blocks require #version 140 or later
0(88) : error C0000: ... or #extension GL_ARB_gpu_shader5 : enable
0(88) : error C0000: ... or #extension GL_ARB_uniform_buffer_object : enable
0(88) : error C7532: layout qualifier 'binding' requires "#version 420" or later
0(88) : error C0000: ... or #extension GL_ARB_shading_language_420pack : enable
0(21) : error C1154: non constant expression in layout value
0(25) : error C7566: uniform blocks require #version 140 or later
0(25) : error C0000: ... or #extension GL_ARB_gpu_shader5 : enable
0(25) : error C0000: ... or #extension GL_ARB_uniform_buffer_object : enable
0(25) : error C7532: layout qualifier 'binding' requires "#version 420" or later
0(25) : error C0000: ... or #extension GL_ARB_shading_language_420pack : enable
0(28) : error C1154: non constant expression in layout value
0(28) : error C7532: layout(binding) requires "#version 420" or later
0(28) : error C0000: ... or #extension GL_ARB_shading_language_420pack : enable
0(29) : error C1154: non constant expression in layout value
0(29) : error C7532: layout(binding) requires "#version 420" or later
0(29) : error C0000: ... or #extension GL_ARB_shading_language_420pack : enable
0(11) : error C7548: 'layout(location)' requires "#extension GL_ARB_explicit_attrib_location : enable" before use
0(11) : error C0000: ... or #extension GL_ARB_separate_shader_objects : enable
0(11) : error C0000: ... or #version 330
0(11) : error C5060: out can't be used with non-varying fragColor

*** 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)))))))));
}

***