Fix CGAL::draw() black rendering on OpenGL < 4.3 (#9399)

## Summary of Changes

Fixes `CGAL::draw()` rendering solid black geometry on systems with
OpenGL < 4.3 by correcting the compatibility GLSL shaders and improving
OpenGL version detection.

### Compatibility shader fixes (`Basic_shaders.h`):

- **`VERTEX_SOURCE_COLOR_COMP`**: Changed `varying` to `attribute` for
vertex inputs (`a_Pos`, `a_Normal`, `a_Color`). In GLSL 1.10/1.20,
vertex shader inputs must use the `attribute` qualifier — `varying` is
only for outputs passed to the fragment shader.
- **`VERTEX_SOURCE_COLOR_COMP`**: Replaced the undefined `mv_matrix`
variable with `mat3(u_Mv) * a_Normal`, using the already-declared `u_Mv`
uniform (matching the OpenGL 4.3 shader path).
- **`VERTEX_SOURCE_P_L_COMP`**: Changed `varying` to `attribute` for
vertex inputs (`a_Pos`, `a_Color`), same fix as above.

### OpenGL version detection fixes (`qglviewer_impl.h`):

- **`defaultConstructor()`**: Initialize `is_ogl_4_3` to `false`.
Previously uninitialized, leading to undefined behavior.
- **`initializeGL()`**: Fixed version check from `format.majorVersion()
!= 4` to `(format.majorVersion() < 4 || (format.majorVersion() == 4 &&
format.minorVersion() < 3))`. The old check incorrectly classified
OpenGL 4.0–4.2 as 4.3-capable and would have broken on future OpenGL 5+.

### Diagnostic warning (`Basic_viewer.h`):

- Added a `std::cerr` warning in `compile_shaders()` when compatibility
shaders are selected, to aid debugging on OpenGL < 4.3 systems.

## Release Management

* Affected package(s): Basic_viewer, GraphicsView
* Issue(s) solved (if any): fix #6754
* Feature/Small Feature (if any): N/A
* License and copyright ownership: N/A

Fixes #6754
Fixes #9292

Author: sloriot

Basic_viewer/include/CGAL/Basic_shaders.h

@@ -721,8 +721,6 @@ const char GEOMETRY_SOURCE_LINE_WIDTH[]=R"DELIM(
 layout (lines) in;
 layout (triangle_strip, max_vertices = 4) out;
 
-in mediump vec4 g_Color[];
-
 in VS_OUT {
   mediump float pointSize;
   mediump vec4 color;

Basic_viewer/include/CGAL/Qt/Basic_viewer.h

@@ -461,7 +461,7 @@ class Basic_viewer : public CGAL::QGLViewer
 
         rendering_program_cylinder.release();
       }
-      else
+      else if (isOpenGL_3_2())
       {
         auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
 
@@ -518,6 +518,52 @@ class Basic_viewer : public CGAL::QGLViewer
 
         rendering_program_line.release();
       }
+      else
+      {
+        auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
+          rendering_program_p_l.bind();
+
+          if (m_use_default_color)
+          {
+            auto edge_color = m_scene.get_default_color_segment();
+            color = QVector3D((double)edge_color.red()/(double)255,
+                              (double)edge_color.green()/(double)255,
+                              (double)edge_color.blue()/(double)255);
+            rendering_program_p_l.setUniformValue("u_DefaultColor", color);
+            rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(1));
+          }
+          else
+          {
+            rendering_program_p_l.setUniformValue("u_UseDefaultColor", static_cast<GLint>(0));
+          }
+          rendering_program_p_l.setUniformValue("u_PointSize", GLfloat(m_size_edges));
+          rendering_program_p_l.setUniformValue("u_IsOrthographic", GLint(is_two_dimensional()));
+
+          rendering_program_p_l.setUniformValue("u_ClipPlane", clipPlane);
+          rendering_program_p_l.setUniformValue("u_PointPlane", plane_point);
+          rendering_program_p_l.setUniformValue("u_RenderingMode", rendering_mode);
+
+          vao[VAO_SEGMENTS].bind();
+          glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(m_scene.number_of_elements(GS::POS_SEGMENTS)));
+        };
+
+        enum {
+          DRAW_ALL = -1,
+          DRAW_INSIDE_ONLY,
+          DRAW_OUTSIDE_ONLY
+        };
+
+        if (m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY)
+        {
+          renderer(DRAW_INSIDE_ONLY);
+        }
+        else
+        {
+          renderer(DRAW_ALL);
+        }
+
+        rendering_program_p_l.release();
+      }
     }
 
     if(m_draw_rays)
