extract shaders to own file and use shared shader loading

Change-Id: I1af7e03a3e46f3cb49162be9351ce22f54d08c52

11 files changed, 274 insertions, 245 deletions

diff --git a/canvas/Library_oglcanvas.mk b/canvas/Library_oglcanvas.mk
index fca6996f70d3..b179e3bab819 100644
--- a/canvas/Library_oglcanvas.mk
+++ b/canvas/Library_oglcanvas.mk
@@ -20,6 +20,7 @@ $(eval $(call gb_Library_use_libraries,oglcanvas,\
 	cppuhelper \
 	comphelper \
 	vcl \
+	vclopengl \
 	tk \
 	tl \
 	i18nlangtag \
diff --git a/canvas/Module_canvas.mk b/canvas/Module_canvas.mk
index 310ad2a95343..a655ed123360 100644
--- a/canvas/Module_canvas.mk
+++ b/canvas/Module_canvas.mk
@@ -24,6 +24,7 @@ $(eval $(call gb_Module_add_targets,canvas,\
 	Library_canvastools \
 	Library_simplecanvas \
 	Library_vclcanvas \
+	Package_opengl \
 ))
 
 ifeq ($(ENABLE_CAIRO_CANVAS),TRUE)
diff --git a/canvas/Package_opengl.mk b/canvas/Package_opengl.mk
new file mode 100644
index 000000000000..af256bffa190
--- /dev/null
+++ b/canvas/Package_opengl.mk
@@ -0,0 +1,22 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+$(eval $(call gb_Package_Package,canvas_opengl_shader,$(SRCDIR)/canvas/opengl))
+
+$(eval $(call gb_Package_add_files,canvas_opengl_shader,$(LIBO_BIN_FOLDER)/opengl,\
+	dummyVertexShader.glsl \
+	linearMultiColorGradientFragmentShader.glsl \
+	linearTwoColorGradientFragmentShader.glsl \
+	radialMultiColorGradientFragmentShader.glsl \
+	radialTwoColorGradientFragmentShader.glsl \
+	rectangularMultiColorGradientFragmentShader.glsl \
+	rectangularTwoColorGradientFragmentShader.glsl \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/canvas/opengl/dummyVertexShader.glsl b/canvas/opengl/dummyVertexShader.glsl
new file mode 100644
index 000000000000..2948ee9b5480
--- /dev/null
+++ b/canvas/opengl/dummyVertexShader.glsl
@@ -0,0 +1,17 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+varying vec2 v_textureCoords2d;
+void main(void)
+{
+    gl_Position = ftransform();
+    v_textureCoords2d = gl_MultiTexCoord0.st;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/opengl/linearMultiColorGradientFragmentShader.glsl b/canvas/opengl/linearMultiColorGradientFragmentShader.glsl
new file mode 100644
index 000000000000..a3f3358c592b
--- /dev/null
+++ b/canvas/opengl/linearMultiColorGradientFragmentShader.glsl
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#version 120
+
+uniform int       i_nColors;
+uniform sampler1D t_colorArray4d;
+uniform sampler1D t_stopArray1d;
+uniform mat3x2    m_transform;
+varying vec2      v_textureCoords2d;
+
+int findBucket(float t)
+{
+    int nMinBucket=0;
+    while( nMinBucket < i_nColors &&
+            texture1D(t_stopArray1d, nMinBucket).s < t )
+        ++nMinBucket;
+    return max(nMinBucket-1,0);
+}
+
+void main(void)
+{
+    const float fAlpha =
+        clamp( (m_transform * vec3(v_textureCoords2d,1)).s,
+                0.0, 1.0 );
+
+    const int nMinBucket=findBucket( fAlpha );
+
+    const float fLerp =
+        (fAlpha-texture1D(t_stopArray1d, nMinBucket).s) /
+        (texture1D(t_stopArray1d, nMinBucket+1).s -
+         texture1D(t_stopArray1d, nMinBucket).s);
+
+    gl_FragColor = mix(texture1D(t_colorArray4d, nMinBucket),
+            texture1D(t_colorArray4d, nMinBucket+1),
+            fLerp);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/opengl/linearTwoColorGradientFragmentShader.glsl b/canvas/opengl/linearTwoColorGradientFragmentShader.glsl
new file mode 100644
index 000000000000..8659bfd1166c
--- /dev/null
+++ b/canvas/opengl/linearTwoColorGradientFragmentShader.glsl
@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#version 120
+
+uniform vec4   v_startColor4d;
+uniform vec4   v_endColor4d;
+uniform mat3x2 m_transform;
+varying vec2   v_textureCoords2d;
+
+void main(void)
+{
+    gl_FragColor = mix(v_startColor4d,
+            v_endColor4d,
+            clamp(
+                (m_transform * vec3(v_textureCoords2d,1)).s,
+                0.0, 1.0));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/opengl/radialMultiColorGradientFragmentShader.glsl b/canvas/opengl/radialMultiColorGradientFragmentShader.glsl
new file mode 100644
index 000000000000..6f61a766fed3
--- /dev/null
+++ b/canvas/opengl/radialMultiColorGradientFragmentShader.glsl
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#version 120
+
+uniform int       i_nColors;
+uniform sampler1D t_colorArray4d;
+uniform sampler1D t_stopArray1d;
+uniform mat3x2    m_transform;
+varying vec2      v_textureCoords2d;
+const vec2        v_center2d = vec2(0,0);
+
+int findBucket(float t)
+{
+    int nMinBucket=0;
+    while( nMinBucket < i_nColors &&
+            texture1D(t_stopArray1d, nMinBucket).s < t )
+        ++nMinBucket;
+    return max(nMinBucket-1,0);
+}
+
+void main(void)
+{
+    const float fAlpha =
+        clamp( 1.0 - distance(
+                    vec2( m_transform * vec3(v_textureCoords2d,1)),
+                    v_center2d),
+                0.0, 1.0 );
+
+    const int nMinBucket=findBucket( fAlpha );
+
+    const float fLerp =
+        (fAlpha-texture1D(t_stopArray1d, nMinBucket).s) /
+        (texture1D(t_stopArray1d, nMinBucket+1).s -
+         texture1D(t_stopArray1d, nMinBucket).s);
+
+    gl_FragColor = mix(texture1D(t_colorArray4d, nMinBucket),
+            texture1D(t_colorArray4d, nMinBucket+1),
+            fLerp);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/opengl/radialTwoColorGradientFragmentShader.glsl b/canvas/opengl/radialTwoColorGradientFragmentShader.glsl
new file mode 100644
index 000000000000..a5d613454b11
--- /dev/null
+++ b/canvas/opengl/radialTwoColorGradientFragmentShader.glsl
@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#version 120
+
+uniform vec4   v_startColor4d;
+uniform vec4   v_endColor4d;
+uniform mat3x2 m_transform;
+varying vec2   v_textureCoords2d;
+const vec2     v_center2d = vec2(0,0);
+
+void main(void)
+{
+    gl_FragColor = mix(v_startColor4d,
+            v_endColor4d,
+            1.0 - distance(
+                vec2(
+                    m_transform * vec3(v_textureCoords2d,1)),
+                v_center2d));
+    }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/opengl/rectangularMultiColorGradientFragmentShader.glsl b/canvas/opengl/rectangularMultiColorGradientFragmentShader.glsl
new file mode 100644
index 000000000000..05a8ae513f02
--- /dev/null
+++ b/canvas/opengl/rectangularMultiColorGradientFragmentShader.glsl
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#version 120
+
+uniform int       i_nColors;
+uniform sampler1D t_colorArray4d;
+uniform sampler1D t_stopArray1d;
+uniform mat3x2    m_transform;
+varying vec2      v_textureCoords2d;
+
+int findBucket(float t)
+{
+    int nMinBucket=0;
+    while( nMinBucket < i_nColors &&
+            texture1D(t_stopArray1d, nMinBucket).s < t )
+        ++nMinBucket;
+    return max(nMinBucket-1,0);
+}
+
+void main(void)
+{
+    const vec2  v = abs( vec2(m_transform * vec3(v_textureCoords2d,1)) );
+    const float fAlpha = 1 - max(v.x, v.y);
+
+    const int nMinBucket=findBucket( fAlpha );
+
+    const float fLerp =
+        (fAlpha-texture1D(t_stopArray1d, nMinBucket).s) /
+        (texture1D(t_stopArray1d, nMinBucket+1).s -
+         texture1D(t_stopArray1d, nMinBucket).s);
+
+    gl_FragColor = mix(texture1D(t_colorArray4d, nMinBucket),
+            texture1D(t_colorArray4d, nMinBucket+1),
+            fLerp);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/opengl/rectangularTwoColorGradientFragmentShader.glsl b/canvas/opengl/rectangularTwoColorGradientFragmentShader.glsl
new file mode 100644
index 000000000000..a92a53342975
--- /dev/null
+++ b/canvas/opengl/rectangularTwoColorGradientFragmentShader.glsl
@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#version 120
+
+uniform vec4   v_startColor4d;
+uniform vec4   v_endColor4d;
+uniform mat3x2 m_transform;
+varying vec2   v_textureCoords2d;
+void main(void)
+{
+    const vec2 v = abs( vec2(m_transform * vec3(v_textureCoords2d,1)) );
+    const float t = max(v.x, v.y);
+    gl_FragColor = mix(v_startColor4d,
+            v_endColor4d,
+            1.0-t);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/canvas/source/opengl/ogl_spritedevicehelper.cxx b/canvas/source/opengl/ogl_spritedevicehelper.cxx
index 781beaf1f050..c7d3beaa136b 100644
--- a/canvas/source/opengl/ogl_spritedevicehelper.cxx
+++ b/canvas/source/opengl/ogl_spritedevicehelper.cxx
@@ -53,197 +53,6 @@ static int lcl_XErrorHandler( unx::Display*, unx::XErrorEvent* )
     return 0;
 }
 
-/** Dummy vertex processing. Simply uses default pipeline for vertex
-   transformation, and forwards texture coodinates to fragment shader
- */
-static const char dummyVertexShader[] =
-{
-    "varying vec2 v_textureCoords2d;                                            "
-    "void main(void)                                                            "
-    "{                                                                          "
-    "    gl_Position = ftransform();                                            "
-    "    v_textureCoords2d = gl_MultiTexCoord0.st;                              "
-    "}                                                                          "
-};
-
-/** Two-color linear gradient
- */
-static const char linearTwoColorGradientFragmentShader[] =
-{
-    "#version 120                                                            \n"
-    "uniform vec4   v_startColor4d;                                            "
-    "uniform vec4   v_endColor4d;                                              "
-    "uniform mat3x2 m_transform;                                               "
-    "varying vec2   v_textureCoords2d;                                         "
-    "void main(void)                                                           "
-    "{                                                                         "
-    "    gl_FragColor = mix(v_startColor4d,                                    "
-    "                       v_endColor4d,                                      "
-    "                       clamp(                                             "
-    "                          (m_transform * vec3(v_textureCoords2d,1)).s,    "
-    "                          0.0, 1.0));                                     "
-    "}                                                                         "
-};
-
-/** N-color linear gradient
- */
-static const char linearMultiColorGradientFragmentShader[] =
-{
-    "#version 120                                                            \n"
-    "uniform int       i_nColors;                                              "
-    "uniform sampler1D t_colorArray4d;                                         "
-    "uniform sampler1D t_stopArray1d;                                          "
-    "uniform mat3x2    m_transform;                                            "
-    "varying vec2      v_textureCoords2d;                                      "
-    "                                                                          "
-    "int findBucket(float t)                                                   "
-    "{                                                                         "
-    "    int nMinBucket=0;                                                     "
-    "    while( nMinBucket < i_nColors &&                                      "
-    "           texture1D(t_stopArray1d, nMinBucket).s < t )                   "
-    "        ++nMinBucket;                                                     "
-    "    return max(nMinBucket-1,0);                                           "
-    "}                                                                         "
-    "                                                                          "
-    "void main(void)                                                           "
-    "{                                                                         "
-    "    const float fAlpha =                                                  "
-    "        clamp( (m_transform * vec3(v_textureCoords2d,1)).s,               "
-    "               0.0, 1.0 );                                                "
-    "                                                                          "
-    "    const int nMinBucket=findBucket( fAlpha );                            "
-    "                                                                          "
-    "    const float fLerp =                                                   "
-    "        (fAlpha-texture1D(t_stopArray1d, nMinBucket).s) /                 "
-    "        (texture1D(t_stopArray1d, nMinBucket+1).s -                       "
-    "         texture1D(t_stopArray1d, nMinBucket).s);                         "
-    "                                                                          "
-    "    gl_FragColor = mix(texture1D(t_colorArray4d, nMinBucket),             "
-    "                       texture1D(t_colorArray4d, nMinBucket+1),           "
-    "                       fLerp);                                            "
-    "}                                                                         "
-};
-
-/** Two-color radial gradient
- */
-static const char radialTwoColorGradientFragmentShader[] =
-{
-    "#version 120                                                             \n"
-    "uniform vec4   v_startColor4d;                                             "
-    "uniform vec4   v_endColor4d;                                               "
-    "uniform mat3x2 m_transform;                                                "
-    "varying vec2   v_textureCoords2d;                                          "
-    "const vec2     v_center2d = vec2(0,0);                                     "
-    "void main(void)                                                            "
-    "{                                                                          "
-    "    gl_FragColor = mix(v_startColor4d,                                     "
-    "                       v_endColor4d,                                       "
-    "                       1.0 - distance(                                     "
-    "                          vec2(                                            "
-    "                             m_transform * vec3(v_textureCoords2d,1)),     "
-    "                          v_center2d));                                    "
-    "}                                                                          "
-};
-
-/** Multi-color radial gradient
- */
-static const char radialMultiColorGradientFragmentShader[] =
-{
-    "#version 120                                                             \n"
-    "uniform int       i_nColors;                                              "
-    "uniform sampler1D t_colorArray4d;                                         "
-    "uniform sampler1D t_stopArray1d;                                          "
-    "uniform mat3x2    m_transform;                                            "
-    "varying vec2      v_textureCoords2d;                                      "
-    "const vec2        v_center2d = vec2(0,0);                                 "
-    "                                                                          "
-    "int findBucket(float t)                                                   "
-    "{                                                                         "
-    "    int nMinBucket=0;                                                     "
-    "    while( nMinBucket < i_nColors &&                                      "
-    "           texture1D(t_stopArray1d, nMinBucket).s < t )                   "
-    "        ++nMinBucket;                                                     "
-    "    return max(nMinBucket-1,0);                                           "
-    "}                                                                         "
-    "                                                                          "
-    "void main(void)                                                           "
-    "{                                                                         "
-    "    const float fAlpha =                                                  "
-    "        clamp( 1.0 - distance(                                            "
-    "               vec2( m_transform * vec3(v_textureCoords2d,1)),            "
-    "                     v_center2d),                                         "
-    "               0.0, 1.0 );                                                "
-    "                                                                          "
-    "    const int nMinBucket=findBucket( fAlpha );                            "
-    "                                                                          "
-    "    const float fLerp =                                                   "
-    "        (fAlpha-texture1D(t_stopArray1d, nMinBucket).s) /                 "
-    "        (texture1D(t_stopArray1d, nMinBucket+1).s -                       "
-    "         texture1D(t_stopArray1d, nMinBucket).s);                         "
-    "                                                                          "
-    "    gl_FragColor = mix(texture1D(t_colorArray4d, nMinBucket),             "
-    "                       texture1D(t_colorArray4d, nMinBucket+1),           "
-    "                       fLerp);                                            "
-    "}                                                                         "
-};
-
-/** Two-color rectangular gradient
- */
-static const char rectangularTwoColorGradientFragmentShader[] =
-{
-    "#version 120                                                             \n"
-    "uniform vec4   v_startColor4d;                                             "
-    "uniform vec4   v_endColor4d;                                               "
-    "uniform mat3x2 m_transform;                                                "
-    "varying vec2   v_textureCoords2d;                                          "
-    "void main(void)                                                            "
-    "{                                                                          "
-    "    const vec2 v = abs( vec2(m_transform * vec3(v_textureCoords2d,1)) );   "
-    "    const float t = max(v.x, v.y);                                         "
-    "    gl_FragColor = mix(v_startColor4d,                                     "
-    "                       v_endColor4d,                                       "
-    "                       1.0-t);                                             "
-    "}                                                                          "
-};
-
-/** Multi-color rectangular gradient
- */
-static const char rectangularMultiColorGradientFragmentShader[] =
-{
-    "#version 120                                                             \n"
-    "uniform int       i_nColors;                                              "
-    "uniform sampler1D t_colorArray4d;                                         "
-    "uniform sampler1D t_stopArray1d;                                          "
-    "uniform mat3x2    m_transform;                                            "
-    "varying vec2      v_textureCoords2d;                                      "
-    "                                                                          "
-    "int findBucket(float t)                                                   "
-    "{                                                                         "
-    "    int nMinBucket=0;                                                     "
-    "    while( nMinBucket < i_nColors &&                                      "
-    "           texture1D(t_stopArray1d, nMinBucket).s < t )                   "
-    "        ++nMinBucket;                                                     "
-    "    return max(nMinBucket-1,0);                                           "
-    "}                                                                         "
-    "                                                                          "
-    "void main(void)                                                           "
-    "{                                                                         "
-    "    const vec2  v = abs( vec2(m_transform * vec3(v_textureCoords2d,1)) ); "
-    "    const float fAlpha = 1 - max(v.x, v.y);                               "
-    "                                                                          "
-    "    const int nMinBucket=findBucket( fAlpha );                            "
-    "                                                                          "
-    "    const float fLerp =                                                   "
-    "        (fAlpha-texture1D(t_stopArray1d, nMinBucket).s) /                 "
-    "        (texture1D(t_stopArray1d, nMinBucket+1).s -                       "
-    "         texture1D(t_stopArray1d, nMinBucket).s);                         "
-    "                                                                          "
-    "    gl_FragColor = mix(texture1D(t_colorArray4d, nMinBucket),             "
-    "                       texture1D(t_colorArray4d, nMinBucket+1),           "
-    "                       fLerp);                                            "
-    "}                                                                         "
-};
-
 static void initContext()
 {
     // need the backside for mirror effects
@@ -529,13 +338,6 @@ namespace oglcanvas
         mpGLPBufContext(NULL),
         mpFBConfig(NULL),
         mpTextureCache(new TextureCache()),
-        mnDummyVertexProgram(0),
-        mnLinearTwoColorGradientFragmentProgram(0),
-        mnLinearMultiColorGradientFragmentProgram(0),
-        mnRadialTwoColorGradientFragmentProgram(0),
-        mnRadialMultiColorGradientFragmentProgram(0),
-        mnRectangularTwoColorGradientFragmentProgram(0),
-        mnRectangularMultiColorGradientFragmentProgram(0),
         mnLinearTwoColorGradientProgram(0),
         mnLinearMultiColorGradientProgram(0),
         mnRadialTwoColorGradientProgram(0),
@@ -648,46 +450,23 @@ namespace oglcanvas
             // init window context
             initContext();
 
-            // compile & link shaders - code courtesy rodo
-            compileShader(mnDummyVertexProgram,
-                          GL_VERTEX_SHADER,
-                          dummyVertexShader);
-            compileShader(mnLinearTwoColorGradientFragmentProgram,
-                          GL_FRAGMENT_SHADER,
-                          linearTwoColorGradientFragmentShader);
-            compileShader(mnLinearMultiColorGradientFragmentProgram,
-                          GL_FRAGMENT_SHADER,
-                          linearMultiColorGradientFragmentShader);
-            compileShader(mnRadialTwoColorGradientFragmentProgram,
-                          GL_FRAGMENT_SHADER,
-                          radialTwoColorGradientFragmentShader);
-            compileShader(mnRadialMultiColorGradientFragmentProgram,
-                          GL_FRAGMENT_SHADER,
-                          radialMultiColorGradientFragmentShader);
-            compileShader(mnRectangularTwoColorGradientFragmentProgram,
-                          GL_FRAGMENT_SHADER,
-                          rectangularTwoColorGradientFragmentShader);
-            compileShader(mnRectangularMultiColorGradientFragmentProgram,
-                          GL_FRAGMENT_SHADER,
-                          rectangularMultiColorGradientFragmentShader);
-            linkShaders(mnLinearTwoColorGradientProgram,
-                        mnDummyVertexProgram,
-                        mnLinearTwoColorGradientFragmentProgram);
-            linkShaders(mnLinearMultiColorGradientProgram,
-                        mnDummyVertexProgram,
-                        mnLinearMultiColorGradientFragmentProgram);
-            linkShaders(mnRadialTwoColorGradientProgram,
-                        mnDummyVertexProgram,
-                        mnRadialTwoColorGradientFragmentProgram);
-            linkShaders(mnRadialMultiColorGradientProgram,
-                        mnDummyVertexProgram,
-                        mnRadialMultiColorGradientFragmentProgram);
-            linkShaders(mnRectangularTwoColorGradientProgram,
-                        mnDummyVertexProgram,
-                        mnRectangularTwoColorGradientFragmentProgram);
-            linkShaders(mnRectangularMultiColorGradientProgram,
-                        mnDummyVertexProgram,
-                        mnRectangularMultiColorGradientFragmentProgram);
+            mnLinearMultiColorGradientProgram =
+                OpenGLHelper::LoadShaders("dummyVertexShader.glsl", "linearMultiColorGradientFragmentShader.glsl");
+
+            mnLinearTwoColorGradientProgram =
+                OpenGLHelper::LoadShaders("dummyVertexShader.glsl", "linearTwoColorGradientFragmentShader.glsl");
+
+            mnRadialMultiColorGradientProgram =
+                OpenGLHelper::LoadShaders("dummyVertexShader.glsl", "radialMultiColorGradientFragmentShader.glsl");
+
+            mnRadialTwoColorGradientProgram =
+                OpenGLHelper::LoadShaders("dummyVertexShader.glsl", "radialTwoColorGradientFragmentShader.glsl");
+
+            mnRectangularMultiColorGradientProgram =
+                OpenGLHelper::LoadShaders("dummyVertexShader.glsl", "rectangularMultiColorGradientFragmentShader.glsl");
+
+            mnRectangularTwoColorGradientProgram =
+                OpenGLHelper::LoadShaders("dummyVertexShader.glsl", "rectangularTwoColorGradientFragmentShader.glsl");
 
             glXMakeCurrent(pDisplay, None, NULL);
         }
@@ -716,13 +495,6 @@ namespace oglcanvas
             glDeleteProgram( mnRadialMultiColorGradientProgram );
             glDeleteProgram( mnLinearTwoColorGradientProgram );
             glDeleteProgram( mnLinearMultiColorGradientProgram );
-            glDeleteShader( mnRectangularTwoColorGradientFragmentProgram );
-            glDeleteShader( mnRectangularMultiColorGradientFragmentProgram );
-            glDeleteShader( mnRadialTwoColorGradientFragmentProgram );
-            glDeleteShader( mnRadialMultiColorGradientFragmentProgram );
-            glDeleteShader( mnLinearTwoColorGradientFragmentProgram );
-            glDeleteShader( mnLinearMultiColorGradientFragmentProgram );
-            glDeleteShader( mnDummyVertexProgram );
 
             glXDestroyContext(reinterpret_cast<unx::Display*>(mpDisplay),
                               reinterpret_cast<unx::GLXContext>(mpGLContext));