Merge lp:~smspillaz/compiz/compiz.simple-animations-returns into lp:compiz/0.9.12

[Sam Spilsbury]

simple-animations: import plugin

Re-import the simple-animations plugin (thanks MC Return!)

[Marco Trevisan (Treviño) (3v1n0)]

Same here: add this to debian/compiz-plugins.install file as well.

[Sam Spilsbury (smspillaz)]

Done

[Marco Trevisan (Treviño) (3v1n0)]

Ouch no... The basename is animationsim.{xml,so}

review: Needs Fixing

[Sam Spilsbury (smspillaz)]

D'oh, of course, how could I forget

[lp:~smspillaz/compiz/compiz.simple-animations-returns]

4025. By Sam Spilsbury <email address hidden> on 2016-05-30

Merge lp:compiz

[Sam Spilsbury (smspillaz)]

These all need to be resubmitted to lp:compiz anyway

review: Resubmit

Unmerged revisions

4025. By Sam Spilsbury <email address hidden> on 2016-05-30

Merge lp:compiz

4024. By Sam Spilsbury <email address hidden> on 2016-05-26

debian: Add simple-animations to compiz-plugins

4023. By Sam Spilsbury <email address hidden> on 2016-05-24

simple-animations: Add and merge the simple-animations plugin

(Thanks MC-Return!)

4022. By Sam Spilsbury <email address hidden> on 2016-05-23

CMakeLists: Enable building animationaddon

4021. By Sam Spilsbury <email address hidden> on 2016-05-23

animationaddon: Provide damage box for dissolveAnim

4020. By Sam Spilsbury <email address hidden> on 2016-05-23

animationaddon: Use opacity which actually fades out for dissolve.

4019. By Sam Spilsbury <email address hidden> on 2016-05-23

animationaddon: Port the animationaddon plugin to use modern GL API.

This involved a lot of changes:
 - Removal of glPush/glPop. State is assumed to be off in newer versions
   of compiz, so switch off whatever gets switched on.
 - Switch from glVertexPointer/glDrawArrays/glDrawElements to GLVertexBuffer
 - Changes in primitive assembly: GL_POLYGON doesn't exist in GLES
   so switch to using GL_TRIANGLES. This meant that the indices
   for all the animatons needed to be re-tesselated. That was done
   by hand using a winding rule which just duplicates the first and
   third vertex around the fourth.
 - Dropping of glTexEnv calls.
 - Reworking of the depth test, since writes to the depth buffer
   have been disabled by default.

Some things still don't work:
 - Anything depending on clipping planes: glClipPlane and friends
   were removed on GLES20 and they are quite difficult to implement
   using other methods.
 - Drawing of decoration textures - these appear to be stretched
   and skewed incorrectly.
 - Lighting. This will require special shaders.

4018. By Sam Spilsbury <email address hidden> on 2016-05-23

animation: Just set values in paint attrib directly

4017. By Sam Spilsbury <email address hidden> on 2016-05-23

animation: Expose drawGeometry function again

Since glDrawGeometry was dropped post GLES, this function mirrors
glDrawTexture and allows animations to specify their own complete
replacement for it.

4016. By Sam Spilsbury <email address hidden> on 2016-05-23

animation: Reset the glPaint index each time it is called in MultiAnim

Before we were allowing the wrapable function handler to reset
the index, which means that each copy of the animation had
different behaviour.

