From 3b838da50a474075d0f25d9626460ac6516f8044 Mon Sep 17 00:00:00 2001
From: Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
Date: Wed, 27 Jan 2021 18:47:38 +0100
Subject: [PATCH 1/7] Re-add clipping plane.

---
 GraphicsView/include/CGAL/Basic_shaders.h     | 275 ++++++++
 .../include/CGAL/Qt/Basic_viewer_qt.h         | 636 ++++++++++++------
 2 files changed, 697 insertions(+), 214 deletions(-)
 create mode 100644 GraphicsView/include/CGAL/Basic_shaders.h

diff --git a/GraphicsView/include/CGAL/Basic_shaders.h b/GraphicsView/include/CGAL/Basic_shaders.h
new file mode 100644
index 00000000000..429f2b52f00
--- /dev/null
+++ b/GraphicsView/include/CGAL/Basic_shaders.h
@@ -0,0 +1,275 @@
+// Copyright (c) 2018  GeometryFactory Sarl (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org).
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
+//
+//
+// Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
+
+#ifndef CGAL_BASIC_SHADERS_H
+#define CGAL_BASIC_SHADERS_H
+
+namespace CGAL
+{
+
+//------------------------------------------------------------------------------
+const char vertex_source_color[]=R"DELIM(
+#version 120
+attribute highp vec4 vertex;
+attribute highp vec3 normal;
+attribute highp vec3 color;
+
+uniform highp mat4 mvp_matrix;
+uniform highp mat4 mv_matrix;
+
+varying highp vec4 fP;
+varying highp vec3 fN;
+varying highp vec4 fColor;
+
+uniform highp float point_size;
+
+varying highp vec4 m_vertex;
+
+void main(void)
+{
+  fP = mv_matrix * vertex;
+  fN = mat3(mv_matrix)* normal;
+  fColor = vec4(color, 1.0);
+  gl_PointSize = point_size;
+
+  m_vertex = vertex;
+
+  gl_Position = mvp_matrix * vertex;
+}
+)DELIM";
+
+const char fragment_source_color[]=R"DELIM(
+#version 120
+varying highp vec4 fP;
+varying highp vec3 fN;
+varying highp vec4 fColor;
+
+varying highp vec4 m_vertex;
+
+uniform highp vec4 light_pos;
+uniform highp vec4 light_diff;
+uniform highp vec4 light_spec;
+uniform highp vec4 light_amb;
+uniform highp float spec_power;
+
+uniform highp vec4 clipPlane;
+uniform highp float rendering_mode;
+uniform highp float rendering_transparency;
+
+void main(void)
+{
+  highp vec3 L = light_pos.xyz - fP.xyz;
+  highp vec3 V = -fP.xyz;
+
+  highp vec3 N = normalize(fN);
+  L = normalize(L);
+  V = normalize(V);
+
+  highp vec3 R = reflect(-L, N);
+  highp vec4 diffuse = vec4(max(dot(N,L), 0.0) * light_diff.rgb * fColor.rgb, 1.0);
+  highp vec4 ambient = vec4(light_amb.rgb * fColor.rgb, 1.0);
+  highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec;
+
+  // onPlane == 1: inside clipping plane, should be solid;
+  // onPlane == -1: outside clipping plane, should be transparent;
+  // onPlane == 0: on clipping plane, whatever;
+  float onPlane = sign(dot(m_vertex.xyz, clipPlane.xyz) - clipPlane.w);
+
+  // rendering_mode == -1: draw all solid;
+  // rendering_mode == 0: draw solid only;
+  // rendering_mode == 1: draw transparent only;
+  if (rendering_mode == (onPlane+1)/2) {
+    // discard other than the corresponding half when rendering
+    discard;
+  }
+
+  // draw corresponding part
+  gl_FragColor = rendering_mode < 1 ? (diffuse + ambient) :
+                      vec4(diffuse.rgb + ambient.rgb, rendering_transparency);
+}
+)DELIM";
+
+const char vertex_source_p_l[]=R"DELIM(
+#version 120
+attribute highp vec4 vertex;
+attribute highp vec3 color;
+
+uniform highp mat4 mvp_matrix;
+varying highp vec4 fColor;
+
+varying highp vec4 m_vertex;
+
+uniform highp float point_size;
+void main(void)
+{
+  gl_PointSize = point_size;
+  fColor = vec4(color, 1.0);
+  m_vertex = vertex;
+  gl_Position = mvp_matrix * vertex;
+}
+)DELIM";
+
+const char fragment_source_p_l[]=R"DELIM(
+#version 120
+varying highp vec4 fColor;
+varying highp vec4 m_vertex;
+uniform highp vec4 clipPlane;
+uniform highp float rendering_mode;
+
+void main(void)
+{
+  // onPlane == 1: inside clipping plane, should be solid;
+  // onPlane == -1: outside clipping plane, should be transparent;
+  // onPlane == 0: on clipping plane, whatever;
+  float onPlane = sign(dot(m_vertex.xyz, clipPlane.xyz) - clipPlane.w);
+
+  // rendering_mode == -1: draw both inside and outside;
+  // rendering_mode == 0: draw inside only;
+  // rendering_mode == 1: draw outside only;
+  if (rendering_mode == (onPlane+1)/2) {
+    // discard other than the corresponding half when rendering
+    discard;
+  }
+
+  gl_FragColor = fColor;
+}
+)DELIM";
+
+const char vertex_source_clipping_plane[]=R"DELIM(
+#version 120
+attribute highp vec4 vertex;
+
+uniform highp mat4 vp_matrix;
+uniform highp mat4 m_matrix;
+
+void main(void)
+{
+  gl_Position = vp_matrix * m_matrix * vertex;
+}
+)DELIM";
+
+const char fragment_source_clipping_plane[]=R"DELIM(
+#version 120
+void main(void)
+{
+  gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+}
+)DELIM";
+
+//------------------------------------------------------------------------------
+//  compatibility shaders
+
+const char vertex_source_color_comp[]=R"DELIM(
+attribute highp vec4 vertex;
+attribute highp vec3 normal;
+attribute highp vec3 color;
+
+uniform highp mat4 mvp_matrix;
+uniform highp mat4 mv_matrix;
+
+varying highp vec4 fP;
+varying highp vec3 fN;
+varying highp vec4 fColor;
+
+uniform highp float point_size;
+
+void main(void)
+{
+  fP = mv_matrix * vertex;
+  highp mat3 mv_matrix_3;
+  mv_matrix_3[0] = mv_matrix[0].xyz;
+  mv_matrix_3[1] = mv_matrix[1].xyz;
+  mv_matrix_3[2] = mv_matrix[2].xyz;
+  fN = mv_matrix_3* normal;
+  fColor = vec4(color, 1.0);
+  gl_PointSize = point_size;
+
+  gl_Position = mvp_matrix * vertex;
+}
+)DELIM";
+
+const char fragment_source_color_comp[]=R"DELIM(
+varying highp vec4 fP;
+varying highp vec3 fN;
+varying highp vec4 fColor;
+
+uniform highp vec4 light_pos;
+uniform highp vec4 light_diff;
+uniform highp vec4 light_spec;
+uniform highp vec4 light_amb;
+uniform highp float spec_power ;
+
+void main(void)
+{
+  highp vec3 L = light_pos.xyz - fP.xyz;
+  highp vec3 V = -fP.xyz;
+
+  highp vec3 N = normalize(fN);
+  L = normalize(L);
+  V = normalize(V);
+
+  highp vec3 R = reflect(-L, N);
+  highp vec4 diffuse = max(dot(N,L), 0.0) * light_diff * fColor;
+  highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec;
+
+  gl_FragColor = light_amb*fColor + diffuse;
+}
+)DELIM";
+
+const char vertex_source_p_l_comp[]=R"DELIM(
+attribute highp vec4 vertex;
+attribute highp vec3 color;
+
+uniform highp mat4 mvp_matrix;
+varying highp vec4 fColor;
+
+uniform highp float point_size;
+
+void main(void)
+{
+  gl_PointSize = point_size;
+  fColor = vec4(color, 1.0);
+  gl_Position = mvp_matrix * vertex;
+}
+)DELIM";
+
+const char fragment_source_p_l_comp[]=R"DELIM(
+varying highp vec4 fColor;
+void main(void)
+{
+  gl_FragColor = fColor;
+}
+)DELIM";
+
+/* const char vertex_source_clipping_plane_comp[]=R"DELIM(
+attribute highp vec4 vertex;
+
+uniform highp mat4 vp_matrix;
+uniform highp mat4 m_matrix;
+
+void main(void)
+{
+  gl_Position = vp_matrix * m_matrix * vertex;
+}
+)DELIM";
+
+const char fragment_source_clipping_plane_comp[]=R"DELIM(
+void main(void)
+{
+  gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+}
+)DELIM";
+*/
+
+}
+
+#endif // CGAL_BASIC_SHADERS_H
diff --git a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
index 11058fe04e6..be88ad7fce4 100644
--- a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
+++ b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
@@ -48,179 +48,13 @@
 #include <cfloat>
 
 #include <CGAL/Buffer_for_vao.h>
+#include <CGAL/Basic_shaders.h>
 #include <CGAL/Qt/CreateOpenGLContext.h>
 #include <CGAL/Qt/constraint.h>
 #include <CGAL/Random.h>
 
 namespace CGAL
 {
-
-//------------------------------------------------------------------------------
-const char vertex_source_color[] =
-  {
-    "#version 120 \n"
-    "attribute highp vec4 vertex;\n"
-    "attribute highp vec3 normal;\n"
-    "attribute highp vec3 color;\n"
-
-    "uniform highp mat4 mvp_matrix;\n"
-    "uniform highp mat4 mv_matrix; \n"
-
-    "varying highp vec4 fP; \n"
-    "varying highp vec3 fN; \n"
-    "varying highp vec4 fColor; \n"
-
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   fP = mv_matrix * vertex; \n"
-    "   fN = mat3(mv_matrix)* normal; \n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_PointSize = point_size;\n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_color[] =
-  {
-    "#version 120 \n"
-    "varying highp vec4 fP; \n"
-    "varying highp vec3 fN; \n"
-    "varying highp vec4 fColor; \n"
-    "uniform highp vec4 light_pos;  \n"
-    "uniform highp vec4 light_diff; \n"
-    "uniform highp vec4 light_spec; \n"
-    "uniform highp vec4 light_amb;  \n"
-    "uniform float spec_power ; \n"
-
-    "void main(void) { \n"
-    "   highp vec3 L = light_pos.xyz - fP.xyz; \n"
-    "   highp vec3 V = -fP.xyz; \n"
-
-    "   highp vec3 N = normalize(fN); \n"
-    "   L = normalize(L); \n"
-    "   V = normalize(V); \n"
-
-    "   highp vec3 R = reflect(-L, N); \n"
-    "   highp vec4 diffuse = max(dot(N,L), 0.0) * light_diff * fColor; \n"
-    "   highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec; \n"
-    "   gl_FragColor = light_amb*fColor + diffuse  ; \n"
-    "} \n"
-    "\n"
-  };
-
-const char vertex_source_p_l[] =
-  {
-    "#version 120 \n"
-    "attribute highp vec4 vertex;\n"
-    "attribute highp vec3 color;\n"
-    "uniform highp mat4 mvp_matrix;\n"
-    "varying highp vec4 fColor; \n"
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   gl_PointSize = point_size;\n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_p_l[] =
-  {
-    "#version 120 \n"
-    "varying highp vec4 fColor; \n"
-    "void main(void) { \n"
-    "gl_FragColor = fColor; \n"
-    "} \n"
-    "\n"
-  };
-
-//------------------------------------------------------------------------------
-//  compatibility shaders
-
-const char vertex_source_color_comp[] =
-  {
-    "attribute highp vec4 vertex;\n"
-    "attribute highp vec3 normal;\n"
-    "attribute highp vec3 color;\n"
-
-    "uniform highp mat4 mvp_matrix;\n"
-    "uniform highp mat4 mv_matrix; \n"
-
-    "varying highp vec4 fP; \n"
-    "varying highp vec3 fN; \n"
-    "varying highp vec4 fColor; \n"
-
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   fP = mv_matrix * vertex; \n"
-    "   highp mat3 mv_matrix_3; \n"
-    "   mv_matrix_3[0] = mv_matrix[0].xyz; \n"
-    "   mv_matrix_3[1] = mv_matrix[1].xyz; \n"
-    "   mv_matrix_3[2] = mv_matrix[2].xyz; \n"
-    "   fN = mv_matrix_3* normal;  \n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_PointSize = point_size;\n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_color_comp[] =
-  {
-    "varying highp vec4 fP; \n"
-    "varying highp vec3 fN; \n"
-    "varying highp vec4 fColor; \n"
-    "uniform highp vec4 light_pos;  \n"
-    "uniform highp vec4 light_diff; \n"
-    "uniform highp vec4 light_spec; \n"
-    "uniform highp vec4 light_amb;  \n"
-    "uniform highp float spec_power ; \n"
-
-    "void main(void) { \n"
-
-    "   highp vec3 L = light_pos.xyz - fP.xyz; \n"
-    "   highp vec3 V = -fP.xyz; \n"
-
-    "   highp vec3 N = normalize(fN); \n"
-    "   L = normalize(L); \n"
-    "   V = normalize(V); \n"
-
-    "   highp vec3 R = reflect(-L, N); \n"
-    "   highp vec4 diffuse = max(dot(N,L), 0.0) * light_diff * fColor; \n"
-    "   highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec; \n"
-
-    "gl_FragColor = light_amb*fColor + diffuse  ; \n"
-    "} \n"
-    "\n"
-  };
-
-const char vertex_source_p_l_comp[] =
-  {
-    "attribute highp vec4 vertex;\n"
-    "attribute highp vec3 color;\n"
-    "uniform highp mat4 mvp_matrix;\n"
-    "varying highp vec4 fColor; \n"
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   gl_PointSize = point_size;\n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_p_l_comp[] =
-  {
-    "varying highp vec4 fColor; \n"
-    "void main(void) { \n"
-    "gl_FragColor = fColor; \n"
-    "} \n"
-    "\n"
-  };
-
-
-
 //------------------------------------------------------------------------------
 inline CGAL::Color get_random_color(CGAL::Random& random)
 {
@@ -329,6 +163,8 @@ public:
     setShortcut(qglviewer::EXIT_VIEWER, ::Qt::CTRL+::Qt::Key_Q);
 
     // Add custom key description (see keyPressEvent).
+    setKeyDescription(::Qt::Key_C, "Switch clipping plane display mode");
+    setKeyDescription(::Qt::Key_C+::Qt::AltModifier, "Toggle clipping plane rendering on/off");
     setKeyDescription(::Qt::Key_E, "Toggles edges display");
     setKeyDescription(::Qt::Key_M, "Toggles mono color");
     setKeyDescription(::Qt::Key_N, "Inverse direction of normals");
@@ -345,6 +181,11 @@ public:
     setKeyDescription(::Qt::Key_PageUp, "Decrease light (all colors, use shift/alt/ctrl for one rgb component)");
     setKeyDescription(::Qt::Key_O, "Toggles 2D mode only");
 
+    // Add custom mouse description
+    setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::LeftButton, "Rotate the clipping plane when enabled");
+    setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::RightButton, "Translate the clipping plane when enabled");
+    setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::MidButton, "Control the clipping plane transparency when enabled");
+
     if (title[0]==0)
       setWindowTitle("CGAL Basic Viewer");
     else
@@ -623,6 +464,7 @@ protected:
   {
     rendering_program_face.removeAllShaders();
     rendering_program_p_l.removeAllShaders();
+    rendering_program_clipping_plane.removeAllShaders();
 
     // Create the buffers
     for (unsigned int i=0; i<NB_VBO_BUFFERS; ++i)
@@ -678,7 +520,7 @@ protected:
 
     QOpenGLShader *fragment_shader_face= new QOpenGLShader(QOpenGLShader::Fragment);
     if(!fragment_shader_face->compileSourceCode(source_))
-    { std::cerr<<"Compiling fragmentsource FAILED"<<std::endl; }
+    { std::cerr<<"Compiling fragment source FAILED"<<std::endl; }
 
     if(!rendering_program_face.addShader(vertex_shader_face))
     { std::cerr<<"adding vertex shader FAILED"<<std::endl; }
@@ -686,6 +528,55 @@ protected:
     { std::cerr<<"adding fragment shader FAILED"<<std::endl; }
     if(!rendering_program_face.link())
     { std::cerr<<"linking Program FAILED"<<std::endl; }
+
+    // clipping plane shader
+
+
+    if (isOpenGL_4_3())
+    {
+      source_ = vertex_source_clipping_plane;
+
+      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_ = fragment_source_clipping_plane;
+
+      QOpenGLShader *fragment_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Fragment);
+      if (!fragment_shader_clipping_plane->compileSourceCode(source_))
+      { std::cerr << "Compiling fragment source for clipping plane FAILED" << std::endl; }
+
+      if (!rendering_program_clipping_plane.addShader(vertex_shader_clipping_plane))
+      { std::cerr << "Adding vertex shader for clipping plane FAILED" << std::endl;}
+      if (!rendering_program_clipping_plane.addShader(fragment_shader_clipping_plane))
+      { std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl; }
+      if (!rendering_program_clipping_plane.link())
+      { std::cerr << "Linking Program for clipping plane FAILED" << std::endl; }
+
+    }
+
+    // source_ = isOpenGL_4_3()
+    //         ? 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()
+    //         ? fragment_source_clipping_plane
+    //         : fragment_source_clipping_plane_comp;
+
+    // QOpenGLShader *fragment_shader_clipping_plane = new QOpenGLShader(QOpenGLShader::Fragment);
+    // if (!fragment_shader_clipping_plane->compileSourceCode(source_))
+    // { std::cerr << "Compiling fragment source for clipping plane FAILED" << std::endl; }
+
+    // if (!rendering_program_clipping_plane.addShader(vertex_shader_clipping_plane))
+    // { std::cerr << "Adding vertex shader for clipping plane FAILED" << std::endl;}
+    // if (!rendering_program_clipping_plane.addShader(fragment_shader_clipping_plane))
+    // { std::cerr << "Adding fragment shader for clipping plane FAILED" << std::endl; }
+    // if (!rendering_program_clipping_plane.link())
+    // { std::cerr << "Linking Program for clipping plane FAILED" << std::endl; }
   }
 
   void initialize_buffers()
@@ -962,6 +853,25 @@ protected:
 
     rendering_program_face.release();
 
+    // 6) clipping plane shader
+    if (isOpenGL_4_3())
+    {
+      rendering_program_clipping_plane.bind();
+
+      vao[VAO_CLIPPING_PLANE].bind();
+      ++bufn;
+      assert(bufn < NB_VBO_BUFFERS);
+      buffers[bufn].bind();
+      buffers[bufn].allocate(arrays[POS_CLIPPING_PLANE].data(),
+                            static_cast<int>(arrays[POS_CLIPPING_PLANE].size() * sizeof(float)));
+      rendering_program_clipping_plane.enableAttributeArray("vertex");
+      rendering_program_clipping_plane.setAttributeBuffer("vertex", GL_FLOAT, 0, 3);
+
+      buffers[bufn].release();
+
+      rendering_program_clipping_plane.release();
+    }
+
     m_are_buffers_initialized = true;
   }
 
@@ -1028,6 +938,21 @@ protected:
     int mvpLocation2 = rendering_program_p_l.uniformLocation("mvp_matrix");
     rendering_program_p_l.setUniformValue(mvpLocation2, mvpMatrix);
     rendering_program_p_l.release();
+
+    if (isOpenGL_4_3())
+    {
+      QMatrix4x4 clipping_mMatrix;
+      clipping_mMatrix.setToIdentity();
+      clipping_mMatrix.rotate(clipping_plane_rotation);
+      clipping_mMatrix.translate(0.0, 0.0, clipping_plane_translation_z);
+
+      rendering_program_clipping_plane.bind();
+      int vpLocation = rendering_program_clipping_plane.uniformLocation("vp_matrix");
+      int mLocation = rendering_program_clipping_plane.uniformLocation("m_matrix");
+      rendering_program_clipping_plane.setUniformValue(vpLocation, mvpMatrix);
+      rendering_program_clipping_plane.setUniformValue(mLocation, clipping_mMatrix);
+      rendering_program_clipping_plane.release();
+    }
   }
 
   // Returns true if the data structure lies on a plane
