slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionImpl.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2008 by Sun Microsystems, Inc.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28 #ifndef INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
  29 #define INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
  30
  31 #include <config_lgpl.h>
  32 #include <glm/glm.hpp>
  33
  34 #include <boost/noncopyable.hpp>
  35 #include <boost/shared_ptr.hpp>
  36
  37 #include <GL/glew.h>
  38
  39 #include <basegfx/vector/b2dvector.hxx>
  40 #include <basegfx/vector/b3dvector.hxx>
  41
  42 #include <vector>
  43
  44 class Primitive;
  45 class Operation;
  46 class SceneObject;
  47 class TransitionData;
  48
  49 struct TransitionSettings
  50 {
  51     TransitionSettings() :
  52         mbUseMipMapLeaving( true ),
  53         mbUseMipMapEntering( true ),
  54         mnRequiredGLVersion( 1.0 ),
  55         mbReflectSlides( false )
  56     {
  57     }
  58
  59     /** Whether to use mipmaping for slides textures
  60      */
  61     bool mbUseMipMapLeaving;
  62     bool mbUseMipMapEntering;
  63
  64     /** which GL version does the transition require
  65      */
  66     float mnRequiredGLVersion;
  67
  68     /** Whether to reflect slides, the reflection happens on flat surface beneath the slides.
  69      ** Now it only works with slides which keep their rectangular shape together.
  70      */
  71     bool mbReflectSlides;
  72 };
  73
  74 typedef std::vector<Primitive> Primitives_t;
  75 typedef std::vector<boost::shared_ptr<SceneObject> > SceneObjects_t;
  76 typedef std::vector<boost::shared_ptr<Operation> > Operations_t;
  77
  78 class TransitionScene
  79 {
  80 public:
  81     TransitionScene()
  82     {
  83     }
  84
  85     TransitionScene(
  86             const Primitives_t& rLeavingSlidePrimitives,
  87             const Primitives_t& rEnteringSlidePrimitives,
  88             const Operations_t& rOverallOperations = Operations_t(),
  89             const SceneObjects_t& rSceneObjects = SceneObjects_t()
  90     )
  91         : maLeavingSlidePrimitives(rLeavingSlidePrimitives)
  92         , maEnteringSlidePrimitives(rEnteringSlidePrimitives)
  93         , maOverallOperations(rOverallOperations)
  94         , maSceneObjects(rSceneObjects)
  95     {
  96     }
  97
  98     TransitionScene(TransitionScene const& rOther);
  99     TransitionScene& operator=(const TransitionScene& rOther);
 100
 101     void swap(TransitionScene& rOther);
 102
 103     const Primitives_t& getLeavingSlide() const
 104     {
 105         return maLeavingSlidePrimitives;
 106     }
 107
 108     const Primitives_t& getEnteringSlide() const
 109     {
 110         return maEnteringSlidePrimitives;
 111     }
 112
 113     const Operations_t& getOperations() const
 114     {
 115         return maOverallOperations;
 116     }
 117
 118     const SceneObjects_t& getSceneObjects() const
 119     {
 120         return maSceneObjects;
 121     }
 122
 123 private:
 124     /** All the primitives that use the leaving slide texture
 125     */
 126     Primitives_t maLeavingSlidePrimitives;
 127
 128     /** All the primitives that use the leaving slide texture
 129     */
 130     Primitives_t maEnteringSlidePrimitives;
 131
 132     /** 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.
 133     */
 134     Operations_t maOverallOperations;
 135
 136     /** All the surrounding scene objects
 137     */
 138     SceneObjects_t maSceneObjects;
 139 };
 140
 141 /** OpenGL 3D Transition class. It implicitly is constructed from XOGLTransition
 142
 143     It holds Primitives and Operations on those primitives.
 144 */
 145 class OGLTransitionImpl : private boost::noncopyable
 146 {
 147 public:
 148     virtual ~OGLTransitionImpl();
 149
 150     /** Prepare transition.
 151       */
 152     void prepare( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex );
 153     /** Display a step of the transition.
 154       */
 155     void display( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight );
 156     /** Clean up after transition.
 157       */
 158     void finish();
 159
 160     TransitionSettings const& getSettings() const
 161     {
 162         return maSettings;
 163     }
 164
 165 protected:
 166     OGLTransitionImpl(const TransitionScene& rScene, const TransitionSettings& rSettings)
 167         : maScene(rScene)
 168         , maSettings(rSettings)
 169     {}
 170
 171     OGLTransitionImpl() {}
 172
 173     TransitionScene const& getScene() const
 174     {
 175         return maScene;
 176     }
 177
 178     void setScene(TransitionScene const& rScene);
 179     // void setSettings(TransitionSettings const& rSettings);
 180
 181     void displaySlide( double nTime, ::sal_Int32 glSlideTex, const Primitives_t& primitives, double SlideWidthScale, double SlideHeightScale );
 182     void displayScene( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight);
 183     void applyOverallOperations( double nTime, double SlideWidthScale, double SlideHeightScale );
 184
 185 private:
 186     /** This function is called in display method to prepare the slides, scene, etc.
 187       *
 188       * Default implementation does nothing.
 189       */
 190     virtual void prepare( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight );
 191
 192     /** This function is called after glx context is ready to let the transition prepare GL related things, like GLSL program.
 193       *
 194       * Default implementation does nothing.
 195       */
 196     virtual void prepareTransition( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex );
 197
 198     /** This function is called when the transition needs to clear after itself, like delete own textures etc.
 199       *
 200       * Default implementation does nothing.
 201       */
 202     virtual void finishTransition();
 203
 204     /** This function is called in display method to display the slides.
 205       *
 206       * Default implementation applies overall operations and then
 207       * displays both slides.
 208       */
 209     virtual void displaySlides_( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale );
 210
 211 private:
 212     TransitionScene maScene;
 213     const TransitionSettings maSettings;
 214 };
 215
 216
 217 // "Constructors" of available transitions
 218 boost::shared_ptr<OGLTransitionImpl> makeOutsideCubeFaceToLeft();
 219 boost::shared_ptr<OGLTransitionImpl> makeInsideCubeFaceToLeft();
 220 boost::shared_ptr<OGLTransitionImpl> makeNByMTileFlip( ::sal_uInt16 n, ::sal_uInt16 m );
 221 boost::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( ::sal_uInt16 nCircles , ::sal_uInt16 nPointsOnCircles );
 222 boost::shared_ptr<OGLTransitionImpl> makeHelix( ::sal_uInt16 nRows );
 223 boost::shared_ptr<OGLTransitionImpl> makeFallLeaving();
 224 boost::shared_ptr<OGLTransitionImpl> makeTurnAround();
 225 boost::shared_ptr<OGLTransitionImpl> makeTurnDown();
 226 boost::shared_ptr<OGLTransitionImpl> makeIris();
 227 boost::shared_ptr<OGLTransitionImpl> makeRochade();
 228 boost::shared_ptr<OGLTransitionImpl> makeVenetianBlinds( bool vertical, int parts );
 229 boost::shared_ptr<OGLTransitionImpl> makeStatic();
 230 boost::shared_ptr<OGLTransitionImpl> makeDissolve();
 231 boost::shared_ptr<OGLTransitionImpl> makeNewsflash();
 232
 233 /** 2D replacements
 234     */
 235 boost::shared_ptr<OGLTransitionImpl> makeDiamond();
 236 boost::shared_ptr<OGLTransitionImpl> makeFadeSmoothly();
 237 boost::shared_ptr<OGLTransitionImpl> makeFadeThroughBlack();
 238
 239 class SceneObject : private boost::noncopyable
 240 {
 241 public:
 242     SceneObject();
 243     virtual ~SceneObject();
 244
 245     virtual void prepare() {}
 246     virtual void display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight) const;
 247     virtual void finish() {}
 248
 249     void pushPrimitive (const Primitive &p);
 250
 251 protected:
 252     /** All the surrounding scene primitives
 253     */
 254     Primitives_t maPrimitives;
 255 };
 256
 257 class Iris : public SceneObject
 258 {
 259 public:
 260     Iris ();
 261
 262     virtual void prepare() SAL_OVERRIDE;
 263     virtual void display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight) const SAL_OVERRIDE;
 264     virtual void finish() SAL_OVERRIDE;
 265
 266 private:
 267     GLuint maTexture;
 268 };
 269
 270 /** This class is a list of Triangles that will share Operations, and could possibly share
 271 */
 272 class Primitive
 273 {
 274 public:
 275     Primitive() {}
 276     // making copy constructor explicit makes the class un-suitable for use with stl containers
 277     Primitive(const Primitive& rvalue);
 278     Primitive& operator=(const Primitive& rvalue);
 279
 280     void swap(Primitive& rOther);
 281
 282     void applyOperations(double nTime, double SlideWidthScale, double SlideHeightScale) const;
 283     void display(double nTime, double SlideWidthScale, double SlideHeightScale) const;
 284
 285     /** 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.
 286
 287     @param SlideLocation0
 288     Location of first Vertex on slide
 289
 290     @param SlideLocation1
 291     Location of second Vertex on slide
 292
 293     @param SlideLocation2
 294     Location of third Vertex on slide
 295
 296     */
 297     void pushTriangle(const glm::vec2& SlideLocation0,const glm::vec2& SlideLocation1,const glm::vec2& SlideLocation2);
 298
 299     /** clear all the vertices, normals, tex coordinates, and normals
 300     */
 301     void clearTriangles();
 302
 303     /** guards against directly changing the vertices
 304
 305         @return
 306         the list of vertices
 307     */
 308     const std::vector<glm::vec3>& getVertices() const {return Vertices;}
 309
 310     /** guards against directly changing the vertices
 311     */
 312     const std::vector<glm::vec3>& getNormals() const {return Normals;}
 313
 314     /** guards against directly changing the vertices
 315
 316         @return
 317         the list of Texture Coordinates
 318
 319     */
 320     const std::vector<glm::vec2>& getTexCoords() const {return TexCoords;}
 321
 322     /** 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.
 323
 324         @return
 325         the list of Operations
 326
 327     */
 328     Operations_t Operations;
 329
 330 private:
 331     /** list of vertices
 332     */
 333     std::vector<glm::vec3> Vertices;
 334
 335     /** list of Normals
 336     */
 337     std::vector<glm::vec3> Normals;
 338
 339     /** list of Texture Coordinates
 340     */
 341     std::vector<glm::vec2> TexCoords;
 342 };
 343
 344 /** This class is to be derived to make any operation (transform) you may need in order to construct your transitions
 345 */
 346 class Operation : private boost::noncopyable
 347 {
 348 public:
 349     virtual ~Operation(){}
 350
 351 protected:
 352     /** 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.
 353     */
 354     bool mbInterpolate;
 355
 356     /** time to begin the transformation
 357     */
 358     double mnT0;
 359
 360     /** time to finish the transformation
 361     */
 362     double mnT1;
 363 public:
 364     /** this is the function that is called to give the Operation to OpenGL.
 365
 366         @param t
 367         time from t = 0 to t = 1
 368
 369         @param SlideWidthScale
 370         width of slide divided by width of window
 371
 372         @param SlideHeightScale
 373         height of slide divided by height of window
 374
 375     */
 376     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const = 0;
 377
 378 protected:
 379     Operation(bool bInterpolate, double nT0, double nT1):
 380         mbInterpolate(bInterpolate), mnT0(nT0), mnT1(nT1){}
 381 };
 382
 383 /** this class is a generic CounterClockWise(CCW) rotation with an axis angle
 384 */
 385 class SRotate: public Operation
 386 {
 387 public:
 388     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 389
 390     /** Constructor
 391
 392         @param Axis
 393         axis to rotate about
 394
 395         @param Origin
 396         position that rotation axis runs through
 397
 398         @param Angle
 399         angle in radians of CCW rotation
 400
 401         @param bInter
 402         see Operation
 403
 404         @param T0
 405         transformation starting time
 406
 407         @param T1
 408         transformation ending time
 409
 410     */
 411     SRotate(const glm::vec3& Axis, const glm::vec3& Origin, double Angle,
 412             bool bInter, double T0, double T1);
 413     virtual ~SRotate(){}
 414 private:
 415     /** axis to rotate CCW about
 416     */
 417     glm::vec3 axis;
 418
 419     /** position that rotation axis runs through
 420     */
 421     glm::vec3 origin;
 422
 423     /** angle in radians of CCW rotation
 424     */
 425     double angle;
 426 };
 427
 428 boost::shared_ptr<SRotate>
 429 makeSRotate(const glm::vec3& Axis, const glm::vec3& Origin, double Angle,
 430         bool bInter, double T0, double T1);
 431
 432 /** scaling transformation
 433 */
 434 class SScale: public Operation
 435 {
 436 public:
 437     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 438
 439     /** Constructor
 440
 441         @param Scale
 442         amount to scale by
 443
 444         @param Origin
 445         position that rotation axis runs through
 446
 447         @param bInter
 448         see Operation
 449
 450         @param T0
 451         transformation starting time
 452
 453         @param T1
 454         transformation ending time
 455
 456     */
 457     SScale(const glm::vec3& Scale, const glm::vec3& Origin,bool bInter, double T0, double T1);
 458     virtual ~SScale(){}
 459 private:
 460     glm::vec3 scale;
 461     glm::vec3 origin;
 462 };
 463
 464 boost::shared_ptr<SScale>
 465 makeSScale(const glm::vec3& Scale, const glm::vec3& Origin,bool bInter, double T0, double T1);
 466
 467 /** translation transformation
 468 */
 469 class STranslate: public Operation
 470 {
 471 public:
 472     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 473
 474     /** Constructor
 475
 476         @param Vector
 477         vector to translate
 478
 479         @param bInter
 480         see Operation
 481
 482         @param T0
 483         transformation starting time
 484
 485         @param T1
 486         transformation ending time
 487
 488     */
 489     STranslate(const glm::vec3& Vector,bool bInter, double T0, double T1);
 490     virtual ~STranslate(){}
 491 private:
 492     /** vector to translate by
 493     */
 494     glm::vec3 vector;
 495 };
 496
 497 boost::shared_ptr<STranslate>
 498 makeSTranslate(const glm::vec3& Vector,bool bInter, double T0, double T1);
 499
 500 /** translation transformation
 501 */
 502 class SEllipseTranslate: public Operation
 503 {
 504 public:
 505     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 506
 507     /** Constructor
 508
 509         @param Vector
 510         vector to translate
 511
 512         @param bInter
 513         see Operation
 514
 515         @param T0
 516         transformation starting time
 517
 518         @param T1
 519         transformation ending time
 520
 521     */
 522     SEllipseTranslate(double dWidth, double dHeight, double dStartPosition, double dEndPosition, bool bInter, double T0, double T1);
 523     virtual ~SEllipseTranslate(){}
 524 private:
 525     /** width and length of the ellipse
 526      */
 527     double width, height;
 528
 529     /** start and end position on the ellipse <0,1>
 530      */
 531     double startPosition;
 532     double endPosition;
 533 };
 534
 535 boost::shared_ptr<SEllipseTranslate>
 536 makeSEllipseTranslate(double dWidth, double dHeight, double dStartPosition, double dEndPosition, bool bInter, double T0, double T1);
 537
 538 /** Same as SRotate, except the depth is scaled by the width of the slide divided by the width of the window.
 539 */
 540 class RotateAndScaleDepthByWidth: public Operation
 541 {
 542 public:
 543     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 544
 545     RotateAndScaleDepthByWidth(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
 546     virtual ~RotateAndScaleDepthByWidth(){}
 547 private:
 548     glm::vec3 axis;
 549     glm::vec3 origin;
 550     double angle;
 551 };
 552
 553 boost::shared_ptr<RotateAndScaleDepthByWidth>
 554 makeRotateAndScaleDepthByWidth(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
 555
 556 /** Same as SRotate, except the depth is scaled by the width of the slide divided by the height of the window.
 557 */
 558 class RotateAndScaleDepthByHeight: public Operation
 559 {
 560 public:
 561     virtual void interpolate(double t,double SlideWidthScale,double SlideHeightScale) const SAL_OVERRIDE;
 562
 563     RotateAndScaleDepthByHeight(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
 564     virtual ~RotateAndScaleDepthByHeight(){}
 565 private:
 566     glm::vec3 axis;
 567     glm::vec3 origin;
 568     double angle;
 569 };
 570
 571 boost::shared_ptr<RotateAndScaleDepthByHeight>
 572 makeRotateAndScaleDepthByHeight(const glm::vec3& Axis,const glm::vec3& Origin,double Angle,bool bInter, double T0, double T1);
 573
 574 #endif // INCLUDED_SLIDESHOW_TRANSITION_HXX_
 575
 576 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */