[Libreoffice-commits] core.git: Branch 'feature/mac-opengl-fixes' - 5 commits - slideshow/Library_OGLTrans.mk slideshow/source

Markus Mohrhard markus.mohrhard at googlemail.com
Wed Aug 27 08:45:53 PDT 2014


 slideshow/Library_OGLTrans.mk                                          |    1 
 slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx   |  493 +++++-----
 slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx   |   67 -
 slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx |    3 
 4 files changed, 306 insertions(+), 258 deletions(-)

New commits:
commit 81f9ac916f043b5d4d64426264ba2714b85554e4
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date:   Wed Aug 27 17:44:59 2014 +0200

    basegfx -> glm in OGLTrans
    
    Change-Id: I3f3002d975f3ee2732c5e132b3b67531356aad5c

diff --git a/slideshow/Library_OGLTrans.mk b/slideshow/Library_OGLTrans.mk
index 20596b5..6a9d2ac 100644
--- a/slideshow/Library_OGLTrans.mk
+++ b/slideshow/Library_OGLTrans.mk
@@ -39,6 +39,7 @@ $(eval $(call gb_Library_use_externals,OGLTrans,\
 	boost_headers \
 	glew \
 	mesa_headers \
+	glm_headers \
 ))
 
 $(eval $(call gb_Library_set_componentfile,OGLTrans,slideshow/source/engine/OGLTrans/ogltrans))
diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
index 17bdff5..f2c94ef 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
@@ -424,19 +424,19 @@ boost::shared_ptr<OGLTransitionImpl> makeOutsideCubeFaceToLeft()
 {
     Primitive Slide;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
 
     Primitives_t aLeavingPrimitives;
     aLeavingPrimitives.push_back(Slide);
 
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),90,false,0.0,1.0));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,-1),90,false,0.0,1.0));
 
     Primitives_t aEnteringPrimitives;
     aEnteringPrimitives.push_back(Slide);
 
     Operations_t aOperations;
-    aOperations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),-90,true,0.0,1.0));
+    aOperations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,-1),-90,true,0.0,1.0));
 
     return makeSimpleTransition(aLeavingPrimitives, aEnteringPrimitives, aOperations);
 }
@@ -445,19 +445,19 @@ boost::shared_ptr<OGLTransitionImpl> makeInsideCubeFaceToLeft()
 {
     Primitive Slide;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
 
     Primitives_t aLeavingPrimitives;
     aLeavingPrimitives.push_back(Slide);
 
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),-90,false,0.0,1.0));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,1),-90,false,0.0,1.0));
 
     Primitives_t aEnteringPrimitives;
     aEnteringPrimitives.push_back(Slide);
 
     Operations_t aOperations;
-    aOperations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),90,true,0.0,1.0));
+    aOperations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,1),90,true,0.0,1.0));
 
     return makeSimpleTransition(aLeavingPrimitives, aEnteringPrimitives, aOperations);
 }
@@ -466,13 +466,13 @@ boost::shared_ptr<OGLTransitionImpl> makeFallLeaving()
 {
     Primitive Slide;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
 
     Primitives_t aEnteringPrimitives;
     aEnteringPrimitives.push_back(Slide);
 
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(1,0,0),basegfx::B3DVector(0,-1,0), 90,true,0.0,1.0));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(1,0,0),glm::vec3(0,-1,0), 90,true,0.0,1.0));
     Primitives_t aLeavingPrimitives;
     aLeavingPrimitives.push_back(Slide);
 
@@ -489,19 +489,19 @@ boost::shared_ptr<OGLTransitionImpl> makeTurnAround()
     TransitionSettings aSettings;
     aSettings.mbReflectSlides = true;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
     Primitives_t aLeavingPrimitives;
     aLeavingPrimitives.push_back(Slide);
 
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0),-180,false,0.0,1.0));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,0),-180,false,0.0,1.0));
     Primitives_t aEnteringPrimitives;
     aEnteringPrimitives.push_back(Slide);
 
     Operations_t aOperations;
-    aOperations.push_back(makeSTranslate(basegfx::B3DVector(0, 0, -1.5),true, 0, 0.5));
-    aOperations.push_back(makeSTranslate(basegfx::B3DVector(0, 0, 1.5), true, 0.5, 1));
-    aOperations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0),basegfx::B3DVector(0, 0, 0), -180, true, 0.0, 1.0));
+    aOperations.push_back(makeSTranslate(glm::vec3(0, 0, -1.5),true, 0, 0.5));
+    aOperations.push_back(makeSTranslate(glm::vec3(0, 0, 1.5), true, 0.5, 1));
+    aOperations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0, 1, 0),glm::vec3(0, 0, 0), -180, true, 0.0, 1.0));
 
     return makeSimpleTransition(aLeavingPrimitives, aEnteringPrimitives, aOperations, aSettings);
 }
@@ -510,14 +510,14 @@ boost::shared_ptr<OGLTransitionImpl> makeTurnDown()
 {
     Primitive Slide;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
     Primitives_t aLeavingPrimitives;
     aLeavingPrimitives.push_back(Slide);
 
-    Slide.Operations.push_back(makeSTranslate(basegfx::B3DVector(0, 0, 0.0001), false, -1.0, 0.0));
-    Slide.Operations.push_back(makeSRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), -90, true, 0.0, 1.0));
-    Slide.Operations.push_back(makeSRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), 90, false, -1.0, 0.0));
+    Slide.Operations.push_back(makeSTranslate(glm::vec3(0, 0, 0.0001), false, -1.0, 0.0));
+    Slide.Operations.push_back(makeSRotate (glm::vec3(0, 0, 1), glm::vec3(-1, 1, 0), -90, true, 0.0, 1.0));
+    Slide.Operations.push_back(makeSRotate (glm::vec3(0, 0, 1), glm::vec3(-1, 1, 0), 90, false, -1.0, 0.0));
     Primitives_t aEnteringPrimitives;
     aEnteringPrimitives.push_back(Slide);
 
@@ -531,13 +531,13 @@ boost::shared_ptr<OGLTransitionImpl> makeIris()
 {
     Primitive Slide;
 
-    Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
-    Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+    Slide.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0,1));
+    Slide.pushTriangle (glm::vec2 (1,0), glm::vec2 (0,1), glm::vec2 (1,1));
     Primitives_t aEnteringPrimitives;
     aEnteringPrimitives.push_back (Slide);
 
-    Slide.Operations.push_back (makeSTranslate (basegfx::B3DVector (0, 0,  0.000001), false, -1, 0));
-    Slide.Operations.push_back (makeSTranslate (basegfx::B3DVector (0, 0, -0.000002), false, 0.5, 1));
+    Slide.Operations.push_back (makeSTranslate (glm::vec3 (0, 0,  0.000001), false, -1, 0));
+    Slide.Operations.push_back (makeSTranslate (glm::vec3 (0, 0, -0.000002), false, 0.5, 1));
     Primitives_t aLeavingPrimitives;
     aLeavingPrimitives.push_back (Slide);
 
@@ -557,12 +557,12 @@ boost::shared_ptr<OGLTransitionImpl> makeIris()
         cyo = (of*y + 1)/2;
         lcxo = (of*lx + 1)/2;
         lcyo = (of*ly + 1)/2;
-        irisPart.pushTriangle (basegfx::B2DVector (lcx, lcy),
-                               basegfx::B2DVector (lcxo, lcyo),
-                               basegfx::B2DVector (cx, cy));
-        irisPart.pushTriangle (basegfx::B2DVector (cx, cy),
-                               basegfx::B2DVector (lcxo, lcyo),
-                               basegfx::B2DVector (cxo, cyo));
+        irisPart.pushTriangle (glm::vec2 (lcx, lcy),
+                               glm::vec2 (lcxo, lcyo),
+                               glm::vec2 (cx, cy));
+        irisPart.pushTriangle (glm::vec2 (cx, cy),
+                               glm::vec2 (lcxo, lcyo),
+                               glm::vec2 (cxo, cyo));
         lx = x;
         ly = y;
         t += 1.0/nSteps;
@@ -577,15 +577,15 @@ boost::shared_ptr<OGLTransitionImpl> makeIris()
 
         rx = cos ((2*M_PI*i)/nParts);
         ry = sin ((2*M_PI*i)/nParts);
-        irisPart.Operations.push_back (makeSRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0),  angle, true, 0.0, 0.5));
-        irisPart.Operations.push_back (makeSRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0), -angle, true, 0.5, 1));
+        irisPart.Operations.push_back (makeSRotate (glm::vec3(0, 0, 1), glm::vec3(rx, ry, 0),  angle, true, 0.0, 0.5));
+        irisPart.Operations.push_back (makeSRotate (glm::vec3(0, 0, 1), glm::vec3(rx, ry, 0), -angle, true, 0.5, 1));
         if (i > 0) {
-            irisPart.Operations.push_back (makeSTranslate (basegfx::B3DVector(rx, ry, 0),  false, -1, 0));
-            irisPart.Operations.push_back (makeSRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(0, 0, 0), i*360.0/nParts, false, -1, 0));
-            irisPart.Operations.push_back (makeSTranslate (basegfx::B3DVector(-1, 0, 0),  false, -1, 0));
+            irisPart.Operations.push_back (makeSTranslate (glm::vec3(rx, ry, 0),  false, -1, 0));
+            irisPart.Operations.push_back (makeSRotate (glm::vec3(0, 0, 1), glm::vec3(0, 0, 0), i*360.0/nParts, false, -1, 0));
+            irisPart.Operations.push_back (makeSTranslate (glm::vec3(-1, 0, 0),  false, -1, 0));
         }
-        irisPart.Operations.push_back(makeSTranslate(basegfx::B3DVector(0, 0, 1), false, -2, 0.0));
-        irisPart.Operations.push_back (makeSRotate (basegfx::B3DVector(1, .5, 0), basegfx::B3DVector(1, 0, 0), -30, false, -1, 0));
+        irisPart.Operations.push_back(makeSTranslate(glm::vec3(0, 0, 1), false, -2, 0.0));
+        irisPart.Operations.push_back (makeSRotate (glm::vec3(1, .5, 0), glm::vec3(1, 0, 0), -30, false, -1, 0));
         pIris->pushPrimitive (irisPart);
     }
 
@@ -653,42 +653,41 @@ boost::shared_ptr<OGLTransitionImpl> makeRochade()
     w = 2.2;
     h = 10;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
 
     Slide.Operations.push_back(makeSEllipseTranslate(w, h, 0.25, -0.25, true, 0, 1));
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,0), -45, true, 0, 1));
     Primitives_t aLeavingSlide;
     aLeavingSlide.push_back(Slide);
 
     Slide.Operations.clear();
     Slide.Operations.push_back(makeSEllipseTranslate(w, h, 0.75, 0.25, true, 0, 1));
-    Slide.Operations.push_back(makeSTranslate(basegfx::B3DVector(0, 0, -h), false, -1, 0));
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
-    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), 45, false, -1, 0));
+    Slide.Operations.push_back(makeSTranslate(glm::vec3(0, 0, -h), false, -1, 0));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,0), -45, true, 0, 1));
+    Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0,1,0),glm::vec3(0,0,0), 45, false, -1, 0));
     Primitives_t aEnteringSlide;
     aEnteringSlide.push_back(Slide);
 
     return makeRochadeTransition(aLeavingSlide, aEnteringSlide, aSettings);
 }
 
-// TODO(Q3): extract to basegfx
-inline basegfx::B2DVector clamp(const basegfx::B2DVector& v)
-{
-    return basegfx::B2DVector(min(max(v.getX(),-1.0),1.0),
-                              min(max(v.getY(),-1.0),1.0));
-}
-
 inline double randFromNeg1to1()
 {
     return ( ( static_cast<double>( rand() ) / static_cast<double>( RAND_MAX ) ) * 2.0 ) - 1.0;
 }
 
 // TODO(Q3): extract to basegfx
-inline basegfx::B3DVector randNormVectorInXYPlane()
+inline glm::vec3 randNormVectorInXYPlane()
+{
+    glm::vec3 toReturn(randFromNeg1to1(),randFromNeg1to1(),0.0);
+    return glm::normalize(toReturn);
+}
+
+template<typename T>
+T clamp(const T& rIn)
 {
-    basegfx::B3DVector toReturn(randFromNeg1to1(),randFromNeg1to1(),0.0);
-    return toReturn/toReturn.getLength();
+    return glm::clamp(rIn, -1.0, 1.0);
 }
 
 boost::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( ::sal_uInt16 nCircles , ::sal_uInt16 nPointsOnCircles )
@@ -699,21 +698,21 @@ boost::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( ::sal_uInt16 nCircles
         makeNByMTileFlip(1,1);
         return makeSimpleTransition();
     }
-    double Radius(1.0/static_cast<double>( nCircles ));
-    double dRadius(Radius);
-    double LastRadius(0.0);
-    double NextRadius(2*Radius);
+    float Radius(1.0/static_cast<double>( nCircles ));
+    float dRadius(Radius);
+    float LastRadius(0.0);
+    float NextRadius(2*Radius);
 
     /// now we know there is at least two circles
     /// the first will always be a full circle
     /// the last will always be the outer shell of the slide with a circle hole
 
     //add the full circle
-    vector<basegfx::B2DVector> unScaledTexCoords;
-    double TempAngle(0.0);
+    vector<glm::vec2> unScaledTexCoords;
+    float TempAngle(0.0);
     for(unsigned int Point(0); Point < nPointsOnCircles; ++Point)
     {
-        unScaledTexCoords.push_back( basegfx::B2DVector( cos(TempAngle - 3.1415926/2.0) , sin(TempAngle- 3.1415926/2.0) ) );
+        unScaledTexCoords.push_back( glm::vec2( cos(TempAngle - 3.1415926/2.0) , sin(TempAngle- 3.1415926/2.0) ) );
 
         TempAngle += dAngle;
     }
@@ -725,16 +724,16 @@ boost::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( ::sal_uInt16 nCircles
         Primitive LeavingSlide;
         for(int Point(0); Point + 1 < nPointsOnCircles; ++Point)
         {
-            EnteringSlide.pushTriangle( basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) );
-            LeavingSlide.pushTriangle( basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0 + basegfx::B2DVector( 0.5, 0.5) );
+            EnteringSlide.pushTriangle( glm::vec2( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0f + glm::vec2( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0f + glm::vec2( 0.5 , 0.5 ) );
+            LeavingSlide.pushTriangle( glm::vec2( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0f + glm::vec2( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0f + glm::vec2( 0.5, 0.5) );
         }
-        EnteringSlide.pushTriangle( basegfx::B2DVector(0.5,0.5) , Radius * unScaledTexCoords[ 0 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ nPointsOnCircles - 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) );
-        LeavingSlide.pushTriangle( basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+        EnteringSlide.pushTriangle( glm::vec2(0.5,0.5) , Radius * unScaledTexCoords[ 0 ] / 2.0f + glm::vec2( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ nPointsOnCircles - 1 ] / 2.0f + glm::vec2( 0.5 , 0.5 ) );
+        LeavingSlide.pushTriangle( glm::vec2(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) , Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) );
 
-        basegfx::B3DVector axis(randNormVectorInXYPlane());
-        EnteringSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
-        LeavingSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
-        EnteringSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
+        glm::vec3 axis(randNormVectorInXYPlane());
+        EnteringSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+        LeavingSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+        EnteringSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , -180, false,0.0,1.0) );
 
         aEnteringSlide.push_back(EnteringSlide);
         aLeavingSlide.push_back(LeavingSlide);
@@ -749,23 +748,23 @@ boost::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( ::sal_uInt16 nCircles
         Primitive EnteringSlide;
         for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
         {
-            EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
-            EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+            EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) );
+            EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) , Radius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) );
 
-            LeavingSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
-            LeavingSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+            LeavingSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) );
+            LeavingSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) , Radius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) );
         }
 
-        EnteringSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
-        EnteringSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+        EnteringSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) );
+        EnteringSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) );
 
-        LeavingSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
-        LeavingSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+        LeavingSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) );
+        LeavingSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) );
 
-        basegfx::B3DVector axis(randNormVectorInXYPlane());
-        EnteringSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
-        LeavingSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
-        EnteringSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
+        glm::vec3 axis(randNormVectorInXYPlane());
+        EnteringSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+        LeavingSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+        EnteringSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , -180, false,0.0,1.0) );
 
         aEnteringSlide.push_back(EnteringSlide);
         aLeavingSlide.push_back(LeavingSlide);
@@ -781,23 +780,23 @@ boost::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( ::sal_uInt16 nCircles
         for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
         {
 
-            EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
-            EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[Side + 1])/2.0 + basegfx::B2DVector(0.5,0.5) );
+            EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) );
+            EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) , clamp(Radius*unScaledTexCoords[Side + 1])/2.0f + glm::vec2(0.5,0.5) );
 
-            LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
-            LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[Side + 1])/2.0 + basegfx::B2DVector(0.5,0.5) );
+            LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) );
+            LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0f + glm::vec2(0.5,0.5) , clamp(Radius*unScaledTexCoords[Side + 1])/2.0f + glm::vec2(0.5,0.5) );
         }
 