=== modified file 'debian/compiz-plugins.install'
--- debian/compiz-plugins.install	2016-05-13 09:45:31 +0000
+++ debian/compiz-plugins.install	2016-05-30 14:34:38 +0000
@@ -2,6 +2,8 @@
 usr/share/compiz/*addhelper.*
 usr/lib/*/compiz/*annotate.*
 usr/share/compiz/*annotate.*
+usr/lib/*/compiz/*animationsim.*
+usr/share/compiz/*animationsim.*
 usr/lib/*/compiz/*bench.*
 usr/share/compiz/*bench.*
 usr/lib/*/compiz/*blur.*

=== modified file 'debian/compiz-plugins.install.armel'
--- debian/compiz-plugins.install.armel	2014-12-02 14:42:34 +0000
+++ debian/compiz-plugins.install.armel	2016-05-30 14:34:38 +0000
@@ -2,6 +2,8 @@
 usr/share/compiz/*addhelper.*
 usr/lib/*/compiz/*annotate.*
 usr/share/compiz/*annotate.*
+usr/lib/*/compiz/*animationsim.*
+usr/share/compiz/*animationsim.*
 usr/lib/*/compiz/*clone.*
 usr/share/compiz/*clone.*
 usr/lib/*/compiz/*crashhandler.*

=== modified file 'debian/compiz-plugins.install.armhf'
--- debian/compiz-plugins.install.armhf	2014-12-02 14:42:34 +0000
+++ debian/compiz-plugins.install.armhf	2016-05-30 14:34:38 +0000
@@ -2,6 +2,8 @@
 usr/share/compiz/*addhelper.*
 usr/lib/*/compiz/*annotate.*
 usr/share/compiz/*annotate.*
+usr/lib/*/compiz/*animationsim.*
+usr/share/compiz/*animationsim.*
 usr/lib/*/compiz/*clone.*
 usr/share/compiz/*clone.*
 usr/lib/*/compiz/*crashhandler.*

=== added directory 'plugins/simple-animations'
=== added file 'plugins/simple-animations/CMakeLists.txt'
--- plugins/simple-animations/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/CMakeLists.txt	2016-05-30 14:34:38 +0000
@@ -0,0 +1,8 @@
+find_package (Compiz REQUIRED)
+
+include (FindOpenGL)
+include (CompizPlugin)
+
+if (OPENGL_GLU_FOUND)
+    compiz_plugin (animationsim PLUGINDEPS composite opengl animation LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
+endif (OPENGL_GLU_FOUND)

=== added file 'plugins/simple-animations/animationsim.xml.in'
--- plugins/simple-animations/animationsim.xml.in	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/animationsim.xml.in	2016-05-30 14:34:38 +0000
@@ -0,0 +1,235 @@
+<compiz>
+  <plugin name="animationsim" useBcop="true">
+    <_short>Simple Animations</_short>
+    <_long>Animations that are simple on the eye</_long>
+    <category>Effects</category>
+    <deps>
+	<requirement>
+	    <plugin>animation</plugin>
+	</requirement>
+	<relation type="after">
+	    <plugin>animation</plugin>
+	</relation>
+    </deps>
+    <options>
+
+      <group>
+	<_short>Effect Settings</_short>
+
+	<subgroup>
+	  <_short>Fly In</_short>
+	  <option name="flyin_direction" type="int">
+	    <_short>Fly In Direction</_short>
+	    <_long>The direction in which the fly in should take place</_long>
+	    <default>0</default>
+	    <desc>
+		<value>0</value>
+		<name>Up</name>
+	    </desc>
+	    <desc>
+		<value>1</value>
+		<name>Left</name>
+	    </desc>
+	    <desc>
+		<value>2</value>
+		<name>Down</name>
+	    </desc>
+	    <desc>
+		<value>3</value>
+		<name>Right</name>
+	    </desc>
+	    <desc>
+		<value>4</value>
+		<name>User Defined</name>
+	    </desc>
+	    <min>0</min>
+	    <max>4</max>
+	  </option>
+	  <option name="flyin_direction_x" type="float">
+	    <_short>UD Direction X</_short>
+	    <_long>Direction and Distance X for user defined fly in</_long>
+	    <default>0</default>
+	    <min>-1000</min>
+	    <max>1000</max>
+		<precision>0.01</precision>
+	  </option>
+	  <option name="flyin_direction_y" type="float">
+	    <_short>UD Direction Y</_short>
+	    <_long>Direction and Distance Y for user defined fly in</_long>
+	    <default>0</default>
+	    <min>-1000</min>
+	    <max>1000</max>
+		<precision>0.01</precision>
+	  </option>
+	  <option name="flyin_fade" type="bool">
+	    <_short>Fade</_short>
+	    <_long>Fade when flying in</_long>
+	    <default>True</default>
+	  </option>
+	  <option name="flyin_distance" type="float">
+	    <_short>Distance</_short>
+	    <_long>Distance to fly in</_long>
+	    <default>20</default>
+	    <min>5</min>
+	    <max>1000</max>
+		<precision>0.01</precision>
+	  </option>
+	</subgroup>
+	<subgroup>
+	  <_short>Rotate In</_short>
+	  <option name="rotatein_direction" type="int">
+	    <_short>Rotate In Direction</_short>
+	    <_long>The direction in which the window rotates</_long>
+	    <default>3</default>
+	    <desc>
+		<value>1</value>
+		<name>Up</name>
+	    </desc>
+	    <desc>
+		<value>2</value>
+		<name>Left</name>
+	    </desc>
+	    <desc>
+		<value>3</value>
+		<name>Down</name>
+	    </desc>
+	    <desc>
+		<value>4</value>
+		<name>Right</name>
+	    </desc>
+	    <min>1</min>
+	    <max>4</max>
+	  </option>
+	  <option name="rotatein_angle" type="float">
+	    <_short>Angle</_short>
+	    <_long>Angle to start from</_long>
+	    <default>90</default>
+	    <min>-720</min>
+	    <max>720</max>
+	  </option>
+	</subgroup>
+	<subgroup>
+	  <_short>Bounce</_short>
+	  <option name="bounce_max_size" type="float">
+	    <_short>Maximum Size</_short>
+	    <_long>Maximum scale factor of window when bouncing</_long>
+	    <default>1.2</default>
+	    <min>1.0</min>
+	    <max>3.0</max>
+	  </option>
+	  <option name="bounce_min_size" type="float">
+	    <_short>Minimum Size</_short>
+	    <_long>Minimum scale factor of window when bouncing</_long>
+	    <default>0.6</default>
+	    <min>0.1</min>
+	    <max>1.0</max>
+	  </option>
+	  <option name="bounce_number" type="int">
+	    <_short>Number of Bounces</_short>
+	    <_long>How many bounces during the animation</_long>
+	    <default>3</default>
+	    <min>0</min>
+	    <max>10</max>
+	  </option>
+	  <option name="bounce_fade" type="bool">
+	    <_short>Fade</_short>
+	    <_long>Fade when flying in</_long>
+	    <default>True</default>
+	  </option>
+	</subgroup>
+	<subgroup>
+	  <_short>Sheet</_short>
+	  <option name="sheet_start_percent" type="float">
+	    <_short>Starting Percent</_short>
+            <_long>How wide the beginning of the sheet animation should be compared to the end</_long>
+	    <default>80.0</default>
+	    <min>1.0</min>
+	    <max>150.0</max>
+	  </option>
+	</subgroup>
+	<subgroup>
+	  <_short>Fan</_short>
+	  <option name="fan_angle" type="float">
+	    <_short>Fan Angle</_short>
+	    <_long>Angle of windows away from the main window</_long>
+	    <default>35</default>
+	    <min>0</min>
+	    <max>90</max>
+	    <precision>0.1</precision>
+	  </option>
+	</subgroup>
+	<subgroup>
+	  <_short>Expand Piecewise</_short>
+	  <option name="expandpw_horiz_first" type="bool">
+	    <_short>First expand horizontally</_short>
+	    <_long>If checked, initially expand horizontally, then vertically</_long>
+	    <default>True</default>
+	  </option>
+	  <option name="expandpw_initial_horiz" type="int">
+	    <_short>Initial horizontal size</_short>
+	    <_long>Number of pixels initially in horizontal direction</_long>
+	    <default>20</default>
+	    <min>0</min>
+	    <max>50</max>
+	  </option>
+	  <option name="expandpw_initial_vert" type="int">
+	    <_short>Initial vertical size</_short>
+	    <_long>Number of pixels initially in vertical direction</_long>
+	    <default>20</default>
+	    <min>0</min>
+	    <max>50</max>
+	  </option>
+	  <option name="expandpw_delay" type="float">
+	    <_short>Delay</_short>
+	    <_long>Delay between expanding horizontally and vertically (expressed as a fraction)</_long>
+	    <default>0.25</default>
+	    <min>0.0</min>
+	    <max>1.0</max>
+	  </option>
+	</subgroup>
+
+      </group>
+
+    </options>
+
+    <extension base_plugin="animation">
+      <base_option>open_effects</base_option>
+      <base_option>open_random_effects</base_option>
+      <base_option>close_effects</base_option>
+      <base_option>close_random_effects</base_option>
+      <restriction>
+	<value>animationsim:Fly In</value>
+	<_name>Fly In</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Bounce</value>
+	<_name>Bounce</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Rotate In</value>
+	<_name>Rotate In</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Sheet</value>
+	<_name>Sheet</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Expand</value>
+	<_name>Expand</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Expand Piecewise</value>
+	<_name>Expand Piecewise</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Pulse</value>
+	<_name>Pulse</_name>
+      </restriction>
+      <restriction>
+	<value>animationsim:Fan</value>
+	<_name>Fan</_name>
+      </restriction>
+    </extension>
+
+  </plugin>
+</compiz>

=== added directory 'plugins/simple-animations/src'
=== added file 'plugins/simple-animations/src/animationsim.cpp'
--- plugins/simple-animations/src/animationsim.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/animationsim.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,164 @@
+/**
+ * Example Animation extension plugin for compiz
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ **/
+
+#include "animationsim.h"
+
+COMPIZ_PLUGIN_20090315 (animationsim, AnimSimPluginVTable);
+
+AnimEffect animEffects[NUM_EFFECTS];
+
+ExtensionPluginAnimSim animSimExtPluginInfo (CompString ("animationsim"),
+					     NUM_EFFECTS, animEffects, NULL,
+                                             NUM_NONEFFECT_OPTIONS);
+
+ExtensionPluginInfo *
+BaseSimAnim::getExtensionPluginInfo ()
+{
+    return &animSimExtPluginInfo;
+}
+
+BaseSimAnim::BaseSimAnim (CompWindow *w,
+			  WindowEvent curWindowEvent,
+			  float duration,
+			  const AnimEffect info,
+			  const CompRect &icon) :
+    Animation::Animation (w, curWindowEvent, duration, info, icon),
+    mCScreen (CompositeScreen::get (::screen)),
+    mGScreen (GLScreen::get (::screen))
+{
+}
+
+AnimEffect AnimEffectFlyIn;
+AnimEffect AnimEffectRotateIn;
+AnimEffect AnimEffectExpand;
+AnimEffect AnimEffectExpandPW;
+AnimEffect AnimEffectBounce;
+AnimEffect AnimEffectSheet;
+AnimEffect AnimEffectPulse;
+AnimEffect AnimEffectFan;
+
+void
+AnimSimScreen::initAnimationList ()
+{
+    int i = 0;
+    AnimEffectUsedFor usedFor = AnimEffectUsedFor::all()
+				.exclude(AnimEventFocus)
+				.exclude(AnimEventShade);
+    AnimEffectUsedFor openUsedFor = AnimEffectUsedFor::all()
+				    .exclude(AnimEventFocus)
+				    .exclude(AnimEventShade)
+				    .exclude(AnimEventMinimize)
+				    .exclude(AnimEventUnminimize);
+
+    animEffects[i++] = AnimEffectFlyIn =
+	new AnimEffectInfo ("animationsim:Fly In", usedFor,
+			    &createAnimation<FlyInAnim>);
+
+    animEffects[i++] = AnimEffectRotateIn =
+	new AnimEffectInfo ("animationsim:Rotate In", usedFor,
+			    &createAnimation<RotateInAnim>);
+
+    animEffects[i++] = AnimEffectExpand =
+	new AnimEffectInfo ("animationsim:Expand", usedFor,
+			    &createAnimation<ExpandAnim>);
+
+    animEffects[i++] = AnimEffectExpandPW =
+	new AnimEffectInfo ("animationsim:Expand Piecewise", usedFor,
+			    &createAnimation<ExpandPWAnim>);
+
+    animEffects[i++] = AnimEffectBounce =
+	new AnimEffectInfo ("animationsim:Bounce", openUsedFor,
+			    &createAnimation<BounceAnim>);
+
+    animEffects[i++] = AnimEffectSheet =
+	new AnimEffectInfo ("animationsim:Sheet", openUsedFor,
+			    &createAnimation<SheetAnim>);
+    animEffects[i++] = AnimEffectPulse =
+	new AnimEffectInfo ("animationsim:Pulse", openUsedFor,
+			    &createAnimation<PulseAnim>);
+    animEffects[i++] = AnimEffectFan =
+	new AnimEffectInfo ("animationsim:Fan", openUsedFor,
+			    &createAnimation<FanAnim>);
+
+    animSimExtPluginInfo.effectOptions = &getOptions ();
+
+    AnimScreen *as = AnimScreen::get (::screen);
+
+    // Extends animation plugin with this set of animation effects.
+    as->addExtension (&animSimExtPluginInfo);
+}
+
+AnimSimScreen::AnimSimScreen (CompScreen *s) :
+    //cScreen (CompositeScreen::get (s)),
+    //gScreen (GLScreen::get (s)),
+    //aScreen (as),
+    PluginClassHandler <AnimSimScreen, CompScreen> (s),
+    mOutput (s->fullscreenOutput ())
+{
+    initAnimationList ();
+}
+
+AnimSimScreen::~AnimSimScreen ()
+{
+    AnimScreen *as = AnimScreen::get (::screen);
+
+    as->removeExtension (&animSimExtPluginInfo);
+
+    for (int i = 0; i < NUM_EFFECTS; i++)
+    {
+	delete animEffects[i];
+	animEffects[i] = NULL;
+    }
+}
+
+AnimSimWindow::AnimSimWindow (CompWindow *w) :
+    PluginClassHandler<AnimSimWindow, CompWindow> (w),
+    mWindow (w),
+    aWindow (AnimWindow::get (w))
+{
+}
+
+AnimSimWindow::~AnimSimWindow ()
+{
+    Animation *curAnim = aWindow->curAnimation ();
+
+    if (!curAnim)
+	return;
+
+    // We need to interrupt and clean up the animation currently being played
+    // by animationsim for this window (if any)
+    if (curAnim->remainingTime () > 0 &&
+	curAnim->getExtensionPluginInfo ()->name ==
+	    CompString ("animationsim"))
+    {
+	aWindow->postAnimationCleanUp ();
+    }
+}
+
+bool
+AnimSimPluginVTable::init ()
+{
+    if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION) |
+        !CompPlugin::checkPluginABI ("composite", COMPIZ_COMPOSITE_ABI) |
+        !CompPlugin::checkPluginABI ("opengl", COMPIZ_OPENGL_ABI) |
+        !CompPlugin::checkPluginABI ("animation", ANIMATION_ABI))
+	 return false;
+
+    return true;
+}

=== added file 'plugins/simple-animations/src/animationsim.h'
--- plugins/simple-animations/src/animationsim.h	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/animationsim.h	2016-05-30 14:34:38 +0000
@@ -0,0 +1,405 @@
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <core/core.h>
+#include <composite/composite.h>
+#include <opengl/opengl.h>
+#include <animation/animation.h>
+
+#include "animationsim_options.h"
+
+extern AnimEffect AnimEffectFlyIn;
+extern AnimEffect AnimEffectBounce;
+extern AnimEffect AnimEffectRotateIn;
+extern AnimEffect AnimEffectSheet;
+extern AnimEffect AnimEffectExpand;
+extern AnimEffect AnimEffectExpandPW;
+extern AnimEffect AnimEffectFan;
+
+// TODO Update this for each added animation effect! (total: 8)
+#define NUM_EFFECTS 8
+
+// This must have the value of the first "effect setting" above
+// in AnimAddonScreenOptions
+#define NUM_NONEFFECT_OPTIONS AnimationsimOptions::FlyinDirection
+
+#define WIN_X(w) ((w)->x () - (w)->input ().left)
+#define WIN_Y(w) ((w)->y () - (w)->input ().top)
+#define WIN_W(w) ((w)->width () + (w)->input ().left + (w)->input ().right)
+#define WIN_H(w) ((w)->height () + (w)->input ().top + (w)->input ().bottom)
+
+class ExtensionPluginAnimSim : public ExtensionPluginInfo
+{
+public:
+    ExtensionPluginAnimSim (const CompString &name,
+			    unsigned int nEffects,
+			    AnimEffect *effects,
+			    CompOption::Vector *effectOptions,
+			    unsigned int firstEffectOptionIndex) :
+	ExtensionPluginInfo (name, nEffects, effects, effectOptions,
+			     firstEffectOptionIndex) {}
+    ~ExtensionPluginAnimSim () {}
+
+    const CompOutput *output () { return mOutput; }
+
+private:
+    const CompOutput *mOutput;
+};
+
+/// Base class for all polygon- and particle-based animations
+class BaseSimAnim :
+virtual public Animation
+{
+public:
+    BaseSimAnim (CompWindow *w,
+		   WindowEvent curWindowEvent,
+		   float duration,
+		   const AnimEffect info,
+		   const CompRect &icon);
+    ~BaseSimAnim () {}
+    
+protected:
+    /// Gets info about the extension plugin that implements this animation.
+    ExtensionPluginInfo *getExtensionPluginInfo ();
+    
+    CompositeScreen *mCScreen;
+    GLScreen *mGScreen;
+    
+};
+
+
+class AnimSimScreen :
+    public PluginClassHandler <AnimSimScreen, CompScreen>,
+    public AnimationsimOptions
+{
+
+public:
+    AnimSimScreen (CompScreen *);
+    ~AnimSimScreen ();
+
+protected:
+    void initAnimationList ();
+
+    CompOutput &mOutput;
+};
+
+class AnimSimWindow :
+    public PluginClassHandler<AnimSimWindow, CompWindow>
+{
+public:
+    AnimSimWindow (CompWindow *);
+    ~AnimSimWindow ();
+
+protected:
+    CompWindow *mWindow;    ///< Window being animated.
+    AnimWindow *aWindow;
+};
+
+/*
+typedef struct _WaveParam
+{
+    float halfWidth;
+    float amp;
+    float pos;
+} WaveParam;
+*/
+
+#define ANIMSIM_SCREEN(s)						      \
+    AnimSimScreen *ass = AnimSimScreen::get (s);
+
+#define ANIMSIM_WINDOW(w)						      \
+    AnimSimWindow *asw = AnimSimWindow::get (w);
+
+class FlyInAnim : public FadeAnim,
+		  virtual public BaseSimAnim,
+          virtual public TransformAnim
+{
+    public:
+	
+	FlyInAnim (CompWindow *w,
+		   WindowEvent curWindowEvent,
+		   float       duration,
+		   const AnimEffect info,
+           const CompRect   &icon) :
+	    Animation::Animation (w, curWindowEvent, duration, info, icon),
+	    BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+	    TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon),
+	    FadeAnim::FadeAnim (w, curWindowEvent, duration, info, icon) {}
+
+    protected:
+	void step () { TransformAnim::step (); }
+	bool updateBBUsed () { return true; }
+	void updateBB (CompOutput &output) {  TransformAnim::updateBB (output); }
+	void applyTransform ();
+	bool requiresTransformedWindow () const { return true; }
+
+	float getFadeProgress ()
+	{
+	    return progressDecelerate (progressLinear ());
+	}
+};
+
+class RotateInAnim: public TransformAnim,
+		    virtual public BaseSimAnim
+{
+    public:
+
+	RotateInAnim (CompWindow *w,
+		      WindowEvent curWindowEvent,
+		      float       duration,
+		      const AnimEffect info,
+		      const CompRect   &icon) :
+	    Animation::Animation (w, curWindowEvent, duration, info, icon),
+	    BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+	    TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon) {}
+
+    protected:
+
+	void step () { TransformAnim::step (); }
+	bool updateBBUsed () { return true; }
+	void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+	void applyTransform ();
+	void prePaintWindow ();
+	void postPaintWindow ();
+
+	inline float getProgress ()
+	{
+	    return progressDecelerate (progressLinear ());
+	}
+};
+
+class ExpandAnim: public TransformAnim,
+		  virtual public BaseSimAnim
+{
+    public:
+
+	ExpandAnim (CompWindow *w,
+		    WindowEvent curWindowEvent,
+		    float	duration,
+		    const AnimEffect info,
+		    const CompRect   &icon) :
+		Animation::Animation (w, curWindowEvent, duration, info, icon),
+		BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+		TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon) {}
+
+    protected:
+
+	inline float getProgress ()
+	{
+	    return progressDecelerate (progressLinear ());
+	}
+
+	void applyTransform ();
+    bool updateBBUsed () { return true; }
+	void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+};
+
+class ExpandPWAnim: public TransformAnim,
+		    virtual public BaseSimAnim
+{
+    public:
+
+	ExpandPWAnim (CompWindow *w,
+		      WindowEvent curWindowEvent,
+		      float	  duration,
+		      const AnimEffect info,
+		      const CompRect   &icon) :
+		Animation::Animation (w, curWindowEvent, duration, info, icon),
+		BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+		TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon)
+		{
+		}
+
+    protected:
+
+	inline float getProgress ()
+	{
+	    return progressDecelerate (progressLinear ());
+	}
+
+	void applyTransform ();
+	bool updateBBUsed () { return true; }
+	void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+};
+
+class BounceAnim: public FadeAnim,
+		  virtual public TransformAnim,
+		  virtual public BaseSimAnim
+{
+    public:
+
+	BounceAnim (CompWindow *w,
+		    WindowEvent curWindowEvent,
+		    float	  duration,
+		    const AnimEffect info,
+		    const CompRect   &icon) :
+	    Animation::Animation (w, curWindowEvent, duration, info, icon),
+	    TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon),
+	    BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+	    FadeAnim::FadeAnim (w, curWindowEvent, duration, info, icon)
+	    {
+		ANIMSIM_SCREEN (screen);
+
+		bounceCount = ass->optionGetBounceNumber ();
+		nBounce = 1;
+		targetScale = ass->optionGetBounceMinSize ();
+		currentScale = ass->optionGetBounceMaxSize ();
+		bounceNeg = false;
+		currBounceProgress = 0.0f;
+		lastProgressMax = 0.0f;
+	    }
+
+    protected:
+
+	void step () { TransformAnim::step (); }
+	void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+	bool updateBBUsed () { return true; }
+	bool requiresTransformedWindow () const { return true; }
+
+	void applyTransform ();
+
+	float getProgress ();
+	float getFadeProgress ()
+	{
+	    return progressDecelerate (progressLinear ());
+	}
+
+	int bounceCount;
+	int nBounce;
+	float targetScale;
+	float currentScale;
+	bool  bounceNeg;
+	float currBounceProgress;
+	float lastProgressMax;
+};
+
+class SheetAnim : public GridAnim,
+		  virtual public BaseSimAnim
+{
+    public:
+
+	SheetAnim (CompWindow *w,
+		   WindowEvent curWindowEvent,
+		   float       duration,
+		   const AnimEffect info,
+		   const CompRect   &icon);
+
+	class WaveParam
+	{
+	    public:
+		float halfWidth;
+		float amp;
+		float pos;
+	};
+
+    protected:
+
+	void initGrid ()
+	{
+	    mGridWidth = 30;
+	    mGridHeight = 30;
+	}
+
+	void step ();
+	void updateBB (CompOutput &output);
+	bool updateBBUsed () { return true; }
+	bool stepRegionUsed () { return true; }
+
+	int sheetsWaveCount;
+	std::vector <WaveParam> sheetsWaves;
+};
+
+class PulseSingleAnim : public TransformAnim,
+			virtual public FadeAnim,
+			virtual public BaseSimAnim
+{
+    public:
+
+	PulseSingleAnim (CompWindow *w,
+			 WindowEvent curWindowEvent,
+			 float	  duration,
+			 const      AnimEffect info,
+			 const	  CompRect   &icon) :
+	    Animation::Animation (w, curWindowEvent, duration, info, icon),
+	    FadeAnim::FadeAnim (w, curWindowEvent, duration, info, icon),
+	    BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+	    TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon) {}
+
+	void step () { TransformAnim::step (); }
+	void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+	bool updateBBUsed () { return true; }
+	
+	float getProgress () { return progressLinear (); }
+	float getFadeProgress ();
+	
+	void applyTransform ();
+
+    protected:
+
+	bool requiresTransformedWindow () const { return true; }
+};
+
+class PulseAnim : public MultiAnim <PulseSingleAnim, 2>
+{
+    public:
+      
+	PulseAnim (CompWindow *w,
+		   WindowEvent curWindowEvent,
+		   float       duration,
+		   const       AnimEffect info,
+		   const       CompRect &icon) :
+	    MultiAnim <PulseSingleAnim, 2>::MultiAnim
+		  (w, curWindowEvent, duration, info, icon) {}
+		  
+};
+
+class FanSingleAnim : public TransformAnim,
+		      virtual public FadeAnim,
+		      virtual public BaseSimAnim
+{
+    public:
+
+	FanSingleAnim (CompWindow  *w,
+		       WindowEvent curWindowEvent,
+		       float	   duration,
+		       const	   AnimEffect info,
+		       const	   CompRect   &icon) :
+	    Animation::Animation (w, curWindowEvent, duration, info, icon),
+	    FadeAnim::FadeAnim (w, curWindowEvent, duration, info, icon),
+	    BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, icon),
+	    TransformAnim::TransformAnim (w, curWindowEvent, duration, info, icon) {}
+
+	void step () { TransformAnim::step (); }
+	void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+	bool updateBBUsed () { return true; }
+	
+	float getProgress () { return progressLinear (); }
+	float getFadeProgress ();
+	
+	void applyTransform ();
+
+    protected:
+
+	bool requiresTransformedWindow () const { return true; }
+};
+
+class FanAnim : public MultiAnim <FanSingleAnim, 6>
+{
+    public:
+
+	FanAnim (CompWindow *w,
+		 WindowEvent curWindowEvent,
+		 float       duration,
+		 const       AnimEffect info,
+		 const       CompRect &icon) :
+	    MultiAnim <FanSingleAnim, 6>::MultiAnim
+	    (w, curWindowEvent, duration, info, icon) {}
+};
+
+class AnimSimPluginVTable:
+	public CompPlugin::VTableForScreenAndWindow <AnimSimScreen, AnimSimWindow>
+{
+    public:
+	bool init ();
+};

