slideshow/source/engine/OGLTrans/OGLTrans_TransitionImpl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: OGLTrans_TransitionImpl.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "OGLTrans_TransitionImpl.hxx"
  32 #include "OGLTrans_Shaders.hxx"
  33 #include <GL/gl.h>
  34 #include <math.h>
  35
  36
  37 void OGLTransitionImpl::clear()
  38 {
  39     for(unsigned int i( 0 ); i < OverallOperations.size(); ++i)
  40         delete OverallOperations[i];
  41     OverallOperations.clear();
  42     maLeavingSlidePrimitives.clear();
  43     maEnteringSlidePrimitives.clear();
  44     for(unsigned int i(0); i < maSceneObjects.size(); ++i)
  45         delete maSceneObjects[i];
  46     maSceneObjects.clear();
  47
  48     mbReflectSlides = false;
  49
  50 #ifdef GL_VERSION_2_0
  51     if( mProgramObject ) {
  52         OGLShaders::glDeleteProgram( mProgramObject );
  53         mProgramObject = 0;
  54     }
  55
  56     if( mVertexObject ) {
  57         OGLShaders::glDeleteShader( mVertexObject );
  58         mVertexObject = 0;
  59     }
  60
  61     if( mFragmentObject ) {
  62         OGLShaders::glDeleteShader( mFragmentObject );
  63         mFragmentObject = 0;
  64     }
  65 #endif
  66
  67     if( maHelperTexture ) {
  68         glDeleteTextures( 1, &maHelperTexture );
  69         maHelperTexture = 0;
  70     }
  71
  72     if( mmClearTransition )
  73         (this->*mmClearTransition)();
  74 }
  75
  76 OGLTransitionImpl::~OGLTransitionImpl()
  77 {
  78     clear();
  79 }
  80
  81 void OGLTransitionImpl::prepare( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex )
  82 {
  83     for(unsigned int i(0); i < maSceneObjects.size(); ++i) {
  84         maSceneObjects[i]->prepare();
  85     }
  86
  87     if( mmPrepareTransition )
  88         (this->*mmPrepareTransition)( glLeavingSlideTex, glEnteringSlideTex );
  89 }
  90
  91 void OGLTransitionImpl::finish()
  92 {
  93     for(unsigned int i(0); i < maSceneObjects.size(); ++i) {
  94         maSceneObjects[i]->finish();
  95     }
  96 }
  97
  98 static void blendSlide( double depth )
  99 {
 100     double showHeight = -1 + depth*2;
 101     GLfloat reflectionColor[] = {0, 0, 0, 0.25};
 102
 103     glDisable( GL_DEPTH_TEST );
 104     glBegin( GL_QUADS );
 105     glColor4fv( reflectionColor );
 106     glVertex3f( -1, -1, 0 );
 107     glColor4f( 0, 0, 0, 1 );
 108     glVertex3f(-1,  showHeight, 0 );
 109     glVertex3f( 1,  showHeight, 0 );
 110     glColor4fv( reflectionColor );
 111     glVertex3f( 1, -1, 0 );
 112     glEnd();
 113
 114     glBegin( GL_QUADS );
 115     glColor4f( 0, 0, 0, 1 );
 116     glVertex3f( -1, showHeight, 0 );
 117     glVertex3f( -1,  1, 0 );
 118     glVertex3f(  1,  1, 0 );
 119     glVertex3f(  1, showHeight, 0 );
 120     glEnd();
 121     glEnable( GL_DEPTH_TEST );
 122 }
 123
 124 static void slideShadow( double nTime, Primitive& primitive, double sw, double sh )
 125 {
 126     double reflectionDepth = 0.3;
 127
 128     glEnable(GL_BLEND);
 129     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 130     glDisable(GL_LIGHTING);
 131
 132     glPushMatrix();
 133     primitive.applyOperations( nTime, sw, sh );
 134     blendSlide( reflectionDepth );
 135     glPopMatrix();
 136
 137     glDisable(GL_BLEND);
 138     glEnable(GL_LIGHTING);
 139 }
 140
 141 void OGLTransitionImpl::display( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
 142                                  double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
 143 {
 144     double SlideWidthScale, SlideHeightScale;
 145
 146     SlideWidthScale = SlideWidth/DispWidth;
 147     SlideHeightScale = SlideHeight/DispHeight;
 148
 149     if( mmPrepare ) {
 150         clear();
 151         (this->*mmPrepare)( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
 152     }
 153
 154     glPushMatrix();
 155     displaySlides( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
 156     displayScene( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
 157     glPopMatrix();
 158 }
 159
 160 void OGLTransitionImpl::applyOverallOperations( double nTime, double SlideWidthScale, double SlideHeightScale )
 161 {
 162     for(unsigned int i(0); i < OverallOperations.size(); ++i)
 163         OverallOperations[i]->interpolate(nTime,SlideWidthScale,SlideHeightScale);
 164 }
 165
 166 void OGLTransitionImpl::displaySlide( double nTime, ::sal_Int32 glSlideTex, std::vector<Primitive>& primitives,
 167                                       double SlideWidthScale, double SlideHeightScale )
 168 {
 169    //TODO change to foreach
 170     glBindTexture(GL_TEXTURE_2D, glSlideTex);
 171
 172     // display slide reflection
 173     // note that depth test is turned off while blending the shadow
 174     // so the slides has to be rendered in right order, see rochade as example
 175     if( mbReflectSlides ) {
 176         double surfaceLevel = -0.04;
 177
 178         /* reflected slides */
 179         glPushMatrix();
 180
 181         glScaled( 1, -1, 1 );
 182         glTranslated( 0, 2 - surfaceLevel, 0 );
 183
 184         glCullFace(GL_FRONT);
 185     for(unsigned int i(0); i < primitives.size(); ++i)
 186         primitives[i].display(nTime, SlideWidthScale, SlideHeightScale);
 187         glCullFace(GL_BACK);
 188
 189     slideShadow( nTime, primitives[0], SlideWidthScale, SlideHeightScale );
 190
 191         glPopMatrix();
 192     }
 193
 194     for(unsigned int i(0); i < primitives.size(); ++i)
 195         primitives[i].display(nTime, SlideWidthScale, SlideHeightScale);
 196 }
 197
 198 void OGLTransitionImpl::displaySlides( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
 199                                        double SlideWidthScale, double SlideHeightScale )
 200 {
 201     if( mmDisplaySlides )
 202         (this->*mmDisplaySlides)( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
 203     else {
 204         applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
 205
 206         glEnable(GL_TEXTURE_2D);
 207         displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
 208         displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
 209     }
 210 }
 211
 212 void OGLTransitionImpl::displayScene( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
 213 {
 214     glEnable(GL_TEXTURE_2D);
 215     for(unsigned int i(0); i < maSceneObjects.size(); ++i)
 216         maSceneObjects[i]->display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
 217 }
 218
 219 void Primitive::display(double nTime, double WidthScale, double HeightScale)
 220 {
 221     glPushMatrix();
 222
 223     applyOperations( nTime, WidthScale, HeightScale );
 224
 225     glEnableClientState( GL_VERTEX_ARRAY );
 226     if(!Normals.empty())
 227     {
 228         glNormalPointer( GL_DOUBLE , 0 , &Normals[0] );
 229         glEnableClientState( GL_NORMAL_ARRAY );
 230     }
 231     glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 232     glTexCoordPointer( 2, GL_DOUBLE, 0, &TexCoords[0] );
 233     glVertexPointer( 3, GL_DOUBLE, 0, &Vertices[0] );
 234     glDrawArrays( GL_TRIANGLES, 0, Vertices.size() );
 235     glPopMatrix();
 236 }
 237
 238 void Primitive::applyOperations(double nTime, double WidthScale, double HeightScale)
 239 {
 240     for(unsigned int i(0); i < Operations.size(); ++i)
 241         Operations[i]->interpolate( nTime ,WidthScale,HeightScale);
 242     glScaled(WidthScale,HeightScale,1);
 243 }
 244
 245 Primitive::~Primitive()
 246 {
 247     for(unsigned int i( 0 ); i < Operations.size(); ++i)
 248         delete Operations[i];
 249 }
 250
 251
 252 void SceneObject::display(double nTime, double /* SlideWidth */, double /* SlideHeight */, double DispWidth, double DispHeight )
 253 {
 254     for(unsigned int i(0); i < maPrimitives.size(); ++i) {
 255         // fixme: allow various model spaces, now we make it so that
 256         // it is regular -1,-1 to 1,1, where the whole display fits in
 257         glPushMatrix();
 258         if (DispHeight > DispWidth)
 259             glScaled(DispHeight/DispWidth, 1, 1);
 260         else
 261             glScaled(1, DispWidth/DispHeight, 1);
 262         maPrimitives[i].display(nTime, 1, 1);
 263         glPopMatrix();
 264     }
 265 }
 266
 267 void SceneObject::pushPrimitive(const Primitive &p)
 268 {
 269     maPrimitives.push_back(p);
 270 }
 271
 272 SceneObject::SceneObject()
 273     : maPrimitives()
 274 {
 275 }
 276
 277 Iris::Iris()
 278     : SceneObject ()
 279 {
 280 }
 281
 282 void Iris::display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
 283 {
 284     glBindTexture(GL_TEXTURE_2D, maTexture);
 285     SceneObject::display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
 286 }
 287
 288 void Iris::prepare()
 289 {
 290     static GLubyte img[3] = { 80, 80, 80 };
 291
 292     glGenTextures(1, &maTexture);
 293     glBindTexture(GL_TEXTURE_2D, maTexture);
 294     glTexImage2D(GL_TEXTURE_2D, 0, 3, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, img);
 295     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
 296     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 297     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
 298     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
 299 }
 300
 301 void Iris::finish()
 302 {
 303     glDeleteTextures(1, &maTexture);
 304 }
 305
 306 void OGLTransitionImpl::makeOutsideCubeFaceToLeft()
 307 {
 308     clear();
 309     Primitive Slide;
 310
 311     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
 312     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
 313
 314     maLeavingSlidePrimitives.push_back(Slide);
 315
 316     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),90,false,0.0,1.0));
 317
 318     maEnteringSlidePrimitives.push_back(Slide);
 319
 320     OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),-90,true,0.0,1.0));
 321 }
 322
 323 void OGLTransitionImpl::makeInsideCubeFaceToLeft()
 324 {
 325     clear();
 326     Primitive Slide;
 327
 328     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
 329     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
 330
 331     maLeavingSlidePrimitives.push_back(Slide);
 332
 333     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),-90,false,0.0,1.0));
 334
 335     maEnteringSlidePrimitives.push_back(Slide);
 336
 337     OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),90,true,0.0,1.0));
 338 }
 339
 340 void OGLTransitionImpl::makeFallLeaving()
 341 {
 342     clear();
 343     Primitive Slide;
 344
 345     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
 346     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
 347     maEnteringSlidePrimitives.push_back(Slide);
 348
 349     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(1,0,0),basegfx::B3DVector(0,-1,0), 90,true,0.0,1.0));
 350     maLeavingSlidePrimitives.push_back(Slide);
 351
 352     mbUseMipMapEntering = false;
 353 }
 354
 355 void OGLTransitionImpl::makeTurnAround()
 356 {
 357     clear();
 358     Primitive Slide;
 359
 360     mbReflectSlides = true;
 361
 362     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
 363     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
 364     maLeavingSlidePrimitives.push_back(Slide);
 365
 366     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0),-180,false,0.0,1.0));
 367     maEnteringSlidePrimitives.push_back(Slide);
 368
 369     OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, -1.5),true, 0, 0.5));
 370     OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, 1.5), true, 0.5, 1));
 371     OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0),basegfx::B3DVector(0, 0, 0), -180, true, 0.0, 1.0));
 372 }
 373
 374 void OGLTransitionImpl::makeTurnDown()
 375 {
 376     clear();
 377     Primitive Slide;
 378
 379     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
 380     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
 381     maLeavingSlidePrimitives.push_back(Slide);
 382
 383     Slide.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, 0.0001), false, -1.0, 0.0));
 384     Slide.Operations.push_back(new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), -90, true, 0.0, 1.0));
 385     Slide.Operations.push_back(new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), 90, false, -1.0, 0.0));
 386     maEnteringSlidePrimitives.push_back(Slide);
 387
 388     mbUseMipMapLeaving = false;
 389 }
 390
 391 void OGLTransitionImpl::makeIris()
 392 {
 393     clear();
 394     Primitive Slide;
 395
 396     Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
 397     Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
 398     maEnteringSlidePrimitives.push_back (Slide);
 399
 400     Slide.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0,  0.000001), false, -1, 0));
 401     Slide.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, -0.000002), false, 0.5, 1));
 402     maLeavingSlidePrimitives.push_back (Slide);
 403
 404
 405     Primitive irisPart, part;
 406     int i, nSteps = 24, nParts = 7;
 407     double lt = 0, t = 1.0/nSteps, cx, cy, lcx, lcy, lx = 1, ly = 0, x, y, cxo, cyo, lcxo, lcyo, of=2.2, f=1.42;
 408
 409     for (i=1; i<=nSteps; i++) {
 410         x = cos ((3*2*M_PI*t)/nParts);
 411         y = -sin ((3*2*M_PI*t)/nParts);
 412         cx = (f*x + 1)/2;
 413         cy = (f*y + 1)/2;
 414         lcx = (f*lx + 1)/2;
 415         lcy = (f*ly + 1)/2;
 416         cxo = (of*x + 1)/2;
 417         cyo = (of*y + 1)/2;
 418         lcxo = (of*lx + 1)/2;
 419         lcyo = (of*ly + 1)/2;
 420         irisPart.pushTriangle (basegfx::B2DVector (lcx, lcy),
 421                                basegfx::B2DVector (lcxo, lcyo),
 422                                basegfx::B2DVector (cx, cy));
 423         irisPart.pushTriangle (basegfx::B2DVector (cx, cy),
 424                                basegfx::B2DVector (lcxo, lcyo),
 425                                basegfx::B2DVector (cxo, cyo));
 426         lx = x;
 427         ly = y;
 428         lt = t;
 429         t += 1.0/nSteps;
 430     }
 431
 432     Iris* pIris = new Iris();
 433     double angle = 87;
 434
 435     for (i = 0; i < nParts; i++) {
 436         irisPart.Operations.clear ();
 437         double rx, ry;
 438
 439         rx = cos ((2*M_PI*i)/nParts);
 440         ry = sin ((2*M_PI*i)/nParts);
 441         irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0),  angle, true, 0.0, 0.5));
 442         irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0), -angle, true, 0.5, 1));
 443         if (i > 0) {
 444             irisPart.Operations.push_back (new STranslate (basegfx::B3DVector(rx, ry, 0),  false, -1, 0));
 445             irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(0, 0, 0), i*360.0/nParts, false, -1, 0));
 446             irisPart.Operations.push_back (new STranslate (basegfx::B3DVector(-1, 0, 0),  false, -1, 0));
 447         }
 448         irisPart.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, 1), false, -2, 0.0));
 449         irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(1, .5, 0), basegfx::B3DVector(1, 0, 0), -30, false, -1, 0));
 450         pIris->pushPrimitive (irisPart);
 451     }
 452
 453     maSceneObjects.push_back (pIris);
 454
 455     mbUseMipMapLeaving = mbUseMipMapEntering = false;
 456 }
 457
 458 void OGLTransitionImpl::displaySlidesRochade( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
 459                           double SlideWidthScale, double SlideHeightScale )
 460 {
 461     applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
 462
 463     glEnable(GL_TEXTURE_2D);
 464
 465     if( nTime > .5) {
 466     displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
 467     displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
 468     } else {
 469     displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
 470     displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
 471     }
 472 }
 473
 474 void OGLTransitionImpl::makeRochade()
 475 {
 476     clear();
 477     Primitive Slide;
 478
 479     mbReflectSlides = true;
 480     mmDisplaySlides = &OGLTransitionImpl::displaySlidesRochade;
 481
 482     double w, h;
 483
 484     w = 2.2;
 485     h = 10;
 486
 487     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
 488     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
 489
 490     Slide.Operations.push_back(new SEllipseTranslate(w, h, 0.25, -0.25, true, 0, 1));
 491     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
 492     maLeavingSlidePrimitives.push_back(Slide);
 493
 494     Slide.Operations.clear();
 495     Slide.Operations.push_back(new SEllipseTranslate(w, h, 0.75, 0.25, true, 0, 1));
 496     Slide.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, -h), false, -1, 0));
 497     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
 498     Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), 45, false, -1, 0));
 499     maEnteringSlidePrimitives.push_back(Slide);
 500
 501     //     OverallOperations.push_back(new SEllipseTranslate(0.5, 2, 0, 1, true, 0, 1));
 502 //      push_back(new STranslate(basegfx::B3DVector(0, 0, -2), true, 0, 0.5));
 503 //      OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, 2), true, 0.5, 1));
 504 }
 505
 506 // TODO(Q3): extract to basegfx
 507 inline basegfx::B2DVector clamp(const basegfx::B2DVector& v)
 508 {
 509     return basegfx::B2DVector(min(max(v.getX(),-1.0),1.0),
 510                               min(max(v.getY(),-1.0),1.0));
 511 }
 512
 513 // TODO(Q3): extract to basegfx
 514 inline basegfx::B3DVector clamp(const basegfx::B3DVector& v)
 515 {
 516     return basegfx::B3DVector(min(max(v.getX(),-1.0),1.0),
 517                               min(max(v.getY(),-1.0),1.0),
 518                               min(max(v.getZ(),-1.0),1.0));
 519 }
 520
 521 inline double randFromNeg1to1()
 522 {
 523     return ( ( static_cast<double>( rand() ) / static_cast<double>( RAND_MAX ) ) * 2.0 ) - 1.0;
 524 }
 525
 526 // TODO(Q3): extract to basegfx
 527 inline basegfx::B3DVector randNormVectorInXYPlane()
 528 {
 529     basegfx::B3DVector toReturn(randFromNeg1to1(),randFromNeg1to1(),0.0);
 530     return toReturn/toReturn.getLength();
 531 }
 532
 533 void OGLTransitionImpl::makeRevolvingCircles( ::sal_uInt16 nCircles , ::sal_uInt16 nPointsOnCircles )
 534 {
 535     clear();
 536     double dAngle(2*3.1415926/static_cast<double>( nPointsOnCircles ));
 537     if(nCircles < 2 || nPointsOnCircles < 4)
 538     {
 539         makeNByMTileFlip(1,1);
 540         return;
 541     }
 542     double Radius(1.0/static_cast<double>( nCircles ));
 543     double dRadius(Radius);
 544     double LastRadius(0.0);
 545     double NextRadius(2*Radius);
 546
 547     /// now we know there is at least two circles
 548     /// the first will always be a full circle
 549     /// the last will always be the outer shell of the slide with a circle hole
 550
 551     //add the full circle
 552     vector<basegfx::B2DVector> unScaledTexCoords;
 553     double TempAngle(0.0);
 554     for(unsigned int Point(0); Point < nPointsOnCircles; ++Point)
 555     {
 556         unScaledTexCoords.push_back( basegfx::B2DVector( cos(TempAngle - 3.1415926/2.0) , sin(TempAngle- 3.1415926/2.0) ) );
 557
 558         TempAngle += dAngle;
 559     }
 560
 561     {
 562         //double angle(0.0);
 563         Primitive EnteringSlide;
 564         Primitive LeavingSlide;
 565         for(int Point(0); Point + 1 < nPointsOnCircles; ++Point)
 566         {
 567             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 ) );
 568             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) );
 569         }
 570         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 ) );
 571         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) );
 572
 573         basegfx::B3DVector axis(randNormVectorInXYPlane());
 574         EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
 575         LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
 576         EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
 577
 578         maEnteringSlidePrimitives.push_back(EnteringSlide);
 579         maLeavingSlidePrimitives.push_back(LeavingSlide);
 580         LastRadius = Radius;
 581         Radius = NextRadius;
 582         NextRadius += dRadius;
 583     }
 584
 585     for(int i(1); i < nCircles - 1; ++i)
 586     {
 587         Primitive LeavingSlide;
 588         Primitive EnteringSlide;
 589         for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
 590         {
 591             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) );
 592             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) );
 593
 594             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) );
 595             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) );
 596         }
 597
 598         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) );
 599         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) );
 600
 601         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) );
 602         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) );
 603
 604         basegfx::B3DVector axis(randNormVectorInXYPlane());
 605         EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
 606         LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
 607         EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
 608
 609         maEnteringSlidePrimitives.push_back(EnteringSlide);
 610         maLeavingSlidePrimitives.push_back(LeavingSlide);
 611
 612         LastRadius = Radius;
 613         Radius = NextRadius;
 614         NextRadius += dRadius;
 615     }
 616     {
 617         Radius = sqrt(2.0);
 618         Primitive LeavingSlide;
 619         Primitive EnteringSlide;
 620         for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
 621         {
 622
 623             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) );
 624             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) );
 625
 626             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) );
 627             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) );
 628         }
 629
 630         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) );
 631         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) );
 632
 633         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) );
 634         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) );
 635
 636         basegfx::B3DVector axis(randNormVectorInXYPlane());
 637         EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
 638         LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
 639         EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
 640
 641         maEnteringSlidePrimitives.push_back(EnteringSlide);
 642         maLeavingSlidePrimitives.push_back(LeavingSlide);
 643     }
 644 }
 645
 646 void OGLTransitionImpl::makeHelix( ::sal_uInt16 nRows )
 647 {
 648     clear();
 649     double invN(1.0/static_cast<double>(nRows));
 650     double iDn = 0.0;
 651     double iPDn = invN;
 652     for(unsigned int i(0); i < nRows; ++i)
 653     {
 654         Primitive Tile;
 655
 656         Tile.pushTriangle(basegfx::B2DVector( 1.0 , iDn ) , basegfx::B2DVector( 0.0 , iDn ) , basegfx::B2DVector( 0.0 , iPDn ));
 657
 658         Tile.pushTriangle(basegfx::B2DVector( 1.0 , iPDn ) , basegfx::B2DVector( 1.0 , iDn ) , basegfx::B2DVector( 0.0 , iPDn ));
 659
 660         Tile.Operations.push_back( new SRotate( basegfx::B3DVector( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , 180 ,
 661                                                 true,min(max(static_cast<double>(i - nRows/2.0)*invN/2.0,0.0),1.0),
 662                                                 min(max(static_cast<double>(i + nRows/2.0)*invN/2.0,0.0),1.0) ) );
 663
 664         maLeavingSlidePrimitives.push_back(Tile);
 665
 666         Tile.Operations.push_back( new SRotate( basegfx::B3DVector( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , -180 , false,0.0,1.0) );
 667
 668         maEnteringSlidePrimitives.push_back(Tile);
 669
 670         iDn += invN;
 671         iPDn += invN;
 672     }
 673 }
 674
 675 void OGLTransitionImpl::makeNByMTileFlip( ::sal_uInt16 n, ::sal_uInt16 m )
 676 {
 677     clear();
 678     double invN(1.0/static_cast<double>(n));
 679     double invM(1.0/static_cast<double>(m));
 680     double iDn = 0.0;
 681     double iPDn = invN;
 682     for(unsigned int i(0); i < n; ++i)
 683     {
 684         double jDm = 0.0;
 685         double jPDm = invM;
 686         for(unsigned int j(0); j < m; ++j)
 687         {
 688             Primitive Tile;
 689
 690             Tile.pushTriangle(basegfx::B2DVector( iPDn , jDm ) , basegfx::B2DVector( iDn , jDm ) , basegfx::B2DVector( iDn , jPDm ));
 691
 692             Tile.pushTriangle(basegfx::B2DVector( iPDn , jPDm ) , basegfx::B2DVector( iPDn , jDm ) , basegfx::B2DVector( iDn , jPDm ));//bottom left corner of tile
 693
 694             Tile.Operations.push_back( new SRotate( 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 ) );
 695             maLeavingSlidePrimitives.push_back(Tile);
 696             Tile.Operations.push_back( new SRotate( 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 ) );
 697
 698             maEnteringSlidePrimitives.push_back(Tile);
 699
 700             jDm += invM;
 701             jPDm += invM;
 702         }
 703         iDn += invN;
 704         iPDn += invN;
 705     }
 706 }
 707
 708 SRotate::SRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
 709 {
 710     nT0 = T0;
 711     nT1 = T1;
 712     bInterpolate = bInter;
 713 }
 714
 715 SScale::SScale(const basegfx::B3DVector& Scale,const basegfx::B3DVector& Origin, bool bInter, double T0, double T1):scale(Scale),origin(Origin)
 716 {
 717     nT0 = T0;
 718     nT1 = T1;
 719     bInterpolate = bInter;
 720 }
 721
 722 RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
 723 {
 724     nT0 = T0;
 725     nT1 = T1;
 726     bInterpolate = bInter;
 727 }
 728
 729 RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
 730 {
 731     nT0 = T0;
 732     nT1 = T1;
 733     bInterpolate = bInter;
 734 }
 735
 736
 737 STranslate::STranslate(const basegfx::B3DVector& Vector, bool bInter, double T0, double T1):vector(Vector)
 738 {
 739     nT0 = T0;
 740     nT1 = T1;
 741     bInterpolate = bInter;
 742 }
 743
 744 inline double intervalInter(double t, double T0, double T1)
 745 {
 746     return ( t - T0 ) / ( T1 - T0 );
 747 }
 748
 749 void STranslate::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
 750 {
 751     if(t <= nT0)
 752         return;
 753     if(!bInterpolate || t > nT1)
 754         t = nT1;
 755     t = intervalInter(t,nT0,nT1);
 756     glTranslated(SlideWidthScale*t*vector.getX(),SlideHeightScale*t*vector.getY(),t*vector.getZ());
 757 }
 758
 759 void SRotate::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
 760 {
 761     if(t <= nT0)
 762         return;
 763     if(!bInterpolate || t > nT1)
 764         t = nT1;
 765     t = intervalInter(t,nT0,nT1);
 766     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
 767     glScaled(SlideWidthScale,SlideHeightScale,1);
 768     glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
 769     glScaled(1/SlideWidthScale,1/SlideHeightScale,1);
 770     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
 771 }
 772
 773 void SScale::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
 774 {
 775     if(t <= nT0)
 776         return;
 777     if(!bInterpolate || t > nT1)
 778         t = nT1;
 779     t = intervalInter(t,nT0,nT1);
 780     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
 781     glScaled((1-t) + t*scale.getX(),(1-t) + t*scale.getY(),(1-t) + t*scale.getZ());
 782     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
 783 }
 784
 785 void RotateAndScaleDepthByWidth::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
 786 {
 787     if(t <= nT0)
 788         return;
 789     if(!bInterpolate || t > nT1)
 790         t = nT1;
 791     t = intervalInter(t,nT0,nT1);
 792     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideWidthScale*origin.getZ());
 793     glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
 794     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideWidthScale*origin.getZ());
 795 }
 796
 797 void RotateAndScaleDepthByHeight::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
 798 {
 799     if(t <= nT0)
 800         return;
 801     if(!bInterpolate || t > nT1)
 802         t = nT1;
 803     t = intervalInter(t,nT0,nT1);
 804     glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideHeightScale*origin.getZ());
 805     glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
 806     glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideHeightScale*origin.getZ());
 807 }
 808
 809 SEllipseTranslate::SEllipseTranslate(double dWidth, double dHeight, double dStartPosition, double dEndPosition, bool bInter, double T0, double T1)
 810 {
 811     nT0 = T0;
 812     nT1 = T1;
 813     bInterpolate = bInter;
 814     width = dWidth;
 815     height = dHeight;
 816     startPosition = dStartPosition;
 817     endPosition = dEndPosition;
 818 }
 819
 820 void SEllipseTranslate::interpolate(double t,double /* SlideWidthScale */,double /* SlideHeightScale */)
 821 {
 822     if(t <= nT0)
 823         return;
 824     if(!bInterpolate || t > nT1)
 825         t = nT1;
 826     t = intervalInter(t,nT0,nT1);
 827
 828     double a1, a2, x, y;
 829     a1 = startPosition*2*M_PI;
 830     a2 = (startPosition + t*(endPosition - startPosition))*2*M_PI;
 831     x = width*(cos (a2) - cos (a1))/2;
 832     y = height*(sin (a2) - sin (a1))/2;
 833
 834     glTranslated(x, 0, y);
 835 }
 836
 837 STranslate* STranslate::clone()
 838 {
 839     return new STranslate(*this);
 840 }
 841 SRotate* SRotate::clone()
 842 {
 843     return new SRotate(*this);
 844 }
 845
 846 SScale* SScale::clone()
 847 {
 848     return new SScale(*this);
 849 }
 850
 851 SEllipseTranslate* SEllipseTranslate::clone()
 852 {
 853     return new SEllipseTranslate(*this);
 854 }
 855
 856 RotateAndScaleDepthByWidth* RotateAndScaleDepthByWidth::clone()
 857 {
 858     return new RotateAndScaleDepthByWidth(*this);
 859 }
 860
 861 RotateAndScaleDepthByHeight* RotateAndScaleDepthByHeight::clone()
 862 {
 863     return new RotateAndScaleDepthByHeight(*this);
 864 }
 865
 866 const Primitive& Primitive::operator=(const Primitive& rvalue)
 867 {
 868     for(unsigned int i( 0 ); i < rvalue.Operations.size(); ++i)
 869         Operations.push_back(rvalue.Operations[i]->clone());
 870     for(unsigned int i( 0 ); i < rvalue.Vertices.size(); ++i)//SPEED! use copy or something. this is slow.
 871         Vertices.push_back(rvalue.Vertices[i]);
 872     for(unsigned int i( 0 ); i < rvalue.TexCoords.size(); ++i)//SPEED! use copy or something. this is slow.
 873         TexCoords.push_back(rvalue.TexCoords[i]);
 874     for(unsigned int i( 0 ); i < rvalue.Normals.size(); ++i)//SPEED! use copy or something. this is slow.
 875         Normals.push_back(rvalue.Normals[i]);
 876     return *this;
 877 }
 878
 879 Primitive::Primitive(const Primitive& rvalue)
 880 {
 881     for(unsigned int i( 0 ); i < rvalue.Operations.size(); ++i)
 882         Operations.push_back(rvalue.Operations[i]->clone());
 883     for(unsigned int i( 0 ); i < rvalue.Vertices.size(); ++i)//SPEED! use copy or something. this is slow.
 884         Vertices.push_back(rvalue.Vertices[i]);
 885     for(unsigned int i( 0 ); i < rvalue.TexCoords.size(); ++i)//SPEED! use copy or something. this is slow.
 886         TexCoords.push_back(rvalue.TexCoords[i]);
 887     for(unsigned int i( 0 ); i < rvalue.Normals.size(); ++i)//SPEED! use copy or something. this is slow.
 888         Normals.push_back(rvalue.Normals[i]);
 889 }
 890
 891 void Primitive::pushTriangle(const basegfx::B2DVector& SlideLocation0,const basegfx::B2DVector& SlideLocation1,const basegfx::B2DVector& SlideLocation2)
 892 {
 893     vector<basegfx::B3DVector> Verts;
 894     vector<basegfx::B2DVector> Texs;
 895     Verts.reserve(3);
 896     Texs.reserve(3);
 897
 898     Verts.push_back(basegfx::B3DVector( 2*SlideLocation0.getX() - 1, -2*SlideLocation0.getY() + 1 , 0.0 ));
 899     Verts.push_back(basegfx::B3DVector( 2*SlideLocation1.getX() - 1, -2*SlideLocation1.getY() + 1 , 0.0 ));
 900     Verts.push_back(basegfx::B3DVector( 2*SlideLocation2.getX() - 1, -2*SlideLocation2.getY() + 1 , 0.0 ));
 901
 902     //figure out if they're facing the correct way, and make them face the correct way.
 903     basegfx::B3DVector Normal( basegfx::cross( Verts[0] - Verts[1] , Verts[1] - Verts[2] ) );
 904     if(Normal.getZ() >= 0.0)//if the normal is facing us
 905     {
 906         Texs.push_back(SlideLocation0);
 907         Texs.push_back(SlideLocation1);
 908         Texs.push_back(SlideLocation2);
 909     }
 910     else // if the normal is facing away from us, make it face us
 911     {
 912         Texs.push_back(SlideLocation0);
 913         Texs.push_back(SlideLocation2);
 914         Texs.push_back(SlideLocation1);
 915         Verts.clear();
 916         Verts.push_back(basegfx::B3DVector( 2*SlideLocation0.getX() - 1, -2*SlideLocation0.getY() + 1 , 0.0 ));
 917         Verts.push_back(basegfx::B3DVector( 2*SlideLocation2.getX() - 1, -2*SlideLocation2.getY() + 1 , 0.0 ));
 918         Verts.push_back(basegfx::B3DVector( 2*SlideLocation1.getX() - 1, -2*SlideLocation1.getY() + 1 , 0.0 ));
 919     }
 920
 921     Vertices.push_back(Verts[0]);
 922     Vertices.push_back(Verts[1]);
 923     Vertices.push_back(Verts[2]);
 924
 925     TexCoords.push_back(Texs[0]);
 926     TexCoords.push_back(Texs[1]);
 927     TexCoords.push_back(Texs[2]);
 928
 929     Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
 930     Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
 931     Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
 932 }
 933
 934 void OGLTransitionImpl::makeDiamond()
 935 {
 936     mmPrepare = &OGLTransitionImpl::prepareDiamond;
 937     mbUseMipMapLeaving = mbUseMipMapEntering = false;
 938 }
 939
 940 void OGLTransitionImpl::prepareDiamond( double nTime, double /* SlideWidth */, double /* SlideHeight */, double /* DispWidth */, double /* DispHeight */ )
 941 {
 942     Primitive Slide1, Slide2;
 943
 944     Slide1.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
 945     Slide1.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
 946     maEnteringSlidePrimitives.push_back (Slide1);
 947
 948
 949     if( nTime >= 0.5 ) {
 950         double m = 1 - nTime;
 951
 952         Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (m,0), basegfx::B2DVector (0,m));
 953         Slide2.pushTriangle (basegfx::B2DVector (nTime,0), basegfx::B2DVector (1,0), basegfx::B2DVector (1,m));
 954         Slide2.pushTriangle (basegfx::B2DVector (1,nTime), basegfx::B2DVector (1,1), basegfx::B2DVector (nTime,1));
 955         Slide2.pushTriangle (basegfx::B2DVector (0,nTime), basegfx::B2DVector (m,1), basegfx::B2DVector (0,1));
 956     } else {
 957         double l = 0.5 - nTime;
 958         double h = 0.5 + nTime;
 959
 960         Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0.5,l));
 961         Slide2.pushTriangle (basegfx::B2DVector (0.5,l), basegfx::B2DVector (1,0), basegfx::B2DVector (h,0.5));
 962         Slide2.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (1,1), basegfx::B2DVector (h,0.5));
 963         Slide2.pushTriangle (basegfx::B2DVector (h,0.5), basegfx::B2DVector (1,1), basegfx::B2DVector (0.5,h));
 964         Slide2.pushTriangle (basegfx::B2DVector (0.5,h), basegfx::B2DVector (1,1), basegfx::B2DVector (0,1));
 965         Slide2.pushTriangle (basegfx::B2DVector (l,0.5), basegfx::B2DVector (0.5,h), basegfx::B2DVector (0,1));
 966         Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (l,0.5), basegfx::B2DVector (0,1));
 967         Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (0.5,l), basegfx::B2DVector (l,0.5));
 968     }
 969     Slide2.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, 0.00000001), false, -1, 0));
 970     maLeavingSlidePrimitives.push_back (Slide2);
 971 }
 972
 973 void OGLTransitionImpl::makeVenetianBlinds( bool vertical, int parts )
 974 {
 975     static double t30 = tan( M_PI/6.0 );
 976     double n, ln = 0;
 977     double p = 1.0/parts;
 978
 979     for( int i=0; i<parts; i++ ) {
 980         Primitive Slide;
 981         n = (i + 1)/(double)parts;
 982         if( vertical ) {
 983             Slide.pushTriangle (basegfx::B2DVector (ln,0), basegfx::B2DVector (n,0), basegfx::B2DVector (ln,1));
 984             Slide.pushTriangle (basegfx::B2DVector (n,0), basegfx::B2DVector (ln,1), basegfx::B2DVector (n,1));
 985             Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(n + ln - 1, 0, -t30*p), -120, true, 0.0, 1.0));
 986         } else {
 987             Slide.pushTriangle (basegfx::B2DVector (0,ln), basegfx::B2DVector (1,ln), basegfx::B2DVector (0,n));
 988             Slide.pushTriangle (basegfx::B2DVector (1,ln), basegfx::B2DVector (0,n), basegfx::B2DVector (1,n));
 989             Slide.Operations.push_back(new RotateAndScaleDepthByHeight(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - n - ln, -t30*p), -120, true, 0.0, 1.0));
 990         }
 991         maLeavingSlidePrimitives.push_back (Slide);
 992
 993         if( vertical ) {
 994             Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(2*n - 1, 0, 0), -60, false, -1, 0));
 995             Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(n + ln - 1, 0, 0), 180, false, -1, 0));
 996         } else {
 997             Slide.Operations.push_back(new SRotate(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - 2*n, 0), -60, false, -1, 0));
 998             Slide.Operations.push_back(new SRotate(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - n - ln, 0), 180, false, -1, 0));
 999         }