-        EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
-        EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[0])/2.0 + basegfx::B2DVector(0.5,0.5) );
+        EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) );
+        EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) , clamp(Radius*unScaledTexCoords[0])/2.0f + glm::vec2(0.5,0.5) );
 
-        LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
-        LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[0])/2.0 + basegfx::B2DVector(0.5,0.5) );
+        LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) );
+        LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0f + glm::vec2(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0f + glm::vec2(0.5,0.5) , clamp(Radius*unScaledTexCoords[0])/2.0f + glm::vec2(0.5,0.5) );
 
-        basegfx::B3DVector axis(randNormVectorInXYPlane());
-        EnteringSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
-        LeavingSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
-        EnteringSlide.Operations.push_back( makeSRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
+        glm::vec3 axis(randNormVectorInXYPlane());
+        EnteringSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
+        LeavingSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
+        EnteringSlide.Operations.push_back( makeSRotate( axis , glm::vec3(0,0,0) , -180, false,0.0,1.0) );
 
         aEnteringSlide.push_back(EnteringSlide);
         aLeavingSlide.push_back(LeavingSlide);
@@ -817,17 +816,17 @@ boost::shared_ptr<OGLTransitionImpl> makeHelix( ::sal_uInt16 nRows )
     {
         Primitive Tile;
 
-        Tile.pushTriangle(basegfx::B2DVector( 1.0 , iDn ) , basegfx::B2DVector( 0.0 , iDn ) , basegfx::B2DVector( 0.0 , iPDn ));
+        Tile.pushTriangle(glm::vec2( 1.0 , iDn ) , glm::vec2( 0.0 , iDn ) , glm::vec2( 0.0 , iPDn ));
 
-        Tile.pushTriangle(basegfx::B2DVector( 1.0 , iPDn ) , basegfx::B2DVector( 1.0 , iDn ) , basegfx::B2DVector( 0.0 , iPDn ));
+        Tile.pushTriangle(glm::vec2( 1.0 , iPDn ) , glm::vec2( 1.0 , iDn ) , glm::vec2( 0.0 , iPDn ));
 
-        Tile.Operations.push_back( makeSRotate( basegfx::B3DVector( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , 180 ,
+        Tile.Operations.push_back( makeSRotate( glm::vec3( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0f , 180 ,
                                                 true,min(max(static_cast<double>(i - nRows/2.0)*invN/2.0,0.0),1.0),
                                                 min(max(static_cast<double>(i + nRows/2.0)*invN/2.0,0.0),1.0) ) );
 
         aLeavingSlide.push_back(Tile);
 
-        Tile.Operations.push_back( makeSRotate( basegfx::B3DVector( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , -180 , false,0.0,1.0) );
+        Tile.Operations.push_back( makeSRotate( glm::vec3( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0f , -180 , false,0.0,1.0) );
 
         aEnteringSlide.push_back(Tile);
 
@@ -854,13 +853,13 @@ boost::shared_ptr<OGLTransitionImpl> makeNByMTileFlip( ::sal_uInt16 n, ::sal_uIn
         {
             Primitive Tile;
 
-            Tile.pushTriangle(basegfx::B2DVector( iPDn , jDm ) , basegfx::B2DVector( iDn , jDm ) , basegfx::B2DVector( iDn , jPDm ));
+            Tile.pushTriangle(glm::vec2( iPDn , jDm ) , glm::vec2( iDn , jDm ) , glm::vec2( iDn , jPDm ));
 
-            Tile.pushTriangle(basegfx::B2DVector( iPDn , jPDm ) , basegfx::B2DVector( iPDn , jDm ) , basegfx::B2DVector( iDn , jPDm ));//bottom left corner of tile
+            Tile.pushTriangle(glm::vec2( iPDn , jPDm ) , glm::vec2( iPDn , jDm ) , glm::vec2( iDn , jPDm ));//bottom left corner of tile
 
-            Tile.Operations.push_back( makeSRotate( basegfx::B3DVector( 1 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , 180 , true, iDn*jDm/2.0 , ((iPDn*jPDm)+1.0)/2.0 ) );
+            Tile.Operations.push_back( makeSRotate( glm::vec3( 1 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0f , 180 , true, iDn*jDm/2.0 , ((iPDn*jPDm)+1.0)/2.0 ) );
             aLeavingSlide.push_back(Tile);
-            Tile.Operations.push_back( makeSRotate( basegfx::B3DVector( 1 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , -180, false, iDn*jDm/2.0 , ((iPDn*jPDm)+1.0)/2.0 ) );
+            Tile.Operations.push_back( makeSRotate( glm::vec3( 1 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0f , -180, false, iDn*jDm/2.0 , ((iPDn*jPDm)+1.0)/2.0 ) );
 
             aEnteringSlide.push_back(Tile);
 
@@ -874,7 +873,7 @@ boost::shared_ptr<OGLTransitionImpl> makeNByMTileFlip( ::sal_uInt16 n, ::sal_uIn
     return makeSimpleTransition(aLeavingSlide, aEnteringSlide);
 }
 
-SRotate::SRotate(const basegfx::B3DVector& Axis, const basegfx::B3DVector& Origin,
+SRotate::SRotate(const glm::vec3& Axis, const glm::vec3& Origin,
         double Angle, bool bInter, double T0, double T1):
     Operation(bInter, T0, T1),
     axis(Axis),
@@ -883,7 +882,7 @@ SRotate::SRotate(const basegfx::B3DVector& Axis, const basegfx::B3DVector& Origi
 {
 }
 
-SScale::SScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,
+SScale::SScale(const glm::vec3& Scale, const glm::vec3& Origin,
         bool bInter, double T0, double T1):
     Operation(bInter, T0, T1),
     scale(Scale),
@@ -891,8 +890,8 @@ SScale::SScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin
 {
 }
 
-RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,
-        const basegfx::B3DVector& Origin, double Angle, bool bInter, double T0, double T1):
+RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const glm::vec3& Axis,
+        const glm::vec3& Origin, double Angle, bool bInter, double T0, double T1):
     Operation(bInter, T0, T1),
     axis(Axis),
     origin(Origin),
@@ -900,8 +899,8 @@ RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector&
 {
 }
 
-RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,
-        const basegfx::B3DVector& Origin, double Angle, bool bInter, double T0, double T1):
+RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const glm::vec3& Axis,
+        const glm::vec3& Origin, double Angle, bool bInter, double T0, double T1):
     Operation(bInter, T0, T1),
     axis(Axis),
     origin(Origin),
@@ -910,26 +909,26 @@ RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVecto
 }
 
 
-STranslate::STranslate(const basegfx::B3DVector& Vector, bool bInter, double T0, double T1):
+STranslate::STranslate(const glm::vec3& Vector, bool bInter, double T0, double T1):
     Operation(bInter, T0, T1),
     vector(Vector)
 {
 }
 
 boost::shared_ptr<SRotate>
-makeSRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1)
+makeSRotate(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1)
 {
     return make_shared<SRotate>(Axis, Origin, Angle, bInter, T0, T1);
 }
 
 boost::shared_ptr<SScale>
-makeSScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,bool bInter, double T0, double T1)
+makeSScale(const glm::vec3& Scale, const glm::vec3& Origin,bool bInter, double T0, double T1)
 {
     return make_shared<SScale>(Scale, Origin, bInter, T0, T1);
 }
 
 boost::shared_ptr<STranslate>
-makeSTranslate(const basegfx::B3DVector& Vector,bool bInter, double T0, double T1)
+makeSTranslate(const glm::vec3& Vector,bool bInter, double T0, double T1)
 {
     return make_shared<STranslate>(Vector, bInter, T0, T1);
 }
@@ -941,13 +940,13 @@ makeSEllipseTranslate(double dWidth, double dHeight, double dStartPosition, doub
 }
 
 boost::shared_ptr<RotateAndScaleDepthByWidth>
-makeRotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1)
+makeRotateAndScaleDepthByWidth(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1)
 {
     return make_shared<RotateAndScaleDepthByWidth>(Axis, Origin, Angle, bInter, T0, T1);
 }
 
 boost::shared_ptr<RotateAndScaleDepthByHeight>
-makeRotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1)
+makeRotateAndScaleDepthByHeight(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1)
 {
     return make_shared<RotateAndScaleDepthByHeight>(Axis, Origin, Angle, bInter, T0, T1);
 }
@@ -965,7 +964,7 @@ void STranslate::interpolate(double t,double SlideWidthScale,double SlideHeightS
     if(!mbInterpolate || t > mnT1)
         t = mnT1;
     t = intervalInter(t,mnT0,mnT1);
-    glTranslated(SlideWidthScale*t*vector.getX(),SlideHeightScale*t*vector.getY(),t*vector.getZ());
+    glTranslated(SlideWidthScale*t*vector.x,SlideHeightScale*t*vector.y,t*vector.z);
     CHECK_GL_ERROR();
 }
 
@@ -977,11 +976,11 @@ void SRotate::interpolate(double t,double SlideWidthScale,double SlideHeightScal
     if(!mbInterpolate || t > mnT1)
         t = mnT1;
     t = intervalInter(t,mnT0,mnT1);
-    glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
+    glTranslated(SlideWidthScale*origin.x,SlideHeightScale*origin.y,origin.z);
     glScaled(SlideWidthScale,SlideHeightScale,1);
-    glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
+    glRotated(t*angle,axis.x,axis.y,axis.z);
     glScaled(1/SlideWidthScale,1/SlideHeightScale,1);
-    glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
+    glTranslated(-SlideWidthScale*origin.x,-SlideHeightScale*origin.y,-origin.z);
     CHECK_GL_ERROR();
 }
 
@@ -993,9 +992,9 @@ void SScale::interpolate(double t,double SlideWidthScale,double SlideHeightScale
     if(!mbInterpolate || t > mnT1)
         t = mnT1;
     t = intervalInter(t,mnT0,mnT1);
-    glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
-    glScaled((1-t) + t*scale.getX(),(1-t) + t*scale.getY(),(1-t) + t*scale.getZ());
-    glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
+    glTranslated(SlideWidthScale*origin.x,SlideHeightScale*origin.y,origin.z);
+    glScaled((1-t) + t*scale.x,(1-t) + t*scale.y,(1-t) + t*scale.z);
+    glTranslated(-SlideWidthScale*origin.x,-SlideHeightScale*origin.y,-origin.z);
     CHECK_GL_ERROR();
 }
 
@@ -1007,9 +1006,9 @@ void RotateAndScaleDepthByWidth::interpolate(double t,double SlideWidthScale,dou
     if(!mbInterpolate || t > mnT1)
         t = mnT1;
     t = intervalInter(t,mnT0,mnT1);
-    glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideWidthScale*origin.getZ());
-    glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
-    glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideWidthScale*origin.getZ());
+    glTranslated(SlideWidthScale*origin.x,SlideHeightScale*origin.y,SlideWidthScale*origin.z);
+    glRotated(t*angle,axis.x,axis.y,axis.z);
+    glTranslated(-SlideWidthScale*origin.x,-SlideHeightScale*origin.y,-SlideWidthScale*origin.z);
     CHECK_GL_ERROR();
 }
 
@@ -1021,9 +1020,9 @@ void RotateAndScaleDepthByHeight::interpolate(double t,double SlideWidthScale,do
     if(!mbInterpolate || t > mnT1)
         t = mnT1;
     t = intervalInter(t,mnT0,mnT1);
-    glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideHeightScale*origin.getZ());
-    glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
-    glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideHeightScale*origin.getZ());
+    glTranslated(SlideWidthScale*origin.x,SlideHeightScale*origin.y,SlideHeightScale*origin.z);
+    glRotated(t*angle,axis.x,axis.y,axis.z);
+    glTranslated(-SlideWidthScale*origin.x,-SlideHeightScale*origin.y,-SlideHeightScale*origin.z);
     CHECK_GL_ERROR();
 }
 
@@ -1079,20 +1078,20 @@ void Primitive::swap(Primitive& rOther)
     swap(TexCoords, rOther.TexCoords);
 }
 
-void Primitive::pushTriangle(const basegfx::B2DVector& SlideLocation0,const basegfx::B2DVector& SlideLocation1,const basegfx::B2DVector& SlideLocation2)
+void Primitive::pushTriangle(const glm::vec2& SlideLocation0,const glm::vec2& SlideLocation1,const glm::vec2& SlideLocation2)
 {
-    vector<basegfx::B3DVector> Verts;
-    vector<basegfx::B2DVector> Texs;
+    vector<glm::vec3> Verts;
+    vector<glm::vec2> Texs;
     Verts.reserve(3);
     Texs.reserve(3);
 
-    Verts.push_back(basegfx::B3DVector( 2*SlideLocation0.getX() - 1, -2*SlideLocation0.getY() + 1 , 0.0 ));
-    Verts.push_back(basegfx::B3DVector( 2*SlideLocation1.getX() - 1, -2*SlideLocation1.getY() + 1 , 0.0 ));
-    Verts.push_back(basegfx::B3DVector( 2*SlideLocation2.getX() - 1, -2*SlideLocation2.getY() + 1 , 0.0 ));
+    Verts.push_back(glm::vec3( 2*SlideLocation0.x - 1, -2*SlideLocation0.y + 1 , 0.0 ));
+    Verts.push_back(glm::vec3( 2*SlideLocation1.x - 1, -2*SlideLocation1.y + 1 , 0.0 ));
+    Verts.push_back(glm::vec3( 2*SlideLocation2.x - 1, -2*SlideLocation2.y + 1 , 0.0 ));
 
     //figure out if they're facing the correct way, and make them face the correct way.
-    basegfx::B3DVector Normal( basegfx::cross( Verts[0] - Verts[1] , Verts[1] - Verts[2] ) );
-    if(Normal.getZ() >= 0.0)//if the normal is facing us
+    glm::vec3 Normal( glm::cross( Verts[0] - Verts[1] , Verts[1] - Verts[2] ) );
+    if(Normal.z >= 0.0)//if the normal is facing us
     {
         Texs.push_back(SlideLocation0);
         Texs.push_back(SlideLocation1);
@@ -1104,9 +1103,9 @@ void Primitive::pushTriangle(const basegfx::B2DVector& SlideLocation0,const base
         Texs.push_back(SlideLocation2);
         Texs.push_back(SlideLocation1);
         Verts.clear();
-        Verts.push_back(basegfx::B3DVector( 2*SlideLocation0.getX() - 1, -2*SlideLocation0.getY() + 1 , 0.0 ));
-        Verts.push_back(basegfx::B3DVector( 2*SlideLocation2.getX() - 1, -2*SlideLocation2.getY() + 1 , 0.0 ));
-        Verts.push_back(basegfx::B3DVector( 2*SlideLocation1.getX() - 1, -2*SlideLocation1.getY() + 1 , 0.0 ));
+        Verts.push_back(glm::vec3( 2*SlideLocation0.x - 1, -2*SlideLocation0.y + 1 , 0.0 ));
+        Verts.push_back(glm::vec3( 2*SlideLocation2.x - 1, -2*SlideLocation2.y + 1 , 0.0 ));
+        Verts.push_back(glm::vec3( 2*SlideLocation1.x - 1, -2*SlideLocation1.y + 1 , 0.0 ));
     }
 
     Vertices.push_back(Verts[0]);
@@ -1117,9 +1116,9 @@ void Primitive::pushTriangle(const basegfx::B2DVector& SlideLocation0,const base
     TexCoords.push_back(Texs[1]);
     TexCoords.push_back(Texs[2]);
 
-    Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
-    Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
-    Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
+    Normals.push_back(glm::vec3(0,0,1));//all normals always face the screen when untransformed.
+    Normals.push_back(glm::vec3(0,0,1));//all normals always face the screen when untransformed.
+    Normals.push_back(glm::vec3(0,0,1));//all normals always face the screen when untransformed.
 }
 
 namespace
@@ -1141,32 +1140,32 @@ void DiamondTransition::prepare_( double nTime, double /* SlideWidth */, double
 {
     Primitive Slide1, Slide2;
 
-    Slide1.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
-    Slide1.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+    Slide1.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0,1));
+    Slide1.pushTriangle (glm::vec2 (1,0), glm::vec2 (0,1), glm::vec2 (1,1));
     Primitives_t aEnteringSlidePrimitives;
     aEnteringSlidePrimitives.push_back (Slide1);
 
     if( nTime >= 0.5 ) {
         double m = 1 - nTime;
 
-        Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (m,0), basegfx::B2DVector (0,m));
-        Slide2.pushTriangle (basegfx::B2DVector (nTime,0), basegfx::B2DVector (1,0), basegfx::B2DVector (1,m));
-        Slide2.pushTriangle (basegfx::B2DVector (1,nTime), basegfx::B2DVector (1,1), basegfx::B2DVector (nTime,1));
-        Slide2.pushTriangle (basegfx::B2DVector (0,nTime), basegfx::B2DVector (m,1), basegfx::B2DVector (0,1));
+        Slide2.pushTriangle (glm::vec2 (0,0), glm::vec2 (m,0), glm::vec2 (0,m));
+        Slide2.pushTriangle (glm::vec2 (nTime,0), glm::vec2 (1,0), glm::vec2 (1,m));
+        Slide2.pushTriangle (glm::vec2 (1,nTime), glm::vec2 (1,1), glm::vec2 (nTime,1));
+        Slide2.pushTriangle (glm::vec2 (0,nTime), glm::vec2 (m,1), glm::vec2 (0,1));
     } else {
         double l = 0.5 - nTime;
         double h = 0.5 + nTime;
 
-        Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0.5,l));
-        Slide2.pushTriangle (basegfx::B2DVector (0.5,l), basegfx::B2DVector (1,0), basegfx::B2DVector (h,0.5));
-        Slide2.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (1,1), basegfx::B2DVector (h,0.5));
-        Slide2.pushTriangle (basegfx::B2DVector (h,0.5), basegfx::B2DVector (1,1), basegfx::B2DVector (0.5,h));
-        Slide2.pushTriangle (basegfx::B2DVector (0.5,h), basegfx::B2DVector (1,1), basegfx::B2DVector (0,1));
-        Slide2.pushTriangle (basegfx::B2DVector (l,0.5), basegfx::B2DVector (0.5,h), basegfx::B2DVector (0,1));
-        Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (l,0.5), basegfx::B2DVector (0,1));
-        Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (0.5,l), basegfx::B2DVector (l,0.5));
+        Slide2.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0.5,l));
+        Slide2.pushTriangle (glm::vec2 (0.5,l), glm::vec2 (1,0), glm::vec2 (h,0.5));
+        Slide2.pushTriangle (glm::vec2 (1,0), glm::vec2 (1,1), glm::vec2 (h,0.5));
+        Slide2.pushTriangle (glm::vec2 (h,0.5), glm::vec2 (1,1), glm::vec2 (0.5,h));
+        Slide2.pushTriangle (glm::vec2 (0.5,h), glm::vec2 (1,1), glm::vec2 (0,1));
+        Slide2.pushTriangle (glm::vec2 (l,0.5), glm::vec2 (0.5,h), glm::vec2 (0,1));
+        Slide2.pushTriangle (glm::vec2 (0,0), glm::vec2 (l,0.5), glm::vec2 (0,1));
+        Slide2.pushTriangle (glm::vec2 (0,0), glm::vec2 (0.5,l), glm::vec2 (l,0.5));
     }