=== added file 'plugins/simple-animations/src/bounce.cpp'
--- plugins/simple-animations/src/bounce.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/bounce.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,76 @@
+/*
+ * Animation plugin for compiz/beryl
+ *
+ * animation.c
+ *
+ * Copyright : (C) 2006 Erkin Bahceci
+ * E-mail    : [e-mail]
+ *
+ * Based on Wobbly and Minimize plugins by
+ *           : David Reveman
+ * E-mail    : [e-mail]>
+ *
+ * Particle system added by : (C) 2006 Dennis Kasprzyk
+ * E-mail                   : [e-mail]
+ *
+ * Beam-Up added by : Florencio Guimaraes
+ * E-mail           : [e-mail]
+ *
+ * Hexagon tessellator added by : Mike Slegeir
+ * E-mail                       : [e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "animationsim.h"
+
+// =====================  Effect: Bounce  =========================
+
+float
+BounceAnim::getProgress ()
+{
+    return progressLinear ();
+}
+
+void
+BounceAnim::applyTransform ()
+{
+    float scale = 1.0f - (targetScale * (currBounceProgress) + currentScale * (1.0f - currBounceProgress));
+    float forwardProgress = getProgress ();;
+    float forwardProgressInc = 1.0f / bounceCount;
+
+    /* last bounce, enure we are going for 0.0 */
+    currBounceProgress = (((1 - forwardProgress) - lastProgressMax) / forwardProgressInc);
+
+    if (currBounceProgress > 1.0f)
+    {
+	currentScale = targetScale;
+	targetScale = -targetScale + targetScale / 2.0f;
+	lastProgressMax = 1.0f - forwardProgress;
+	currBounceProgress = 0.0f;
+	nBounce++;
+    }
+
+    GLMatrix *transform = &mTransform;
+
+    transform->translate (WIN_X (mWindow) + WIN_W (mWindow) / 2.0f,
+			  WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f, 0.0f);
+
+    transform->scale (scale, scale, 1.0f);
+
+    transform->translate (-(WIN_X (mWindow) + WIN_W (mWindow) / 2.0f),
+			  -(WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f), 0.0f);
+
+}