@@ -1039,6 +964,13 @@ protected:
   virtual void draw()
   {
     glEnable(GL_DEPTH_TEST);
+
+    // get clipping plane model matrix
+    QMatrix4x4 clipping_mMatrix;
+    clipping_mMatrix.setToIdentity();
+    clipping_mMatrix.rotate(clipping_plane_rotation);
+    QVector4D clipPlane = clipping_mMatrix * QVector4D(0.0, 0.0, 1.0, clipping_plane_translation_z);
+
     if(!m_are_buffers_initialized)
     { initialize_buffers(); }
 
@@ -1071,31 +1003,55 @@ protected:
     {
       rendering_program_p_l.bind();
 
-      vao[VAO_MONO_POINTS].bind();
-      color.setRgbF((double)m_vertices_mono_color.red()/(double)255,
-                    (double)m_vertices_mono_color.green()/(double)255,
-                    (double)m_vertices_mono_color.blue()/(double)255);
-      rendering_program_p_l.setAttributeValue("color",color);
-      rendering_program_p_l.setUniformValue("point_size", GLfloat(m_size_points));
-      glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(arrays[POS_MONO_POINTS].size()/3));
-      vao[VAO_MONO_POINTS].release();
-
-      vao[VAO_COLORED_POINTS].bind();
-      if (m_use_mono_color)
-      {
+      // rendering_mode == -1: draw all
+      // rendering_mode == 0: draw inside clipping plane
+      // rendering_mode == 1: draw outside clipping plane
+      auto renderer = [this, &color, &clipPlane](float rendering_mode) {
+        vao[VAO_MONO_POINTS].bind();
         color.setRgbF((double)m_vertices_mono_color.red()/(double)255,
                       (double)m_vertices_mono_color.green()/(double)255,
-                    (double)m_vertices_mono_color.blue()/(double)255);
-        rendering_program_p_l.disableAttributeArray("color");
+                      (double)m_vertices_mono_color.blue()/(double)255);
         rendering_program_p_l.setAttributeValue("color",color);
+        rendering_program_p_l.setUniformValue("point_size", GLfloat(m_size_points));
+        rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
+        glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(arrays[POS_MONO_POINTS].size()/3));
+        vao[VAO_MONO_POINTS].release();
+
+        vao[VAO_COLORED_POINTS].bind();
+        if (m_use_mono_color)
+        {
+          color.setRgbF((double)m_vertices_mono_color.red()/(double)255,
+                        (double)m_vertices_mono_color.green()/(double)255,
+                      (double)m_vertices_mono_color.blue()/(double)255);
+          rendering_program_p_l.disableAttributeArray("color");
+          rendering_program_p_l.setAttributeValue("color",color);
+        }
+        else
+        {
+          rendering_program_p_l.enableAttributeArray("color");
+        }
+        rendering_program_p_l.setUniformValue("point_size", GLfloat(m_size_points));
+        rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
+        glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(arrays[POS_COLORED_POINTS].size()/3));
+        vao[VAO_COLORED_POINTS].release();
+      };
+
+      enum {
+        DRAW_ALL = -1, // draw all
+        DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
+        DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
+      };
+
+      if (m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY)
+      {
+        renderer(DRAW_INSIDE_ONLY);
       }
       else
       {
-        rendering_program_p_l.enableAttributeArray("color");
+        renderer(DRAW_ALL);
       }
-      rendering_program_p_l.setUniformValue("point_size", GLfloat(m_size_points));
-      glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(arrays[POS_COLORED_POINTS].size()/3));
-      vao[VAO_COLORED_POINTS].release();
 
       rendering_program_p_l.release();
     }
@@ -1104,31 +1060,55 @@ protected:
     {
       rendering_program_p_l.bind();
 
-      vao[VAO_MONO_SEGMENTS].bind();
-      color.setRgbF((double)m_edges_mono_color.red()/(double)255,
-                    (double)m_edges_mono_color.green()/(double)255,
-                    (double)m_edges_mono_color.blue()/(double)255);
-      rendering_program_p_l.setAttributeValue("color",color);
-      glLineWidth(m_size_edges);
-      glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_MONO_SEGMENTS].size()/3));
-      vao[VAO_MONO_SEGMENTS].release();
-
-      vao[VAO_COLORED_SEGMENTS].bind();
-      if (m_use_mono_color)
-      {
+      // rendering_mode == -1: draw all
+      // rendering_mode == 0: draw inside clipping plane
+      // rendering_mode == 1: draw outside clipping plane
+      auto renderer = [this, &color, &clipPlane](float rendering_mode) {
+        vao[VAO_MONO_SEGMENTS].bind();
         color.setRgbF((double)m_edges_mono_color.red()/(double)255,
                       (double)m_edges_mono_color.green()/(double)255,
                       (double)m_edges_mono_color.blue()/(double)255);
-        rendering_program_p_l.disableAttributeArray("color");
         rendering_program_p_l.setAttributeValue("color",color);
+        rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
+        glLineWidth(m_size_edges);
+        glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_MONO_SEGMENTS].size()/3));
+        vao[VAO_MONO_SEGMENTS].release();
+
+        vao[VAO_COLORED_SEGMENTS].bind();
+        if (m_use_mono_color)
+        {
+          color.setRgbF((double)m_edges_mono_color.red()/(double)255,
+                        (double)m_edges_mono_color.green()/(double)255,
+                        (double)m_edges_mono_color.blue()/(double)255);
+          rendering_program_p_l.disableAttributeArray("color");
+          rendering_program_p_l.setAttributeValue("color",color);
+        }
+        else
+        {
+          rendering_program_p_l.enableAttributeArray("color");
+        }
+        rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
+        glLineWidth(m_size_edges);
+        glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_COLORED_SEGMENTS].size()/3));
+        vao[VAO_COLORED_SEGMENTS].release();
+      };
+
+      enum {
+        DRAW_ALL = -1, // draw all
+        DRAW_INSIDE_ONLY, // draw only the part inside the clipping plane
+        DRAW_OUTSIDE_ONLY // draw only the part outside the clipping plane
+      };
+
+      if (m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY)
+      {
+        renderer(DRAW_INSIDE_ONLY);
       }
       else
       {
-        rendering_program_p_l.enableAttributeArray("color");
+        renderer(DRAW_ALL);
       }
-      glLineWidth(m_size_edges);
-      glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_COLORED_SEGMENTS].size()/3));
-      vao[VAO_COLORED_SEGMENTS].release();
 
       rendering_program_p_l.release();
     }
@@ -1214,29 +1194,102 @@ protected:
     {
       rendering_program_face.bind();
 
+      // reference: https://stackoverflow.com/questions/37780345/opengl-how-to-create-order-independent-transparency
+      // rendering_mode == -1: draw all as solid;
+      // rendering_mode == 0: draw solid only;
+      // rendering_mode == 1: draw transparent only;
+      auto renderer = [this, &color, &clipPlane](float rendering_mode) {
+
       vao[VAO_MONO_FACES].bind();
       color.setRgbF((double)m_faces_mono_color.red()/(double)255,
                     (double)m_faces_mono_color.green()/(double)255,
                     (double)m_faces_mono_color.blue()/(double)255);
       rendering_program_face.setAttributeValue("color",color);
+      rendering_program_face.setUniformValue("rendering_mode", rendering_mode);
+      rendering_program_face.setUniformValue("rendering_transparency", clipping_plane_rendering_transparency);
+      rendering_program_face.setUniformValue("clipPlane", clipPlane);
       glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(arrays[POS_MONO_FACES].size()/3));
       vao[VAO_MONO_FACES].release();
 
-      vao[VAO_COLORED_FACES].bind();
-      if (m_use_mono_color)
+        vao[VAO_COLORED_FACES].bind();
+        if (m_use_mono_color)
+        {
+          color.setRgbF((double)m_faces_mono_color.red()/(double)255,
+                        (double)m_faces_mono_color.green()/(double)255,
+                        (double)m_faces_mono_color.blue()/(double)255);
+          rendering_program_face.disableAttributeArray("color");
+          rendering_program_face.setAttributeValue("color",color);
+        }
+        else
+        {
+          rendering_program_face.enableAttributeArray("color");
+        }
+        rendering_program_face.setUniformValue("rendering_mode", rendering_mode);
+        rendering_program_face.setUniformValue("rendering_transparency", clipping_plane_rendering_transparency);
+        rendering_program_face.setUniformValue("clipPlane", clipPlane);
+        glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(arrays[POS_COLORED_FACES].size()/3));
+        vao[VAO_COLORED_FACES].release();
+      };
+
+      auto renderer_clipping_plane = [this](bool clipping_plane_rendering) {
+        if (!isOpenGL_4_3()) return;
+        if (!clipping_plane_rendering) return;
+        // render clipping plane here
+        rendering_program_clipping_plane.bind();
+        vao[VAO_CLIPPING_PLANE].bind();
+        glLineWidth(0.1f);
+        glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_CLIPPING_PLANE].size() / 3));
+        glLineWidth(1.0f);
+        vao[VAO_CLIPPING_PLANE].release();
+        rendering_program_clipping_plane.release();
+      };
+
+      enum {
+        DRAW_SOLID_ALL = -1, // draw all mesh in solid mode
+        DRAW_SOLID_HALF, // draw only the mesh inside the clipping plane as solid
+        DRAW_TRANSPARENT_HALF // draw only the mesh outside the clipping plane as transparent
+      };
+
+      if (m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_TRANSPARENT_HALF)
       {
-        color.setRgbF((double)m_faces_mono_color.red()/(double)255,
-                      (double)m_faces_mono_color.green()/(double)255,
-                      (double)m_faces_mono_color.blue()/(double)255);
-        rendering_program_face.disableAttributeArray("color");
-        rendering_program_face.setAttributeValue("color",color);
+        // The z-buffer will prevent transparent objects from being displayed behind other transparent objects.
+        // Before rendering all transparent objects, disable z-testing first.
+
+        // 1. draw solid first
+        renderer(DRAW_SOLID_HALF);
+
+        // 2. draw transparent layer second with back face culling to avoid messy triangles
+        glDepthMask(false); //disable z-testing
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_CULL_FACE);
+        glCullFace(GL_BACK);
+        glFrontFace(GL_CW);
+        renderer(DRAW_TRANSPARENT_HALF);
+
+        // 3. draw solid again without culling and blend to make sure the solid mesh is visible
+        glDepthMask(true); //enable z-testing
+        glDisable(GL_CULL_FACE);
+        glDisable(GL_BLEND);
+        renderer(DRAW_SOLID_HALF);
+
+        // 4. render clipping plane here
+        renderer_clipping_plane(clipping_plane_rendering);
+      }
+      else if (m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_WIRE_HALF ||
+               m_use_clipping_plane == CLIPPING_PLANE_SOLID_HALF_ONLY)
+      {
+        // 1. draw solid HALF
+        renderer(DRAW_SOLID_HALF);
+
+        // 2. render clipping plane here
+        renderer_clipping_plane(clipping_plane_rendering);
       }
       else
       {
-        rendering_program_face.enableAttributeArray("color");
+        // 1. draw solid FOR ALL
+        renderer(DRAW_SOLID_ALL);
       }