-    Slide2.Operations.push_back (makeSTranslate (basegfx::B3DVector (0, 0, 0.00000001), false, -1, 0));
+    Slide2.Operations.push_back (makeSTranslate (glm::vec3 (0, 0, 0.00000001), false, -1, 0));
     Primitives_t aLeavingSlidePrimitives;
     aLeavingSlidePrimitives.push_back (Slide2);
 
@@ -1201,22 +1200,22 @@ boost::shared_ptr<OGLTransitionImpl> makeVenetianBlinds( bool vertical, int part
         Primitive Slide;
         n = (i + 1)/(double)parts;
         if( vertical ) {
-            Slide.pushTriangle (basegfx::B2DVector (ln,0), basegfx::B2DVector (n,0), basegfx::B2DVector (ln,1));
-            Slide.pushTriangle (basegfx::B2DVector (n,0), basegfx::B2DVector (ln,1), basegfx::B2DVector (n,1));
-            Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(n + ln - 1, 0, -t30*p), -120, true, 0.0, 1.0));
+            Slide.pushTriangle (glm::vec2 (ln,0), glm::vec2 (n,0), glm::vec2 (ln,1));
+            Slide.pushTriangle (glm::vec2 (n,0), glm::vec2 (ln,1), glm::vec2 (n,1));
+            Slide.Operations.push_back(makeRotateAndScaleDepthByWidth(glm::vec3(0, 1, 0), glm::vec3(n + ln - 1, 0, -t30*p), -120, true, 0.0, 1.0));
         } else {
-            Slide.pushTriangle (basegfx::B2DVector (0,ln), basegfx::B2DVector (1,ln), basegfx::B2DVector (0,n));
-            Slide.pushTriangle (basegfx::B2DVector (1,ln), basegfx::B2DVector (0,n), basegfx::B2DVector (1,n));
-            Slide.Operations.push_back(makeRotateAndScaleDepthByHeight(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - n - ln, -t30*p), -120, true, 0.0, 1.0));
+            Slide.pushTriangle (glm::vec2 (0,ln), glm::vec2 (1,ln), glm::vec2 (0,n));
+            Slide.pushTriangle (glm::vec2 (1,ln), glm::vec2 (0,n), glm::vec2 (1,n));
+            Slide.Operations.push_back(makeRotateAndScaleDepthByHeight(glm::vec3(1, 0, 0), glm::vec3(0, 1 - n - ln, -t30*p), -120, true, 0.0, 1.0));
         }
         aLeavingSlide.push_back (Slide);
 
         if( vertical ) {
-            Slide.Operations.push_back(makeSRotate(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(2*n - 1, 0, 0), -60, false, -1, 0));
-            Slide.Operations.push_back(makeSRotate(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(n + ln - 1, 0, 0), 180, false, -1, 0));
+            Slide.Operations.push_back(makeSRotate(glm::vec3(0, 1, 0), glm::vec3(2*n - 1, 0, 0), -60, false, -1, 0));
+            Slide.Operations.push_back(makeSRotate(glm::vec3(0, 1, 0), glm::vec3(n + ln - 1, 0, 0), 180, false, -1, 0));
         } else {
-            Slide.Operations.push_back(makeSRotate(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - 2*n, 0), -60, false, -1, 0));
-            Slide.Operations.push_back(makeSRotate(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - n - ln, 0), 180, false, -1, 0));
+            Slide.Operations.push_back(makeSRotate(glm::vec3(1, 0, 0), glm::vec3(0, 1 - 2*n, 0), -60, false, -1, 0));
+            Slide.Operations.push_back(makeSRotate(glm::vec3(1, 0, 0), glm::vec3(0, 1 - n - ln, 0), 180, false, -1, 0));
         }
         aEnteringSlide.push_back (Slide);
         ln = n;