=== added file 'plugins/simple-animations/src/expand-piecewise.cpp'
--- plugins/simple-animations/src/expand-piecewise.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/expand-piecewise.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,90 @@
+/*
+ * Animation plugin for compiz/beryl
+ *
+ * animation.c
+ *
+ * Copyright : (C) 2006 Erkin Bahceci
+ * E-mail    : [e-mail]
+ *
+ * Based on Wobbly and Minimize plugins by
+ *           : David Reveman
+ * E-mail    : [e-mail]>
+ *
+ * Particle system added by : (C) 2006 Dennis Kasprzyk
+ * E-mail                   : [e-mail]
+ *
+ * Beam-Up added by : Florencio Guimaraes
+ * E-mail           : [e-mail]
+ *
+ * Hexagon tessellator added by : Mike Slegeir
+ * E-mail                       : [e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "animationsim.h"
+#define DELTA 0.0001f
+
+// =====================  Effect: ExpandPW  =========================
+
+void
+ExpandPWAnim::applyTransform ()
+{
+    ANIMSIM_SCREEN (screen);
+
+    GLMatrix *transform = &mTransform;
+
+    float forwardProgress = 1.0f - getProgress ();
+
+    float initialXScale = ass->optionGetExpandpwInitialHoriz () / (float) mWindow->width ();
+    float initialYScale = ass->optionGetExpandpwInitialVert ()  / (float) mWindow->height ();
+
+    // animation movement
+    transform->translate (WIN_X (mWindow) + WIN_W (mWindow) / 2.0f,
+			  WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f,
+			  0.0f);
+
+    float xScale;
+    float yScale;
+    float switchPointP;
+    float switchPointN;
+    float delay = ass->optionGetExpandpwDelay ();
+
+    if (ass->optionGetExpandpwHorizFirst ())
+    {
+        switchPointP = mWindow->width () / (float) (mWindow->width () + mWindow->height ()) + mWindow->height () / (float) (mWindow->width () + mWindow->height ()) * delay;
+        switchPointN = mWindow->width () / (float) (mWindow->width () + mWindow->height ()) - mWindow->width () / (float) (mWindow->width () + mWindow->height ()) * delay;
+        if(switchPointP >= 1.0f) switchPointP = 1.0f - DELTA;
+        if(switchPointN <= 0.0f) switchPointN = 0.0f + DELTA;
+        xScale = initialXScale + (1.0f - initialXScale) * (forwardProgress < switchPointN ? 1.0f - (switchPointN - forwardProgress)/switchPointN : 1.0f);
+        yScale = initialYScale + (1.0f - initialYScale) * (forwardProgress > switchPointP ? (forwardProgress - switchPointP)/(1.0f-switchPointP) : 0.0f);
+    }
+    else
+    {
+        switchPointP = mWindow->height () / (float) (mWindow->width () + mWindow->height ()) + mWindow->width () / (float) (mWindow->width () + mWindow->height ()) * delay;
+        switchPointN = mWindow->height () / (float) (mWindow->width () + mWindow->height ()) - mWindow->height () / (float) (mWindow->width () + mWindow->height ()) * delay;
+        if(switchPointP >= 1.0f) switchPointP = 1.0f - DELTA;
+        if(switchPointN <= 0.0f) switchPointN = 0.0f + DELTA;
+        xScale = initialXScale + (1.0f - initialXScale) * (forwardProgress > switchPointP ? (forwardProgress - switchPointP)/(1.0f-switchPointP) : 0.0f);
+        yScale = initialYScale + (1.0f - initialYScale) * (forwardProgress < switchPointN ? 1.0f - (switchPointN - forwardProgress)/switchPointN : 1.0f);
+    }
+
+    transform->scale (xScale, yScale, 0.0f);
+
+    transform->translate (-(WIN_X (mWindow) + WIN_W (mWindow) / 2.0f),
+			  -(WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f),
+			  0.0f);
+
+}

=== added file 'plugins/simple-animations/src/expand.cpp'
--- plugins/simple-animations/src/expand.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/expand.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,70 @@
+/*
+ * Animation plugin for compiz/beryl
+ *
+ * animation.c
+ *
+ * Copyright : (C) 2006 Erkin Bahceci
+ * E-mail    : [e-mail]
+ *
+ * Based on Wobbly and Minimize plugins by
+ *           : David Reveman
+ * E-mail    : [e-mail]>
+ *
+ * Particle system added by : (C) 2006 Dennis Kasprzyk
+ * E-mail                   : [e-mail]
+ *
+ * Beam-Up added by : Florencio Guimaraes
+ * E-mail           : [e-mail]
+ *
+ * Hexagon tessellator added by : Mike Slegeir
+ * E-mail                       : [e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "animationsim.h"
+
+// =====================  Effect: Expand  =========================
+
+void
+ExpandAnim::applyTransform ()
+{
+    GLMatrix *transform = &mTransform;
+    float defaultXScale = 0.3f;
+    float forwardProgress;
+    float expandProgress;
+    const float expandPhaseEnd = 0.5f;
+
+    forwardProgress = getProgress ();
+
+    if ((1 - forwardProgress) < expandPhaseEnd)
+	expandProgress = (1 - forwardProgress) / expandPhaseEnd;
+    else
+	expandProgress = 1.0f;
+
+    // animation movement
+    transform->translate (WIN_X (mWindow) + WIN_W (mWindow) / 2.0f,
+			  WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f,
+			  0.0f); 
+
+    transform->scale (defaultXScale + (1.0f - defaultXScale) *
+		      expandProgress,
+		      (1 - forwardProgress), 0.0f);
+
+    transform->translate (-(WIN_X (mWindow) + WIN_W (mWindow) / 2.0f),
+		      	  -(WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f),
+		      	  0.0f);
+
+}

=== added file 'plugins/simple-animations/src/fan.cpp'
--- plugins/simple-animations/src/fan.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/fan.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,51 @@
+#include "animationsim.h"
+
+float
+FanSingleAnim::getFadeProgress ()
+{
+    return getProgress ();
+};
+
+void
+FanSingleAnim::applyTransform ()
+{
+    /* Starting angle is as a percentage of whichever fan number we are
+     * closest to the center
+     */
+    
+    ANIMSIM_SCREEN (screen);
+    
+    int num = MultiAnim <FanSingleAnim, 6>::getCurrAnimNumber (mAWindow);
+    
+    if (num > 2)
+	num += 1;
+    
+    float div = (ass->optionGetFanAngle () * 2) / 6;
+    float startAng = -(ass->optionGetFanAngle ()) + (div * num);
+    float currAng = getProgress () * startAng;
+    float offset = (1 - getProgress ()) * (WIN_H (mWindow) / 2);
+    
+    if (num > 3)
+	num += 1;
+    
+    if (num > 3)
+    {
+	mTransform.translate (WIN_X (mWindow) + WIN_W (mWindow) - offset,
+			      WIN_Y (mWindow) + WIN_H (mWindow),
+			      0.0f);
+	mTransform.rotate (currAng, 0.0f, 0.0f, 1.0f);
+	mTransform.translate (-(WIN_X (mWindow) + WIN_W (mWindow) - offset),
+			      -(WIN_Y (mWindow) + WIN_H (mWindow)),
+			      0.0f);
+    }
+    else
+    {
+	mTransform.translate (WIN_X (mWindow) + offset,
+			      WIN_Y (mWindow) + WIN_H (mWindow),
+			      0.0f);
+	mTransform.rotate (currAng, 0.0f, 0.0f, 1.0f);
+	mTransform.translate (-(WIN_X (mWindow) + offset),
+			      -(WIN_Y (mWindow) + WIN_H (mWindow)),
+			      0.0f);
+    }
+}

