slideshow/source/inc/box2dtools.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #pragma once
  11
  12 #include "shape.hxx"
  13 #include "shapeattributelayer.hxx"
  14 #include "attributemap.hxx"
  15 #include <unordered_map>
  16 #include <queue>
  17
  18 class b2Body;
  19 class b2World;
  20
  21 namespace slideshow::internal
  22 {
  23 class ShapeManager;
  24 typedef std::shared_ptr<ShapeManager> ShapeManagerSharedPtr;
  25 }
  26
  27 namespace box2d::utils
  28 {
  29 class box2DBody;
  30 class box2DWorld;
  31 typedef std::shared_ptr<box2DWorld> Box2DWorldSharedPtr;
  32 typedef std::shared_ptr<box2DBody> Box2DBodySharedPtr;
  33
  34 enum box2DBodyType
  35 {
  36     BOX2D_STATIC_BODY = 0,
  37     BOX2D_KINEMATIC_BODY,
  38     BOX2D_DYNAMIC_BODY
  39 };
  40
  41 enum box2DNonsimulatedShapeUpdateType
  42 {
  43     BOX2D_UPDATE_POSITION_CHANGE,
  44     BOX2D_UPDATE_POSITION,
  45     BOX2D_UPDATE_ANGLE,
  46     BOX2D_UPDATE_SIZE,
  47     BOX2D_UPDATE_VISIBILITY,
  48     BOX2D_UPDATE_LINEAR_VELOCITY,
  49     BOX2D_UPDATE_ANGULAR_VELOCITY
  50 };
  51
  52 /// Holds required information to perform an update to box2d
  53 /// body of a shape that was altered by an animation effect
  54 struct Box2DDynamicUpdateInformation
  55 {
  56     /// reference to the shape that the update belongs to
  57     css::uno::Reference<css::drawing::XShape> mxShape;
  58     union {
  59         ::basegfx::B2DPoint maPosition;
  60         ::basegfx::B2DVector maVelocity;
  61         double mfAngle;
  62         double mfAngularVelocity;
  63         bool mbVisibility;
  64     };
  65     box2DNonsimulatedShapeUpdateType meUpdateType;
  66     /// amount of steps to delay the update for
  67     int mnDelayForSteps = 0;
  68 };
  69
  70 /** Class that manages the Box2D World
  71
  72     This class is used when there's a physics animation going on,
  73     it handles the stepping through the box2d world, updating the
  74     shapes in the box2d world if they were changed by ongoing animations.
  75  */
  76 class box2DWorld
  77 {
  78 private:
  79     /// Pointer to the real Box2D World that this class manages
  80     std::unique_ptr<b2World> mpBox2DWorld;
  81     /// Scale factor for conversions between LO user space coordinates to Box2D World coordinates
  82     double mfScaleFactor;
  83     bool mbShapesInitialized;
  84     /// Holds whether or not there is a PhysicsAnimation that
  85     /// is stepping the Box2D World. Used to create a lock mechanism
  86     bool mbHasWorldStepper;
  87     /// Flag used to stop overstepping that occurs when a physics
  88     /// animation effect transfers step-lock to another one.
  89     bool mbAlreadyStepped;
  90     /// Number of Physics Animations going on
  91     int mnPhysicsAnimationCounter;
  92     std::unordered_map<css::uno::Reference<css::drawing::XShape>, Box2DBodySharedPtr>
  93         mpXShapeToBodyMap;
  94
  95     /** Queue that holds any required information to keep LO animation effects
  96         and Box2DWorld in sync
  97
  98         Is processed before every step of the box2d world by processUpdateQueue.
  99         Holds position, rotation, visibility etc. changes and associated values.
 100      */
 101     std::queue<Box2DDynamicUpdateInformation> maShapeParallelUpdateQueue;
 102
 103     /// Creates a static frame in Box2D world that corresponds to the slide borders
 104     void createStaticFrameAroundSlide(const ::basegfx::B2DVector& rSlideSize);
 105
 106     /** Sets shape's corresponding Box2D body to the specified position
 107
 108         Body is teleported to the specified position, not moved
 109
 110         @param xShape
 111         Shape reference
 112
 113         @param rOutPos
 114         Position in LO user space coordinates
 115      */
 116     void setShapePosition(const css::uno::Reference<css::drawing::XShape>& xShape,
 117                           const ::basegfx::B2DPoint& rOutPos);
 118
 119     /** Moves shape's corresponding Box2D body to specified position
 120
 121         Moves shape's corresponding Box2D body to specified position as if
 122         the body had velocity to reach that point in given time frame.
 123
 124         @param xShape
 125         Shape reference
 126
 127         @param rOutPos
 128         Position in LO user space coordinates
 129
 130         @param fPassedTime
 131         Time frame which the Box2D body should move to the specified position.
 132      */
 133     void setShapePositionByLinearVelocity(const css::uno::Reference<css::drawing::XShape>& xShape,
 134                                           const ::basegfx::B2DPoint& rOutPos,
 135                                           const double fPassedTime);
 136
 137     /** Sets linear velocity of the shape's corresponding Box2D body
 138
 139         Moves shape's corresponding Box2D body to specified position as if
 140         the body had velocity to reach that point in given time frame.
 141
 142         @param xShape
 143         Shape reference
 144
 145         @param rVelocity
 146         Velocity vector in LO user space coordinates.
 147      */
 148     void setShapeLinearVelocity(const css::uno::Reference<css::drawing::XShape>& xShape,
 149                                 const basegfx::B2DVector& rVelocity);
 150
 151     /** Sets rotation angle of the shape's corresponding Box2D body
 152
 153         @param xShape
 154         Shape reference
 155
 156         @param fAngle
 157         Angle of rotation in degrees.
 158      */
 159     void setShapeAngle(const css::uno::Reference<css::drawing::XShape>& xShape,
 160                        const double fAngle);
 161
 162     /** Rotates shape's corresponding Box2D body to specified angle
 163
 164         Rotates the Box2D body to specified angle as if the body
 165         had exact angular velocity to reach that point in given
 166         time frame
 167
 168         @param xShape
 169         Shape reference
 170
 171         @param fAngle
 172         Angle of rotation in degrees.
 173
 174         @param fPassedTime
 175         Time frame which the Box2D body should rotate to the specified angle.
 176      */
 177     void setShapeAngleByAngularVelocity(const css::uno::Reference<css::drawing::XShape>& xShape,
 178                                         const double fAngle, const double fPassedTime);
 179
 180     /** Sets angular velocity of the shape's corresponding Box2D body.
 181
 182         @param xShape
 183         Shape reference
 184
 185         @param fAngularVelocity
 186         Angular velocity in degrees per second.
 187      */
 188     void setShapeAngularVelocity(const css::uno::Reference<css::drawing::XShape>& xShape,
 189                                  const double fAngularVelocity);
 190
 191     /** Sets whether a shape's corresponding Box2D body has collision in the Box2D World or not
 192
 193         Used for animations that change the visibility of the shape.
 194
 195         @param xShape
 196         Shape reference
 197
 198         @param bCanCollide
 199         true if collisions should be enabled for the corresponding Box2D body of this shape
 200         and false if it should be disabled.
 201     */
 202     void setShapeCollision(const css::uno::Reference<css::drawing::XShape>& xShape,
 203                            const bool bCanCollide);
 204
 205     /** Process the updates queued in the maShapeParallelUpdateQueue
 206
 207         Called on each step of the box2DWorld.
 208
 209         @param fPassedTime
 210         Time frame to process the updates accordingly (needed for proper simulations)
 211      */
 212     void processUpdateQueue(const double fPassedTime);
 213
 214     /** Simulate and step through time in the Box2D World
 215
 216         Used in stepAmount
 217
 218         @attention fTimeStep should not vary.
 219      */
 220     void step(const float fTimeStep = 1.0f / 100.0f, const int nVelocityIterations = 6,
 221               const int nPositionIterations = 2);
 222
 223     /// Queue a rotation update that is simulated as if shape's corresponding box2D body rotated to given angle when processed
 224     void queueDynamicRotationUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 225                                     const double fAngle);
 226
 227     /// Queue an angular velocity update that sets the shape's corresponding box2D body angular velocity to the given value when processed
 228     void queueAngularVelocityUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 229                                     const double fAngularVelocity, const int nDelayForSteps = 0);
 230
 231     /// Queue an collision update that sets the collision of shape's corresponding box2D body when processed
 232     void queueShapeVisibilityUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 233                                     const bool bVisibility);
 234
 235     void queueShapePositionUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 236                                   const ::basegfx::B2DPoint& rOutPos);
 237
 238 public:
 239     box2DWorld(const ::basegfx::B2DVector& rSlideSize);
 240     ~box2DWorld();
 241
 242     bool initiateWorld(const ::basegfx::B2DVector& rSlideSize);
 243
 244     /** Simulate and step through a given amount of time in the Box2D World
 245
 246         @param fPassedTime
 247         Amount of time to step through
 248
 249         @return Amount of time actually stepped through, since it is possible
 250         to only step through a multiple of fTimeStep
 251
 252         @attention fTimeStep should not vary.
 253     */
 254     double stepAmount(const double fPassedTime, const float fTimeStep = 1.0f / 100.0f,
 255                       const int nVelocityIterations = 6, const int nPositionIterations = 2);
 256
 257     /// @return whether shapes in the slide are initialized as Box2D bodies or not
 258     bool shapesInitialized();
 259     /// @return whether the Box2D World is initialized or not
 260     bool isInitialized() const;
 261
 262     /** Make the shape's corresponding box2D body a dynamic one.
 263
 264         A dynamic body will be affected by other bodies and the gravity.
 265
 266         @param xShape
 267         Shape reference
 268
 269         @param rStartVelocity
 270         Velocity of the shape after making it dynamic
 271
 272         @param fDensity
 273         Density of the body that is in kg/m^2
 274
 275         @param fBounciness
 276         Bounciness of the body that is usually in between [0,1].
 277         Even though it could take values that are >1, it is way too chaotic.
 278
 279         @return box2d body pointer
 280      */
 281     Box2DBodySharedPtr makeShapeDynamic(const css::uno::Reference<css::drawing::XShape>& xShape,
 282                                         const basegfx::B2DVector& rStartVelocity,
 283                                         const double fDensity, const double fBounciness);
 284
 285     /** Make the Box2D body corresponding to the given shape a static one
 286
 287         A static body will not be affected by other bodies and the gravity. But will
 288         affect other bodies that are dynamic (will still collide with them but won't
 289         move etc.)
 290
 291         @param pShape
 292         Pointer to the shape to alter the corresponding Box2D body of
 293
 294         @return box2d body pointer
 295      */
 296     Box2DBodySharedPtr makeShapeStatic(const slideshow::internal::ShapeSharedPtr& pShape);
 297
 298     /** Create a static body that is represented by the shape's geometry
 299
 300         @return pointer to the box2d body
 301      */
 302     Box2DBodySharedPtr createStaticBody(const slideshow::internal::ShapeSharedPtr& rShape,
 303                                         const float fDensity = 1.0f, const float fFriction = 0.3f);
 304
 305     /// Initiate all the shapes in the current slide in the box2DWorld as static ones
 306     void initiateAllShapesAsStaticBodies(
 307         const slideshow::internal::ShapeManagerSharedPtr& pShapeManager);
 308
 309     /// @return whether the box2DWorld has a stepper or not
 310     bool hasWorldStepper() const;
 311
 312     /// Set the flag for whether the box2DWorld has a stepper or not
 313     void setHasWorldStepper(const bool bHasWorldStepper);
 314
 315     /// Queue a position update that is simulated as if shape's corresponding box2D body moved to given position when processed
 316     void queueDynamicPositionUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 317                                     const ::basegfx::B2DPoint& rOutPos);
 318
 319     /// Queue a update that sets the corresponding box2D body's linear velocity to the given value when processed
 320     void queueLinearVelocityUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 321                                    const ::basegfx::B2DVector& rVelocity,
 322                                    const int nDelayForSteps = 0);
 323
 324     /// Queue an appropriate update for the animation effect that is in parallel with a physics animation
 325     void
 326     queueShapeAnimationUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 327                               const slideshow::internal::ShapeAttributeLayerSharedPtr& pAttrLayer,
 328                               const slideshow::internal::AttributeType eAttrType,
 329                               const bool bIsFirstUpdate);
 330
 331     /// Queue an appropriate update for a path animation that is in parallel with a physics animation
 332     void queueShapePathAnimationUpdate(
 333         const css::uno::Reference<css::drawing::XShape>& xShape,
 334         const slideshow::internal::ShapeAttributeLayerSharedPtr& pAttrLayer,
 335         const bool bIsFirstUpdate);
 336
 337     /// Queue an appropriate update for the animation effect that just ended
 338     void queueShapeAnimationEndUpdate(const css::uno::Reference<css::drawing::XShape>& xShape,
 339                                       const slideshow::internal::AttributeType eAttrType);
 340
 341     /** Alert that a physics animation effect has ended
 342
 343         Makes the given shape static, if this was the last physics animation effect
 344         that was in parallel, box2d bodies that are owned by the mpXShapeToBodyMap
 345         are dumped and potentially destroyed.
 346
 347         @attention the box2d body owned by the PhysicsAnimation won't be destroyed.
 348      */
 349     void alertPhysicsAnimationEnd(const slideshow::internal::ShapeSharedPtr& pShape);
 350
 351     /** Alert that a physics animation effect has started
 352
 353         Initiates the box2D world if it is not initiated yet, and likewise constructs
 354         box2d bodies for the shapes in the current slide if they are not constructed.
 355      */
 356     void
 357     alertPhysicsAnimationStart(const ::basegfx::B2DVector& rSlideSize,
 358                                const slideshow::internal::ShapeManagerSharedPtr& pShapeManager);
 359 };
 360
 361 /// Class that manages a single box2D Body
 362 class box2DBody
 363 {
 364 private:
 365     /// Pointer to the body that this class manages
 366     std::shared_ptr<b2Body> mpBox2DBody;
 367     /// Scale factor for conversions between LO user space coordinates to Box2D World coordinates
 368     double mfScaleFactor;
 369
 370 public:
 371     box2DBody(std::shared_ptr<b2Body> pBox2DBody, double fScaleFactor);
 372
 373     /// @return current position in LO user space coordinates
 374     ::basegfx::B2DPoint getPosition() const;
 375
 376     /** Set the position of box2d body
 377
 378         @param rPos
 379         Position in LO user space coordinates
 380      */
 381     void setPosition(const ::basegfx::B2DPoint& rPos);
 382
 383     /** Moves body to the specified position
 384
 385         Moves body to the specified position by setting velocity of
 386         the body so that it reaches to rDesiredPos in given time fram
 387
 388         @param rDesiredPos
 389         Position to arrive in the time frame
 390
 391         @param fPassedTime
 392         Amount of time for the movement to take place
 393      */
 394     void setPositionByLinearVelocity(const ::basegfx::B2DPoint& rDesiredPos,
 395                                      const double fPassedTime);
 396
 397     /** Sets linear velocity of the body
 398
 399         @param rVelocity
 400         Velocity vector in LO user space coordinates
 401      */
 402     void setLinearVelocity(const ::basegfx::B2DVector& rVelocity);
 403
 404     /** Rotate body to specified angle of rotation
 405
 406         Rotates body to specified rotation as if the body had
 407         angular velocity to reach that state in given time frame
 408
 409         @param fDesiredAngle
 410         Rotation angle in degrees to arrive in the time frame
 411
 412         @param fPassedTime
 413         Amount of time for the movement to take place
 414      */
 415     void setAngleByAngularVelocity(const double fDesiredAngle, const double fPassedTime);
 416
 417     /** Sets angular velocity of the body
 418
 419         @param fAngularVelocity
 420         Angular velocity in degrees per second
 421      */
 422     void setAngularVelocity(const double fAngularVelocity);
 423
 424     /// Sets whether the body have collisions or not
 425     void setCollision(const bool bCanCollide);
 426
 427     /// @return current angle of rotation of the body
 428     double getAngle() const;
 429
 430     /** Set angle of the box2d body
 431
 432         @param fAngle
 433         Angle in degrees
 434      */
 435     void setAngle(const double fAngle);
 436
 437     /** Set density and restitution of the box2d body
 438
 439         @param fDensity
 440         Density in kg/m^2
 441
 442         @param fRestitution
 443         Restitution (elasticity) coefficient, usually in the range [0,1]
 444      */
 445     void setDensityAndRestitution(const double fDensity, const double fRestitution);
 446
 447     /** Set restitution of the box2d body
 448
 449         @param fRestitution
 450         Restitution (elasticity) coefficient, usually in the range [0,1]
 451      */
 452     void setRestitution(const double fRestitution);
 453
 454     /// Set type of the body
 455     void setType(box2DBodyType eType);
 456
 457     /// @return type of the body
 458     box2DBodyType getType() const;
 459 };
 460
 461 /** Make the Box2D body a dynamic one
 462
 463     A dynamic body will be affected by other bodies and the gravity.
 464
 465     @param pBox2DBody
 466     Pointer to the Box2D body
 467  */
 468 Box2DBodySharedPtr makeBodyDynamic(const Box2DBodySharedPtr& pBox2DBody);
 469
 470 /** Make the Box2D body a static one
 471
 472     A static body will not be affected by other bodies and the gravity.
 473
 474     @param pBox2DBody
 475     Pointer to the Box2D body
 476  */
 477 Box2DBodySharedPtr makeBodyStatic(const Box2DBodySharedPtr& pBox2DBody);
 478 }
 479
 480 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */