Merge lp:~mc-return/compiz/compiz.merge-plugin-animationjc into lp:compiz/0.9.10

[MC Return]

Added the unsupported, but fully working plug-in "animationjc" converted from git to bzr (including history) to lp:compiz.

Adds the unsupported, but fully working plug-in "animationjc" converted from git to bzr (including history) to Compiz 0.9.8.

[Sam Spilsbury (smspillaz)]

I feel like animationjc and animationextra should probably be merged into either animation or animationaddon. Two less plugins to maintain. Thoughts?

[MC Return (mc-return)]

Black Hole, Flicker, Ghost, Popcorn & Raindrop

[MC Return (mc-return)]

Sam, I would fully agree on that.
I have a few other ideas regarding the simplification and optimization of CCSM in general as well: For example hiding plug-ins that depend on other plug-ins and make no sense being shown in CCSM and just confuse the user (like hiding all cube-related plug-ins in CCSM if the cube is disabled for example), but that is offtopic here and requires some other place of discussion I guess ;)

[MC Return (mc-return)]

There is another animations-plug-in that is missing, but currently crashes latest Compiz versions (but did already work in 0.9.x series). It is called simple-animations (Animations that are easy on the eyes). What should we do with that one, Sam ?

[MC Return (mc-return)]

I guess animations-add-on was just separated to introduce and define a "Animation Time Step For Intense Effects" which can differ from the "Animation Time Step" usually used, but this function could be moved to one plug-in also, so it won't get lost...

[Sam Spilsbury (smspillaz)]

Animationaddon exist so that distributions don't have to ship huge binaries of stuff they don't use ;-)

In any case, I'll get around to looking at the best way to approach this soon. It will take a low priority though over the next few weeks since we really need to ramp up efforts to fix up the OpenGL|ES work before I go on holiday since I won't even have a computer -.- .

[MC Return (mc-return)]