=== added file 'plugins/simple-animations/src/flyin.cpp'
--- plugins/simple-animations/src/flyin.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/flyin.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,86 @@
+/*
+ * Animation plugin for compiz/beryl
+ *
+ * animation.c
+ *
+ * Copyright : (C) 2006 Erkin Bahceci
+ * E-mail    : [e-mail]
+ *
+ * Based on Wobbly and Minimize plugins by
+ *           : David Reveman
+ * E-mail    : [e-mail]>
+ *
+ * Particle system added by : (C) 2006 Dennis Kasprzyk
+ * E-mail                   : [e-mail]
+ *
+ * Beam-Up added by : Florencio Guimaraes
+ * E-mail           : [e-mail]
+ *
+ * Hexagon tessellator added by : Mike Slegeir
+ * E-mail                       : [e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "animationsim.h"
+
+// =====================  Effect: Flyin  =========================
+
+void
+FlyInAnim::applyTransform ()
+{
+    GLMatrix *transform = &mTransform;
+    float offsetX = 0, offsetY = 0;
+    float xTrans, yTrans;
+    float forwardProgress;
+
+    ANIMSIM_SCREEN (screen);
+
+    int direction = ass->optionGetFlyinDirection ();
+    float distance = ass->optionGetFlyinDistance ();
+
+    switch (direction)
+    {
+	case 0:
+	    offsetX = 0;	 
+	    offsetY = distance;
+	    break;
+	case 1:
+	    offsetX = distance;
+	    offsetY = 0;
+	    break;
+	case 2:
+	    offsetX = 0;
+	    offsetY = -distance;
+	    break;
+	case 3:
+	    offsetX = -distance;
+	    offsetY = 0;
+	    break;
+	case 4:
+	    offsetX = ass->optionGetFlyinDirectionX ();
+	    offsetY = ass->optionGetFlyinDirectionY ();
+	    break;
+    }
+
+    forwardProgress = progressLinear ();
+    xTrans = -(forwardProgress * offsetX);
+    yTrans = -(forwardProgress * offsetY);
+    Point3d translation = Point3d (xTrans, yTrans, 0);
+
+    // animation movement
+    transform->translate (translation.x (), translation.y (), translation.z ());
+
+}

=== added file 'plugins/simple-animations/src/pulse.cpp'
--- plugins/simple-animations/src/pulse.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/pulse.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,50 @@
+#include "animationsim.h"
+
+/* Keep the "principal" window at 100% opacity, only fade out
+ * the window that is "pulsing" away
+ */
+
+float
+PulseSingleAnim::getFadeProgress ()
+{
+    int num = MultiAnim <PulseSingleAnim, 2>::getCurrAnimNumber (mAWindow);
+    
+    if (num == 1)
+	return 1 - getProgress ();
+    else
+	return 0.0f;
+};
+
+void
+PulseSingleAnim::applyTransform ()
+{
+    float scale = 1.0f + (1- getProgress ());
+    
+    /* Add a bit of a "kick" for open, close,
+     * minimize, unminimize, etc anims */
+    
+    switch (mCurWindowEvent)
+    {
+	case WindowEventOpen:
+	case WindowEventClose:
+	case WindowEventMinimize:
+	case WindowEventUnminimize:
+	    scale -= 0.2f;
+	default:
+	    break;
+    }
+    
+    if (MultiAnim <PulseSingleAnim, 2>::getCurrAnimNumber (mAWindow) == 0)
+	if (scale > 1.0f)
+	    scale = 1.0f;
+  
+    GLMatrix *transform = &mTransform;
+
+    transform->translate (WIN_X (mWindow) + WIN_W (mWindow) / 2.0f,
+			  WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f, 0.0f);
+
+    transform->scale (scale, scale, 1.0f);
+
+    transform->translate (-(WIN_X (mWindow) + WIN_W (mWindow) / 2.0f),
+			  -(WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f), 0.0f);
+}
\ No newline at end of file