-      glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(arrays[POS_COLORED_FACES].size()/3));
-      vao[VAO_COLORED_FACES].release();
 
       if (is_two_dimensional())
         glPolygonOffset(offset_factor, offset_units);
@@ -1294,6 +1347,32 @@ protected:
                                                        bb.ymax(),
                                                        bb.zmax()));
 
+    // init clipping plane array
+    auto generate_clipping_plane = [this](qreal size, int nbSubdivisions)
+    {
+      for (int i = 0; i <= nbSubdivisions; i++)
+      {
+        const float pos = float(size*(2.0*i/nbSubdivisions-1.0));
+        arrays[POS_CLIPPING_PLANE].push_back(pos);
+        arrays[POS_CLIPPING_PLANE].push_back(float(-size));
+        arrays[POS_CLIPPING_PLANE].push_back(0.f);
+
+        arrays[POS_CLIPPING_PLANE].push_back(pos);
+        arrays[POS_CLIPPING_PLANE].push_back(float(+size));
+        arrays[POS_CLIPPING_PLANE].push_back(0.f);
+
+        arrays[POS_CLIPPING_PLANE].push_back(float(-size));
+        arrays[POS_CLIPPING_PLANE].push_back(pos);
+        arrays[POS_CLIPPING_PLANE].push_back(0.f);
+
+        arrays[POS_CLIPPING_PLANE].push_back(float(size));
+        arrays[POS_CLIPPING_PLANE].push_back(pos);
+        arrays[POS_CLIPPING_PLANE].push_back(0.f);
+      }
+    };
+    clipping_plane_rendering_size = ((bb.xmax() - bb.xmin()) + (bb.ymax() - bb.ymin()) + (bb.zmax() - bb.zmin())) / 3;
+    generate_clipping_plane(3.0 * clipping_plane_rendering_size, 30);
+
     this->showEntireScene();
   }
 
@@ -1307,7 +1386,45 @@ protected:
   {
     const ::Qt::KeyboardModifiers modifiers = e->modifiers();
 
-    if ((e->key()==::Qt::Key_E) && (modifiers==::Qt::NoButton))
+    if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::NoButton))
+    {
+      if (!isOpenGL_4_3()) return;
+      if (!is_two_dimensional())
+      {
+        // toggle clipping plane
+        m_use_clipping_plane = (m_use_clipping_plane + 1) % CLIPPING_PLANE_END_INDEX;
+        switch(m_use_clipping_plane)
+        {
+        case CLIPPING_PLANE_OFF: displayMessage(QString("Draw clipping = flase")); break;
+        case CLIPPING_PLANE_SOLID_HALF_TRANSPARENT_HALF: clipping_plane_rendering=true; displayMessage(QString("Draw clipping = solid half & transparent half")); break;
+        case CLIPPING_PLANE_SOLID_HALF_WIRE_HALF: displayMessage(QString("Draw clipping = solid half & wireframe half")); break;
+        case CLIPPING_PLANE_SOLID_HALF_ONLY: displayMessage(QString("Draw clipping = solid half only")); break;
+        default: break;
+        }
+        update();
+      }
+    }
+    else if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::ControlModifier))
+    {
+      if (!isOpenGL_4_3()) return;
+      if (m_use_clipping_plane!=CLIPPING_PLANE_OFF)
+      {
+        // enable clipping operation i.e. rotation, translation, and transparency adjustment
+        clipping_plane_operation = true;
+        update();
+      }
+    }
+    else if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::AltModifier))
+    {
+      if (!isOpenGL_4_3()) return;
+      if (m_use_clipping_plane!=CLIPPING_PLANE_OFF)
+      {
+        clipping_plane_rendering = !clipping_plane_rendering;
+        displayMessage(QString("Draw clipping plane=%1.").arg(clipping_plane_rendering?"true":"false"));
+        update();
+      }
+    }
+    else if ((e->key()==::Qt::Key_E) && (modifiers==::Qt::NoButton))
     {
       m_draw_edges=!m_draw_edges;
       displayMessage(QString("Draw edges=%1.").arg(m_draw_edges?"true":"false"));
@@ -1489,6 +1606,73 @@ protected:
       CGAL::QGLViewer::keyPressEvent(e);
   }
 
+ virtual void keyReleaseEvent(QKeyEvent *e)
+  {
+    const ::Qt::KeyboardModifiers modifiers = e->modifiers();
+    if ((e->key()==::Qt::Key_C))
+    {
+      clipping_plane_operation = false;
+    }
+  }
+
+  virtual void mousePressEvent(QMouseEvent *e) {
+    if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::LeftButton) {
+      // rotation starting point
+      clipping_plane_rotation_tracker = QVector2D(e->localPos());
+    }
+    else if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::RightButton)
+    {
+      // translation starting point
+      clipping_plane_translation_tracker = QVector2D(e->localPos());
+    }
+    else
+    {
+      CGAL::QGLViewer::mousePressEvent(e);
+    }
+  }
+
+  virtual void mouseMoveEvent(QMouseEvent *e) {
+    if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::LeftButton)
+    {
+      // rotation ending point
+      QVector2D diff = QVector2D(e->localPos()) - clipping_plane_rotation_tracker;
+      clipping_plane_rotation_tracker = QVector2D(e->localPos());
+
+      QVector3D axis = QVector3D(diff.y(), diff.x(), 0.0);
+      float angle = diff.length();
+      clipping_plane_rotation = QQuaternion::fromAxisAndAngle(axis, angle) * clipping_plane_rotation;
+
+      update();
+    }
+    else if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::RightButton)
+    {
+      // translation ending point
+      QVector2D diff = QVector2D(e->localPos()) - clipping_plane_translation_tracker;
+      clipping_plane_translation_tracker = QVector2D(e->localPos());
+
+      clipping_plane_translation_z += clipping_plane_rendering_size / 500 * (diff.y() > 0 ? -1.0 : diff.y() < 0 ? 1.0 : 0.0) * diff.length();
+
+      update();
+    }
+    else
+    {
+      CGAL::QGLViewer::mouseMoveEvent(e);
+    }
+  }
+
+  virtual void wheelEvent(QWheelEvent *e)
+  {
+    if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier) {
+      clipping_plane_rendering_transparency += (e->delta() / 120.0) / 50.0;
+      // clip to 0-1
+      clipping_plane_rendering_transparency = clipping_plane_rendering_transparency > 1.0 ? 1.0 : clipping_plane_rendering_transparency < 0.0 ? 0.0 : clipping_plane_rendering_transparency;
+    }
+    else
+    {
+      CGAL::QGLViewer::wheelEvent(e);
+    }
+  }
+
   virtual QString helpString() const
   { return helpString("CGAL Basic Viewer"); }
 
@@ -1536,6 +1720,16 @@ protected:
   bool m_draw_text;
   bool m_no_2D_mode;
 
+  enum {
+    CLIPPING_PLANE_OFF = 0,
+    CLIPPING_PLANE_SOLID_HALF_TRANSPARENT_HALF,
+    CLIPPING_PLANE_SOLID_HALF_WIRE_HALF,
+    CLIPPING_PLANE_SOLID_HALF_ONLY,
+    CLIPPING_PLANE_END_INDEX
+  };
+
+  int m_use_clipping_plane = CLIPPING_PLANE_OFF;
+
   double m_size_points;
   double m_size_edges;
   double m_size_rays;
@@ -1568,6 +1762,7 @@ protected:
     POS_COLORED_LINES,
     POS_MONO_FACES,
     POS_COLORED_FACES,
+    POS_CLIPPING_PLANE,
     END_POS,
     BEGIN_COLOR=END_POS,
     COLOR_POINTS=BEGIN_COLOR,
@@ -1596,6 +1791,7 @@ protected:
   Buffer_for_vao<float> m_buffer_for_colored_lines;
   Buffer_for_vao<float> m_buffer_for_mono_faces;
   Buffer_for_vao<float> m_buffer_for_colored_faces;
+  Buffer_for_vao<float> m_buffer_for_clipping_plane;
 
   static const unsigned int NB_VBO_BUFFERS=(END_POS-BEGIN_POS)+
     (END_COLOR-BEGIN_COLOR)+2; // +2 for 2 vectors of normals
@@ -1614,12 +1810,24 @@ protected:
       VAO_COLORED_LINES,
       VAO_MONO_FACES,
       VAO_COLORED_FACES,
+      VAO_CLIPPING_PLANE,
       NB_VAO_BUFFERS
     };
   QOpenGLVertexArrayObject vao[NB_VAO_BUFFERS];
 
   QOpenGLShaderProgram rendering_program_face;
   QOpenGLShaderProgram rendering_program_p_l;