@@ -1293,8 +1292,8 @@ boost::shared_ptr<OGLTransitionImpl> makeFadeSmoothly()
 {
     Primitive Slide;
 
-    Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
-    Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+    Slide.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0,1));
+    Slide.pushTriangle (glm::vec2 (1,0), glm::vec2 (0,1), glm::vec2 (1,1));
     Primitives_t aLeavingSlide;
     aLeavingSlide.push_back (Slide);
     Primitives_t aEnteringSlide;
@@ -1364,8 +1363,8 @@ boost::shared_ptr<OGLTransitionImpl> makeFadeThroughBlack()
 {
     Primitive Slide;
 
-    Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
-    Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+    Slide.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0,1));
+    Slide.pushTriangle (glm::vec2 (1,0), glm::vec2 (0,1), glm::vec2 (1,1));
     Primitives_t aLeavingSlide;
     aLeavingSlide.push_back (Slide);
     Primitives_t aEnteringSlide;
@@ -1576,8 +1575,8 @@ boost::shared_ptr<OGLTransitionImpl> makeStatic()
 {
     Primitive Slide;
 
-    Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
-    Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+    Slide.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0,1));
+    Slide.pushTriangle (glm::vec2 (1,0), glm::vec2 (0,1), glm::vec2 (1,1));
     Primitives_t aLeavingSlide;
     aLeavingSlide.push_back (Slide);
     Primitives_t aEnteringSlide;
@@ -1627,8 +1626,8 @@ boost::shared_ptr<OGLTransitionImpl> makeDissolve()
 {
     Primitive Slide;
 
-    Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
-    Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+    Slide.pushTriangle (glm::vec2 (0,0), glm::vec2 (1,0), glm::vec2 (0,1));
+    Slide.pushTriangle (glm::vec2 (1,0), glm::vec2 (0,1), glm::vec2 (1,1));
     Primitives_t aLeavingSlide;
     aLeavingSlide.push_back (Slide);
     Primitives_t aEnteringSlide;
@@ -1645,25 +1644,25 @@ boost::shared_ptr<OGLTransitionImpl> makeNewsflash()
 {
     Primitive Slide;
 
-    Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
-    Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
-    Slide.Operations.push_back(makeSRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0,0,0),3000,true,0,0.5));
-    Slide.Operations.push_back(makeSScale(basegfx::B3DVector(0.01,0.01,0.01),basegfx::B3DVector(0,0,0),true,0,0.5));
-    Slide.Operations.push_back(makeSTranslate(basegfx::B3DVector(-10000, 0, 0),false, 0.5, 2));
+    Slide.pushTriangle(glm::vec2(0,0),glm::vec2(1,0),glm::vec2(0,1));
+    Slide.pushTriangle(glm::vec2(1,0),glm::vec2(0,1),glm::vec2(1,1));
+    Slide.Operations.push_back(makeSRotate(glm::vec3(0,0,1),glm::vec3(0,0,0),3000,true,0,0.5));
+    Slide.Operations.push_back(makeSScale(glm::vec3(0.01,0.01,0.01),glm::vec3(0,0,0),true,0,0.5));
+    Slide.Operations.push_back(makeSTranslate(glm::vec3(-10000, 0, 0),false, 0.5, 2));
     Primitives_t aLeavingSlide;
     aLeavingSlide.push_back(Slide);
 
     Slide.Operations.clear();