=== added file 'plugins/simple-animations/src/rotatein.cpp'
--- plugins/simple-animations/src/rotatein.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/rotatein.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,210 @@
+/*
+ * Animation plugin for compiz/beryl
+ *
+ * animation.c
+ *
+ * Copyright : (C) 2006 Erkin Bahceci
+ * E-mail    : [e-mail]
+ *
+ * Based on Wobbly and Minimize plugins by
+ *           : David Reveman
+ * E-mail    : [e-mail]>
+ *
+ * Particle system added by : (C) 2006 Dennis Kasprzyk
+ * E-mail                   : [e-mail]
+ *
+ * Beam-Up added by : Florencio Guimaraes
+ * E-mail           : [e-mail]
+ *
+ * Hexagon tessellator added by : Mike Slegeir
+ * E-mail                       : [e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "animationsim.h"
+
+// =====================  Effect: RotateIn  =========================
+
+void
+RotateInAnim::applyTransform ()
+{
+    ANIMSIM_SCREEN (screen);
+
+    GLMatrix *transform = &mTransform;
+    float xRot, yRot;
+    float angleX = 0, angleY = 0;
+    float originX = 0, originY = 0;
+    float forwardProgress;
+
+    int direction = ass->optionGetRotateinDirection ();
+
+    switch (direction)
+    {
+	case 1:
+	    angleX = 0;
+	    angleY = -ass->optionGetRotateinAngle ();
+	    originX = WIN_X (mWindow);
+	    originY = WIN_Y (mWindow) + WIN_H (mWindow);
+	    break;
+	case 2:
+	    angleX = ass->optionGetRotateinAngle ();
+	    angleY = 0;
+	    originX = WIN_X (mWindow);
+	    originY = WIN_Y (mWindow);
+	    break;
+	case 3:
+	    angleX = 0;
+	    angleY = ass->optionGetRotateinAngle ();
+	    originX = WIN_X (mWindow);
+	    originY = WIN_Y (mWindow);
+	    break;
+	case 4:
+	    angleX = -ass->optionGetRotateinAngle ();
+	    angleY = 0;
+	    originX = WIN_X (mWindow) + WIN_W (mWindow);
+	    originY = WIN_Y (mWindow);
+	    break;
+    }
+
+    forwardProgress = getProgress ();
+    xRot = (forwardProgress * angleX);
+    yRot = (forwardProgress * angleY);
+
+    transform->translate (WIN_X (mWindow) + WIN_W (mWindow) / 2.0f,
+			  WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f,
+			  0.0f);
+
+    perspectiveDistortAndResetZ (*transform);
+
+    transform->translate (-(WIN_X (mWindow) + WIN_W (mWindow) / 2.0f),
+			  -(WIN_Y (mWindow) + WIN_H (mWindow) / 2.0f),
+			  0.0f);
+
+    // animation movement
+    transform->translate (originX, originY, 0.0f);
+
+    transform->rotate (yRot, 1.0f, 0.0f, 0.0f);
+    transform->rotate (xRot, 0.0f, 1.0f, 0.0f);
+
+    transform->translate (-originX, -originY, 0.0f);
+
+}
+
+void 
+RotateInAnim::prePaintWindow ()
+{
+    float forwardProgress = getProgress ();
+    float xRot, yRot;
+    float angleX = 0, angleY = 0;
+    Bool  xInvert = FALSE, yInvert = FALSE;
+    int currentCull, invertCull;
+
+    glGetIntegerv (GL_CULL_FACE_MODE, &currentCull);
+    invertCull = (currentCull == GL_BACK) ? GL_FRONT : GL_BACK;
+
+    ANIMSIM_SCREEN (screen);
+
+    int direction = ass->optionGetRotateinDirection ();
+
+    switch (direction)
+    {
+	case 1:
+	    angleX = 0;
+	    angleY = -ass->optionGetRotateinAngle ();
+	    break;
+	case 2:
+	    angleX = ass->optionGetRotateinAngle ();
+	    angleY = 0;
+	    break;
+	case 3:
+	    angleX = 0;
+	    angleY = ass->optionGetRotateinAngle ();
+	    break;
+	case 4:
+	    angleX = -ass->optionGetRotateinAngle ();
+	    angleY = 0;
+	    break;
+    }
+
+    /* FIXME: This could be fancy vectorial normal direction calculation */
+
+    xRot = fabs(fmodf(forwardProgress * angleX, 360.0f));
+    yRot = fabs(fmodf(forwardProgress * angleY, 360.0f));
+
+    if (xRot > 270.0f)
+	xInvert = TRUE;
+
+    if (yRot > 270.0f)
+	yInvert = TRUE;
+
+    if ((xInvert || yInvert) && !(xInvert && yInvert))
+	glCullFace (invertCull);
+}
+
+void
+RotateInAnim::postPaintWindow ()
+{
+    float forwardProgress = getProgress ();
+    float xRot, yRot;
+    float angleX = 0, angleY = 0;
+    Bool  xInvert = FALSE, yInvert = FALSE;
+    int currentCull, invertCull;
+
+    glGetIntegerv (GL_CULL_FACE_MODE, &currentCull);
+    invertCull = (currentCull == GL_BACK) ? GL_FRONT : GL_BACK;
+
+    ANIMSIM_SCREEN (screen);
+
+    int direction = ass->optionGetRotateinDirection ();
+
+    switch (direction)
+    {
+	case 1:
+	    angleX = 0;
+	    angleY = -ass->optionGetRotateinAngle ();
+	    break;
+	case 2:
+	    angleX = ass->optionGetRotateinAngle ();
+	    angleY = 0;
+	    break;
+	case 3:
+	    angleX = 0;
+	    angleY = ass->optionGetRotateinAngle ();
+	    break;
+	case 4:
+	    angleX = -ass->optionGetRotateinAngle ();
+	    angleY = 0;
+	    break;
+    }
+
+    /* FIXME: This could be fancy vectorial normal direction calculation */
+
+    xRot = fabs(fmodf(forwardProgress * angleX, 360.0f));
+    yRot = fabs(fmodf(forwardProgress * angleY, 360.0f));
+
+    if (xRot > 270.0f)
+	xInvert = TRUE;
+
+    if (yRot > 270.0f)
+	yInvert = TRUE;
+
+    /* We have to assume that invertCull will be
+     * the actual inversion of our previous cull
+     */
+
+    if ((xInvert || yInvert) && !(xInvert && yInvert))
+	glCullFace (invertCull);
+}