+  QOpenGLShaderProgram rendering_program_clipping_plane;
+
+  // variables for clipping plane
+  bool clipping_plane_operation = false; // will be enabled/diabled when ctrl+c is pressed/released, which is used for clipping plane translation and rotation;
+  QVector2D clipping_plane_rotation_tracker; // will be enabled when ctrl+c+left is pressed, which is used to record rotation;
+  QQuaternion clipping_plane_rotation; // real rotation;
+  QVector2D clipping_plane_translation_tracker; // will be enabled when ctrl+c+right is pressed, which is used to record translation;
+  float clipping_plane_translation_z = 0.0f; // real translation;
+  bool clipping_plane_rendering = true; // will be toggled when alt+c is pressed, which is used for indicating whether or not to render the clipping plane ;
+  float clipping_plane_rendering_transparency = 0.5f; // to what extent the transparent part should be rendered;
+  float clipping_plane_rendering_size; // to what extent the size of clipping plane should be rendered;
 
   std::vector<std::tuple<Local_point, QString> > m_texts;
 };

From de7dd44307b8016f26568dc0897feac4b810f7a1 Mon Sep 17 00:00:00 2001
From: Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
Date: Wed, 27 Jan 2021 18:53:59 +0100
Subject: [PATCH 2/7] add licence header

---
 GraphicsView/include/CGAL/Basic_shaders.h  | 2 ++
 GraphicsView/include/CGAL/Buffer_for_vao.h | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/GraphicsView/include/CGAL/Basic_shaders.h b/GraphicsView/include/CGAL/Basic_shaders.h
index 429f2b52f00..92422b0dc3a 100644
--- a/GraphicsView/include/CGAL/Basic_shaders.h
+++ b/GraphicsView/include/CGAL/Basic_shaders.h
@@ -13,6 +13,8 @@
 #ifndef CGAL_BASIC_SHADERS_H
 #define CGAL_BASIC_SHADERS_H
 
+#include <CGAL/license/GraphicsView.h>
+
 namespace CGAL
 {
 
diff --git a/GraphicsView/include/CGAL/Buffer_for_vao.h b/GraphicsView/include/CGAL/Buffer_for_vao.h
index c27e24e50c9..2be331a35f5 100644
--- a/GraphicsView/include/CGAL/Buffer_for_vao.h
+++ b/GraphicsView/include/CGAL/Buffer_for_vao.h
@@ -908,7 +908,7 @@ protected:
   bool m_zero_y; /// True iff all points have y==0
   bool m_zero_z; /// True iff all points have z==0
 
-  bool m_inverse_normal;;
+  bool m_inverse_normal;
 
   // Local variables, used when we started a new face.g
   bool m_face_started;

From a7a3931f0ac67a730a7a063b53010066b5061526 Mon Sep 17 00:00:00 2001
From: Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
Date: Tue, 2 Feb 2021 10:27:57 +0100
Subject: [PATCH 3/7] Update shaders

---
 GraphicsView/include/CGAL/Basic_shaders.h | 88 ++++++++++++-----------
 1 file changed, 47 insertions(+), 41 deletions(-)

diff --git a/GraphicsView/include/CGAL/Basic_shaders.h b/GraphicsView/include/CGAL/Basic_shaders.h
index 92422b0dc3a..b3204549697 100644
--- a/GraphicsView/include/CGAL/Basic_shaders.h
+++ b/GraphicsView/include/CGAL/Basic_shaders.h
@@ -20,21 +20,21 @@ namespace CGAL
 
 //------------------------------------------------------------------------------
 const char vertex_source_color[]=R"DELIM(
-#version 120
-attribute highp vec4 vertex;
-attribute highp vec3 normal;
-attribute highp vec3 color;
+#version 150
+in highp vec4 vertex;
+in highp vec3 normal;
+in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
 uniform highp mat4 mv_matrix;
 
-varying highp vec4 fP;
-varying highp vec3 fN;
-varying highp vec4 fColor;
+out highp vec4 fP;
+out highp vec3 fN;
+out highp vec4 fColor;
 
 uniform highp float point_size;
 
-varying highp vec4 m_vertex;
+out highp vec4 m_vertex;
 
 void main(void)
 {
@@ -50,12 +50,13 @@ void main(void)
 )DELIM";
 
 const char fragment_source_color[]=R"DELIM(
-#version 120
-varying highp vec4 fP;
-varying highp vec3 fN;
-varying highp vec4 fColor;
+#version 150
+out highp vec4 fP;
+out highp vec3 fN;
+out highp vec4 fColor;
 
-varying highp vec4 m_vertex;
+out highp vec4 m_vertex;
+out highp vec4 out_color;
 
 uniform highp vec4 light_pos;
 uniform highp vec4 light_diff;
@@ -95,20 +96,20 @@ void main(void)
   }
 
   // draw corresponding part
-  gl_FragColor = rendering_mode < 1 ? (diffuse + ambient) :
+  out_color = rendering_mode < 1 ? (diffuse + ambient) :
                       vec4(diffuse.rgb + ambient.rgb, rendering_transparency);
 }
 )DELIM";
 
 const char vertex_source_p_l[]=R"DELIM(
-#version 120
-attribute highp vec4 vertex;
-attribute highp vec3 color;
+#version 150
+in highp vec4 vertex;
+in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
-varying highp vec4 fColor;
+out highp vec4 fColor;
 
-varying highp vec4 m_vertex;
+out highp vec4 m_vertex;
 
 uniform highp float point_size;
 void main(void)
@@ -121,9 +122,10 @@ void main(void)
 )DELIM";
 
 const char fragment_source_p_l[]=R"DELIM(
-#version 120
-varying highp vec4 fColor;
-varying highp vec4 m_vertex;
+#version 150
+out highp vec4 fColor;
+out highp vec4 m_vertex;
+out highp vec4 out_color;
 uniform highp vec4 clipPlane;
 uniform highp float rendering_mode;
 
@@ -142,13 +144,13 @@ void main(void)
     discard;
   }
 
-  gl_FragColor = fColor;
+  out_color = fColor;
 }
 )DELIM";
 
 const char vertex_source_clipping_plane[]=R"DELIM(
-#version 120
-attribute highp vec4 vertex;
+#version 150
+in highp vec4 vertex;
 
 uniform highp mat4 vp_matrix;
 uniform highp mat4 m_matrix;
@@ -160,10 +162,11 @@ void main(void)
 )DELIM";
 
 const char fragment_source_clipping_plane[]=R"DELIM(
-#version 120
+#version 150
+out highp vec4 out_color;
 void main(void)
 {
-  gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+  out_color = vec4(0.0, 0.0, 0.0, 1.0);
 }
 )DELIM";
 
@@ -171,16 +174,16 @@ void main(void)
 //  compatibility shaders
 
 const char vertex_source_color_comp[]=R"DELIM(
-attribute highp vec4 vertex;
-attribute highp vec3 normal;
-attribute highp vec3 color;
+in highp vec4 vertex;
+in highp vec3 normal;
+in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
 uniform highp mat4 mv_matrix;
 
-varying highp vec4 fP;
-varying highp vec3 fN;
-varying highp vec4 fColor;
+out highp vec4 fP;
+out highp vec3 fN;
+out highp vec4 fColor;
 
 uniform highp float point_size;
 
@@ -200,9 +203,10 @@ void main(void)
 )DELIM";
 
 const char fragment_source_color_comp[]=R"DELIM(
-varying highp vec4 fP;
-varying highp vec3 fN;
-varying highp vec4 fColor;
+out highp vec4 fP;
+out highp vec3 fN;
+out highp vec4 fColor;
+out highp vec4 out_color;
 
 uniform highp vec4 light_pos;
 uniform highp vec4 light_diff;
@@ -223,13 +227,13 @@ void main(void)
   highp vec4 diffuse = max(dot(N,L), 0.0) * light_diff * fColor;
   highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec;
 
-  gl_FragColor = light_amb*fColor + diffuse;
+  out_color = light_amb*fColor + diffuse;
 }
 )DELIM";
 
 const char vertex_source_p_l_comp[]=R"DELIM(
-attribute highp vec4 vertex;
-attribute highp vec3 color;
+in highp vec4 vertex;
+in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
 varying highp vec4 fColor;
@@ -246,9 +250,10 @@ void main(void)
 
 const char fragment_source_p_l_comp[]=R"DELIM(
 varying highp vec4 fColor;
+out highp vec4 out_color;
 void main(void)
 {
-  gl_FragColor = fColor;
+  out_color = fColor;
 }
 )DELIM";
 
@@ -265,9 +270,10 @@ void main(void)
 )DELIM";
 
 const char fragment_source_clipping_plane_comp[]=R"DELIM(
+out highp vec4 out_color;
 void main(void)
 {
-  gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+  out_color = vec4(0.0, 0.0, 0.0, 1.0);
 }
 )DELIM";
 */

From 77b9ebc19c16fe03bb41046b058a550a79124510 Mon Sep 17 00:00:00 2001
From: Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
Date: Tue, 2 Feb 2021 12:06:40 +0100
Subject: [PATCH 4/7] Update shaders

---
 GraphicsView/include/CGAL/Basic_shaders.h | 46 +++++++++++------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/GraphicsView/include/CGAL/Basic_shaders.h b/GraphicsView/include/CGAL/Basic_shaders.h
index b3204549697..19b1d09f2de 100644
--- a/GraphicsView/include/CGAL/Basic_shaders.h
+++ b/GraphicsView/include/CGAL/Basic_shaders.h
@@ -27,13 +27,11 @@ in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
 uniform highp mat4 mv_matrix;
+uniform highp float point_size;
 
 out highp vec4 fP;
 out highp vec3 fN;
 out highp vec4 fColor;
-
-uniform highp float point_size;
-
 out highp vec4 m_vertex;
 
 void main(void)
@@ -51,12 +49,10 @@ void main(void)
 
 const char fragment_source_color[]=R"DELIM(
 #version 150
-out highp vec4 fP;
-out highp vec3 fN;
-out highp vec4 fColor;
-
-out highp vec4 m_vertex;
-out highp vec4 out_color;
+in highp vec4 fP;
+in highp vec3 fN;
+in highp vec4 fColor;
+in highp vec4 m_vertex;
 
 uniform highp vec4 light_pos;
 uniform highp vec4 light_diff;
@@ -68,6 +64,8 @@ uniform highp vec4 clipPlane;
 uniform highp float rendering_mode;
 uniform highp float rendering_transparency;
 