-    Slide.Operations.push_back(makeSRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0,0,0),-3000,true,0.5,1));
-    Slide.Operations.push_back(makeSTranslate(basegfx::B3DVector(-100, 0, 0),false, -1, 1));
-    Slide.Operations.push_back(makeSTranslate(basegfx::B3DVector(100, 0, 0),false, 0.5, 1));
-    Slide.Operations.push_back(makeSScale(basegfx::B3DVector(0.01,0.01,0.01),basegfx::B3DVector(0,0,0),false,-1,1));
-    Slide.Operations.push_back(makeSScale(basegfx::B3DVector(100,100,100),basegfx::B3DVector(0,0,0),true,0.5,1));
+    Slide.Operations.push_back(makeSRotate(glm::vec3(0,0,1),glm::vec3(0,0,0),-3000,true,0.5,1));
+    Slide.Operations.push_back(makeSTranslate(glm::vec3(-100, 0, 0),false, -1, 1));
+    Slide.Operations.push_back(makeSTranslate(glm::vec3(100, 0, 0),false, 0.5, 1));
+    Slide.Operations.push_back(makeSScale(glm::vec3(0.01,0.01,0.01),glm::vec3(0,0,0),false,-1,1));
+    Slide.Operations.push_back(makeSScale(glm::vec3(100,100,100),glm::vec3(0,0,0),true,0.5,1));
     Primitives_t aEnteringSlide;
     aEnteringSlide.push_back(Slide);
 
     Operations_t aOverallOperations;
-    aOverallOperations.push_back(makeSRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0.2,0.2,0),1080,true,0,1));
+    aOverallOperations.push_back(makeSRotate(glm::vec3(0,0,1),glm::vec3(0.2,0.2,0),1080,true,0,1));
 
     return makeSimpleTransition(aLeavingSlide, aEnteringSlide, aOverallOperations);
 }
diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
index 77bf3d6..460b3bf 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
@@ -29,6 +29,7 @@
 #define INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
 
 #include <config_lgpl.h>
+#include <glm/glm.hpp>
 
 #include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
@@ -293,7 +294,7 @@ public:
     Location of third Vertex on slide
 
     */
-    void pushTriangle(const basegfx::B2DVector& SlideLocation0,const basegfx::B2DVector& SlideLocation1,const basegfx::B2DVector& SlideLocation2);
+    void pushTriangle(const glm::vec2& SlideLocation0,const glm::vec2& SlideLocation1,const glm::vec2& SlideLocation2);
 
     /** clear all the vertices, normals, tex coordinates, and normals
     */
@@ -304,11 +305,11 @@ public:
         @return
         the list of vertices
     */
-    const std::vector<basegfx::B3DVector>& getVertices() const {return Vertices;}
+    const std::vector<glm::vec3>& getVertices() const {return Vertices;}
 
     /** guards against directly changing the vertices
     */
-    const std::vector<basegfx::B3DVector>& getNormals() const {return Normals;}
+    const std::vector<glm::vec3>& getNormals() const {return Normals;}
 
     /** guards against directly changing the vertices
 
@@ -316,7 +317,7 @@ public:
         the list of Texture Coordinates
 
     */
-    const std::vector<basegfx::B2DVector>& getTexCoords() const {return TexCoords;}
+    const std::vector<glm::vec2>& getTexCoords() const {return TexCoords;}
 
     /** list of Operations to be performed on this primitive.These operations will be called in the order they were pushed back in. In OpenGL this effectively uses the operations in the opposite order they were pushed back.
 
@@ -329,15 +330,15 @@ public:
 private:
     /** list of vertices
     */
-    std::vector<basegfx::B3DVector> Vertices;
+    std::vector<glm::vec3> Vertices;
 
     /** list of Normals
     */
-    std::vector<basegfx::B3DVector> Normals;
+    std::vector<glm::vec3> Normals;
 
     /** list of Texture Coordinates
     */
-    std::vector<basegfx::B2DVector> TexCoords;
+    std::vector<glm::vec2> TexCoords;
 };
 
 /** This class is to be derived to make any operation (tranform) you may need in order to construct your transitions
@@ -407,16 +408,17 @@ public:
         transformation ending time
 
     */
-    SRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
+    SRotate(const glm::vec3& Axis, const glm::vec3& Origin, double Angle,
+            bool bInter, double T0, double T1);
     virtual ~SRotate(){}
 private:
     /** axis to rotate CCW about
     */
-    basegfx::B3DVector axis;
+    glm::vec3 axis;
 
     /** position that rotation axis runs through
     */
-    basegfx::B3DVector origin;
+    glm::vec3 origin;
 
     /** angle in radians of CCW rotation
     */
@@ -424,7 +426,8 @@ private:
 };
 
 boost::shared_ptr<SRotate>
-makeSRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
+makeSRotate(const glm::vec3& Axis, const glm::vec3& Origin, double Angle,
+        bool bInter, double T0, double T1);
 
 /** scaling transformation
 */
@@ -451,15 +454,15 @@ public:
         transformation ending time
 
     */
-    SScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,bool bInter, double T0, double T1);
+    SScale(const glm::vec3& Scale, const glm::vec3& Origin,bool bInter, double T0, double T1);
     virtual ~SScale(){}
 private:
-    basegfx::B3DVector scale;
-    basegfx::B3DVector origin;
+    glm::vec3 scale;
+    glm::vec3 origin;
 };
 
 boost::shared_ptr<SScale>
-makeSScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,bool bInter, double T0, double T1);
+makeSScale(const glm::vec3& Scale, const glm::vec3& Origin,bool bInter, double T0, double T1);
 
 /** translation transformation
 */
@@ -483,16 +486,16 @@ public:
         transformation ending time
 
     */
-    STranslate(const basegfx::B3DVector& Vector,bool bInter, double T0, double T1);
+    STranslate(const glm::vec3& Vector,bool bInter, double T0, double T1);
     virtual ~STranslate(){}
 private:
     /** vector to translate by
     */
-    basegfx::B3DVector vector;
+    glm::vec3 vector;
 };
 
 boost::shared_ptr<STranslate>
-makeSTranslate(const basegfx::B3DVector& Vector,bool bInter, double T0, double T1);
+makeSTranslate(const glm::vec3& Vector,bool bInter, double T0, double T1);
 
 /** translation transformation
 */
@@ -539,16 +542,16 @@ class RotateAndScaleDepthByWidth: public Operation
 public:
     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 
-    RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
+    RotateAndScaleDepthByWidth(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
     virtual ~RotateAndScaleDepthByWidth(){}
 private:
-    basegfx::B3DVector axis;
-    basegfx::B3DVector origin;
+    glm::vec3 axis;
+    glm::vec3 origin;
     double angle;
 };
 
 boost::shared_ptr<RotateAndScaleDepthByWidth>
-makeRotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
+makeRotateAndScaleDepthByWidth(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
 
 /** Same as SRotate, except the depth is scaled by the width of the slide divided by the height of the window.
 */
@@ -557,16 +560,16 @@ class RotateAndScaleDepthByHeight: public Operation
 public:
     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 
-    RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
+    RotateAndScaleDepthByHeight(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
     virtual ~RotateAndScaleDepthByHeight(){}
 private:
-    basegfx::B3DVector axis;
-    basegfx::B3DVector origin;
+    glm::vec3 axis;
+    glm::vec3 origin;
     double angle;
 };
 
 boost::shared_ptr<RotateAndScaleDepthByHeight>
-makeRotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
+makeRotateAndScaleDepthByHeight(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
 
 #endif // INCLUDED_SLIDESHOW_TRANSITION_HXX_
 
commit 9497bbc3e32e7937d8e1666dcc265f3f384cd972
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date:   Wed Aug 27 17:01:23 2014 +0200

    use constructor initializer list
    
    Change-Id: I0bb1345f05dbd835e3f7debc66a824ccf44ef88b

diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
index d05e38f..17bdff5 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
@@ -876,54 +876,44 @@ boost::shared_ptr<OGLTransitionImpl> makeNByMTileFlip( ::sal_uInt16 n, ::sal_uIn
 
 SRotate::SRotate(const basegfx::B3DVector& Axis, const basegfx::B3DVector& Origin,
         double Angle, bool bInter, double T0, double T1):
+    Operation(bInter, T0, T1),
     axis(Axis),
     origin(Origin),
     angle(Angle)
 {
-    nT0 = T0;
-    nT1 = T1;
-    bInterpolate = bInter;
 }
 
 SScale::SScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,
         bool bInter, double T0, double T1):
+    Operation(bInter, T0, T1),
     scale(Scale),
     origin(Origin)
 {
-    nT0 = T0;
-    nT1 = T1;
-    bInterpolate = bInter;
 }
 
 RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,
         const basegfx::B3DVector& Origin, double Angle, bool bInter, double T0, double T1):
+    Operation(bInter, T0, T1),
     axis(Axis),
     origin(Origin),
     angle(Angle)
 {
-    nT0 = T0;
-    nT1 = T1;
-    bInterpolate = bInter;
 }
 
 RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,
         const basegfx::B3DVector& Origin, double Angle, bool bInter, double T0, double T1):
+    Operation(bInter, T0, T1),
     axis(Axis),
     origin(Origin),
     angle(Angle)
 {
-    nT0 = T0;
-    nT1 = T1;
-    bInterpolate = bInter;
 }
 
 
 STranslate::STranslate(const basegfx::B3DVector& Vector, bool bInter, double T0, double T1):
+    Operation(bInter, T0, T1),
     vector(Vector)
 {
-    nT0 = T0;
-    nT1 = T1;
-    bInterpolate = bInter;
 }
 
 boost::shared_ptr<SRotate>
@@ -970,11 +960,11 @@ inline double intervalInter(double t, double T0, double T1)
 void STranslate::interpolate(double t,double SlideWidthScale,double SlideHeightScale) const
 {
     CHECK_GL_ERROR();
-    if(t <= nT0)
+    if(t <= mnT0)
         return;
-    if(!bInterpolate || t > nT1)
-        t = nT1;
-    t = intervalInter(t,nT0,nT1);
+    if(!mbInterpolate || t > mnT1)
+        t = mnT1;
+    t = intervalInter(t,mnT0,mnT1);
     glTranslated(SlideWidthScale*t*vector.getX(),SlideHeightScale*t*vector.getY(),t*vector.getZ());
     CHECK_GL_ERROR();
 }
