[Libreoffice-commits] core.git: slideshow/opengl

[Emmanuel Gil Peyrot]

 slideshow/opengl/honeycombVertexShader.glsl |   41 +++++++++++++++++++++-------
 slideshow/opengl/vortexVertexShader.glsl    |   15 +++++++---
 2 files changed, 42 insertions(+), 14 deletions(-)

New commits:
commit db9fe1ea4a1e0e33dece63652c2b076fb323ec63
Author: Emmanuel Gil Peyrot <emmanuel.peyrot at collabora.com>
Date:   Wed Feb 24 20:21:12 2016 +0000

    slideshow: Add an ugly workaround for Intel’s matrix multiplication
    
    When more than three multiplications are chained, Intel’s Windows
    driver returns a mat4 containing only zeroes, likely due to a
    misbehaving optimisation.  This patch prevents it from doing any
    optimisation by doing each multiplication in its own uniform block.
    
    Change-Id: I0b435d3a5444afd47f78c379f0d2e442d2c2cfc0
    Reviewed-on: https://gerrit.libreoffice.org/22470
    Tested-by: Jenkins <ci at libreoffice.org>
    Reviewed-by: Tomaž Vajngerl <quikee at gmail.com>

diff --git a/slideshow/opengl/honeycombVertexShader.glsl b/slideshow/opengl/honeycombVertexShader.glsl
index 32fdece..c3484d3 100644
--- a/slideshow/opengl/honeycombVertexShader.glsl
+++ b/slideshow/opengl/honeycombVertexShader.glsl
@@ -25,10 +25,21 @@ uniform float shadow;
 uniform mat4 orthoProjectionMatrix;
 uniform mat4 orthoViewMatrix;
 
+// Workaround for Intel's Windows driver, to prevent optimisation breakage.
+uniform float zero;
+
 out mat4 projectionMatrix;
 out mat4 modelViewMatrix;
 out mat4 shadowMatrix;
 
+mat4 identityMatrix(void)
+{
+    return mat4(1.0, 0.0, 0.0, 0.0,
+                0.0, 1.0, 0.0, 0.0,
+                0.0, 0.0, 1.0, 0.0,
+                0.0, 0.0, 0.0, 1.0);
+}
+
 mat4 translationMatrix(vec3 axis)
 {
     return mat4(1.0,    0.0,    0.0,    0.0,
@@ -61,25 +72,35 @@ mat4 rotationMatrix(vec3 axis, float angle)
 void main( void )
 {
     mat4 nmodelViewMatrix = u_modelViewMatrix * u_operationsTransformMatrix * u_sceneTransformMatrix * u_primitiveTransformMatrix;
-    mat4 transformMatrix;
+    mat4 transformMatrix = identityMatrix();
 
     // TODO: use the aspect ratio of the slide instead.
     mat4 slideScaleMatrix = scaleMatrix(vec3(0.75, 1, 1));
     mat4 invertSlideScaleMatrix = scaleMatrix(1.0 / vec3(0.75, 1, 1));
 
+    // These ugly zero comparisons are a workaround for Intel's Windows driver optimisation bug.
     if (selectedTexture > 0.5) {
         // Leaving texture
-        transformMatrix = translationMatrix(vec3(0, 0, 6 * time))
-            * scaleMatrix(vec3(1 + pow(2 * time, 2.1), 1 + pow(2 * time, 2.1), 0))
-            * slideScaleMatrix
-            * rotationMatrix(vec3(0.0, 0.0, 1.0), -pow(time, 3) * M_PI)
-            * invertSlideScaleMatrix;
+        if (zero < 1.0)
+            transformMatrix = invertSlideScaleMatrix * transformMatrix;
+        if (zero < 2.0)
+            transformMatrix = rotationMatrix(vec3(0.0, 0.0, 1.0), -pow(time, 3) * M_PI) * transformMatrix;
+        if (zero < 3.0)
+            transformMatrix = slideScaleMatrix * transformMatrix;
+        if (zero < 4.0)
+            transformMatrix = scaleMatrix(vec3(1 + pow(2 * time, 2.1), 1 + pow(2 * time, 2.1), 0)) * transformMatrix;
+        if (zero < 5.0)
+            transformMatrix = translationMatrix(vec3(0, 0, 6 * time)) * transformMatrix;
     } else {
         // Entering texture
-        transformMatrix = translationMatrix(vec3(0, 0, 28 * (sqrt(time) - 1)))
-            * slideScaleMatrix
-            * rotationMatrix(vec3(0.0, 0.0, 1.0), pow(0.8 * (time - 1.0), 2.0) * M_PI)
-            * invertSlideScaleMatrix;
+        if (zero < 1.0)
+            transformMatrix = invertSlideScaleMatrix * transformMatrix;
+        if (zero < 2.0)
+            transformMatrix = rotationMatrix(vec3(0.0, 0.0, 1.0), pow(0.8 * (time - 1.0), 2.0) * M_PI) * transformMatrix;
+        if (zero < 3.0)
+            transformMatrix = slideScaleMatrix * transformMatrix;
+        if (zero < 4.0)
+            transformMatrix = translationMatrix(vec3(0, 0, 28 * (sqrt(time) - 1))) * transformMatrix;
     }
 
     if (shadow < 0.5) {
diff --git a/slideshow/opengl/vortexVertexShader.glsl b/slideshow/opengl/vortexVertexShader.glsl
index 3d5838e..5c6fe23 100644
--- a/slideshow/opengl/vortexVertexShader.glsl
+++ b/slideshow/opengl/vortexVertexShader.glsl
@@ -26,6 +26,9 @@ uniform ivec2 numTiles;
 uniform sampler2D permTexture;
 uniform float slide;
 
+// Workaround for Intel's Windows driver, to prevent optimisation breakage.
+uniform float zero;
+
 out vec2 g_texturePosition;
 out vec3 g_normal;
 out mat4 modelViewMatrix;
@@ -130,10 +133,14 @@ void main( void )
         vec3 translationVector = vec3(rotationFuzz, 0.0, 0.0);
 
         // Compute the actual rotation matrix.
-        transform = translationMatrix(translationVector)
-                  * rotationMatrix(vec3(0.0, 1.0, 0.0), clamp(rotation, -1.0, 1.0) * M_PI)
-                  * translationMatrix(-translationVector)
-                  * transform;
+
+        // Intel's Windows driver gives a wrong matrix when all operations are done at once.
+        if (zero < 1.0)
+            transform = translationMatrix(translationVector) * transform;
+        if (zero < 2.0)
+            transform = rotationMatrix(vec3(0.0, 1.0, 0.0), clamp(rotation, -1.0, 1.0) * M_PI) * transform;
+        if (zero < 3.0)
+            transform = translationMatrix(-translationVector) * transform;
     }
 
     modelViewMatrix = u_modelViewMatrix * u_operationsTransformMatrix * u_sceneTransformMatrix * u_primitiveTransformMatrix;