+out highp vec4 out_color;
+
 void main(void)
 {
   highp vec3 L = light_pos.xyz - fP.xyz;
@@ -107,11 +105,11 @@ in highp vec4 vertex;
 in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
-out highp vec4 fColor;
+uniform highp float point_size;
 
+out highp vec4 fColor;
 out highp vec4 m_vertex;
 
-uniform highp float point_size;
 void main(void)
 {
   gl_PointSize = point_size;
@@ -123,12 +121,14 @@ void main(void)
 
 const char fragment_source_p_l[]=R"DELIM(
 #version 150
-out highp vec4 fColor;
-out highp vec4 m_vertex;
-out highp vec4 out_color;
+in highp vec4 fColor;
+in highp vec4 m_vertex;
+
 uniform highp vec4 clipPlane;
 uniform highp float rendering_mode;
 
+out highp vec4 out_color;
+
 void main(void)
 {
   // onPlane == 1: inside clipping plane, should be solid;
@@ -180,13 +180,12 @@ in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
 uniform highp mat4 mv_matrix;
+uniform highp float point_size;
 
 out highp vec4 fP;
 out highp vec3 fN;
 out highp vec4 fColor;
 
-uniform highp float point_size;
-
 void main(void)
 {
   fP = mv_matrix * vertex;
@@ -203,10 +202,9 @@ void main(void)
 )DELIM";
 
 const char fragment_source_color_comp[]=R"DELIM(
-out highp vec4 fP;
-out highp vec3 fN;
-out highp vec4 fColor;
-out highp vec4 out_color;
+in highp vec4 fP;
+in highp vec3 fN;
+in highp vec4 fColor;
 
 uniform highp vec4 light_pos;
 uniform highp vec4 light_diff;
@@ -214,6 +212,8 @@ uniform highp vec4 light_spec;
 uniform highp vec4 light_amb;
 uniform highp float spec_power ;
 
+out highp vec4 out_color;
+
 void main(void)
 {
   highp vec3 L = light_pos.xyz - fP.xyz;
@@ -236,10 +236,10 @@ in highp vec4 vertex;
 in highp vec3 color;
 
 uniform highp mat4 mvp_matrix;
-varying highp vec4 fColor;
-
 uniform highp float point_size;
 
+out highp vec4 fColor;
+
 void main(void)
 {
   gl_PointSize = point_size;
@@ -249,7 +249,7 @@ void main(void)
 )DELIM";
 
 const char fragment_source_p_l_comp[]=R"DELIM(
-varying highp vec4 fColor;
+in highp vec4 fColor;
 out highp vec4 out_color;
 void main(void)
 {

From a09a4684f4aa726ccd0f2777654e5af12163cb6a Mon Sep 17 00:00:00 2001
From: Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
Date: Wed, 3 Feb 2021 08:56:52 +0100
Subject: [PATCH 5/7] Start to use manipulated frame for clipping plane

---
 .../include/CGAL/Qt/Basic_viewer_qt.h         | 45 +++++++++++++++++--
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
index be88ad7fce4..b815e85593e 100644
--- a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
+++ b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
@@ -31,8 +31,8 @@
 #include <QKeyEvent>
 
 #include <CGAL/Qt/qglviewer.h>
+#include <CGAL/Qt/manipulatedFrame.h>
 #include <QKeyEvent>
-#include <QOpenGLFunctions>
 #include <QOpenGLVertexArrayObject>
 #include <QGLBuffer>
 #include <QOpenGLShaderProgram>
@@ -186,6 +186,15 @@ public:
     setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::RightButton, "Translate the clipping plane when enabled");
     setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::MidButton, "Control the clipping plane transparency when enabled");
 
+    /*
+      TODO
+
+      setMouseBinding(::Qt::NoModifier, ::Qt::LeftButton, qglviewer::FRAME, qglviewer::ROTATE);
+      setMouseBinding(::Qt::NoModifier, ::Qt::RightButton, qglviewer::FRAME, qglviewer::TRANSLATE);
+      setMouseBinding(::Qt::NoModifier, ::Qt::MidButton, qglviewer::FRAME, qglviewer::ZOOM);
+      setWheelBinding(::Qt::NoModifier, qglviewer::FRAME, qglviewer::ZOOM);
+    */
+
     if (title[0]==0)
       setWindowTitle("CGAL Basic Viewer");
     else
@@ -464,7 +473,7 @@ protected:
   {
     rendering_program_face.removeAllShaders();
     rendering_program_p_l.removeAllShaders();
-    rendering_program_clipping_plane.removeAllShaders();
+    rendering_program_clipping_plane.removeAllShaders(); // TODO remove this shader: replace by QGLViewer::drawGrid
 
     // Create the buffers
     for (unsigned int i=0; i<NB_VBO_BUFFERS; ++i)
@@ -531,7 +540,7 @@ protected:
 
     // clipping plane shader
 
-
+    // TODO REMOVE
     if (isOpenGL_4_3())
     {
       source_ = vertex_source_clipping_plane;
@@ -853,6 +862,7 @@ protected:
 
     rendering_program_face.release();
 
+    // TODO remove
     // 6) clipping plane shader
     if (isOpenGL_4_3())
     {
@@ -939,6 +949,7 @@ protected:
     rendering_program_p_l.setUniformValue(mvpLocation2, mvpMatrix);
     rendering_program_p_l.release();
 
+    // TODO remove
     if (isOpenGL_4_3())
     {
       QMatrix4x4 clipping_mMatrix;
@@ -1311,6 +1322,13 @@ protected:
       }
       glEnable(GL_LIGHTING);
     }
+
+    // Multiply matrix to get in the frame coordinate system.
+    // glMultMatrixd(manipulatedFrame()->matrix()); // Linker error
+    // Scale down the drawings
+    // glScalef(0.3f, 0.3f, 0.3f); // Linker error
+    // Draw an axis using the QGLViewer static function
+    // drawAxis();
   }
 
   virtual void init()
@@ -1348,6 +1366,7 @@ protected:
                                                        bb.zmax()));
 
     // init clipping plane array
+    // TODO REMOVE
     auto generate_clipping_plane = [this](qreal size, int nbSubdivisions)
     {
       for (int i = 0; i <= nbSubdivisions; i++)
@@ -1393,6 +1412,19 @@ protected:
       {
         // toggle clipping plane
         m_use_clipping_plane = (m_use_clipping_plane + 1) % CLIPPING_PLANE_END_INDEX;
+        // TODO verify
+        if (m_use_clipping_plane==CLIPPING_PLANE_OFF)
+        {
+          delete m_frame_plane;
+          m_frame_plane=nullptr;
+          setManipulatedFrame(nullptr);
+        }
+        else if (m_frame_plane==nullptr)
+        {
+          m_frame_plane=new CGAL::qglviewer::ManipulatedFrame;
+          setManipulatedFrame(m_frame_plane);
+        }
+
         switch(m_use_clipping_plane)
         {
         case CLIPPING_PLANE_OFF: displayMessage(QString("Draw clipping = flase")); break;
@@ -1606,6 +1638,7 @@ protected:
       CGAL::QGLViewer::keyPressEvent(e);
   }
 
+  // TODO maybe remove
  virtual void keyReleaseEvent(QKeyEvent *e)
   {
     const ::Qt::KeyboardModifiers modifiers = e->modifiers();
@@ -1615,6 +1648,7 @@ protected:
     }
   }
 
+  // TODO maybe remove
   virtual void mousePressEvent(QMouseEvent *e) {
     if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::LeftButton) {
       // rotation starting point
@@ -1631,6 +1665,7 @@ protected:
     }
   }
 
+  // TODO maybe remove
   virtual void mouseMoveEvent(QMouseEvent *e) {
     if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::LeftButton)
     {
@@ -1660,6 +1695,7 @@ protected:
     }
   }
 
+  // TODO maybe remove
   virtual void wheelEvent(QWheelEvent *e)
   {
     if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier) {
@@ -1728,7 +1764,8 @@ protected:
     CLIPPING_PLANE_END_INDEX
   };
 
-  int m_use_clipping_plane = CLIPPING_PLANE_OFF;
+  int m_use_clipping_plane=CLIPPING_PLANE_OFF;
+  CGAL::qglviewer::ManipulatedFrame* m_frame_plane=nullptr;
 
   double m_size_points;
   double m_size_edges;

From 5e63293747b98142bd14bde5ef2644e3fdddfab4 Mon Sep 17 00:00:00 2001
From: Maxime Gimeno <maxime.gimeno@gmail.com>
Date: Wed, 3 Feb 2021 11:39:41 +0100
Subject: [PATCH 6/7] Replace plane manipulation by frame manipulation.

---
 GraphicsView/include/CGAL/Basic_shaders.h     |   6 +-
 .../include/CGAL/Qt/Basic_viewer_qt.h         | 146 +++++-------------
 2 files changed, 40 insertions(+), 112 deletions(-)

diff --git a/GraphicsView/include/CGAL/Basic_shaders.h b/GraphicsView/include/CGAL/Basic_shaders.h
index 19b1d09f2de..1e9f7697c0a 100644
--- a/GraphicsView/include/CGAL/Basic_shaders.h
+++ b/GraphicsView/include/CGAL/Basic_shaders.h
@@ -61,6 +61,7 @@ uniform highp vec4 light_amb;
 uniform highp float spec_power;
 
 uniform highp vec4 clipPlane;
+uniform highp vec4 pointPlane;
 uniform highp float rendering_mode;
 uniform highp float rendering_transparency;
 
@@ -83,7 +84,7 @@ void main(void)
   // onPlane == 1: inside clipping plane, should be solid;
   // onPlane == -1: outside clipping plane, should be transparent;
   // onPlane == 0: on clipping plane, whatever;
-  float onPlane = sign(dot(m_vertex.xyz, clipPlane.xyz) - clipPlane.w);
+  float onPlane = sign(dot((m_vertex.xyz-pointPlane.xyz), clipPlane.xyz));
 
   // rendering_mode == -1: draw all solid;
   // rendering_mode == 0: draw solid only;
@@ -125,6 +126,7 @@ in highp vec4 fColor;
 in highp vec4 m_vertex;
 
 uniform highp vec4 clipPlane;
+uniform highp vec4 pointPlane;
 uniform highp float rendering_mode;
 
 out highp vec4 out_color;
@@ -134,7 +136,7 @@ void main(void)
   // onPlane == 1: inside clipping plane, should be solid;
   // onPlane == -1: outside clipping plane, should be transparent;
   // onPlane == 0: on clipping plane, whatever;
-  float onPlane = sign(dot(m_vertex.xyz, clipPlane.xyz) - clipPlane.w);
+  float onPlane = sign(dot((m_vertex.xyz-pointPlane.xyz), clipPlane.xyz));
 
   // rendering_mode == -1: draw both inside and outside;
   // rendering_mode == 0: draw inside only;
diff --git a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
index b815e85593e..02ed93e8ca2 100644
--- a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
+++ b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
@@ -186,14 +186,15 @@ public:
     setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::RightButton, "Translate the clipping plane when enabled");
     setMouseBindingDescription(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::MidButton, "Control the clipping plane transparency when enabled");
 
-    /*
-      TODO
+    setMouseBinding(::Qt::ControlModifier, ::Qt::LeftButton, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
+    setMouseBinding(::Qt::ControlModifier, ::Qt::RightButton, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
+    setMouseBinding(::Qt::ControlModifier, ::Qt::MidButton, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
+    setWheelBinding(::Qt::ControlModifier, qglviewer::FRAME, qglviewer::NO_MOUSE_ACTION);
 
-      setMouseBinding(::Qt::NoModifier, ::Qt::LeftButton, qglviewer::FRAME, qglviewer::ROTATE);
-      setMouseBinding(::Qt::NoModifier, ::Qt::RightButton, qglviewer::FRAME, qglviewer::TRANSLATE);
-      setMouseBinding(::Qt::NoModifier, ::Qt::MidButton, qglviewer::FRAME, qglviewer::ZOOM);
-      setWheelBinding(::Qt::NoModifier, qglviewer::FRAME, qglviewer::ZOOM);
-    */
+    setMouseBinding(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::LeftButton, qglviewer::FRAME, qglviewer::ROTATE);
+    setMouseBinding(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::RightButton, qglviewer::FRAME, qglviewer::TRANSLATE);
+    setMouseBinding(::Qt::Key_C, ::Qt::ControlModifier, ::Qt::MidButton, qglviewer::FRAME, qglviewer::ZOOM);
+    setWheelBinding(::Qt::Key_C, ::Qt::ControlModifier, qglviewer::FRAME, qglviewer::ZOOM);
 
     if (title[0]==0)
       setWindowTitle("CGAL Basic Viewer");
@@ -473,7 +474,7 @@ protected:
   {
     rendering_program_face.removeAllShaders();
     rendering_program_p_l.removeAllShaders();
-    rendering_program_clipping_plane.removeAllShaders(); // TODO remove this shader: replace by QGLViewer::drawGrid
+    rendering_program_clipping_plane.removeAllShaders();
 
     // Create the buffers
     for (unsigned int i=0; i<NB_VBO_BUFFERS; ++i)
@@ -540,7 +541,7 @@ protected:
 
     // clipping plane shader
 
-    // TODO REMOVE
+
     if (isOpenGL_4_3())
     {
       source_ = vertex_source_clipping_plane;
@@ -862,7 +863,7 @@ protected:
 
     rendering_program_face.release();
 
-    // TODO remove
+
     // 6) clipping plane shader
     if (isOpenGL_4_3())
     {
@@ -949,13 +950,16 @@ protected:
     rendering_program_p_l.setUniformValue(mvpLocation2, mvpMatrix);
     rendering_program_p_l.release();
 
-    // TODO remove
+
     if (isOpenGL_4_3())
     {
       QMatrix4x4 clipping_mMatrix;
       clipping_mMatrix.setToIdentity();
-      clipping_mMatrix.rotate(clipping_plane_rotation);
-      clipping_mMatrix.translate(0.0, 0.0, clipping_plane_translation_z);
+      if(m_frame_plane)
+      {
+        for(int i=0; i< 16 ; i++)
+          clipping_mMatrix.data()[i] =  m_frame_plane->matrix()[i];
+      }
 
       rendering_program_clipping_plane.bind();
       int vpLocation = rendering_program_clipping_plane.uniformLocation("vp_matrix");
@@ -976,12 +980,15 @@ protected:
   {
     glEnable(GL_DEPTH_TEST);
 
-    // get clipping plane model matrix
     QMatrix4x4 clipping_mMatrix;
     clipping_mMatrix.setToIdentity();
-    clipping_mMatrix.rotate(clipping_plane_rotation);
-    QVector4D clipPlane = clipping_mMatrix * QVector4D(0.0, 0.0, 1.0, clipping_plane_translation_z);
-
+    if(m_frame_plane)
+    {
+      for(int i=0; i< 16 ; i++)
+        clipping_mMatrix.data()[i] =  m_frame_plane->matrix()[i];
+    }
+    QVector4D clipPlane = clipping_mMatrix * QVector4D(0.0, 0.0, 1.0, 0.0);
+    QVector4D plane_point = clipping_mMatrix * QVector4D(0,0,0,1);
     if(!m_are_buffers_initialized)
     { initialize_buffers(); }
 
@@ -1017,7 +1024,7 @@ protected:
       // rendering_mode == -1: draw all
       // rendering_mode == 0: draw inside clipping plane
       // rendering_mode == 1: draw outside clipping plane
-      auto renderer = [this, &color, &clipPlane](float rendering_mode) {
+      auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
         vao[VAO_MONO_POINTS].bind();
         color.setRgbF((double)m_vertices_mono_color.red()/(double)255,
                       (double)m_vertices_mono_color.green()/(double)255,
@@ -1025,6 +1032,7 @@ protected:
         rendering_program_p_l.setAttributeValue("color",color);
         rendering_program_p_l.setUniformValue("point_size", GLfloat(m_size_points));
         rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("pointPlane", plane_point);
         rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
         glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(arrays[POS_MONO_POINTS].size()/3));
         vao[VAO_MONO_POINTS].release();
@@ -1044,6 +1052,7 @@ protected:
         }
         rendering_program_p_l.setUniformValue("point_size", GLfloat(m_size_points));
         rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("pointPlane", plane_point);
         rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
         glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(arrays[POS_COLORED_POINTS].size()/3));
         vao[VAO_COLORED_POINTS].release();
@@ -1074,13 +1083,14 @@ protected:
       // rendering_mode == -1: draw all
       // rendering_mode == 0: draw inside clipping plane
       // rendering_mode == 1: draw outside clipping plane
-      auto renderer = [this, &color, &clipPlane](float rendering_mode) {
+      auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
         vao[VAO_MONO_SEGMENTS].bind();
         color.setRgbF((double)m_edges_mono_color.red()/(double)255,
                       (double)m_edges_mono_color.green()/(double)255,
                       (double)m_edges_mono_color.blue()/(double)255);
         rendering_program_p_l.setAttributeValue("color",color);
         rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("pointPlane", plane_point);
         rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
         glLineWidth(m_size_edges);
         glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_MONO_SEGMENTS].size()/3));
@@ -1100,6 +1110,7 @@ protected:
           rendering_program_p_l.enableAttributeArray("color");
         }
         rendering_program_p_l.setUniformValue("clipPlane", clipPlane);
+        rendering_program_p_l.setUniformValue("pointPlane", plane_point);
         rendering_program_p_l.setUniformValue("rendering_mode", rendering_mode);
         glLineWidth(m_size_edges);
         glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(arrays[POS_COLORED_SEGMENTS].size()/3));
@@ -1209,7 +1220,7 @@ protected:
       // rendering_mode == -1: draw all as solid;
       // rendering_mode == 0: draw solid only;
       // rendering_mode == 1: draw transparent only;
-      auto renderer = [this, &color, &clipPlane](float rendering_mode) {
+      auto renderer = [this, &color, &clipPlane, &plane_point](float rendering_mode) {
 
       vao[VAO_MONO_FACES].bind();
       color.setRgbF((double)m_faces_mono_color.red()/(double)255,
@@ -1219,6 +1230,7 @@ protected:
       rendering_program_face.setUniformValue("rendering_mode", rendering_mode);
       rendering_program_face.setUniformValue("rendering_transparency", clipping_plane_rendering_transparency);
       rendering_program_face.setUniformValue("clipPlane", clipPlane);
+      rendering_program_face.setUniformValue("pointPlane", plane_point);
       glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(arrays[POS_MONO_FACES].size()/3));
       vao[VAO_MONO_FACES].release();
 
@@ -1238,6 +1250,7 @@ protected:
         rendering_program_face.setUniformValue("rendering_mode", rendering_mode);
         rendering_program_face.setUniformValue("rendering_transparency", clipping_plane_rendering_transparency);
         rendering_program_face.setUniformValue("clipPlane", clipPlane);
+        rendering_program_face.setUniformValue("pointPlane", plane_point);
         glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(arrays[POS_COLORED_FACES].size()/3));
         vao[VAO_COLORED_FACES].release();
       };
@@ -1366,7 +1379,6 @@ protected:
                                                        bb.zmax()));
 
     // init clipping plane array
-    // TODO REMOVE
     auto generate_clipping_plane = [this](qreal size, int nbSubdivisions)
     {
       for (int i = 0; i <= nbSubdivisions; i++)
@@ -1412,12 +1424,11 @@ protected:
       {
         // toggle clipping plane
         m_use_clipping_plane = (m_use_clipping_plane + 1) % CLIPPING_PLANE_END_INDEX;
-        // TODO verify
-        if (m_use_clipping_plane==CLIPPING_PLANE_OFF)
+        if (m_use_clipping_plane==CLIPPING_PLANE_OFF && m_frame_plane)
         {
+          setManipulatedFrame(nullptr);
           delete m_frame_plane;
           m_frame_plane=nullptr;
-          setManipulatedFrame(nullptr);
         }
         else if (m_frame_plane==nullptr)
         {
@@ -1436,16 +1447,7 @@ protected:
         update();
       }
     }
-    else if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::ControlModifier))
-    {
-      if (!isOpenGL_4_3()) return;
-      if (m_use_clipping_plane!=CLIPPING_PLANE_OFF)
-      {
-        // enable clipping operation i.e. rotation, translation, and transparency adjustment
-        clipping_plane_operation = true;
-        update();
-      }
-    }
+
     else if ((e->key()==::Qt::Key_C) && (modifiers==::Qt::AltModifier))
     {
       if (!isOpenGL_4_3()) return;
@@ -1638,77 +1640,6 @@ protected:
       CGAL::QGLViewer::keyPressEvent(e);
   }
 
-  // TODO maybe remove
- virtual void keyReleaseEvent(QKeyEvent *e)
-  {
-    const ::Qt::KeyboardModifiers modifiers = e->modifiers();
-    if ((e->key()==::Qt::Key_C))
-    {
-      clipping_plane_operation = false;
-    }
-  }
-
-  // TODO maybe remove
-  virtual void mousePressEvent(QMouseEvent *e) {
-    if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::LeftButton) {
-      // rotation starting point
-      clipping_plane_rotation_tracker = QVector2D(e->localPos());
-    }
-    else if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::RightButton)
-    {
-      // translation starting point
-      clipping_plane_translation_tracker = QVector2D(e->localPos());
-    }
-    else
-    {
-      CGAL::QGLViewer::mousePressEvent(e);
-    }
-  }
-
-  // TODO maybe remove
-  virtual void mouseMoveEvent(QMouseEvent *e) {
-    if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::LeftButton)
-    {
-      // rotation ending point
-      QVector2D diff = QVector2D(e->localPos()) - clipping_plane_rotation_tracker;
-      clipping_plane_rotation_tracker = QVector2D(e->localPos());
-
-      QVector3D axis = QVector3D(diff.y(), diff.x(), 0.0);
-      float angle = diff.length();
-      clipping_plane_rotation = QQuaternion::fromAxisAndAngle(axis, angle) * clipping_plane_rotation;
-
-      update();
-    }
-    else if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier && e->buttons() == ::Qt::RightButton)
-    {
-      // translation ending point
-      QVector2D diff = QVector2D(e->localPos()) - clipping_plane_translation_tracker;
-      clipping_plane_translation_tracker = QVector2D(e->localPos());
-
-      clipping_plane_translation_z += clipping_plane_rendering_size / 500 * (diff.y() > 0 ? -1.0 : diff.y() < 0 ? 1.0 : 0.0) * diff.length();
-
-      update();
-    }
-    else
-    {
-      CGAL::QGLViewer::mouseMoveEvent(e);
-    }
-  }
-
-  // TODO maybe remove
-  virtual void wheelEvent(QWheelEvent *e)
-  {
-    if (clipping_plane_operation && e->modifiers() == ::Qt::ControlModifier) {
-      clipping_plane_rendering_transparency += (e->delta() / 120.0) / 50.0;
-      // clip to 0-1
-      clipping_plane_rendering_transparency = clipping_plane_rendering_transparency > 1.0 ? 1.0 : clipping_plane_rendering_transparency < 0.0 ? 0.0 : clipping_plane_rendering_transparency;
-    }
-    else
-    {
-      CGAL::QGLViewer::wheelEvent(e);
-    }
-  }
-
   virtual QString helpString() const
   { return helpString("CGAL Basic Viewer"); }
 
@@ -1857,11 +1788,6 @@ protected:
   QOpenGLShaderProgram rendering_program_clipping_plane;
 
   // variables for clipping plane
-  bool clipping_plane_operation = false; // will be enabled/diabled when ctrl+c is pressed/released, which is used for clipping plane translation and rotation;
-  QVector2D clipping_plane_rotation_tracker; // will be enabled when ctrl+c+left is pressed, which is used to record rotation;
-  QQuaternion clipping_plane_rotation; // real rotation;
-  QVector2D clipping_plane_translation_tracker; // will be enabled when ctrl+c+right is pressed, which is used to record translation;
-  float clipping_plane_translation_z = 0.0f; // real translation;
   bool clipping_plane_rendering = true; // will be toggled when alt+c is pressed, which is used for indicating whether or not to render the clipping plane ;
   float clipping_plane_rendering_transparency = 0.5f; // to what extent the transparent part should be rendered;
   float clipping_plane_rendering_size; // to what extent the size of clipping plane should be rendered;

From 1561f3a5235ce44c8f040650b4d1f0b6ed15903a Mon Sep 17 00:00:00 2001
From: Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
Date: Tue, 23 Feb 2021 11:11:04 +0100
Subject: [PATCH 7/7] Remove duplicated shaders

---
 .../include/CGAL/Qt/Basic_viewer_qt.h         | 166 ------------------
 1 file changed, 166 deletions(-)

diff --git a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
index ffdb131e2c2..f306e419ce7 100644
--- a/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
+++ b/GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
@@ -55,172 +55,6 @@
 
 namespace CGAL
 {
-//------------------------------------------------------------------------------
-const char vertex_source_color[] =
-  {
-    "#version 150 \n"
-    "in highp vec4 vertex;\n"
-    "in highp vec3 normal;\n"
-    "in highp vec3 color;\n"
-
-    "uniform highp mat4 mvp_matrix;\n"
-    "uniform highp mat4 mv_matrix; \n"
-
-    "out highp vec4 fP; \n"
-    "out highp vec3 fN; \n"
-    "out highp vec4 fColor; \n"
-
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   fP = mv_matrix * vertex; \n"
-    "   fN = mat3(mv_matrix)* normal; \n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_PointSize = point_size;\n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_color[] =
-  {
-    "#version 150 \n"
-    "in highp vec4 fP; \n"
-    "in highp vec3 fN; \n"
-    "in highp vec4 fColor; \n"
-    "uniform highp vec4 light_pos;  \n"
-    "uniform highp vec4 light_diff; \n"
-    "uniform highp vec4 light_spec; \n"
-    "uniform highp vec4 light_amb;  \n"
-    "uniform float spec_power ; \n"
-    "out vec4 out_color; \n"
-
-    "void main(void) { \n"
-    "   highp vec3 L = light_pos.xyz - fP.xyz; \n"
-    "   highp vec3 V = -fP.xyz; \n"
-
-    "   highp vec3 N = normalize(fN); \n"
-    "   L = normalize(L); \n"
-    "   V = normalize(V); \n"
-
-    "   highp vec3 R = reflect(-L, N); \n"
-    "   highp vec4 diffuse = max(dot(N,L), 0.0) * light_diff * fColor; \n"
-    "   highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec; \n"
-    "   out_color = light_amb*fColor + diffuse  ; \n"
-    "} \n"
-    "\n"
-  };
-
-const char vertex_source_p_l[] =
-  {
-    "#version 150 \n"
-    "in highp vec4 vertex;\n"
-    "in highp vec3 color;\n"
-    "uniform highp mat4 mvp_matrix;\n"
-    "out highp vec4 fColor; \n"
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   gl_PointSize = point_size;\n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_p_l[] =
-  {
-    "#version 150 \n"
-    "in highp vec4 fColor; \n"
-    "out vec4 out_color; \n"
-    "void main(void) { \n"
-    "out_color = fColor; \n"
-    "} \n"
-    "\n"
-  };
-
-//------------------------------------------------------------------------------
-//  compatibility shaders
-
-const char vertex_source_color_comp[] =
-  {
-    "attribute highp vec4 vertex;\n"
-    "attribute highp vec3 normal;\n"
-    "attribute highp vec3 color;\n"
-
-    "uniform highp mat4 mvp_matrix;\n"
-    "uniform highp mat4 mv_matrix; \n"
-
-    "varying highp vec4 fP; \n"
-    "varying highp vec3 fN; \n"
-    "varying highp vec4 fColor; \n"
-
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   fP = mv_matrix * vertex; \n"
-    "   highp mat3 mv_matrix_3; \n"
-    "   mv_matrix_3[0] = mv_matrix[0].xyz; \n"
-    "   mv_matrix_3[1] = mv_matrix[1].xyz; \n"
-    "   mv_matrix_3[2] = mv_matrix[2].xyz; \n"
-    "   fN = mv_matrix_3* normal;  \n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_PointSize = point_size;\n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_color_comp[] =
-  {
-    "varying highp vec4 fP; \n"
-    "varying highp vec3 fN; \n"
-    "varying highp vec4 fColor; \n"
-    "uniform highp vec4 light_pos;  \n"
-    "uniform highp vec4 light_diff; \n"
-    "uniform highp vec4 light_spec; \n"
-    "uniform highp vec4 light_amb;  \n"
-    "uniform highp float spec_power ; \n"
-
-    "void main(void) { \n"
-
-    "   highp vec3 L = light_pos.xyz - fP.xyz; \n"
-    "   highp vec3 V = -fP.xyz; \n"
-
-    "   highp vec3 N = normalize(fN); \n"
-    "   L = normalize(L); \n"
-    "   V = normalize(V); \n"
-
-    "   highp vec3 R = reflect(-L, N); \n"
-    "   highp vec4 diffuse = max(dot(N,L), 0.0) * light_diff * fColor; \n"
-    "   highp vec4 specular = pow(max(dot(R,V), 0.0), spec_power) * light_spec; \n"
-
-    "gl_FragColor = light_amb*fColor + diffuse  ; \n"
-    "} \n"
-    "\n"
-  };
-
-const char vertex_source_p_l_comp[] =
-  {
-    "attribute highp vec4 vertex;\n"
-    "attribute highp vec3 color;\n"
-    "uniform highp mat4 mvp_matrix;\n"
-    "varying highp vec4 fColor; \n"
-    "uniform highp float point_size; \n"
-    "void main(void)\n"
-    "{\n"
-    "   gl_PointSize = point_size;\n"
-    "   fColor = vec4(color, 1.0); \n"
-    "   gl_Position = mvp_matrix * vertex;\n"
-    "}"
-  };
-
-const char fragment_source_p_l_comp[] =
-  {
-    "varying highp vec4 fColor; \n"
-    "void main(void) { \n"
-    "gl_FragColor = fColor; \n"
-    "} \n"
-    "\n"
-  };
-
 //------------------------------------------------------------------------------
 inline CGAL::Color get_random_color(CGAL::Random& random)
 {