@@ -661,7 +707,7 @@ class Basic_viewer : public CGAL::QGLViewer
       };
 
       auto renderer_clipping_plane = [this](bool clipping_plane_rendering) {
-        if (!isOpenGL_4_3()) return;
+        if (!isOpenGL_3_2()) return;
         if (!clipping_plane_rendering) return;
         // render clipping plane here
         rendering_program_clipping_plane.bind();
@@ -840,6 +886,13 @@ class Basic_viewer : public CGAL::QGLViewer
 protected:
   void compile_shaders()
   {
+    static bool s_compat_warning_shown = false;
+    if (!isOpenGL_3_2() && !s_compat_warning_shown)
+    {
+      std::cerr<<"CGAL Basic_viewer: OpenGL < 3.2 detected, using compatibility shaders"<<std::endl;
+      s_compat_warning_shown = true;
+    }
+
     rendering_program_face.removeAllShaders();
     rendering_program_p_l.removeAllShaders();
     rendering_program_line.removeAllShaders();
@@ -864,19 +917,19 @@ class Basic_viewer : public CGAL::QGLViewer
 
     // Vertices and segments shader
 
-    // const char* source_ = isOpenGL_4_3()
+    // const char* source_ = isOpenGL_3_2()
     //     ? VERTEX_SOURCE_P_L
     //     : VERTEX_SOURCE_P_L_COMP;
 
-    const char* source_ = isOpenGL_4_3()
+    const char* source_ = isOpenGL_3_2()
                           ? VERTEX_SOURCE_P_L
                           : VERTEX_SOURCE_P_L_COMP;
 
     QOpenGLShader *vertex_shader_p_l = new QOpenGLShader(QOpenGLShader::Vertex);
     if(!vertex_shader_p_l->compileSourceCode(source_))
     { std::cerr<<"Compiling vertex source FAILED"<<std::endl; }
 
-    source_ = isOpenGL_4_3()
+    source_ = isOpenGL_3_2()
         ? FRAGMENT_SOURCE_P_L
         : FRAGMENT_SOURCE_P_L_COMP;
 
@@ -888,20 +941,22 @@ class Basic_viewer : public CGAL::QGLViewer
     { std::cerr<<"adding vertex shader FAILED"<<std::endl; }
     if(!rendering_program_p_l.addShader(fragment_shader_p_l))
     { std::cerr<<"adding fragment shader FAILED"<<std::endl; }
+    rendering_program_p_l.bindAttributeLocation("a_Pos", 0);
+    rendering_program_p_l.bindAttributeLocation("a_Color", 1);
     if(!rendering_program_p_l.link())
     { std::cerr<<"linking Program FAILED"<<std::endl; }
 
     // Faces shader
 
-    source_ = isOpenGL_4_3()
+    source_ = isOpenGL_3_2()
             ? VERTEX_SOURCE_COLOR
             : VERTEX_SOURCE_COLOR_COMP;
 
     QOpenGLShader *vertex_shader_face = new QOpenGLShader(QOpenGLShader::Vertex);
     if(!vertex_shader_face->compileSourceCode(source_))
     { std::cerr<<"Compiling vertex source FAILED"<<std::endl; }
 
-    source_ = isOpenGL_4_3()
+    source_ = isOpenGL_3_2()
             ? FRAGMENT_SOURCE_COLOR
             : FRAGMENT_SOURCE_COLOR_COMP;
 
@@ -916,7 +971,7 @@ class Basic_viewer : public CGAL::QGLViewer
     if(!rendering_program_face.link())
     { std::cerr<<"linking Program FAILED"<<std::endl; }
 
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       // clipping plane shader
       source_ = VERTEX_SOURCE_CLIPPING_PLANE;
@@ -940,15 +995,15 @@ class Basic_viewer : public CGAL::QGLViewer
 
     }
 
-    // source_ = isOpenGL_4_3()
+    // source_ = isOpenGL_3_2()
     //         ? VERTEX_SOURCE_CLIPPING_PLANE
     //         : vertex_source_clipping_plane_comp;
 
     // QOpenGLShader *vertex_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Vertex);
     // if (!vertex_shader_clipping_plane->compileSourceCode(source_))
     // { std::cerr << "Compiling vertex source for clipping plane FAILED" << std::endl; }
 
-    // source_ = isOpenGL_4_3()
+    // source_ = isOpenGL_3_2()
     //         ? FRAGMENT_SOURCE_CLIPPING_PLANE
     //         : fragment_source_clipping_plane_comp;
 
@@ -964,7 +1019,7 @@ class Basic_viewer : public CGAL::QGLViewer
     // { std::cerr << "Linking Program for clipping plane FAILED" << std::endl; }
 
     // Sphere shader
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       source_ = VERTEX_SOURCE_SHAPE;
 
@@ -996,7 +1051,7 @@ class Basic_viewer : public CGAL::QGLViewer
     }
 
     // Cylinder shader
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       source_ = VERTEX_SOURCE_SHAPE;
 
