slideshow/source/engine/OGLTrans/OGLTrans_TransitionImpl.hxx

   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.hxx,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 #ifndef INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
  31 #define INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
  32
  33 #include <basegfx/vector/b2dvector.hxx>
  34 #include <basegfx/vector/b3dvector.hxx>
  35
  36 #include <tools/prewin.h>
  37 #include <tools/postwin.h>
  38
  39 #if defined( WNT )
  40 #include <tools/prewin.h>
  41 #include <tools/postwin.h>
  42 #elif defined( OS2 )
  43 #elif defined( QUARTZ )
  44 #elif defined( UNX )
  45 #endif
  46
  47 #include <vector>
  48 #include <GL/gl.h>
  49
  50 using namespace std;
  51
  52 class Primitive;
  53 class Operation;
  54 class SceneObject;
  55
  56
  57 /** OpenGL 3D Transition class. It implicitly is constructed from XOGLTransition
  58
  59     This class is capable of making itself into many difference transitions. It holds Primitives and Operations on those primitives.
  60 */
  61 class OGLTransitionImpl
  62 {
  63 public:
  64     OGLTransitionImpl() :
  65         mbUseMipMapLeaving( true ),
  66         mbUseMipMapEntering( true ),
  67         mnRequiredGLVersion( 1.0 ),
  68         maLeavingSlidePrimitives(),
  69         maEnteringSlidePrimitives(),
  70         maSceneObjects(),
  71         mbReflectSlides( false ),
  72         mVertexObject( 0 ),
  73         mFragmentObject( 0 ),
  74         mProgramObject( 0 ),
  75         maHelperTexture( 0 ),
  76         mmPrepare( NULL ),
  77         mmPrepareTransition( NULL ),
  78         mmClearTransition( NULL ),
  79         mmDisplaySlides( NULL )
  80     {}
  81
  82     ~OGLTransitionImpl();
  83
  84     void prepare( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex );
  85     void display( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight );
  86     void finish();
  87
  88     void makeOutsideCubeFaceToLeft();
  89     void makeInsideCubeFaceToLeft();
  90     void makeNByMTileFlip( ::sal_uInt16 n, ::sal_uInt16 m );
  91     void makeRevolvingCircles( ::sal_uInt16 nCircles , ::sal_uInt16 nPointsOnCircles );
  92     void makeHelix( ::sal_uInt16 nRows );
  93     void makeFallLeaving();
  94     void makeTurnAround();
  95     void makeTurnDown();
  96     void makeIris();
  97     void makeRochade();
  98     void makeVenetianBlinds( bool vertical, int parts );
  99     void makeStatic();
 100     void makeDissolve();
 101     void makeNewsflash();
 102
 103     /** 2D replacements
 104      */
 105     void makeDiamond();
 106     void makeFadeSmoothly();
 107     void makeFadeThroughBlack();
 108
 109     /** Whether to use mipmaping for slides textures
 110      */
 111     bool mbUseMipMapLeaving;
 112     bool mbUseMipMapEntering;
 113
 114     /** which GL version does the transition require
 115      */
 116     float mnRequiredGLVersion;
 117
 118 private:
 119     /** clears all the primitives and operations
 120     */
 121     void clear();
 122
 123     /** All the primitives that use the leaving slide texture
 124     */
 125     vector<Primitive> maLeavingSlidePrimitives;
 126
 127     /** All the primitives that use the leaving slide texture
 128     */
 129     vector<Primitive> maEnteringSlidePrimitives;
 130
 131     /** All the surrounding scene objects
 132     */
 133     vector<SceneObject*> maSceneObjects;
 134
 135     /** All the operations that should be applied to both leaving and entering slide primitives. 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.
 136     */
 137     vector<Operation*> OverallOperations;
 138
 139     /** Whether to reflect slides, the reflection happens on flat surface beneath the slides.
 140      ** Now it only works with slides which keep their rectangular shape together.
 141      */
 142     bool mbReflectSlides;
 143
 144     /** GLSL objects, shaders and program
 145      */
 146     GLuint mVertexObject, mFragmentObject, mProgramObject;
 147
 148     /** various data */
 149     GLuint maHelperTexture;
 150
 151     /** When this method is not NULL, it is called in display method to prepare the slides, scene, etc.
 152      ** We might later replace this by cleaner derived class.
 153      */
 154     void (OGLTransitionImpl::*mmPrepare)( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight );
 155
 156     /** When this method is not NULL, it is called after glx context is ready to let the transition prepare GL related things, like GLSL program.
 157      ** We might later replace this by cleaner derived class.
 158      */
 159     void (OGLTransitionImpl::*mmPrepareTransition)( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex );
 160
 161     /** When this method is not NULL, it is called when the transition needs to clear after itself, like delete own textures etc.
 162      ** We might later replace this by cleaner derived class.
 163      */
 164     void (OGLTransitionImpl::*mmClearTransition)();
 165
 166     /** When this method is not NULL, it is called in display method to display the slides.
 167      ** We might later replace this by cleaner derived class.
 168      */
 169     void (OGLTransitionImpl::*mmDisplaySlides)( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 170
 171     void displaySlides( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 172     void displaySlide( double nTime, ::sal_Int32 glSlideTex, std::vector<Primitive>& primitives, double SlideWidthScale, double SlideHeightScale );
 173     void displayScene( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight);
 174     void applyOverallOperations( double nTime, double SlideWidthScale, double SlideHeightScale );
 175
 176     /** various transitions helper methods
 177      */
 178     void prepareDiamond( double nTime, double SlideWidth, double SlideHeight,double DispWidth, double DispHeight );
 179     void displaySlidesFadeSmoothly( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 180         void displaySlidesFadeThroughBlack( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 181         void displaySlidesRochade( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 182     void displaySlidesShaders( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 183     void prepareStatic( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex );
 184     void prepareDissolve( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex );
 185     void preparePermShader();
 186 };
 187
 188 class SceneObject
 189 {
 190 public:
 191     SceneObject();
 192
 193     virtual void prepare() {};
 194     virtual void display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight);
 195     virtual void finish() {};
 196
 197     void pushPrimitive (const Primitive &p);
 198
 199 protected:
 200     /** All the surrounding scene primitives
 201     */
 202     vector<Primitive> maPrimitives;
 203 };
 204
 205 class Iris : public SceneObject
 206 {
 207 public:
 208     Iris ();
 209
 210     virtual void prepare();
 211     virtual void display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight);
 212     virtual void finish();
 213
 214 private:
 215
 216     GLuint maTexture;
 217 };
 218
 219 /** This class is a list of Triangles that will share Operations, and could possibly share
 220 */
 221 class Primitive
 222 {
 223 public:
 224     Primitive() {}
 225     // making copy constructor explicit makes the class un-suitable for use with stl containers
 226     Primitive(const Primitive& rvalue);
 227     ~Primitive();
 228
 229     void applyOperations(double nTime, double SlideWidthScale, double SlideHeightScale);
 230     void display(double nTime, double SlideWidthScale, double SlideHeightScale);
 231     const Primitive& operator=(const Primitive& rvalue);
 232
 233     /** PushBack a vertex,normal, and tex coord. Each SlideLocation is where on the slide is mapped to this location ( from (0,0) to (1,1)  ). This will make sure the correct aspect ratio is used, and helps to make slides begin and end at the correct position. (0,0) is the top left of the slide, and (1,1) is the bottom right.
 234
 235     @param SlideLocation0
 236     Location of first Vertex on slide
 237
 238     @param SlideLocation1
 239     Location of second Vertex on slide
 240
 241     @param SlideLocation2
 242     Location of third Vertex on slide
 243
 244     */
 245     void pushTriangle(const basegfx::B2DVector& SlideLocation0,const basegfx::B2DVector& SlideLocation1,const basegfx::B2DVector& SlideLocation2);
 246
 247     /** clear all the vertices, normals, tex coordinates, and normals
 248     */
 249     void clearTriangles();
 250
 251     /** guards against directly changing the vertices
 252
 253         @return
 254         the list of vertices
 255     */
 256     const vector<basegfx::B3DVector>& getVertices() const {return Vertices;}
 257
 258     /** guards against directly changing the vertices
 259     */
 260     const vector<basegfx::B3DVector>& getNormals() const {return Normals;}
 261
 262     /** guards against directly changing the vertices
 263
 264         @return
 265         the list of Texture Coordinates
 266
 267     */
 268     const vector<basegfx::B2DVector>& getTexCoords() const {return TexCoords;}
 269
 270     /** 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.
 271
 272         @return
 273         the list of Operations
 274
 275     */
 276     vector<Operation*> Operations;
 277
 278 private:
 279     /** list of vertices
 280     */
 281     vector<basegfx::B3DVector> Vertices;
 282
 283     /** list of Normals
 284     */
 285     vector<basegfx::B3DVector> Normals;
 286
 287     /** list of Texture Coordinates
 288     */
 289     vector<basegfx::B2DVector> TexCoords;
 290 };
 291
 292 /** This class is to be derived to make any operation (tranform) you may need in order to construct your transitions
 293 */
 294 class Operation
 295 {
 296 public:
 297     Operation(){}
 298     virtual ~Operation(){}
 299
 300     /** 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.
 301     */
 302     bool bInterpolate;
 303
 304     /** time to begin the transformation
 305     */
 306     double nT0;
 307
 308     /** time to finish the transformation
 309     */
 310     double nT1;
 311 public:
 312     /** this is the function that is called to give the Operation to OpenGL.
 313
 314         @param t
 315         time from t = 0 to t = 1
 316
 317         @param SlideWidthScale
 318         width of slide divided by width of window
 319
 320         @param SlideHeightScale
 321         height of slide divided by height of window
 322
 323     */
 324     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) = 0;
 325
 326     /** return a copy of this operation
 327     */
 328     virtual Operation* clone() = 0;
 329 };
 330
 331 /** this class is a generic CounterClockWise(CCW) rotation with an axis angle
 332 */
 333 class SRotate: public Operation
 334 {
 335 public:
 336     void interpolate(double t,double SlideWidthScale,double SlideHeightScale);
 337     virtual SRotate* clone();
 338
 339     /** Constructor
 340
 341         @param Axis
 342         axis to rotate about
 343
 344         @param Origin
 345         position that rotation axis runs through
 346
 347         @param Angle
 348         angle in radians of CCW rotation
 349
 350         @param bInter
 351         see Operation
 352
 353         @param T0
 354         transformation starting time
 355
 356         @param T1
 357         transformation ending time
 358
 359     */
 360     SRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
 361     ~SRotate(){}
 362 private:
 363     /** axis to rotate CCW about
 364     */
 365     basegfx::B3DVector axis;
 366
 367     /** position that rotation axis runs through
 368     */
 369     basegfx::B3DVector origin;
 370
 371     /** angle in radians of CCW rotation
 372     */
 373     double angle;
 374 };
 375
 376 /** scaling transformation
 377 */
 378 class SScale: public Operation
 379 {
 380 public:
 381     void interpolate(double t,double SlideWidthScale,double SlideHeightScale);
 382     SScale* clone();
 383
 384     /** Constructor
 385
 386         @param Scale
 387         amount to scale by
 388
 389         @param Origin
 390         position that rotation axis runs through
 391
 392         @param bInter
 393         see Operation
 394
 395         @param T0
 396         transformation starting time
 397
 398         @param T1
 399         transformation ending time
 400
 401     */
 402     SScale(const basegfx::B3DVector& Scale, const basegfx::B3DVector& Origin,bool bInter, double T0, double T1);
 403     ~SScale(){}
 404 private:
 405     basegfx::B3DVector scale;
 406     basegfx::B3DVector origin;
 407 };
 408
 409 /** translation transformation
 410 */
 411 class STranslate: public Operation
 412 {
 413 public:
 414     void interpolate(double t,double SlideWidthScale,double SlideHeightScale);
 415     STranslate* clone();
 416
 417     /** Constructor
 418
 419         @param Vector
 420         vector to translate
 421
 422         @param bInter
 423         see Operation
 424
 425         @param T0
 426         transformation starting time
 427
 428         @param T1
 429         transformation ending time
 430
 431     */
 432     STranslate(const basegfx::B3DVector& Vector,bool bInter, double T0, double T1);
 433     ~STranslate(){}
 434 private:
 435     /** vector to translate by
 436     */
 437     basegfx::B3DVector vector;
 438 };
 439
 440 /** translation transformation
 441 */
 442 class SEllipseTranslate: public Operation
 443 {
 444 public:
 445     void interpolate(double t,double SlideWidthScale,double SlideHeightScale);
 446     SEllipseTranslate* clone();
 447
 448     /** Constructor
 449
 450         @param Vector
 451         vector to translate
 452
 453         @param bInter
 454         see Operation
 455
 456         @param T0
 457         transformation starting time
 458
 459         @param T1
 460         transformation ending time
 461
 462     */
 463     SEllipseTranslate(double dWidth, double dHeight, double dStartPosition, double dEndPosition, bool bInter, double T0, double T1);
 464     ~SEllipseTranslate(){}
 465 private:
 466     /** width and length of the ellipse
 467      */
 468     double width, height;
 469
 470     /** start and end position on the ellipse <0,1>
 471      */
 472     double startPosition;
 473     double endPosition;
 474 };
 475
 476 /** Same as SRotate, except the depth is scaled by the width of the slide divided by the width of the window.
 477 */
 478 class RotateAndScaleDepthByWidth: public Operation
 479 {
 480 public:
 481     void interpolate(double t,double SlideWidthScale,double SlideHeightScale);
 482     RotateAndScaleDepthByWidth* clone();
 483
 484     RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
 485     ~RotateAndScaleDepthByWidth(){}
 486 private:
 487     basegfx::B3DVector axis;
 488     basegfx::B3DVector origin;
 489     double angle;
 490 };
 491
 492 /** Same as SRotate, except the depth is scaled by the width of the slide divided by the height of the window.
 493 */
 494 class RotateAndScaleDepthByHeight: public Operation
 495 {
 496 public:
 497     void interpolate(double t,double SlideWidthScale,double SlideHeightScale);
 498     RotateAndScaleDepthByHeight* clone();
 499
 500     RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle,bool bInter, double T0, double T1);
 501     ~RotateAndScaleDepthByHeight(){}
 502 private:
 503     basegfx::B3DVector axis;
 504     basegfx::B3DVector origin;
 505     double angle;
 506 };
 507
 508 #endif // INCLUDED_SLIDESHOW_TRANSITION_HXX_
 509