1000         maEnteringSlidePrimitives.push_back (Slide);
1001         ln = n;
1002     }
1003 }
1004
1005 void OGLTransitionImpl::displaySlidesFadeSmoothly( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale )
1006 {
1007     applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
1008
1009     glDisable(GL_DEPTH_TEST);
1010
1011     displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
1012
1013     glDisable(GL_LIGHTING);
1014     glEnable(GL_BLEND);
1015     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1016     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1017     glColor4f( 1, 1, 1, nTime );
1018     displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
1019     glDisable(GL_BLEND);
1020     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1021     glEnable(GL_LIGHTING);
1022
1023     glEnable(GL_DEPTH_TEST);
1024 }
1025
1026 void OGLTransitionImpl::makeFadeSmoothly()
1027 {
1028     Primitive Slide;
1029
1030     Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
1031     Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
1032     maLeavingSlidePrimitives.push_back (Slide);
1033     maEnteringSlidePrimitives.push_back (Slide);
1034
1035     mmDisplaySlides = &OGLTransitionImpl::displaySlidesFadeSmoothly;
1036     mbUseMipMapLeaving = mbUseMipMapEntering = false;
1037 }
1038
1039 void OGLTransitionImpl::displaySlidesFadeThroughBlack( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale )
1040 {
1041     applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
1042
1043     glDisable(GL_DEPTH_TEST);
1044
1045     glDisable(GL_LIGHTING);
1046     glEnable(GL_BLEND);
1047     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1048     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1049     if( nTime < 0.5 ) {
1050     glColor4f( 1, 1, 1, 1 - nTime*2 );
1051     displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
1052     } else {
1053     glColor4f( 1, 1, 1, (nTime - 0.5)*2 );
1054     displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
1055     }
1056     glDisable(GL_BLEND);
1057     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1058     glEnable(GL_LIGHTING);
1059
1060     glEnable(GL_DEPTH_TEST);
1061 }
1062
1063 void OGLTransitionImpl::makeFadeThroughBlack()
1064 {
1065     Primitive Slide;
1066
1067     Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
1068     Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
1069     maLeavingSlidePrimitives.push_back (Slide);
1070     maEnteringSlidePrimitives.push_back (Slide);
1071
1072     mmDisplaySlides = &OGLTransitionImpl::displaySlidesFadeThroughBlack;
1073     mbUseMipMapLeaving = mbUseMipMapEntering = false;
1074 }
1075
1076 static const char* basicVertexShader = "\n\
1077 varying vec2 v_texturePosition;\n\
1078 \n\
1079 void main( void )\n\
1080 {\n\
1081     gl_Position = ftransform();\n\
1082     v_texturePosition = gl_MultiTexCoord0.xy;\n\
1083 }\n\
1084 ";
1085
1086 static const char* staticFragmentShader = "\n\
1087 uniform sampler2D leavingSlideTexture;\n\
1088 uniform sampler2D enteringSlideTexture;\n\
1089 uniform sampler2D permTexture;\n\
1090 uniform float time;\n\
1091 varying vec2 v_texturePosition;\n\
1092 \n\
1093 float snoise(vec2 P) {\n\
1094 \n\
1095   return texture2D(permTexture, P).r;\n\
1096 }\n\
1097 \n\
1098 \n\
1099 #define PART 0.5\n\
1100 #define START 0.4\n\
1101 #define END 0.9\n\
1102 \n\
1103 void main() {\n\
1104     float sn = snoise(10.0*v_texturePosition+time*0.07);\n\
1105     if( time < PART ) {\n\
1106         float sn1 = snoise(vec2(time*15.0, 20.0*v_texturePosition.y));\n\
1107         float sn2 = snoise(v_texturePosition);\n\
1108         if (sn1 > 1.0 - time*time && sn2 < 2.0*time+0.1)\n\
1109             gl_FragColor = vec4(sn, sn, sn, 1.0);\n\
1110         else if (time > START )\n\
1111             gl_FragColor = ((time-START)/(PART - START))*vec4(sn, sn, sn, 1.0) + (1.0 - (time - START)/(PART - START))*texture2D(leavingSlideTexture, v_texturePosition);\n\
1112         else\n\
1113             gl_FragColor = texture2D(leavingSlideTexture, v_texturePosition);\n\
1114     } else if ( time < PART ) {\n\
1115             gl_FragColor = texture2D(leavingSlideTexture, v_texturePosition);\n\
1116     } else if ( time > END ) {\n\
1117         gl_FragColor = ((1.0 - time)/(1.0 - END))*vec4(sn, sn, sn, 1.0) + ((time - END)/(1.0 - END))*texture2D(enteringSlideTexture, v_texturePosition);\n\
1118     } else \n\
1119         gl_FragColor = vec4(sn, sn, sn, 1.0);\n\
1120 }\n\
1121 ";
1122
1123 static const char* dissolveFragmentShader = "\n\
1124 uniform sampler2D leavingSlideTexture;\n\
1125 uniform sampler2D enteringSlideTexture;\n\
1126 uniform sampler2D permTexture;\n\
1127 uniform float time;\n\
1128 varying vec2 v_texturePosition;\n\
1129 \n\
1130 float snoise(vec2 P) {\n\
1131 \n\
1132   return texture2D(permTexture, P).r;\n\
1133 }\n\
1134 \n\
1135 void main() {\n\
1136      float sn = snoise(10.0*v_texturePosition);\n\
1137      if( sn < time)\n\
1138          gl_FragColor = texture2D(enteringSlideTexture, v_texturePosition);\n\
1139      else\n\
1140          gl_FragColor = texture2D(leavingSlideTexture, v_texturePosition);\n\
1141 }\n\
1142 ";
1143
1144 int permutation256 [256]= {
1145 215, 100, 200, 204, 233,  50,  85, 196,
1146  71, 141, 122, 160,  93, 131, 243, 234,
1147 162, 183,  36, 155,   4,  62,  35, 205,
1148  40, 102,  33,  27, 255,  55, 214, 156,
1149  75, 163, 134, 126, 249,  74, 197, 228,
1150  72,  90, 206, 235,  17,  22,  49, 169,
1151 227,  89,  16,   5, 117,  60, 248, 230,
1152 217,  68, 138,  96, 194, 170, 136,  10,
1153 112, 238, 184, 189, 176,  42, 225, 212,
1154  84,  58, 175, 244, 150, 168, 219, 236,
1155 101, 208, 123,  37, 164, 110, 158, 201,
1156  78, 114,  57,  48,  70, 142, 106,  43,
1157 232,  26,  32, 252, 239,  98, 191,  94,
1158  59, 149,  39, 187, 203, 190,  19,  13,
1159 133,  45,  61, 247,  23,  34,  20,  52,
1160 118, 209, 146, 193, 222,  18,   1, 152,
1161  46,  41,  91, 148, 115,  25, 135,  77,
1162 254, 147, 224, 161,   9, 213, 223, 250,
1163 231, 251, 127, 166,  63, 179,  81, 130,
1164 139,  28, 120, 151, 241,  86, 111,   0,
1165  88, 153, 172, 182, 159, 105, 178,  47,
1166  51, 167,  65,  66,  92,  73, 198, 211,
1167 245, 195,  31, 220, 140,  76, 221, 186,
1168 154, 185,  56,  83,  38, 165, 109,  67,
1169 124, 226, 132,  53, 229,  29,  12, 181,
1170 121,  24, 207, 199, 177, 113,  30,  80,
1171   3,  97, 188,  79, 216, 173,   8, 145,
1172  87, 128, 180, 237, 240, 137, 125, 104,
1173  15, 242, 119, 246, 103, 143,  95, 144,
1174   2,  44,  69, 157, 192, 174,  14,  54,
1175 218,  82,  64, 210,  11,   6, 129,  21,
1176 116, 171,  99, 202,   7, 107, 253, 108
1177 };
1178
1179 void initPermTexture(GLuint *texID)
1180 {
1181   glGenTextures(1, texID);
1182   glBindTexture(GL_TEXTURE_2D, *texID);
1183
1184   static bool initialized = false;
1185   static unsigned char permutation2D[256*256*4];
1186   if( !initialized ) {
1187       int x, y;
1188
1189       for( y=0; y < 256; y++ )
1190           for( x=0; x < 256; x++ )
1191               permutation2D[x*4 + y*1024] = permutation256[(y + permutation256[x]) & 0xff];
1192
1193       initialized = true;
1194   }
1195
1196   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, permutation2D );
1197   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
1198   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
1199 }
1200
1201 void OGLTransitionImpl::preparePermShader()
1202 {
1203 #ifdef GL_VERSION_2_0
1204     if( mProgramObject ) {
1205         OGLShaders::glUseProgram( mProgramObject );
1206
1207         GLint location = OGLShaders::glGetUniformLocation( mProgramObject, "leavingSlideTexture" );
1208         if( location != -1 ) {
1209             OGLShaders::glUniform1i( location, 0 );  // texture unit 0
1210         }
1211
1212         glActiveTexture(GL_TEXTURE1);
1213         if( !maHelperTexture )
1214             initPermTexture( &maHelperTexture );
1215         glActiveTexture(GL_TEXTURE0);
1216
1217         location = OGLShaders::glGetUniformLocation( mProgramObject, "permTexture" );
1218         if( location != -1 ) {
1219             OGLShaders::glUniform1i( location, 1 );  // texture unit 1
1220         }
1221
1222         location = OGLShaders::glGetUniformLocation( mProgramObject, "enteringSlideTexture" );
1223         if( location != -1 ) {
1224             OGLShaders::glUniform1i( location, 2 );  // texture unit 2
1225         }
1226     }
1227 #endif
1228 }
1229
1230 void OGLTransitionImpl::prepareStatic( ::sal_Int32 /* glLeavingSlideTex */, ::sal_Int32 /* glEnteringSlideTex */ )
1231 {
1232     mProgramObject = OGLShaders::LinkProgram( basicVertexShader, staticFragmentShader );
1233
1234     preparePermShader();
1235 }
1236
1237 void OGLTransitionImpl::displaySlidesShaders( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
1238                                               double SlideWidthScale, double SlideHeightScale )
1239 {
1240     applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
1241
1242 #ifdef GL_VERSION_2_0
1243     if( mProgramObject ) {
1244         GLint location = OGLShaders::glGetUniformLocation( mProgramObject, "time" );
1245         if( location != -1 ) {
1246             OGLShaders::glUniform1f( location, nTime );
1247         }
1248     }
1249
1250     glActiveTexture( GL_TEXTURE2 );
1251     glBindTexture( GL_TEXTURE_2D, glEnteringSlideTex );
1252     glActiveTexture( GL_TEXTURE0 );
1253 #endif
1254
1255     displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
1256 }
1257
1258 void OGLTransitionImpl::makeStatic()
1259 {
1260     Primitive Slide;
1261
1262     Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
1263     Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
1264     maLeavingSlidePrimitives.push_back (Slide);
1265     maEnteringSlidePrimitives.push_back (Slide);
1266
1267     mmDisplaySlides = &OGLTransitionImpl::displaySlidesShaders;
1268     mmPrepareTransition = &OGLTransitionImpl::prepareStatic;
1269     mbUseMipMapLeaving = mbUseMipMapEntering = false;
1270
1271     mnRequiredGLVersion = 2.0;
1272 }
1273
1274 void OGLTransitionImpl::prepareDissolve( ::sal_Int32 /* glLeavingSlideTex */, ::sal_Int32 /* glEnteringSlideTex */ )
1275 {
1276     mProgramObject = OGLShaders::LinkProgram( basicVertexShader, dissolveFragmentShader );
1277
1278     preparePermShader();
1279 }
1280
1281 void OGLTransitionImpl::makeDissolve()
1282 {
1283     Primitive Slide;
1284
1285     Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
1286     Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
1287     maLeavingSlidePrimitives.push_back (Slide);
1288     maEnteringSlidePrimitives.push_back (Slide);
1289
1290     mmDisplaySlides = &OGLTransitionImpl::displaySlidesShaders;
1291     mmPrepareTransition = &OGLTransitionImpl::prepareDissolve;
1292     mbUseMipMapLeaving = mbUseMipMapEntering = false;
1293
1294     mnRequiredGLVersion = 2.0;
1295 }
1296
1297 void OGLTransitionImpl::makeNewsflash()
1298 {
1299     Primitive Slide;
1300
1301     Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
1302     Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
1303     Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0,0,0),3000,true,0,0.5));
1304     Slide.Operations.push_back(new SScale(basegfx::B3DVector(0.01,0.01,0.01),basegfx::B3DVector(0,0,0),true,0,0.5));
1305     Slide.Operations.push_back(new STranslate(basegfx::B3DVector(-10000, 0, 0),false, 0.5, 2));
1306     maLeavingSlidePrimitives.push_back(Slide);
1307
1308     Slide.Operations.clear();
1309     Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0,0,0),-3000,true,0.5,1));
1310     Slide.Operations.push_back(new STranslate(basegfx::B3DVector(-100, 0, 0),false, -1, 1));
1311     Slide.Operations.push_back(new STranslate(basegfx::B3DVector(100, 0, 0),false, 0.5, 1));
1312     Slide.Operations.push_back(new SScale(basegfx::B3DVector(0.01,0.01,0.01),basegfx::B3DVector(0,0,0),false,-1,1));
1313     Slide.Operations.push_back(new SScale(basegfx::B3DVector(100,100,100),basegfx::B3DVector(0,0,0),true,0.5,1));
1314     maEnteringSlidePrimitives.push_back(Slide);
1315
1316     OverallOperations.push_back(new SRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0.2,0.2,0),1080,true,0,1));
1317 }
1318