=== added file 'plugins/simple-animations/src/sheet.cpp'
--- plugins/simple-animations/src/sheet.cpp	1970-01-01 00:00:00 +0000
+++ plugins/simple-animations/src/sheet.cpp	2016-05-30 14:34:38 +0000
@@ -0,0 +1,275 @@
+/*
+ * Animation plugin for compiz/beryl
+ *
+ * animation.c
+ *
+ * Copyright : (C) 2006 Erkin Bahceci
+ * E-mail    : [e-mail]
+ *
+ * Based on Wobbly and Minimize plugins by
+ *           : David Reveman
+ * E-mail    : [e-mail]>
+ *
+ * Particle system added by : (C) 2006 Dennis Kasprzyk
+ * E-mail                   : [e-mail]
+ *
+ * Beam-Up added by : Florencio Guimaraes
+ * E-mail           : [e-mail]
+ *
+ * Hexagon tessellator added by : Mike Slegeir
+ * E-mail                       : [e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#include "animationsim.h"
+
+SheetAnim::SheetAnim (CompWindow *w,
+		      WindowEvent curWindowEvent,
+		      float       duration,
+		      const AnimEffect info,
+		      const CompRect   &minIcon) :
+    Animation::Animation (w, curWindowEvent, duration, info, minIcon),
+    BaseSimAnim::BaseSimAnim (w, curWindowEvent, duration, info, minIcon),
+    GridAnim::GridAnim (w, curWindowEvent, duration, info, minIcon)
+{
+    int maxWaves;
+    float waveAmpMin, waveAmpMax;
+    CompWindow *parent = 0;
+    CompRect   icon = minIcon;
+
+    foreach (parent, screen->windows ())
+    {
+	if (parent->transientFor () == w->id () && parent->id () != w->id ())
+	    break;
+    }
+
+    if (parent)
+    {
+	icon.setX (WIN_X (parent) + WIN_W (parent) / 2.0f);
+	icon.setY (WIN_Y (parent));
+	icon.setWidth (WIN_W (w));
+    }
+    else
+    {
+	icon.setX (screen->width () / 2.0f);
+	icon.setY (0.0f);;
+	icon.setWidth (WIN_W (w));
+    }
+
+    maxWaves = 0;
+    waveAmpMin = 0.0f;
+    waveAmpMax = 0.0f;
+
+    if (maxWaves == 0)
+    {
+	sheetsWaveCount = 0;
+    }
+    else
+    {
+	// Initialize waves
+
+	float distance = WIN_Y(w) + WIN_H(w) - icon.y ();
+
+	sheetsWaveCount =
+	1 + (float)maxWaves *distance;
+
+	if (sheetsWaves.empty ())
+	{
+	    sheetsWaves.resize (sheetsWaveCount);
+	}
+	// Compute wave parameters
+
+	int ampDirection = (RAND_FLOAT() < 0.5 ? 1 : -1);
+	float minHalfWidth = 0.22f;
+	float maxHalfWidth = 0.38f;
+
+	for (unsigned int i = 0; i < sheetsWaves.size (); i++)
+	{
+	    sheetsWaves[i].amp =
+		ampDirection * (waveAmpMax - waveAmpMin) *
+		rand() / RAND_MAX + ampDirection * waveAmpMin;
+	    sheetsWaves[i].halfWidth =
+		RAND_FLOAT() * (maxHalfWidth -
+				minHalfWidth) + minHalfWidth;
+
+	    // avoid offset at top and bottom part by added waves
+	    float availPos = 1 - 2 * sheetsWaves[i].halfWidth;
+	    float posInAvailSegment = 0;
+
+	    if (i > 0)
+	        posInAvailSegment =
+		    (availPos / sheetsWaveCount) * rand() / RAND_MAX;
+
+	    sheetsWaves[i].pos =
+	        (posInAvailSegment +
+	         i * availPos / sheetsWaveCount +
+	         sheetsWaves[i].halfWidth);
+
+	    // switch wave direction
+	    ampDirection *= -1;
+	}
+    }
+}
+
+void
+SheetAnim::updateBB (CompOutput &output)
+{
+    // TODO: Just consider the corner objects
+
+    CompositeScreen::get (screen)->damageScreen (); // XXX: *COUGH!!!!*
+}
+
+void
+SheetAnim::step ()
+{
+    GridModel *model = mModel;
+    CompRect &icon = mIcon;
+    CompWindow *parent = 0;
+
+    foreach (parent, screen->windows ())
+    {
+	if (parent->transientFor () == mWindow->id () && parent->id () != mWindow->id ())
+	    break;
+    }
+
+    if (parent)
+    {
+	icon.setX (WIN_X (parent) + WIN_W (parent) / 2.0f);
+	icon.setY (WIN_Y (parent));
+	icon.setWidth (WIN_W (mWindow));
+    }
+    else
+    {
+	icon.setX (screen->width () / 2.0f);
+	icon.setY (0.0f);;
+	icon.setWidth (WIN_W (mWindow));
+    }
+
+    float forwardProgress = progressLinear ();
+
+    if (sheetsWaveCount > 0 && sheetsWaves.empty ())
+	return;
+
+    float iconCloseEndY;
+    float iconFarEndY;
+    float winFarEndY;
+    float winVisibleCloseEndY;
+    float winw = WIN_W(mWindow);
+    float winh = WIN_H(mWindow);
+
+
+    iconFarEndY = icon.y ();
+    iconCloseEndY = icon.y () + icon.height ();
+    winFarEndY = WIN_Y(mWindow) + winh;
+    winVisibleCloseEndY = WIN_Y(mWindow);
+    if (winVisibleCloseEndY < iconCloseEndY)
+	winVisibleCloseEndY = iconCloseEndY;
+
+
+    float preShapePhaseEnd = 0.22f;
+    float preShapeProgress  = 0;
+    float postStretchProgress = 0;
+    float stretchProgress = 0;
+    float stretchPhaseEnd =
+	preShapePhaseEnd + (1 - preShapePhaseEnd) *
+	(iconCloseEndY -
+	 winVisibleCloseEndY) / ((iconCloseEndY - winFarEndY) +
+				 (iconCloseEndY - winVisibleCloseEndY));
+    if (stretchPhaseEnd < preShapePhaseEnd + 0.1)
+	stretchPhaseEnd = preShapePhaseEnd + 0.1;
+
+    if (forwardProgress < preShapePhaseEnd)
+    {
+	preShapeProgress = forwardProgress / preShapePhaseEnd;
+
+	// Slow down "shaping" toward the end
+	preShapeProgress = 1 - progressDecelerate (1 - preShapeProgress);
+    }
+
+    if (forwardProgress < preShapePhaseEnd)
+    {
+	stretchProgress = forwardProgress / stretchPhaseEnd;
+    }
+    else
+    {
+	if (forwardProgress < stretchPhaseEnd)
+	{
+	    stretchProgress = forwardProgress / stretchPhaseEnd;
+	}
+	else
+	{
+	    postStretchProgress =
+		(forwardProgress - stretchPhaseEnd) / (1 - stretchPhaseEnd);
+	}
+    }
+
+    GridModel::GridObject *object = mModel->objects ();
+    unsigned int i;
+    for (i = 0; i < mModel->numObjects (); i++, object++)
+    {
+	float origx = mWindow->x () + (winw * object->gridPosition ().x () -
+				     mWindow->output ().left) * model->scale ().x ();
+	float origy = mWindow->y () + (winh * object->gridPosition ().y () -
+				     mWindow->output ().top) * model->scale ().y ();
+	float icony = icon.y () + icon.height ();
+
+	float stretchedPos;
+	Point3d &objPos = object->position ();
+	stretchedPos =
+		object->gridPosition ().y () * origy +
+		(1 - object->gridPosition ().y ()) * icony;
+
+	// Compute current y position
+	if (forwardProgress < preShapePhaseEnd)
+	{
+	    objPos.setY ((1 - stretchProgress) * origy +
+		stretchProgress * stretchedPos);
+	}
+	else
+	{
+	    if (forwardProgress < stretchPhaseEnd)
+	    {
+		objPos.setY ((1 - stretchProgress) * origy +
+		    stretchProgress * stretchedPos);
+	    }
+	    else
+	    {
+		objPos.setY ((1 - postStretchProgress) *
+		    stretchedPos +
+		    postStretchProgress *
+		    (stretchedPos + (iconCloseEndY - winFarEndY)));
+	    }
+	}
+
+	// Compute "target shape" x position
+	float yProgress = (iconCloseEndY - object->position ().y () ) / (iconCloseEndY - winFarEndY);
+
+	float targetx = yProgress * (origx - icon.x ())
+	 + icon.x () + icon.width () * (object->gridPosition ().x () - 0.5);
+
+	// Compute current x position
+	if (forwardProgress < preShapePhaseEnd)
+	    objPos.setX ((1 - preShapeProgress) * origx + preShapeProgress * targetx);
+	else
+	    objPos.setX (targetx);
+
+	if (object->position ().y () < iconFarEndY)
+	    objPos.setY (iconFarEndY);
+
+	// No need to set object->position.z to 0, since they won't be used
+	// due to modelAnimIs3D being FALSE for magic lamp.
+    }
+}