Thanks for looking into that issue.
Unfortunately I found out that exactly those plug-ins here, which I merged first, do not seem to work with latest Compiz 0.9.7.8 anymore. :(
I can enable "Animations Experimental" and change settings, but when I select one of those 5 plug-ins (Black Hole, Flicker, Ghost, Popcorn & Raindrop) in "Animations" (for the Open-animation for example) they simply do not work. They do not crash Compiz, but they seem to not be executed either. :(

[Daniel van Vugt (vanvugt)]

This branch keeps failing to build (when merged with lp:compiz)

In file included from /home/dan/bzr/compiz/tmp.jc/plugins/animationjc/src/popcorn.cpp:1:0:
/home/dan/bzr/compiz/tmp.jc/plugins/animationjc/src/private.h:6:33: fatal error: composite/composite.h: No such file or directory
compilation terminated.

review: Needs Fixing

[MC Return (mc-return)]

I tried to investigate what exactly is the problem here, but did not find out yet.
The strange thing about this error is that composite/composite.h should exist and the other animation plug-ins use almost the same code.
Another strangeness here is the fact that it compiles as standalone plug-in (but does not work then), but does not compile when merged with lp:compiz.

[MC Return (mc-return)]

The PLUGINDEPS opengl and composite are missing to fix compilation here.

Unfortunately I am having problems to upload to launchpad since a few days, I hope I'll be able to fix this soonish though.

[Sam Spilsbury (smspillaz)]

Hey just wanted to say thanks for working on this! It seems like a lot of plugins were lost when git.compiz.org went down, so this is the only mirror I've been able to find of them.

Unmerged revisions

3254. By MC Return on 2012-08-15

Fixed [-Werror=maybe-uninitialized] compiler warning for the float 'displacement'

3253. By MC Return on 2012-08-12

Removed plugins/animationjc/VERSION

3252. By MC Return on 2012-08-12

Added missing PLUGINDEPS composite and opengl to CMakeLists.txt to fix compilation

3251. By MC Return on 2012-07-12

Rebased on latest lp:compiz (r3285)

3250. By MC Return on 2012-06-17

Added the unsupported, but fully working plug-in "animationjc" converted from git to bzr (including history) to Compiz 0.9.8.

=== added directory 'plugins/animationjc'
=== added file 'plugins/animationjc/CMakeLists.txt'
--- plugins/animationjc/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/CMakeLists.txt	2013-04-02 20:51:55 +0000
@@ -0,0 +1,7 @@
+find_package (Compiz REQUIRED)
+include (CompizPlugin)
+include (FindOpenGL)
+
+if (OPENGL_GLU_FOUND)
+    compiz_plugin (animationjc PLUGINDEPS composite opengl animation LIBRARIES ${OPENGL_glu_LIBRARY} INCDIRS ${OPENGL_INCLUDE_DIR})
+endif (OPENGL_GLU_FOUND)

=== added file 'plugins/animationjc/animationjc.xml.in'
--- plugins/animationjc/animationjc.xml.in	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/animationjc.xml.in	2013-04-02 20:51:55 +0000
@@ -0,0 +1,154 @@
+<compiz>
+  <!-- animationaddon metadata -->
+  <plugin name="animationjc" useBcop="true">
+    <_short>Animations Experimental</_short>
+    <_long>Extra window animations</_long>
+    <category>Effects</category>
+    <deps>
+      <requirement>
+	<plugin>opengl</plugin>
+	<plugin>animation</plugin>
+      </requirement>
+      <relation type="after">
+	<plugin>opengl</plugin>
+	<plugin>composite</plugin>
+	<plugin>animation</plugin>
+	<plugin>decor</plugin>
+      </relation>
+    </deps>
+
+    <options>
+    <group>
+      <_short>Effect Settings</_short>
+
+      <subgroup>
+        <_short>Black Hole</_short>
+	<option name="blackhole_delay" type="float">
+	  <_short>Delay</_short>
+	  <default>0.75</default>
+	  <min>0.0</min>
+	  <max>0.99</max>
+	  <precision>0.01</precision>
+	</option>
+      </subgroup>
+
+      <subgroup>
+        <_short>Flicker</_short>
+	<option name="flicker_amplitude" type="int">
+	  <_short>Amplitude</_short>
+	  <default>3</default>
+	  <min>1</min>
+	  <max>10</max>
+	</option>
+      </subgroup>
+
+      <subgroup>
+        <_short>Ghost</_short>
+	<option name="ghost_grid" type="int">
+	  <_short>Grid</_short>
+	  <default>20</default>
+	  <min>2</min>
+	  <max>20</max>
+	</option>
+
+	<option name="ghost_saturation" type="float">
+	  <_short>Saturation</_short>
+	  <default>0.0</default>
+	  <min>0.0</min>
+	  <max>1.0</max>
+	  <precision>0.1</precision>
+	</option>
+
+	<option name="ghost_amplitude" type="float">
+	  <_short>Amplitude</_short>
+	  <default>1.0</default>
+	  <min>0.0</min>
+	  <max>5.0</max>
+	</option>
+
+	<option name="ghost_wave_speed" type="float">
+	  <_short>Wave Speed</_short>
+	  <default>1.0</default>
+	  <min>0.0</min>
+	  <max>5.0</max>
+	</option>
+      </subgroup>
+
+      <subgroup>
+        <_short>Popcorn</_short>
+	<option name="popcorn_kernel_height" type="float">
+	  <_short>Kernel Height</_short>
+	  <default>1.0</default>
+	  <min>0.0</min>
+	  <max>5.0</max>
+	  <precision>0.1</precision>
+	</option>
+      </subgroup>
+
+      <subgroup>
+        <_short>Raindrop</_short>
+
+	<option name="raindrop_amplitude" type="float">
+	  <_short>Amplitude</_short>
+	  <default>1.0</default>
+	  <min>-5.0</min>
+	  <max>5.0</max>
+	  <precision>0.1</precision>
+	</option>
+
+	<option name="raindrop_wavelength" type="float">
+	  <_short>Wavelength</_short>
+	  <default>0.4</default>
+	  <min>0.0</min>
+	  <max>1.0</max>
+	  <precision>0.05</precision>
+	</option>
+
+	<option name="raindrop_num_waves" type="int">
+	  <_short>Number of Waves</_short>
+	  <default>1</default>
+	  <min>1</min>
+	  <max>5</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>
+      <base_option>minimize_effects</base_option>
+      <base_option>minimize_random_effects</base_option>
+      <restriction>
+        <value>animationjc:Black Hole</value>
+        <_name>Black Hole</_name>
+      </restriction>
+      <restriction>
+        <value>animationjc:Ghost</value>
+        <_name>Ghost</_name>
+      </restriction>
+      <restriction>
+        <value>animationjc:Popcorn</value>
+        <_name>Popcorn</_name>
+      </restriction>
+    </extension>
+
+    <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>
+      <base_option>focus_effects</base_option>
+      <restriction>
+        <value>animationjc:Flicker</value>
+        <_name>Flicker</_name>
+      </restriction>
+      <restriction>
+        <value>animationjc:Raindrop</value>
+        <_name>Raindrop</_name>
+      </restriction>
+    </extension>
+  </plugin>
+</compiz>

=== added file 'plugins/animationjc/compiz-animationjc.pc.in'
--- plugins/animationjc/compiz-animationjc.pc.in	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/compiz-animationjc.pc.in	2013-04-02 20:51:55 +0000
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: compiz-animationjc
+Description: Animation JC plugin for compiz
+Version: @VERSION@
+
+Requires: compiz compiz-composite compiz-opengl compiz-animation
+Libs: -L${libdir} -lanimationjc
+Cflags: @COMPIZ_CFLAGS@

=== added directory 'plugins/animationjc/include'
=== added directory 'plugins/animationjc/include/animationjc'
=== added file 'plugins/animationjc/include/animationjc/animationjc.h'
--- plugins/animationjc/include/animationjc/animationjc.h	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/include/animationjc/animationjc.h	2013-04-02 20:51:55 +0000
@@ -0,0 +1,343 @@
+#ifndef _COMPIZ_ANIMATIONJC_H
+#define _COMPIZ_ANIMATIONJC_H
+
+#define ANIMATIONADDON_ABI 20091206
+
+#include <core/pluginclasshandler.h>
+
+#include <vector>
+#include <boost/ptr_container/ptr_vector.hpp>
+
+using namespace::std;
+
+class PrivateAnimJCScreen;
+
+/*
+class AnimJCScreen :
+    public PluginClassHandler<AnimJCScreen, CompScreen, ANIMATIONADDON_ABI>,
+    public CompOption::Class
+{
+public:
+    AnimJCScreen (CompScreen *);
+    ~AnimJCScreen ();
+
+    CompOption::Vector &getOptions ();
+    bool setOption (const CompString &name, CompOption::Value &value);
+
+    int getIntenseTimeStep ();
+
+private:
+    PrivateAnimJCScreen *priv;
+};
+*/
+
+/// Base class for all polygon- and particle-based animations
+class BaseAddonAnim :
+    virtual public Animation
+{
+public:
+    BaseAddonAnim (CompWindow *w,
+		   WindowEvent curWindowEvent,
+		   float duration,
+		   const AnimEffect info,
+		   const CompRect &icon);
+    ~BaseAddonAnim () {}
+
+    bool needsDepthTest () { return mDoDepthTest; }
+
+protected:
+    /// Gets info about the extension plugin that implements this animation.
+    ExtensionPluginInfo *getExtensionPluginInfo ();
+
+    int mIntenseTimeStep;
+
+    CompositeScreen *mCScreen;
+    GLScreen *mGScreen;
+
+    bool mDoDepthTest;  ///< Whether depth testing should be used in the effect
+};
+
+// Particle stuff
+
+class Particle
+{
+public:
+    Particle () : life (0.0f) {}
+
+    float life;		///< particle life
+    float fade;		///< fade speed
+    float width;	///< particle width
+    float height;	///< particle height
+    float w_mod;	///< particle size modification during life
+    float h_mod;	///< particle size modification during life
+    float r;		///< red value
+    float g;		///< green value
+    float b;		///< blue value
+    float a;		///< alpha value
+    float x;		///< X position
+    float y;		///< Y position
+    float z;		///< Z position
+    float xi;		///< X direction
+    float yi;		///< Y direction
+    float zi;		///< Z direction
+    float xg;		///< X gravity
+    float yg;		///< Y gravity
+    float zg;		///< Z gravity
+    float xo;		///< orginal X position
+    float yo;		///< orginal Y position
+    float zo;		///< orginal Z position
+};
+
+class ParticleSystem
+{
+    friend class ParticleAnim;
+
+public:
+    ParticleSystem (int    numParticles,
+                    float  slowdown,
+		    float  darkenAmount,
+		    GLuint blendMode);
+    ~ParticleSystem ();
+
+    void draw (int offsetX = 0, int offsetY = 0);
+    void update (float time);
+    vector<Particle> &particles () { return mParticles; }
+    void activate () { mActive = true; }
+    bool active () { return mActive; }
+    void setOrigin (int x, int y) { mX = x; mY = y; }
+
+protected:
+    CompWindow *mWindow;
+
+    vector<Particle> mParticles;
+
+    float  mSlowDown;
+    float  mDarkenAmount;
+    GLuint mBlendMode;
+    GLuint mTex;
+    bool   mActive;
+    int    mX, mY;
+
+    GLScreen *mGScreen;
+
+    vector<GLfloat> mVerticesCache;
+    vector<GLfloat> mCoordsCache;
+    vector<GLfloat> mColorsCache;
+    vector<GLfloat> mDColorsCache;
+};
+
+class ParticleAnim :
+    public BaseAddonAnim,
+    public PartialWindowAnim
+{
+public:
+    ParticleAnim (CompWindow *w,
+		  WindowEvent curWindowEvent,
+		  float duration,
+		  const AnimEffect info,
+		  const CompRect &icon);
+    ~ParticleAnim () {}
+    void postPaintWindow ();
+    bool postPaintWindowUsed () { return true; }
+    void updateBB (CompOutput &output);
+    bool updateBBUsed () { return true; }
+    bool prePreparePaint (int msSinceLastPaint);
+    void initLightDarkParticles (int numLightParticles,
+                                 int numDarkParticles,
+                                 float lightSlowDown,
+                                 float darkSlowDown);
+
+protected:
+    boost::ptr_vector<ParticleSystem> mParticleSystems;
+};
+
+// Polygon stuff
+
+typedef enum
+{
+    CorrectPerspectiveNone = 0,
+    CorrectPerspectivePolygon,
+    CorrectPerspectiveWindow
+} CorrectPerspective;
+
+/// Base class for per-PolygonObject effect parameter classes
+class PolygonEffectParameters
+{
+};
+
+/// This is intended to be a closed 3D piece of a window with convex polygon
+/// faces and quad-strip sides. Since decoration texture is separate from
+/// the window texture, it is more complicated than it would be with a single
+/// texture: we use glClipPlane with the rectangles (clips) to clip 3D space
+/// to the region falling within that clip.
+/// If the polygon is on an edge/corner, it also has 2D shadow quad(s)
+/// (to be faded out at the beginning of 3D animation if necessary).
+class PolygonObject
+{
+public:
+    int nVertices;		///< number of total vertices (front + back)
+    int nSides;			///< number of sides
+    GLfloat *vertices;		///< Positions of vertices relative to center
+    GLushort *sideIndices;	///< Indices of quad strip for "sides"
+    GLfloat *normals;		///< Surface normals for 2+nSides faces
+
+    Boxf boundingBox;		///< Bound. box to test intersection with clips
+
+    // Animation effect parameters
+
+    Point3d centerPosStart;	///< Starting position of center
+    float rotAngleStart;	///< Starting rotation angle
+
+    Point3d centerPos;		///< Position of center
+    Vector3d rotAxis;		///< Rotation axis vector
+    float rotAngle;		///< Rotation angle
+    Point3d rotAxisOffset;	///< Rotation axis translate amount
+
+    Point centerRelPos;		///< Relative pos of center within the window
+
+    Vector3d finalRelPos;	///< Velocity factor for scripted movement
+    float finalRotAng;		///< Final rotation angle around rotAxis
+
+    float moveStartTime;	///< Movement starts at this time ([0-1] range)
+    float moveDuration;		///< Movement lasts this long     ([0-1] range)
+
+    float fadeStartTime;	///< Fade out starts at this time ([0,1] range)
+    float fadeDuration;		///< Duration of fade out         ([0,1] range)
+
+    /** Pointer to a struct that can contain
+	custom parameters for an individual effect */
+    PolygonEffectParameters *effectParameters;
+
+    float boundSphereRadius;    ///< Radius of bounding sphere
+};
+
+/// Info about intersection of a polygon and clip
+class PolygonClipInfo
+{
+public:
+    PolygonClipInfo (const PolygonObject *p);
+
+    const PolygonObject *p; ///< the intersecting polygon-object
+
+    /// Texture coord.s for each vertex of the polygon-object
+    /// ordered as: Front v1.x, y, v2.x, y, ...,
+    ///             followed by back vertex texture coordinates.
+    vector<GLfloat> vertexTexCoords;
+};
+
+class Clip4Polygons	        ///< Rectangular clips
+{				///< (to hold clips passed to AddWindowGeometry)
+public:
+    CompRect box;		///< Coords
+    Boxf boxf;			///< Float coords (for small clipping adjustment)
+    GLTexture::Matrix texMatrix;///< Corresponding texture coord. matrix
+
+    /// True if this clip likely intersects all polygons
+    /// (for the window-contents clip). Used for optimization purposes.
+    bool intersectsMostPolygons;
+
+    /// For polygons that intersect this clip.
+    /// Only used when intersectsMostPolygons is false.
+    list<PolygonClipInfo *> intersectingPolygonInfos;
+
+    /// Texture coord.s for each vertex of each polygon-object
+    /// ordered as: Front p1.v1.x, y, p1.v2.x, .y, p2.v1.x, .y, ...,
+    ///             followed by back vertex texture coordinates.
+    /// Only used when intersectsMostPolygons is true.
+    vector<GLfloat> polygonVertexTexCoords;
+};
+
+class PolygonAnim :
+    virtual public Animation,
+    public BaseAddonAnim
+{
+public:
+    PolygonAnim (CompWindow *w,
+		 WindowEvent curWindowEvent,
+		 float duration,
+		 const AnimEffect info,
+		 const CompRect &icon);
+    ~PolygonAnim ();
+
+    void step ();
+    void prePaintWindow ();
+    void postPaintWindow ();
+    bool postPaintWindowUsed () { return true; }
+    void addGeometry (const GLTexture::MatrixList &matrix,
+                      const CompRegion            &region,
+                      const CompRegion            &clipRegion,
+                      unsigned int                maxGridWidth,
+                      unsigned int                maxGridHeight);
+    void drawGeometry ();
+    virtual void updateBB (CompOutput &output);
+    bool updateBBUsed () { return true; }
+    bool prePreparePaint (int msSinceLastPaint);
+    bool moveUpdate (int dx, int dy);
+
+    virtual void stepPolygon (PolygonObject *p,
+			      float forwardProgress);
+    virtual void transformPolygon (const PolygonObject *p) {}
+
+    /// For effects that have decel. motion
+    virtual bool deceleratingMotion () { return false; }
+
+    bool tessellateIntoRectangles (int gridSizeX,
+				   int gridSizeY,
+				   float thickness);
+    bool tessellateIntoHexagons (int gridSizeX,
+				 int gridSizeY,
+				 float thickness);
+    bool tessellateIntoGlass (int gridSizeX,
+			      int gridSizeY,
+			      float thickness);
+
+    void prePaintOutput (CompOutput *output);
+    void deceleratingAnimStepPolygon (PolygonObject *p,
+                                      float forwardProgress);
+
+protected:
+    void getPerspectiveCorrectionMat (const PolygonObject *p,
+				      GLfloat *mat,
+				      GLMatrix *matf,
+				      const CompOutput &output);
+    void processIntersectingPolygons ();
+    virtual void freePolygonObjects ();
+    void freeClipsPolygons ();
+    void prepareDrawingForAttrib (GLFragment::Attrib &attrib);
+
+    int mNumDrawGeometryCalls;
+    int mNumClipsPassed;	 /**< # of clips passed to animAddWindowGeometry so far
+				      in this draw step */
+    bool mClipsUpdated;          ///< whether stored clips are updated in this anim step
+
+    vector<Clip4Polygons> mClips;///< Rect. clips collected in addGeometries
+    int mFirstNondrawnClip;
+    vector<int> mLastClipInGroup;/**< Index of the last clip in each group of clips
+				      drawn in drawGeometry func. */
+
+    bool mDoLighting;            ///< Whether lighting should be used in the effect
+    CorrectPerspective mCorrectPerspective;
+
+    vector<PolygonObject *> mPolygons; ///< The polygons in this set
+    float mThickness;		///< Window thickness (depth along z axis)
+    int mNumTotalFrontVertices;	///< Total # of polygon vertices on front faces
+    float mBackAndSidesFadeDur;	///< How long side and back faces should fade in/out
+    float mAllFadeDuration;	/**< Duration of fade out at the end in [0,1] range
+				     when all polygons fade out at the same time.
+				     If >-1, this overrides fadeDuration in PolygonObject */
+
+    bool mIncludeShadows;        ///< Whether to include shadows in polygon
+
+private:
+    inline void drawPolygonClipIntersection (const PolygonObject *p,
+					     const Clip4Polygons &c,
+					     const GLfloat *vertexTexCoords,
+					     int pass,
+					     float forwardProgress,
+					     GLdouble clipPlane[4][4],
+					     const CompOutput &output,
+					     float newOpacity,
+					     bool decelerates,
+					     GLfloat skewMat[16]);
+};
+#endif

=== added directory 'plugins/animationjc/src'
=== added file 'plugins/animationjc/src/animationjc.cpp'
--- plugins/animationjc/src/animationjc.cpp	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/animationjc.cpp	2013-04-02 20:51:55 +0000
@@ -0,0 +1,145 @@
+#include "private.h"
+
+class AnimJCPluginVTable :
+    public CompPlugin::VTableForScreenAndWindow<AnimJCScreen, AnimJCWindow>
+{
+public:
+    bool init ();
+};
+
+COMPIZ_PLUGIN_20090315 (animationjc, AnimJCPluginVTable);
+
+AnimEffect animEffects[NUM_EFFECTS];
+
+ExtensionPluginAnimJC animJCExtPluginInfo (CompString ("animationjc"),
+					   NUM_EFFECTS, animEffects, NULL,
+                                           NUM_NONEFFECT_OPTIONS);
+
+AnimEffect AnimEffectBlackHole;
+AnimEffect AnimEffectFlicker;
+AnimEffect AnimEffectGhost;
+AnimEffect AnimEffectPopcorn;
+AnimEffect AnimEffectRaindrop;
+
+ExtensionPluginInfo *
+BaseAddonAnim::getExtensionPluginInfo ()
+{
+    return &animJCExtPluginInfo;
+}
+
+BaseAddonAnim::BaseAddonAnim (CompWindow *w,
+			      WindowEvent curWindowEvent,
+			      float duration,
+			      const AnimEffect info,
+			      const CompRect &icon) :
+    Animation::Animation (w, curWindowEvent, duration, info, icon),
+    mIntenseTimeStep (AnimJCScreen::get (::screen)->getIntenseTimeStep ()),
+    mCScreen (CompositeScreen::get (::screen)),
+    mGScreen (GLScreen::get (::screen)),
+    mDoDepthTest (false)
+{
+}
+
+void
+AnimJCScreen::initAnimationList ()
+{
+    int i = 0;
+
+    animEffects[i++] = AnimEffectBlackHole =
+        new AnimEffectInfo ("animationjc:Black Hole",
+                            true, true, true, false, false,
+                            &createAnimation<BlackHoleAnim>);
+
+    animEffects[i++] = AnimEffectFlicker =
+        new AnimEffectInfo ("animationjc:Flicker",
+                            true, true, true, false, true,
+                            &createAnimation<FlickerAnim>);
+
+    animEffects[i++] = AnimEffectGhost =
+        new AnimEffectInfo ("animationjc:Ghost",
+                            true, true, true, false, false,
+                            &createAnimation<GhostAnim>);
+
+    animEffects[i++] = AnimEffectPopcorn =
+        new AnimEffectInfo ("animationjc:Popcorn",
+                            true, true, true, false, false,
+                            &createAnimation<PopcornAnim>);
+
+    animEffects[i++] = AnimEffectRaindrop =
+        new AnimEffectInfo ("animationjc:Raindrop",
+                            true, true, true, false, true,
+                            &createAnimation<RaindropAnim>);
+
+    animJCExtPluginInfo.effectOptions = &getOptions ();
+
+    AnimScreen *as = AnimScreen::get (::screen);
+
+    // Extends animation plugin with this set of animation effects.
+    as->addExtension (&animJCExtPluginInfo);
+}
+
+PrivateAnimJCScreen::PrivateAnimJCScreen (CompScreen *s) :
+    mOutput (s->fullscreenOutput ())
+{
+}
+
+PrivateAnimJCScreen::~PrivateAnimJCScreen ()
+{
+    AnimScreen *as = AnimScreen::get (::screen);
+
+    as->removeExtension (&animJCExtPluginInfo);
+
+    for (int i = 0; i < NUM_EFFECTS; i++)
+    {
+	delete animEffects[i];
+	animEffects[i] = NULL;
+    }
+}
+
+AnimJCScreen::AnimJCScreen (CompScreen *s) :
+    PluginClassHandler<AnimJCScreen, CompScreen, ANIMATIONADDON_ABI> (s),
+    priv (new PrivateAnimJCScreen (s))
+{
+    initAnimationList ();
+}
+
+AnimJCScreen::~AnimJCScreen ()
+{
+    delete priv;
+}
+
+AnimJCWindow::AnimJCWindow (CompWindow *w) :
+    PluginClassHandler<AnimJCWindow, CompWindow> (w),
+    mWindow (w),
+    aWindow (AnimWindow::get (w))
+{
+}
+
+AnimJCWindow::~AnimJCWindow ()
+{
+    Animation *curAnim = aWindow->curAnimation ();
+
+    if (!curAnim)
+	return;
+
+    // We need to interrupt and clean up the animation currently being played
+    // by animationaddon for this window (if any)
+    if (curAnim->remainingTime () > 0 &&
+	curAnim->getExtensionPluginInfo ()->name ==
+	    CompString ("animationjc"))
+    {
+	aWindow->postAnimationCleanUp ();
+    }
+}
+
+bool
+AnimJCPluginVTable::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/animationjc/src/blackhole.cpp'
--- plugins/animationjc/src/blackhole.cpp	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/blackhole.cpp	2013-04-02 20:51:55 +0000
@@ -0,0 +1,79 @@
+#include "private.h"
+
+#include <algorithm>
+
+BlackHoleAnim::BlackHoleAnim (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),
+    GridTransformAnim::GridTransformAnim (w, curWindowEvent, duration, info,
+                                          icon)
+{
+}
+
+void
+BlackHoleAnim::initGrid ()
+{
+    mGridWidth = 20;
+    mGridHeight = 20;
+}
+
+void
+BlackHoleAnim::step ()
+{
+    CompRect winRect (mAWindow->savedRectsValid () ?
+                      mAWindow->saveWinRect () :
+                      mWindow->geometry ());
+    CompRect outRect (mAWindow->savedRectsValid () ?
+                      mAWindow->savedOutRect () :
+                      mWindow->outputRect ());
+    CompWindowExtents outExtents (mAWindow->savedRectsValid () ?
+			          mAWindow->savedOutExtents () :
+			          mWindow->output ());
+
+    int wx = winRect.x ();
+    int wy = winRect.y ();
+
+    int owidth = outRect.width ();
+    int oheight = outRect.height ();
+
+    float centerx = wx + mModel->scale ().x () *
+	    (owidth * 0.5 - outExtents.left);
+    float centery = wy + mModel->scale ().y () *
+	    (oheight * 0.5 - outExtents.top);
+
+    float delay = AnimJCScreen::get (screen)->optionGetBlackholeDelay ();
+    float tau = (1. - delay) / 8.;
+
+    GridModel::GridObject *object = mModel->objects ();
+    unsigned int n = mModel->numObjects ();
+    for (unsigned int i = 0; i < n; i++, object++)
+    {
+	// find distance to center in grid terms, 0..1
+	float gridDistance = 2 * max (fabs (object->gridPosition ().x ()-0.5),
+				      fabs (object->gridPosition ().y ()-0.5));
+
+	// use that and tau to find r
+	float cutoff = gridDistance * delay;
+	float r = 1;
+	if (getBlackHoleProgress () > cutoff)
+	    r = exp (-(getBlackHoleProgress () - cutoff) / tau);
+
+	// find real original coordinates
+	float origx = wx + mModel->scale ().x () *
+		(owidth * object->gridPosition ().x () -
+		outExtents.left);
+	float origy = wy + mModel->scale ().y () *
+                (oheight * object->gridPosition ().y () -
+                outExtents.top);
+
+	// shrink toward center by r
+	Point3d &objPos = object->position ();
+	objPos.setX ((origx-centerx) * r + centerx);
+	objPos.setY ((origy-centery) * r + centery);
+	objPos.setZ (0);
+    }
+}

=== added file 'plugins/animationjc/src/flicker.cpp'
--- plugins/animationjc/src/flicker.cpp	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/flicker.cpp	2013-04-02 20:51:55 +0000
@@ -0,0 +1,96 @@
+#include <private.h>
+
+void
+FlickerSingleAnim::updateAttrib (GLWindowPaintAttrib &attrib)
+{
+    int layer = MultiAnim <FlickerSingleAnim,5>::getCurrAnimNumber (mAWindow);
+    float o = 0.2;
+    attrib.opacity *= o / (1. - (4-layer)*o);
+}
+
+void
+FlickerSingleAnim::initGrid ()
+{
+    mGridWidth = 2;
+    mGridHeight = 20;
+}
+
+void
+FlickerSingleAnim::step ()
+{
+    int layer = MultiAnim <FlickerSingleAnim,5>::getCurrAnimNumber (mAWindow);
+
+    CompRect winRect (mAWindow->savedRectsValid () ?
+                      mAWindow->saveWinRect () :
+                      mWindow->geometry ());
+    CompRect outRect (mAWindow->savedRectsValid () ?
+                      mAWindow->savedOutRect () :
+                      mWindow->outputRect ());
+    CompWindowExtents outExtents (mAWindow->savedRectsValid () ?
+                                  mAWindow->savedOutExtents () :
+                                  mWindow->output ());
+
+    int wx = winRect.x ();
+    int wy = winRect.y ();
+    int owidth = outRect.width ();
+    int oheight = outRect.height ();
+
+    float t = 1 - progressLinear ();
+    if (mCurWindowEvent == WindowEventClose)
+	t = 1 - t;
+
+    float amplitude = AnimJCScreen::get (screen)->optionGetFlickerAmplitude ();
+    float waveLength = 0.4;
+    float wavePosition = -waveLength + (1. + waveLength) * t;
+
+    float displacement = 0;
+
+    GridModel::GridObject *object = mModel->objects ();
+    unsigned int n = mModel->numObjects ();
+    for (unsigned int i = 0; i < n; i++, object++)
+    {
+	Point3d &objPos = object->position ();
+
+	if (i % 2 == 0) // left side; reuse old displacement on right side
+	{
+	    float distFromWave = object->gridPosition ().y () - wavePosition;
+
+	    if (distFromWave > 0 && distFromWave <= waveLength)
+	    {
+		displacement = amplitude * sin (distFromWave/waveLength * M_PI);
+	    }
+	    else
+	    {
+		displacement = 0;
+	    }
+	}
+
+        float x = wx + mModel->scale ().x () *
+            (owidth * object->gridPosition ().x () - outExtents.left);
+
+	float y = wy + mModel->scale ().y () *
+	    (oheight * object->gridPosition ().y () - outExtents.top);
+
+	switch (layer)
+	{
+	    case 1:
+		x -= displacement;
+		break;
+	    case 2:
+		x += displacement;
+		break;
+	    case 3:
+		y -= displacement;
+		break;
+	    case 4:
+		y += displacement;
+		break;
+	    default:
+		break;
+	}
+
+        objPos.setX (x);
+	objPos.setY (y);
+	objPos.setZ (0);
+    }
+}

=== added file 'plugins/animationjc/src/ghost.cpp'
--- plugins/animationjc/src/ghost.cpp	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/ghost.cpp	2013-04-02 20:51:55 +0000
@@ -0,0 +1,98 @@
+#include "private.h"
+
+GhostAnim::GhostAnim (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),
+    GridTransformAnim::GridTransformAnim (w, curWindowEvent, duration, info,
+                                          icon)
+{
+}
+
+void
+GhostAnim::updateAttrib (GLWindowPaintAttrib &attrib)
+{
+    AnimJCScreen *ajs = AnimJCScreen::get (screen);
+    attrib.opacity *= 1. - progressLinear ();
+    attrib.saturation *= ajs->optionGetGhostSaturation ();
+}
+
+void
+GhostAnim::initGrid ()
+{
+    AnimJCScreen *ajs = AnimJCScreen::get (screen);
+    mGridWidth = ajs->optionGetGhostGrid ();
+    mGridHeight = ajs->optionGetGhostGrid ();
+}
+
+void
+GhostAnim::step ()
+{
+    float t = 1. - progressLinear ();
+    if (mCurWindowEvent == WindowEventClose)
+	t = 1. - t;
+
+    CompRect winRect (mAWindow->savedRectsValid () ?
+                      mAWindow->saveWinRect () :
+                      mWindow->geometry ());
+    CompRect outRect (mAWindow->savedRectsValid () ?
+                      mAWindow->savedOutRect () :
+                      mWindow->outputRect ());
+    CompWindowExtents outExtents (mAWindow->savedRectsValid () ?
+			          mAWindow->savedOutExtents () :
+			          mWindow->output ());
+
+    int wx = winRect.x ();
+    int wy = winRect.y ();
+
+    int owidth = outRect.width ();
+    int oheight = outRect.height ();
+
+    AnimJCScreen *ajs = AnimJCScreen::get (screen);
+
+    float waveAmp = 3 * ajs->optionGetGhostAmplitude ();
+    float waveLengthX1 = 0.4;
+    float waveLengthX2 = 0.3;
+    float waveLengthY1 = 0.45;
+    float waveLengthY2 = 0.35;
+    float wavePositionX1 =  0.25 * t * ajs->optionGetGhostWaveSpeed ();
+    float wavePositionX2 = -0.25 * t * ajs->optionGetGhostWaveSpeed ();
+    float wavePositionY1 =  0.25 * t * ajs->optionGetGhostWaveSpeed ();
+    float wavePositionY2 = -0.25 * t * ajs->optionGetGhostWaveSpeed ();
+
+    GridModel::GridObject *object = mModel->objects ();
+    unsigned int n = mModel->numObjects ();
+    for (unsigned int i = 0; i < n; i++, object++)
+    {
+	Point3d &objPos = object->position ();
+
+	float origx = wx + mModel->scale ().x () *
+		(owidth * object->gridPosition ().x () -
+		outExtents.left);
+
+	float origy = wy + mModel->scale ().y () *
+		(oheight * object->gridPosition ().y () -
+		outExtents.top);
+
+	float x = object->gridPosition ().x ();
+	float y = object->gridPosition ().y ();
+
+	float distFromWaveX1 = x - wavePositionX1;
+	float distFromWaveX2 = x - wavePositionX2;
+	float distFromWaveY1 = y - wavePositionY1;
+	float distFromWaveY2 = y - wavePositionY2;
+
+	objPos.setX (origx +
+		     waveAmp * sin (distFromWaveX1 / waveLengthX1 * 2 * M_PI) +
+		     waveAmp * sin (distFromWaveX2 / waveLengthX2 * 2 * M_PI));
+
+	objPos.setY (origy +
+		     waveAmp * sin (distFromWaveY1 / waveLengthY1 * 2 * M_PI) +
+		     waveAmp * sin (distFromWaveY2 / waveLengthY2 * 2 * M_PI));
+
+	objPos.setZ (0);
+    }
+}

=== added file 'plugins/animationjc/src/popcorn.cpp'
--- plugins/animationjc/src/popcorn.cpp	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/popcorn.cpp	2013-04-02 20:51:55 +0000
@@ -0,0 +1,60 @@
+#include <private.h>
+
+#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)
+
+float
+PopcornSingleAnim::layerProgress (int layer)
+{
+    if (layer == 0)
+	return 0;
+
+    float tStart = (5. - layer) / 6.;
+    float tEnd = tStart + 1./3.;
+
+    float t = progressLinear ();
+
+    if (t < tStart)
+	return 0;
+
+    if (t > tEnd)
+	return 1;
+
+    return (t - tStart) / (tEnd - tStart);
+}
+
+void
+PopcornSingleAnim::updateAttrib (GLWindowPaintAttrib &attrib)
+{
+    int layer = MultiAnim <PopcornSingleAnim, 6>::getCurrAnimNumber (mAWindow);
+
+    attrib.opacity *= 1. - progressLinear ();
+
+    attrib.opacity *= 1. - layerProgress (layer);
+}
+
+void
+PopcornSingleAnim::applyTransform ()
+{
+    int layer = MultiAnim <PopcornSingleAnim, 6>::getCurrAnimNumber (mAWindow);
+
+    if (layer == 0) return;
+
+    float p = layerProgress (layer);
+
+    float v = 40.;
+    float theta = (54. + 144.*(layer-1)) / 180. * 3.14159265;
+    float dx = v * cos (theta) * p;
+    float dy = -v * sin (theta) * p;
+
+    mTransform.translate (dx, dy,
+	    0.16*p*AnimJCScreen::get (screen)->optionGetPopcornKernelHeight ());
+}
+
+void
+PopcornSingleAnim::updateBB (CompOutput &output)
+{
+    TransformAnim::updateBB (output);
+}

=== added file 'plugins/animationjc/src/private.h'
--- plugins/animationjc/src/private.h	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/private.h	2013-04-02 20:51:55 +0000
@@ -0,0 +1,232 @@
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <core/core.h>
+#include <composite/composite.h>
+#include <opengl/opengl.h>
+
+#include <boost/foreach.hpp>
+#define foreach BOOST_FOREACH
+
+#include <animation/animation.h>
+#include <animationjc/animationjc.h>
+
+#include "animationjc_options.h"
+
+extern AnimEffect AnimEffectBlackHole;
+extern AnimEffect AnimEffectFlicker;
+extern AnimEffect AnimEffectGhost;
+extern AnimEffect AnimEffectPopcorn;
+extern AnimEffect AnimEffectRaindrop;
+
+#define NUM_EFFECTS 5
+
+// This must have the value of the first "effect setting" above
+// in AnimJCScreenOptions
+#define NUM_NONEFFECT_OPTIONS 0
+
+class ExtensionPluginAnimJC : public ExtensionPluginInfo
+{
+public:
+    ExtensionPluginAnimJC (const CompString &name,
+			      unsigned int nEffects,
+			      AnimEffect *effects,
+			      CompOption::Vector *effectOptions,
+			      unsigned int firstEffectOptionIndex) :
+	ExtensionPluginInfo (name, nEffects, effects, effectOptions,
+			     firstEffectOptionIndex) {}
+    ~ExtensionPluginAnimJC () {}
+
+    const CompOutput *output () { return mOutput; }
+
+private:
+    const CompOutput *mOutput;
+};
+
+class AnimJCScreen :
+    public PluginClassHandler<AnimJCScreen, CompScreen, ANIMATIONADDON_ABI>,
+    public AnimationjcOptions
+{
+public:
+    AnimJCScreen (CompScreen *);
+    ~AnimJCScreen ();
+
+    int getIntenseTimeStep ();
+
+    void initAnimationList ();
+
+private:
+    PrivateAnimJCScreen *priv;
+};
+
+class PrivateAnimJCScreen
+{
+    friend class AnimJCScreen;
+
+public:
+    PrivateAnimJCScreen (CompScreen *);
+    ~PrivateAnimJCScreen ();
+
+protected:
+    CompOutput &mOutput;
+};
+
+class AnimJCWindow :
+    public PluginClassHandler<AnimJCWindow, CompWindow>
+{
+public:
+    AnimJCWindow (CompWindow *);
+    ~AnimJCWindow ();
+
+protected:
+    CompWindow *mWindow;    ///< Window being animated.
+    AnimWindow *aWindow;
+};
+
+/*** BLACK HOLE **************************************************************/
+
+class BlackHoleAnim :
+    public GridTransformAnim
+{
+public:
+    BlackHoleAnim (CompWindow *w,
+                   WindowEvent curWindowEvent,
+                   float duration,
+                   const AnimEffect info,
+                   const CompRect &icon);
+
+    float getBlackHoleProgress () { return progressLinear (); }
+
+    void initGrid ();
+    inline bool using3D () { return false; }
+    void step ();
+};
+
+/*** RAINDROP ****************************************************************/
+
+class RaindropAnim :
+    public GridTransformAnim
+{
+public:
+    RaindropAnim (CompWindow *w,
+                  WindowEvent curWindowEvent,
+                  float duration,
+                  const AnimEffect info,
+                  const CompRect &icon);
+
+    void initGrid ();
+
+    inline bool using3D () { return true; }
+
+    void step ();
+};
+
+/*** POPCORN *****************************************************************/
+
+class PopcornSingleAnim :
+    public TransformAnim
+{
+public:
+    PopcornSingleAnim (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)
+    {
+    }
+
+    float layerProgress (int);
+
+    void applyTransform ();
+
+    void updateAttrib (GLWindowPaintAttrib &);
+
+    void updateBB (CompOutput &output);
+    bool updateBBUsed () { return true; }
+};
+
+class PopcornAnim :
+    public MultiAnim <PopcornSingleAnim, 6>
+{
+public:
+    PopcornAnim (CompWindow *w,
+                 WindowEvent curWindowEvent,
+                 float duration,
+                 const AnimEffect info,
+                 const CompRect &icon) :
+	    MultiAnim <PopcornSingleAnim, 6>::MultiAnim
+		    (w, curWindowEvent, duration, info, icon)
+    {
+    }
+};
+
+/*** GHOST *******************************************************************/
+
+class GhostAnim :
+    public GridTransformAnim
+{
+public:
+    GhostAnim (CompWindow *w,
+               WindowEvent curWindowEvent,
+               float duration,
+               const AnimEffect info,
+               const CompRect &icon);
+
+    void initGrid ();
+
+    inline bool using3D () { return true; }
+
+    void step ();
+
+    void updateAttrib (GLWindowPaintAttrib &);
+};
+
+/*** FLICKER *****************************************************************/
+
+class FlickerSingleAnim :
+    public GridTransformAnim
+{
+public:
+    FlickerSingleAnim (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),
+	    GridTransformAnim::GridTransformAnim
+		    (w, curWindowEvent, duration, info, icon)
+    {
+    }
+
+    void updateAttrib (GLWindowPaintAttrib &);
+
+    void initGrid ();
+
+    void step ();
+
+    bool updateBBUsed () { return true; }
+    void updateBB (CompOutput &output) { TransformAnim::updateBB (output); }
+};
+
+class FlickerAnim :
+    public MultiAnim <FlickerSingleAnim, 5>
+{
+public:
+    FlickerAnim (CompWindow *w,
+                 WindowEvent curWindowEvent,
+                 float duration,
+                 const AnimEffect info,
+                 const CompRect &icon) :
+	    MultiAnim <FlickerSingleAnim, 5>::MultiAnim
+		    (w, curWindowEvent, duration, info, icon)
+    {
+    }
+};

=== added file 'plugins/animationjc/src/raindrop.cpp'
--- plugins/animationjc/src/raindrop.cpp	1970-01-01 00:00:00 +0000
+++ plugins/animationjc/src/raindrop.cpp	2013-04-02 20:51:55 +0000
@@ -0,0 +1,85 @@
+#include "private.h"
+
+#include <algorithm>
+
+RaindropAnim::RaindropAnim (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),
+    GridTransformAnim::GridTransformAnim (w, curWindowEvent, duration, info,
+                                          icon)
+{
+}
+
+void
+RaindropAnim::initGrid ()
+{
+    mGridWidth = 20;
+    mGridHeight = 20;
+}
+
+void
+RaindropAnim::step ()
+{
+    float t = 1. - progressLinear ();
+    if (mCurWindowEvent == WindowEventClose)
+	t = 1. - t;
+
+    CompRect winRect (mAWindow->savedRectsValid () ?
+                      mAWindow->saveWinRect () :
+                      mWindow->geometry ());
+    CompRect outRect (mAWindow->savedRectsValid () ?
+                      mAWindow->savedOutRect () :
+                      mWindow->outputRect ());
+    CompWindowExtents outExtents (mAWindow->savedRectsValid () ?
+			          mAWindow->savedOutExtents () :
+			          mWindow->output ());
+
+    int wx = winRect.x ();
+    int wy = winRect.y ();
+
+    int owidth = outRect.width ();
+    int oheight = outRect.height ();
+
+    AnimJCScreen *ajs = AnimJCScreen::get (screen);
+
+    float waveLength = ajs->optionGetRaindropWavelength ();
+    int numWaves = ajs->optionGetRaindropNumWaves ();
+    float waveAmp = (pow ((float)oheight / ::screen->height (), 0.4) * 0.08) *
+	    ajs->optionGetRaindropAmplitude ();
+    float wavePosition = -waveLength * numWaves +
+	    (1. + waveLength * numWaves) * t;
+
+    GridModel::GridObject *object = mModel->objects ();
+    unsigned int n = mModel->numObjects ();
+    for (unsigned int i = 0; i < n; i++, object++)
+    {
+	Point3d &objPos = object->position ();
+
+        float origx = wx + mModel->scale ().x () *
+		(owidth * object->gridPosition ().x () -
+		outExtents.left);
+        objPos.setX (origx);
+
+	float origy = wy + mModel->scale ().y () *
+		(oheight * object->gridPosition ().y () -
+		outExtents.top);
+        objPos.setY (origy);
+
+	// find distance to center in grid terms
+	float gridDistance = sqrt (pow (object->gridPosition ().x ()-0.5, 2) +
+			           pow (object->gridPosition ().y ()-0.5, 2)) *
+			     sqrt (2);
+
+	float distFromWave = gridDistance - wavePosition;
+	if (distFromWave < waveLength*numWaves && distFromWave > 0)
+	    objPos.setZ (waveAmp *
+		    sin (3.14159265 * distFromWave / waveLength / numWaves) *
+		    pow (sin (3.14159265 * distFromWave / waveLength), 2));
+	else
+	    objPos.setZ (0);
+    }
+}