@@ -982,11 +972,11 @@ void STranslate::interpolate(double t,double SlideWidthScale,double SlideHeightS
 void SRotate::interpolate(double t,double SlideWidthScale,double SlideHeightScale) const
 {
     CHECK_GL_ERROR();
-    if(t <= nT0)
+    if(t <= mnT0)
         return;
-    if(!bInterpolate || t > nT1)
-        t = nT1;
-    t = intervalInter(t,nT0,nT1);
+    if(!mbInterpolate || t > mnT1)
+        t = mnT1;
+    t = intervalInter(t,mnT0,mnT1);
     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
     glScaled(SlideWidthScale,SlideHeightScale,1);
     glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
@@ -998,11 +988,11 @@ void SRotate::interpolate(double t,double SlideWidthScale,double SlideHeightScal
 void SScale::interpolate(double t,double SlideWidthScale,double SlideHeightScale) const
 {
     CHECK_GL_ERROR();
-    if(t <= nT0)
+    if(t <= mnT0)
         return;
-    if(!bInterpolate || t > nT1)
-        t = nT1;
-    t = intervalInter(t,nT0,nT1);
+    if(!mbInterpolate || t > mnT1)
+        t = mnT1;
+    t = intervalInter(t,mnT0,mnT1);
     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
     glScaled((1-t) + t*scale.getX(),(1-t) + t*scale.getY(),(1-t) + t*scale.getZ());
     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
@@ -1012,11 +1002,11 @@ void SScale::interpolate(double t,double SlideWidthScale,double SlideHeightScale
 void RotateAndScaleDepthByWidth::interpolate(double t,double SlideWidthScale,double SlideHeightScale) const
 {
     CHECK_GL_ERROR();
-    if(t <= nT0)
+    if(t <= mnT0)
         return;
-    if(!bInterpolate || t > nT1)
-        t = nT1;
-    t = intervalInter(t,nT0,nT1);
+    if(!mbInterpolate || t > mnT1)
+        t = mnT1;
+    t = intervalInter(t,mnT0,mnT1);
     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideWidthScale*origin.getZ());
     glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideWidthScale*origin.getZ());
@@ -1026,11 +1016,11 @@ void RotateAndScaleDepthByWidth::interpolate(double t,double SlideWidthScale,dou
 void RotateAndScaleDepthByHeight::interpolate(double t,double SlideWidthScale,double SlideHeightScale) const
 {
     CHECK_GL_ERROR();
-    if(t <= nT0)
+    if(t <= mnT0)
         return;
-    if(!bInterpolate || t > nT1)
-        t = nT1;
-    t = intervalInter(t,nT0,nT1);
+    if(!mbInterpolate || t > mnT1)
+        t = mnT1;
+    t = intervalInter(t,mnT0,mnT1);
     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideHeightScale*origin.getZ());
     glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideHeightScale*origin.getZ());
@@ -1038,11 +1028,9 @@ void RotateAndScaleDepthByHeight::interpolate(double t,double SlideWidthScale,do
 }
 
 SEllipseTranslate::SEllipseTranslate(double dWidth, double dHeight, double dStartPosition,
-        double dEndPosition, bool bInter, double T0, double T1)
+        double dEndPosition, bool bInter, double T0, double T1):
+    Operation(bInter, T0, T1)
 {
-    nT0 = T0;
-    nT1 = T1;
-    bInterpolate = bInter;
     width = dWidth;
     height = dHeight;
     startPosition = dStartPosition;
@@ -1051,11 +1039,11 @@ SEllipseTranslate::SEllipseTranslate(double dWidth, double dHeight, double dStar
 
 void SEllipseTranslate::interpolate(double t,double /* SlideWidthScale */,double /* SlideHeightScale */) const
 {
-    if(t <= nT0)
+    if(t <= mnT0)
         return;
-    if(!bInterpolate || t > nT1)
-        t = nT1;
-    t = intervalInter(t,nT0,nT1);
+    if(!mbInterpolate || t > mnT1)
+        t = mnT1;
+    t = intervalInter(t,mnT0,mnT1);
 
     double a1, a2, x, y;
     a1 = startPosition*2*M_PI;
diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
index 0e8de1c..77bf3d6 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
@@ -348,17 +348,17 @@ public:
     virtual ~Operation(){}
 
 protected:
-    /** Should this operation be interpolated . If TRUE, the transform will smoothly move from making no difference from t = 0.0 to nT0 to being completely transformed from t = nT1 to 1. If FALSE, the transform will be inneffectual from t = 0 to nT0, and completely transformed from t = nT0 to 1.
+    /** Should this operation be interpolated . If TRUE, the transform will smoothly move from making no difference from t = 0.0 to mnT0 to being completely transformed from t = mnT1 to 1. If FALSE, the transform will be inneffectual from t = 0 to mnT0, and completely transformed from t = mnT0 to 1.
     */
-    bool bInterpolate;
+    bool mbInterpolate;
 
     /** time to begin the transformation
     */
-    double nT0;
+    double mnT0;
 
     /** time to finish the transformation
     */
-    double nT1;
+    double mnT1;
 public:
     /** this is the function that is called to give the Operation to OpenGL.
 
@@ -375,8 +375,8 @@ public:
     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const = 0;
 
 protected:
-    Operation():
-        bInterpolate(false), nT0(0.0), nT1(0.0){}
+    Operation(bool bInterpolate, double nT0, double nT1):
+        mbInterpolate(bInterpolate), mnT0(nT0), mnT1(nT1){}
 };
 
 /** this class is a generic CounterClockWise(CCW) rotation with an axis angle
commit edddc039c563faeeec008d9d3ad79d5423b2a370
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date:   Wed Aug 27 16:54:29 2014 +0200

    improve readability
    
    Change-Id: I7a8791c661cbd3c602c0d12d228b63ffc416a96c

diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
index efa3ec9..d05e38f 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
@@ -874,28 +874,43 @@ boost::shared_ptr<OGLTransitionImpl> makeNByMTileFlip( ::sal_uInt16 n, ::sal_uIn
     return makeSimpleTransition(aLeavingSlide, aEnteringSlide);
 }
 
-SRotate::SRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
+SRotate::SRotate(const basegfx::B3DVector& Axis, const basegfx::B3DVector& Origin,
+        double Angle, bool bInter, double T0, double T1):
+    axis(Axis),
+    origin(Origin),
+    angle(Angle)
 {
     nT0 = T0;
     nT1 = T1;
     bInterpolate = bInter;
 }
 
-SScale::SScale(const basegfx::B3DVector& Scale,const basegfx::B3DVector& Origin, bool bInter, double T0, double T1):scale(Scale),origin(Origin)
+SScale::SScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,
+        bool bInter, double T0, double T1):
+    scale(Scale),
+    origin(Origin)
 {
     nT0 = T0;
     nT1 = T1;
     bInterpolate = bInter;
 }
 
-RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
+RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,
+        const basegfx::B3DVector& Origin, double Angle, bool bInter, double T0, double T1):
+    axis(Axis),
+    origin(Origin),
+    angle(Angle)
 {
     nT0 = T0;
     nT1 = T1;
     bInterpolate = bInter;
 }
 
-RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
+RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,
+        const basegfx::B3DVector& Origin, double Angle, bool bInter, double T0, double T1):
+    axis(Axis),
+    origin(Origin),
+    angle(Angle)
 {
     nT0 = T0;
     nT1 = T1;
@@ -903,7 +918,8 @@ RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVecto
 }
 
 
-STranslate::STranslate(const basegfx::B3DVector& Vector, bool bInter, double T0, double T1):vector(Vector)
+STranslate::STranslate(const basegfx::B3DVector& Vector, bool bInter, double T0, double T1):
+    vector(Vector)
 {
     nT0 = T0;
     nT1 = T1;
@@ -1021,7 +1037,8 @@ void RotateAndScaleDepthByHeight::interpolate(double t,double SlideWidthScale,do
     CHECK_GL_ERROR();
 }
 
-SEllipseTranslate::SEllipseTranslate(double dWidth, double dHeight, double dStartPosition, double dEndPosition, bool bInter, double T0, double T1)
+SEllipseTranslate::SEllipseTranslate(double dWidth, double dHeight, double dStartPosition,
+        double dEndPosition, bool bInter, double T0, double T1)
 {
     nT0 = T0;
     nT1 = T1;
commit 2457c7635c1d672738ebc1647d8dd9641d3676f4
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date:   Wed Aug 27 16:51:07 2014 +0200

    no need to make these variables public
    
    Change-Id: I9b57d6811252c75186e03ed6928bd8829fa0307c

diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
index f66eebb..0e8de1c 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx
@@ -347,6 +347,7 @@ class Operation : private boost::noncopyable
 public:
     virtual ~Operation(){}
 
+protected:
     /** Should this operation be interpolated . If TRUE, the transform will smoothly move from making no difference from t = 0.0 to nT0 to being completely transformed from t = nT1 to 1. If FALSE, the transform will be inneffectual from t = 0 to nT0, and completely transformed from t = nT0 to 1.
     */
     bool bInterpolate;
@@ -374,7 +375,8 @@ public:
     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const = 0;
 
 protected:
-    Operation():bInterpolate(false), nT0(0.0), nT1(0.0){}
+    Operation():
+        bInterpolate(false), nT0(0.0), nT1(0.0){}
 };
 
 /** this class is a generic CounterClockWise(CCW) rotation with an axis angle
commit ded98c615e7f8dbf69a8f8d85f7405261de9b3cf
Author: Markus Mohrhard <markus.mohrhard at googlemail.com>
Date:   Wed Aug 27 16:46:30 2014 +0200

    more OpenGL error checking in OGLTrans
    
    Change-Id: I7eff84d18be92423b3d8616162bfaf5be5203a9d

diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
index 6af1027..efa3ec9 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.cxx
@@ -172,11 +172,16 @@ void OGLTransitionImpl::display( double nTime, ::sal_Int32 glLeavingSlideTex, ::
     const double SlideWidthScale = SlideWidth/DispWidth;
     const double SlideHeightScale = SlideHeight/DispHeight;
 
+    CHECK_GL_ERROR();
     prepare_( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
 
+    CHECK_GL_ERROR();
     glPushMatrix();
+    CHECK_GL_ERROR();
     displaySlides_( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
+    CHECK_GL_ERROR();
     displayScene( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
+    CHECK_GL_ERROR();
     glPopMatrix();
     CHECK_GL_ERROR();
 }
@@ -195,8 +200,9 @@ OGLTransitionImpl::displaySlide(
         double SlideWidthScale, double SlideHeightScale )
 {
     CHECK_GL_ERROR();
-   //TODO change to foreach
+    //TODO change to foreach
     glBindTexture(GL_TEXTURE_2D, glSlideTex);
+    CHECK_GL_ERROR();
 
     // display slide reflection
     // note that depth test is turned off while blending the shadow
@@ -240,18 +246,29 @@ void Primitive::display(double nTime, double WidthScale, double HeightScale) con
     CHECK_GL_ERROR();
     glPushMatrix();
 
+    CHECK_GL_ERROR();
     applyOperations( nTime, WidthScale, HeightScale );
 
+    CHECK_GL_ERROR();
     glEnableClientState( GL_VERTEX_ARRAY );
+    CHECK_GL_ERROR();
     if(!Normals.empty())
     {
+        CHECK_GL_ERROR();
         glNormalPointer( GL_DOUBLE , 0 , &Normals[0] );
+        CHECK_GL_ERROR();
         glEnableClientState( GL_NORMAL_ARRAY );
+        CHECK_GL_ERROR();
     }
+    CHECK_GL_ERROR();
     glEnableClientState( GL_TEXTURE_COORD_ARRAY );
+    CHECK_GL_ERROR();
     glTexCoordPointer( 2, GL_DOUBLE, 0, &TexCoords[0] );
+    CHECK_GL_ERROR();
     glVertexPointer( 3, GL_DOUBLE, 0, &Vertices[0] );
+    CHECK_GL_ERROR();
     glDrawArrays( GL_TRIANGLES, 0, Vertices.size() );
+    CHECK_GL_ERROR();
     glPopMatrix();
     CHECK_GL_ERROR();
 }
@@ -271,13 +288,17 @@ void SceneObject::display(double nTime, double /* SlideWidth */, double /* Slide
     for(unsigned int i(0); i < maPrimitives.size(); ++i) {
         // fixme: allow various model spaces, now we make it so that
         // it is regular -1,-1 to 1,1, where the whole display fits in
+        CHECK_GL_ERROR();
         glPushMatrix();
+        CHECK_GL_ERROR();
         if (DispHeight > DispWidth)
             glScaled(DispHeight/DispWidth, 1, 1);
         else
             glScaled(1, DispWidth/DispHeight, 1);
         maPrimitives[i].display(nTime, 1, 1);
+        CHECK_GL_ERROR();
         glPopMatrix();
+        CHECK_GL_ERROR();
     }
     CHECK_GL_ERROR();
 }
@@ -305,6 +326,7 @@ Iris::Iris()
 void Iris::display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight ) const
 {
     glBindTexture(GL_TEXTURE_2D, maTexture);
+    CHECK_GL_ERROR();
     SceneObject::display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
 }
 
@@ -1217,19 +1239,32 @@ void FadeSmoothlyTransition::displaySlides_( double nTime, ::sal_Int32 glLeaving
     CHECK_GL_ERROR();
     applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
 
+    CHECK_GL_ERROR();
     glDisable(GL_DEPTH_TEST);
 
+    CHECK_GL_ERROR();
     displaySlide( nTime, glLeavingSlideTex, getScene().getLeavingSlide(), SlideWidthScale, SlideHeightScale );
+    CHECK_GL_ERROR();
 
+    CHECK_GL_ERROR();
     glDisable(GL_LIGHTING);
+    CHECK_GL_ERROR();
     glEnable(GL_BLEND);
+    CHECK_GL_ERROR();
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    CHECK_GL_ERROR();
     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    CHECK_GL_ERROR();
     glColor4f( 1, 1, 1, nTime );
+    CHECK_GL_ERROR();
     displaySlide( nTime, glEnteringSlideTex, getScene().getEnteringSlide(), SlideWidthScale, SlideHeightScale );
+    CHECK_GL_ERROR();
     glDisable(GL_BLEND);
+    CHECK_GL_ERROR();
     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+    CHECK_GL_ERROR();
     glEnable(GL_LIGHTING);
+    CHECK_GL_ERROR();
 
     glEnable(GL_DEPTH_TEST);
     CHECK_GL_ERROR();
diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx
index 00c84ca..48c6175 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx
@@ -396,8 +396,11 @@ bool OGLTransitionerImpl::initWindowFromSlideShowView( const Reference< presenta
 
     CHECK_GL_ERROR();
     glEnable(GL_CULL_FACE);
+    CHECK_GL_ERROR();
     glCullFace(GL_BACK);
+    CHECK_GL_ERROR();
     glClearColor (0, 0, 0, 0);
+    CHECK_GL_ERROR();
     glClear(GL_COLOR_BUFFER_BIT);
     CHECK_GL_ERROR();
 


More information about the Libreoffice-commits mailing list