@@ -1023,12 +1078,14 @@ class Basic_viewer : public CGAL::QGLViewer
       { std::cerr << "Adding geometry shader for cylinder FAILED" << std::endl;}
       if (!rendering_program_cylinder.addShader(fragment_shader_cylinder))
       { std::cerr << "Adding fragment shader for cylinder FAILED" << std::endl; }
+      rendering_program_cylinder.bindAttributeLocation("a_Pos", 0);
+      rendering_program_cylinder.bindAttributeLocation("a_Color", 1);
       if (!rendering_program_cylinder.link())
       { std::cerr << "Linking Program for cylinder FAILED" << std::endl; }
     }
 
     // Normal shader
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       source_ = VERTEX_SOURCE_NORMAL;
 
@@ -1060,7 +1117,7 @@ class Basic_viewer : public CGAL::QGLViewer
     }
 
     // Triangle shader
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       source_ = VERTEX_SOURCE_TRIANGLE;
 
@@ -1092,7 +1149,7 @@ class Basic_viewer : public CGAL::QGLViewer
     }
 
     // Line shader
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       source_ = VERTEX_SOURCE_LINE_WIDTH;
 
@@ -1119,6 +1176,8 @@ class Basic_viewer : public CGAL::QGLViewer
       { std::cerr << "Adding geometry shader for line FAILED" << std::endl;}
       if (!rendering_program_line.addShader(fragment_shader_line))
       { std::cerr << "Adding fragment shader for line FAILED" << std::endl; }
+      rendering_program_line.bindAttributeLocation("a_Pos", 0);
+      rendering_program_line.bindAttributeLocation("a_Color", 1);
       if (!rendering_program_line.link())
       { std::cerr << "Linking Program for line FAILED" << std::endl; }
     }
@@ -1241,7 +1300,7 @@ class Basic_viewer : public CGAL::QGLViewer
     rendering_program_face.setAttributeBuffer("a_Color",GL_FLOAT,0,3);
 
     // 6) clipping plane shader
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       generate_clipping_plane();
 
@@ -1340,7 +1399,7 @@ class Basic_viewer : public CGAL::QGLViewer
     rendering_program_sphere.setUniformValue(mvpLocation, mvpMatrix);
     rendering_program_sphere.release();
 
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       QMatrix4x4 clipping_mMatrix;
       clipping_mMatrix.setToIdentity();
@@ -1355,7 +1414,7 @@ class Basic_viewer : public CGAL::QGLViewer
       rendering_program_clipping_plane.release();
     }
 
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       rendering_program_normal.bind();
 
@@ -1374,7 +1433,7 @@ class Basic_viewer : public CGAL::QGLViewer
       rendering_program_normal.release();
     }
 
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       rendering_program_triangle.bind();
 
@@ -1383,7 +1442,7 @@ class Basic_viewer : public CGAL::QGLViewer
       rendering_program_triangle.release();
     }
 
-    if (isOpenGL_4_3())
+    if (isOpenGL_3_2())
     {
       rendering_program_line.bind();
 
@@ -1559,7 +1618,7 @@ class Basic_viewer : public CGAL::QGLViewer
       const ::Qt::KeyboardModifiers modifiers = e->modifiers();
       if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::NoButton))
       {
-        if (!isOpenGL_4_3()) return;
+        if (!isOpenGL_3_2()) return;
         if (!is_two_dimensional())
         {
           // toggle clipping plane
@@ -1583,7 +1642,7 @@ class Basic_viewer : public CGAL::QGLViewer
 
       else if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::AltModifier))
       {
-        if (!isOpenGL_4_3()) return;
+        if (!isOpenGL_3_2()) return;
         if (m_use_clipping_plane!=CLIPPING_PLANE_OFF)
         {
           clipping_plane_rendering = !clipping_plane_rendering;

GraphicsView/include/CGAL/Qt/qglviewer.h

@@ -1211,6 +1211,7 @@ private Q_SLOTS:
   qglviewer::Vec _offset;
   //C o n t e x t
   bool is_ogl_4_3;
+  bool is_ogl_3_2;
   bool is_sharing;
   bool is_linked;
   QOpenGLContext* shared_context;
@@ -1223,6 +1224,13 @@ private Q_SLOTS:
   //! @returns `false` if the context is ES 2.0.
   bool isOpenGL_4_3()const {return is_ogl_4_3; }
 
+  //! Is used to know if the openGL context supports GLSL 1.50 (OpenGL 3.2).
+  //! This is the requirement for the modern (`#version 150`) shaders, which is
+  //! weaker than isOpenGL_4_3(). Use this to select modern vs compatibility
+  //! shaders, and isOpenGL_4_3() for the OpenGL 4.3 C++ API.
+  //! @returns `true` if the context is at least OpenGL 3.2.
+  bool isOpenGL_3_2()const {return is_ogl_3_2; }
+
 };
 
 } //end CGAL

GraphicsView/include/CGAL/Qt/qglviewer_impl.h

@@ -152,6 +152,8 @@ void CGAL::QGLViewer::defaultConstructor() {
   is_sharing = false;
   is_linked = false;
   shared_context = nullptr;
+  is_ogl_4_3 = false;
+  is_ogl_3_2 = false;
   _first_tick  = true;
 }
 
@@ -205,17 +207,23 @@ void CGAL::QGLViewer::initializeGL() {
   {
     QSurfaceFormat format = context()->format();
     context()->format().setOption(QSurfaceFormat::DebugContext);
-    if ( !context()->isValid()
-         || format.majorVersion() != 4
-         || QCoreApplication::arguments().contains(QStringLiteral("--old")))
-
-    {
-      is_ogl_4_3 = false;
-    }
-    else
-    {
-      is_ogl_4_3 = true;
-    }
+    const bool gl_is_valid = context()->isValid();
+    const bool force_old =
+        QCoreApplication::arguments().contains(QStringLiteral("--old"));
+    const int gl_major = format.majorVersion();
+    const int gl_minor = format.minorVersion();
+
+    // is_ogl_4_3 gates the real OpenGL 4.3 C++ API (QOpenGLFunctions_4_3_Core),
+    // used e.g. by the CGAL Lab demo. Behaviour unchanged.
+    is_ogl_4_3 = gl_is_valid && !force_old
+                 && !(gl_major < 4 || (gl_major == 4 && gl_minor < 3));
+
+    // is_ogl_3_2 gates the modern GLSL 1.50 (#version 150) shader path, which
+    // only needs OpenGL 3.2. Basic_viewer uses this to pick modern vs
+    // compatibility shaders, so the modern path also works on contexts such as
+    // macOS 4.1 core profiles.
+    is_ogl_3_2 = gl_is_valid && !force_old
+                 && !(gl_major < 3 || (gl_major == 3 && gl_minor < 2));
 
     QSurfaceFormat cur_f = QOpenGLContext::currentContext()->format();
     const char* rt =(cur_f.renderableType() == QSurfaceFormat::OpenGLES) ? "GLES" : "GL";