Merge lp:~mc-return/compiz/compiz.merge-cubeaddon-improvements into lp:compiz/0.9.11

[MC Return]

Cubeaddon, cleanup:

Declaration of variables outside of loops.
Declaration and assignment of local variables in one line.
Merged if condition checks.
Use pre- instead of postfix increments.
Removed redundant brackets.
Added and removed newlines.
Fixed indentation.
float rS = cDist2 + 0.5; is needed in both if-else branches.

Cubeaddon, speedup:

Calculation of static values outside of loops, no need to
recalculate those multiple times (float premultColors[],
float normalizedOpacity).
Just call optionGetGroundSize () once, save the value in
the float groundSize and use this in following calculations.
Introduced
GLfloat cubeDistance = cubeScreen->distance ();,
GLfloat cubeDistanceSquared = cubeDistance * cubeDistance;,
float tsSize = 360.0f / static_cast <float> (size);,
float aScale = 1.0 / scale;,
float outputWidth = static_cast <float> (output->width ());,
float outputHeight = static_cast <float> (output->height ());,
int jPlus1 = j + 1;,
float halfW = w / 2.0f;,
float xSq = x * x;,
float cDistW = cDist * w;,
float rMinusXSq = r - xSq;,
int iCapElem = i * (CAP_ELEMENTS + 1);,
float halfAngle = angle / 2.0f;,
float degToRad = M_PI / 180.0f; and
GLfloat gsf = -0.5f + static_cast <GLfloat> (((1 - v) *
optionGetGroundSize ()) + v);
and used those variables in the following calculations.
Do not call screen->width (); twice in a row (several times).
Do not calculate
mCapFill[1] - 0.5,
sqrt (0.5 + cDist2) - 0.5; and
point[1] - 0.5 twice in a row.
Introduced GLfloat gSY = static_cast <GLfloat>(groundSize - 0.5f); and
used this variable in the assignment of the ground2Vertices[] array.
Introduced GLfloat halfV = v / 2.0f; and used this variable in the
assignment of the GLfloat vertices[] array.

Just enable GL_BLEND if it is disabled and just disable
it afterwards, if it was disabled before.

Still WIP.

Unmerged revisions

3757. By MC Return on 2013-07-21

Merged latest lp:compiz

3756. By MC Return on 2013-07-21

Added missing whitespace
Renamed csDistance and csDistanceSquared to cubeDistance and
cubeDistanceSquared
NULL-initialized the GLVertexBuffer *streamingBuffer pointer
Renamed oWidth and oHeight to outputWidth and outputHeight

3755. By MC Return on 2013-07-06

Introduced GLfloat gSY = static_cast <GLfloat>(groundSize - 0.5f); and
used this variable in the assignment of the ground2Vertices[] array
Introduced GLfloat halfV = v / 2.0f; and used this variable in the
assignment of the GLfloat vertices[] array
Added missing whitespace
Reverted alignment in the ctor

3754. By MC Return on 2013-07-06

Cubeaddon, multiple improvements
(please see main commit message for details)

=== modified file 'plugins/cubeaddon/src/cubeaddon.cpp'
--- plugins/cubeaddon/src/cubeaddon.cpp	2013-05-09 13:43:07 +0000
+++ plugins/cubeaddon/src/cubeaddon.cpp	2013-07-24 16:09:50 +0000
@@ -34,21 +34,23 @@
  */
 CubeaddonScreen::CubeCap::CubeCap ()
 {
-    mCurrent    = 0;
-    mLoaded     = false;
+    mCurrent = 0;
+    mLoaded  = false;
 }
 
 /*
  * Attempt to load current cap image (if any)
  */
 void
-CubeaddonScreen::CubeCap::load (bool scale, bool aspect, bool clamp)
+CubeaddonScreen::CubeCap::load (bool scale,
+				bool aspect,
+				bool clamp)
 {
     /* we need to clear the texture, if no texture files are specified */
     if (mFiles.empty ())
     {
 	mTexture.clear ();
-	mLoaded = false;
+	mLoaded  = false;
 	mCurrent = 0;
 
 	return;
@@ -64,7 +66,7 @@
     mLoaded = false;
 
     CompString imgName = mFiles[mCurrent].s ();
-    CompString pname = "cubeaddon";
+    CompString pname   = "cubeaddon";
     mTexture = GLTexture::readImageToTexture (imgName, pname, tSize);
 
     if (mTexture.empty ())
@@ -78,10 +80,10 @@
     mLoaded = true;
     mTexMat.reset ();
 
-    mTexMat[0] = mTexture[0]->matrix ().xx;
-    mTexMat[1] = mTexture[0]->matrix ().yx;
-    mTexMat[4] = mTexture[0]->matrix ().xy;
-    mTexMat[5] = mTexture[0]->matrix ().yy;
+    mTexMat[0]  = mTexture[0]->matrix ().xx;
+    mTexMat[1]  = mTexture[0]->matrix ().yx;
+    mTexMat[4]  = mTexture[0]->matrix ().xy;
+    mTexMat[5]  = mTexture[0]->matrix ().yy;
     mTexMat[12] = mTexture[0]->matrix ().x0;
     mTexMat[13] = mTexture[0]->matrix ().y0;
 
@@ -135,6 +137,7 @@
 	glTexParameteri (mTexture[0]->target (), GL_TEXTURE_WRAP_S, GL_REPEAT);
 	glTexParameteri (mTexture[0]->target (), GL_TEXTURE_WRAP_T, GL_REPEAT);
     }
+
     mTexture[0]->disable ();
 }
 
@@ -144,63 +147,68 @@
  * Switch cap, load it and damage screen if possible
  */
 bool
-CubeaddonScreen::changeCap (bool top, int change)
+CubeaddonScreen::changeCap (bool top,
+			    int  change)
 {
-    CubeCap *cap = (top)? &mTopCap : &mBottomCap;
-
-    int count = cap->mFiles.size ();
+    CubeCap *cap  = (top) ? &mTopCap : &mBottomCap;
+    int     count = cap->mFiles.size ();
 
     /* mCurrent just changes in this case */
     if (count && change)
 	cap->mCurrent = (cap->mCurrent + change + count) % count;
 
     if (top)
-    {
 	cap->load (optionGetTopScale (), optionGetTopAspect (),
 		   optionGetTopClamp ());
-    }
     else
     {
 	cap->load (optionGetBottomScale (), optionGetBottomAspect (),
 		   optionGetBottomClamp ());
 	cap->mTexMat.scale (1.0, -1.0, 1.0);
     }
+
     cScreen->damageScreen ();
 
     return false;
 }
 
 bool
-CubeaddonScreen::setOption (const CompString &name, CompOption::Value &value)
+CubeaddonScreen::setOption (const CompString  &name,
+			    CompOption::Value &value)
 {
     unsigned int index;
 
     bool rv = CubeaddonOptions::setOption (name, value);
 
     if (!rv || !CompOption::findOption (getOptions (), name, &index))
-        return false;
+	return false;
 
-    switch (index) {
+    switch (index)
+    {
 	case CubeaddonOptions::TopImages :
 	    mTopCap.mFiles   = optionGetTopImages ();
-            mTopCap.mCurrent = 0;
-            changeCap (true, 0);
+	    mTopCap.mCurrent = 0;
+	    changeCap (true, 0);
 	    break;
+
 	case CubeaddonOptions::BottomImages :
 	    mBottomCap.mFiles   = optionGetBottomImages ();
-            mBottomCap.mCurrent = 0;
-            changeCap (false, 0);
+	    mBottomCap.mCurrent = 0;
+	    changeCap (false, 0);
 	    break;
+
 	case CubeaddonOptions::TopScale :
 	case CubeaddonOptions::TopAspect :
 	case CubeaddonOptions::TopClamp :
-            changeCap (true, 0);
+	    changeCap (true, 0);
 	    break;
+
 	case CubeaddonOptions::BottomScale :
 	case CubeaddonOptions::BottomAspect :
 	case CubeaddonOptions::BottomClamp :
-            changeCap (false, 0);
+	    changeCap (false, 0);
 	    break;
+
 	default:
 	    break;
     }
@@ -211,7 +219,11 @@
 void
 CubeaddonScreen::drawBasicGround ()
 {
-    glEnable (GL_BLEND);
+    GLboolean glBlendEnabled = glIsEnabled (GL_BLEND);
+
+    if (!glBlendEnabled)
+	glEnable (GL_BLEND);
+
     glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     float i = optionGetIntensity () * 2;
 
@@ -221,9 +233,9 @@
     GLfloat ground1Vertices[] =
     {
 	-0.5, -0.5, 0.0,
-	0.5, -0.5, 0.0,
-	-0.5, 0.0, 0.0,
-	0.5, 0.0, 0.0
+	 0.5, -0.5, 0.0,
+	-0.5,  0.0, 0.0,
+	 0.5,  0.0, 0.0
     };
 
     unsigned short maxG1Color = MAX (0.0f, 1.0f - i) * 65535;
@@ -242,17 +254,22 @@
 
     streamingBuffer->addVertices (4, ground1Vertices);
     streamingBuffer->addColors (4, ground1Colors);
+
     if (streamingBuffer->end ())
 	streamingBuffer->render (transform);
 
-    if (optionGetGroundSize () > 0.0)
+    float groundSize = optionGetGroundSize ();
+
+    if (groundSize)
     {
+	GLfloat gSY = static_cast <GLfloat>(groundSize - 0.5f);
+
 	GLfloat ground2Vertices[] =
 	{
 	    -0.5, -0.5, 0.0,
-	    0.5, -0.5, 0.0,
-	    -0.5, static_cast <GLfloat> (-0.5 + optionGetGroundSize ()), 0.0,
-	    0.5, static_cast <GLfloat> (-0.5 + optionGetGroundSize ()), 0.0
+	     0.5, -0.5, 0.0,
+	    -0.5,  gSY, 0.0,
+	     0.5,  gSY, 0.0
 	};
 
 	streamingBuffer->begin (GL_TRIANGLE_STRIP);
@@ -261,12 +278,15 @@
 	streamingBuffer->addColors (1, optionGetGroundColor2 ());
 	streamingBuffer->addColors (1, optionGetGroundColor2 ());
 	streamingBuffer->addVertices (4, ground2Vertices);
+
 	if (streamingBuffer->end ())
 	    streamingBuffer->render (transform);
     }
 
     glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-    glDisable (GL_BLEND);
+
+    if (!glBlendEnabled)
+	glDisable (GL_BLEND);
 }
 
 bool 
@@ -285,24 +305,25 @@
 }
 
 void 
-CubeaddonScreen::cubeGetRotation (float &x, float &v, float &progress)
+CubeaddonScreen::cubeGetRotation (float &x,
+				  float &v,
+				  float &progress)
 {
-
     cubeScreen->cubeGetRotation (x, v, progress);
 
     if (optionGetMode () == ModeAbove && v > 0.0 && mReflection)
     {
 	mVRot = v;
-	v = 0.0;
+	v     = 0.0;
     }
     else
 	mVRot = 0.0;
 }
 
 void 
-CubeaddonScreen::cubeClearTargetOutput (float xRotate, float vRotate)
+CubeaddonScreen::cubeClearTargetOutput (float xRotate,
+					float vRotate)
 {
-
     if (mReflection)
 	glCullFace (GL_BACK);
 
@@ -324,14 +345,17 @@
     if (rv || cubeScreen->unfolded ())
 	return rv;
 
+    GLfloat cubeDistance        = cubeScreen->distance ();
+    GLfloat cubeDistanceSquared = cubeDistance * cubeDistance;
+
     if (mDeform > 0.0 && optionGetDeformation () == DeformationCylinder)
     {
 	float z[3];
 
-	z[0] = cubeScreen->invert () * cubeScreen->distance ();
-	z[1] = z[0] + (0.25 / cubeScreen->distance ());
+	z[0] = cubeScreen->invert () * cubeDistance;
+	z[1] = z[0] + (0.25 / cubeDistance);
 	z[2] = cubeScreen->invert () *
-	       sqrtf (0.25 + (cubeScreen->distance () * cubeScreen->distance ()));
+	       sqrtf (0.25 + cubeDistanceSquared);
 
 	std::vector<GLVector> vPoints[3];
 
@@ -352,16 +376,16 @@
 	bool ftb3 = cubeScreen->cubeCheckOrientation (sAttrib, transform,
 						      output, vPoints[2]);
 
-	rv = (order == FTB && (ftb1 || ftb2 || ftb3)) ||
+	rv = (order == FTB && ( ftb1 ||  ftb2 ||  ftb3)) ||
 	     (order == BTF && (!ftb1 || !ftb2 || !ftb3));
     }
     else if (mDeform > 0.0 && optionGetDeformation () == DeformationSphere)
     {
 	float z[4];
 
-	z[0] = sqrtf (0.5 + (cubeScreen->distance () * cubeScreen->distance ()));
-	z[1] = z[0] + (0.25 / cubeScreen->distance ());
-	z[2] = sqrtf (0.25 + (cubeScreen->distance () * cubeScreen->distance ()));
+	z[0] = sqrtf (0.5  + cubeDistanceSquared);
+	z[1] = z[0] + (0.25 / cubeDistance);
+	z[2] = sqrtf (0.25 + cubeDistanceSquared);
 	z[3] = z[2] + 0.5;
 
 	std::vector<GLVector> vPoints[4];
@@ -388,7 +412,7 @@
 	bool ftb4 = cubeScreen->cubeCheckOrientation (sAttrib, transform,
 						      output, vPoints[3]);
 
-	rv = (order == FTB && (ftb1 || ftb2 || ftb3 || ftb4)) ||
+	rv = (order == FTB && (ftb1  || ftb2  || ftb3  || ftb4)) ||
 	     (order == BTF && (!ftb1 || !ftb2 || !ftb3 || !ftb4));
     }
 
@@ -405,12 +429,14 @@
 {
     GLScreenPaintAttrib sa;
     GLMatrix            sTransform;
+    GLVertexBuffer      *streamingBuffer = NULL;
     int                 cullNorm, cullInv;
     bool                wasCulled = glIsEnabled (GL_CULL_FACE);
     float               cInv = (top) ? 1.0: -1.0;
+    float               tsSize = 360.0f / static_cast <float> (size);
     CubeCap             *cap;
     bool                cAspect;
-    unsigned short	*color;
+    unsigned short      *color;
 
     glGetIntegerv (GL_CULL_FACE_MODE, &cullNorm);
     cullInv   = (cullNorm == GL_BACK)? GL_FRONT : GL_BACK;
@@ -422,7 +448,10 @@
 
     int opacity = cubeScreen->desktopOpacity () * color[3] / 0xffff;
 
-    glEnable (GL_BLEND);
+    GLboolean glBlendEnabled = glIsEnabled (GL_BLEND);
+
+    if (!glBlendEnabled)
+	glEnable (GL_BLEND);
 
     if (top)
     {
@@ -437,21 +466,28 @@
 
     glEnable(GL_CULL_FACE);
 
-    for (int l = 0; l < ((cubeScreen->invert () == 1) ? 2 : 1); l++)
+    unsigned int vertexIndex;
+    float normalizedOpacity = opacity / static_cast <float> (OPAQUE);
+    float premultColors[] =
+    {
+	(color[0] / OPAQUE) * normalizedOpacity,
+	(color[1] / OPAQUE) * normalizedOpacity,
+	(color[2] / OPAQUE) * normalizedOpacity
+    };
+
+    for (int l = 0; l < ((cubeScreen->invert () == 1) ? 2 : 1); ++l)
     {
 	glCullFace(((l == 1) ^ top) ? cullInv : cullNorm);
 
-	for (int i = 0; i < size; i++)
+	for (int i = 0; i < size; ++i)
 	{
-	    GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
+	    streamingBuffer = GLVertexBuffer::streamingBuffer ();
 
 	    streamingBuffer->begin (GL_TRIANGLE_FAN);
 
 	    if (optionGetDeformation () == DeformationSphere &&
 		optionGetDeformCaps ())
-	    {
 		streamingBuffer->addNormals (CAP_NVERTEX / 3, (l == 0) ? mCapFill : mCapFillNorm);
-	    }
 	    else
 	    {
 		GLfloat nonDeformNormals[] = { 0.0f, (l == 0) ? 1.0f : -1.0f, 0.0f };
@@ -460,20 +496,24 @@
 
 	    sa = sAttrib;
 	    sTransform = transform;
+
 	    if (cubeScreen->invert () == 1)
 	    {
-		sa.yRotate += (360.0f / size) * cubeScreen->xRotations ();
+		sa.yRotate += tsSize * cubeScreen->xRotations ();
+
 		if (!adjust)
-		    sa.yRotate -= (360.0f / size) * screen->vp ().x ();
+		    sa.yRotate -= tsSize * screen->vp ().x ();
 	    }
 	    else
 	    {
 		sa.yRotate += 180.0f;
-		sa.yRotate -= (360.0f / size) * cubeScreen->xRotations ();
+		sa.yRotate -= tsSize * cubeScreen->xRotations ();
+
 		if (!adjust)
-		    sa.yRotate += (360.0f / size) * screen->vp ().x ();
+		    sa.yRotate += tsSize * screen->vp ().x ();
 	    }
-	    sa.yRotate += (360.0f / size) * i;
+
+	    sa.yRotate += tsSize * i;
 
 	    gScreen->glApplyTransform (sa, output, &sTransform);
 
@@ -482,25 +522,18 @@
 	    cTransform.scale (cubeScreen->outputXScale (), cubeScreen->outputYScale (), 1.0f);
 	    cTransform.scale (1.0, cInv, 1.0);
 
-	    float normalizedOpacity = opacity / static_cast <float> (OPAQUE);
-	    float premultColors[] =
-	    {
-		(color[0] / OPAQUE) * normalizedOpacity,
-		(color[1] / OPAQUE) * normalizedOpacity,
-		(color[2] / OPAQUE) * normalizedOpacity
-	    };
-
 	    streamingBuffer->color4f (premultColors[0],
 				      premultColors[1],
 				      premultColors[2],
 				      normalizedOpacity);
 
 	    streamingBuffer->addVertices (CAP_ELEMENTS + 2, mCapFill);
+
 	    if (streamingBuffer->end ())
 		streamingBuffer->render (cTransform);
 
 	    if (optionGetDeformation () == DeformationSphere &&
-	        optionGetDeformCaps ())
+		optionGetDeformCaps ())
 	    {
 #ifndef USE_GLES
 		streamingBuffer->begin (GL_QUADS);
@@ -516,7 +549,7 @@
 
 		for (unsigned int i = 0; i < CAP_NIDX; ++i)
 		{
-		    unsigned int   vertexIndex = idx[i] * 3;
+		    vertexIndex = idx[i] * 3;
 
 		    *(capVerticesPtr++) = (mCapFill[vertexIndex]);
 		    *(capVerticesPtr++) = (mCapFill[vertexIndex + 1]);
@@ -533,7 +566,7 @@
 	    if (cap->mLoaded)
 	    {
 		GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
-		GLMatrix texMat = cap->mTexMat;
+		GLMatrix       texMat           = cap->mTexMat;
 
 		if (cubeScreen->invert () != 1)
 		    texMat.scale (-1.0, 1.0, 1.0);
@@ -547,17 +580,18 @@
 					  normalizedOpacity,
 					  normalizedOpacity);
 
-	        cap->mTexture[0]->enable (GLTexture::Good);
+		cap->mTexture[0]->enable (GLTexture::Good);
 
 		if (cAspect)
 		{
-		    float scale, xScale = 1.0, yScale = 1.0;
-		    scale = (float)output->width () / (float)output->height ();
+		    float xScale = 1.0, yScale = 1.0;
+		    float scale  = (float)output->width () / (float)output->height ();
+		    float aScale = 1.0 / scale;
 
 		    if (output->width () > output->height ())
 		    {
 			xScale = 1.0;
-			yScale = 1.0 / scale;
+			yScale = aScale;
 		    }
 		    else
 		    {
@@ -567,32 +601,34 @@
 
 		    if (optionGetTopScale ())
 		    {
-			scale = xScale;
+			scale  = xScale;
 			xScale = 1.0 / yScale;
-			yScale = 1.0 / scale;
+			yScale = aScale;
 		    }
 
 		    texMat.scale (xScale, yScale, 1.0);
 		}
 		
-		texMat.rotate (-(360.0f / size) * i, 0.0, 0.0, 1.0);
+		texMat.rotate (-tsSize * i, 0.0, 0.0, 1.0);
 
 		GLVector sGen (texMat[0], texMat[8], texMat[4], texMat[12]);
 		GLVector tGen (texMat[1], texMat[9], texMat[5], texMat[13]);
 
 		/* Generate texCoords for the top section of the
 		 * cap */
-		GLfloat texCoords[(CAP_ELEMENTS + 2) * 2];
-		GLfloat *texCoordsPtr = texCoords;
+		GLfloat  texCoords[(CAP_ELEMENTS + 2) * 2];
+		GLfloat  *texCoordsPtr = texCoords;
+		float    s, t;
 
-		for (unsigned int i = 0; i < CAP_ELEMENTS + 2; i++)
+		for (unsigned int i = 0; i < CAP_ELEMENTS + 2; ++i)
 		{
 		    GLVector v (mCapFill[i * 3],
 				mCapFill[i * 3 + 1],
 				mCapFill[i * 3 + 2],
 				1.0f);
-		    float s = v * sGen;
-		    float t = v * tGen;
+
+		    s = v * sGen;
+		    t = v * tGen;
 
 		    *(texCoordsPtr++) = s;
 		    *(texCoordsPtr++) = t;
@@ -601,11 +637,12 @@
 		streamingBuffer->addTexCoords (0, CAP_NVERTEX / 3, &texCoords[0]);
 		streamingBuffer->addVertices (CAP_NVERTEX / 3, mCapFill);
 		streamingBuffer->setMaxVertices (CAP_ELEMENTS + 2);
+
 		if (streamingBuffer->end ())
 		    streamingBuffer->render (cTransform);
 
 		if (optionGetDeformation () == DeformationSphere &&
-	            optionGetDeformCaps ())
+		    optionGetDeformCaps ())
 		{
 #ifndef USE_GLES
 		    streamingBuffer->begin (GL_QUADS);
@@ -632,13 +669,14 @@
 		    GLushort *idx = mCapFillIdx;
 		    GLfloat  capVertices[CAP_NIDX * 3];
 		    GLfloat  texCoords[CAP_NIDX * 2];
+		    GLfloat  *capVerticesPtr = capVertices;
+		    GLfloat  *texCoordsPtr   = texCoords;
 
-		    GLfloat *capVerticesPtr = capVertices;
-		    GLfloat *texCoordsPtr = texCoords;
+		    unsigned int vertexIndex;
 
 		    for (unsigned int i = 0; i < CAP_NIDX; ++i)
 		    {
-			unsigned int   vertexIndex = idx[i] * 3;
+			vertexIndex = idx[i] * 3;
 
 			GLVector v (mCapFill[vertexIndex],
 				    mCapFill[vertexIndex + 1],
@@ -653,8 +691,8 @@
 			 * texCoord.s = dot (vec4 (obj, 1.0), sGenPlane)
 			 * texCoord.t = dot (vec4 (obj, 1.0), tGenPlane)
 			 */
-			float s = v * sGen;
-			float t = v * tGen;
+			s = v * sGen;
+			t = v * tGen;
 
 			*(texCoordsPtr++) = s;
 			*(texCoordsPtr++) = t;
@@ -673,9 +711,11 @@
 	}
     }
 
-    glDisable (GL_BLEND);
+    if (!glBlendEnabled)
+	glDisable (GL_BLEND);
 
     glCullFace (cullNorm);
+
     if (!wasCulled)
 	glDisable (GL_CULL_FACE);
 }
@@ -719,7 +759,7 @@
 	cubeScreen->cubePaintBottom (sAttrib, transform, output, size, normal);
     else
 	paintCap (sAttrib, transform, output, size,
-	      false, optionGetAdjustBottom ());
+		  false, optionGetAdjustBottom ());
 }
 
 void 
@@ -731,57 +771,50 @@
 {
     if (caScreen->mDeform > 0.0)
     {
-	GLVertexBuffer     *vb = gWindow->vertexBuffer ();
-	int                i, oldVCount = vb->countVertices ();
-	GLfloat            *v;
-	int                offX = 0, offY = 0;
-	int                sx1, sx2, sw, sy1, sy2, sh;
-	float              radSquare, last[2][4];
-	float              inv = (cubeScreen->invert () == 1) ? 1.0 : -1.0;
-
-	float              ang, sx1g, sx2g, sy1g, sy2g;
-	
-	CubeScreen::MultioutputMode   cMOM = cubeScreen->multioutputMode ();
-	int                           caD = caScreen->optionGetDeformation ();
-	float                         cDist = cubeScreen->distance ();
-	
+	CubeScreen::MultioutputMode cMOM  = cubeScreen->multioutputMode ();
+	int                         caD   = caScreen->optionGetDeformation ();
+	float                       cDist = cubeScreen->distance ();
+	float                       radSquare;
 
 	if (caD == CubeaddonScreen::DeformationCylinder || cubeScreen->unfolded ())
-	{
-	    radSquare = (cDist * cDist) + 0.25;
-	}
+	    radSquare     = cDist * cDist + 0.25;
 	else
 	{
 	    maxGridHeight = MIN (CUBEADDON_GRID_SIZE, maxGridHeight);
-	    radSquare = (cDist * cDist) + 0.5;
+	    radSquare     = cDist * cDist + 0.5;
 	}
 
 	gWindow->glAddGeometry (matrix, region, clip, 
 				MIN (CUBEADDON_GRID_SIZE, maxGridWidth),
 				maxGridHeight);
 
-	vb = gWindow->vertexBuffer ();
+	GLVertexBuffer *vb       = gWindow->vertexBuffer ();
+	int            oldVCount = vb->countVertices ();
 	
-	v  = vb->getVertices ();
-	v += vb->getVertexStride () - 3;
-	v += vb->getVertexStride () * oldVCount;
+	GLfloat *v = vb->getVertices ();
+	v         += vb->getVertexStride () - 3;
+	v         += vb->getVertexStride () * oldVCount;
+
+	int offX = 0, offY = 0;
 
 	if (!window->onAllViewports ())
 	{
 	    CompPoint offset = caScreen->cScreen->windowPaintOffset ();
-	    offset = window->getMovementForOffset (offset);
-	    offX = offset.x ();
-	    offY = offset.y ();
+	    offset           = window->getMovementForOffset (offset);
+	    offX             = offset.x ();
+	    offY             = offset.y ();
 	}
-	
+
+	int sx1, sx2, sw, sy1, sy2, sh;
+
 	if (cMOM == CubeScreen::OneBigCube)
 	{
 	    sx1 = 0;
 	    sx2 = screen->width ();
-	    sw  = screen->width ();
+	    sw  = sx2;
 	    sy1 = 0;
 	    sy2 = screen->height ();
-	    sh  = screen->height ();
+	    sh  = sy2;
 	}
 	else if (cMOM == CubeScreen::MultipleCubes)
 	{
@@ -798,10 +831,10 @@
 	    {
 		sx1 = 0;
 		sx2 = screen->width ();
-		sw  = screen->width ();
+		sw  = sx2;
 		sy1 = 0;
 		sy2 = screen->height ();
-		sh  = screen->height ();
+		sh  = sy2;
 	    }
 	    else
 	    {
@@ -814,26 +847,29 @@
 	    }
 	}
 	
-	sx1g = sx1 - CUBEADDON_GRID_SIZE;
-	sx2g = sx2 + CUBEADDON_GRID_SIZE;
-	sy1g = sy1 - CUBEADDON_GRID_SIZE;
-	sy2g = sy2 + CUBEADDON_GRID_SIZE;
+	float sx1g = sx1 - CUBEADDON_GRID_SIZE;
+	float sx2g = sx2 + CUBEADDON_GRID_SIZE;
+	float sy1g = sy1 - CUBEADDON_GRID_SIZE;
+	float sy2g = sy2 + CUBEADDON_GRID_SIZE;
+	float inv  = (cubeScreen->invert () == 1) ? 1.0 : -1.0;
+	float last[2][4];
+	float ang;
+	int   i;
 
 	if (caD == CubeaddonScreen::DeformationCylinder || cubeScreen->unfolded ())
 	{
 	    float lastX = std::numeric_limits <float>::min (), lastZ = 0.0;
 	
-	    for (i = oldVCount; i < vb->countVertices (); i++)
+	    for (i = oldVCount; i < vb->countVertices (); ++i)
 	    {
 		if (v[0] == lastX)
-		{
 		    v[2] = lastZ;
-		}
 		else if (v[0] + offX >= sx1g &&
 			 v[0] + offY < sx2g)
 		{
 		    ang = (((v[0] + offX - sx1) / (float)sw) - 0.5);
 		    ang *= ang;
+
 		    if (ang < radSquare)
 		    {
 			v[2] = sqrtf (radSquare - ang) - cDist;
@@ -849,12 +885,13 @@
 	}
 	else
 	{
-
 	    last[0][0] = -1000000000.0;
 	    last[1][0] = -1000000000.0;
 
-	    int cLast = 0;
-	    for (i = oldVCount; i < vb->countVertices (); i++)
+	    int   cLast = 0;
+	    float vpx, vpy;
+
+	    for (i = oldVCount; i < vb->countVertices (); ++i)
 	    {
 		if (last[0][0] == v[0] && last[0][1] == v[1])
 		{
@@ -871,8 +908,8 @@
 		    continue;
 		}
 		
-		float vpx = v[0] + offX;
-		float vpy = v[1] + offY;
+		vpx = v[0] + offX;
+		vpy = v[1] + offY;
 		
 		if (vpx >= sx1g && vpx < sx2g &&
 		    vpy >= sy1g && vpy < sy2g)
@@ -883,8 +920,8 @@
 		    float a2 = (((vpy - sy1) / (float)sh) - 0.5);
 		    a2 *= a2;
 
-		    ang = atanf (a1 / cDist);
-		    a2 = sqrtf (radSquare - a2);
+		    ang      = atanf (a1 / cDist);
+		    a2       = sqrtf (radSquare - a2);
 		    int iang = (((int)(ang * RAD2I1024)) + 1024) & 0x3ff;
 
 		    v[2] += ((caScreen->mCosT [iang] * a2) - cDist) * caScreen->mDeform * inv;
@@ -898,9 +935,7 @@
 	}
     }
     else
-    {
 	gWindow->glAddGeometry (matrix, region, clip, maxGridWidth, maxGridHeight);
-    }
 }
 
 bool 
@@ -921,9 +956,9 @@
 	
 	int x1 = window->x () - window->output ().left + offset.x ();
 	int x2 = window->x () + window->width () + window->output ().right + offset.x ();
-	if (x1 < 0 && x2 < 0)
-	    return false;
-	if (x1 > screen->width () && x2 > screen->width ())
+
+	if ((x1 < 0 && x2 < 0) ||
+	    (x1 > screen->width () && x2 > screen->width ()))
 	    return false;
     }
 
@@ -944,8 +979,8 @@
 	float     x, y;
 	GLfloat   *v, *n;
 	
-	GLVertexBuffer               *vb = gWindow->vertexBuffer ();
-	CubeScreen::MultioutputMode  cMOM = cubeScreen->multioutputMode ();
+	GLVertexBuffer               *vb   = gWindow->vertexBuffer ();
+	CubeScreen::MultioutputMode  cMOM  = cubeScreen->multioutputMode ();
 	float                        cDist = cubeScreen->distance ();
 
 	float inv = (cubeScreen->invert () == 1) ? 1.0: -1.0;
@@ -956,14 +991,14 @@
 	if ((int) caScreen->mWinNormSize < vertexCount * 3)
 	{
 	    delete [] caScreen->mWinNormals;
-	    caScreen->mWinNormals = new GLfloat[vertexCount * 3];
+	    caScreen->mWinNormals  = new GLfloat[vertexCount * 3];
 	    caScreen->mWinNormSize = vertexCount * 3;
 	}
 	
 	if (!window->onAllViewports ())
 	{
 	    CompPoint offset = caScreen->cScreen->windowPaintOffset ();
-	    offset = window->getMovementForOffset (offset);
+	    offset           = window->getMovementForOffset (offset);
 	    offX = offset.x ();
 	    offY = offset.y ();
 	}
@@ -972,10 +1007,10 @@
 	{
 	    sx1 = 0;
 	    sx2 = screen->width ();
-	    sw  = screen->width ();
+	    sw  = sx2;
 	    sy1 = 0;
 	    sy2 = screen->height ();
-	    sh  = screen->height ();
+	    sh  = sy2;
 	}
 	else if (cMOM == CubeScreen::MultipleCubes)
 	{
@@ -1013,7 +1048,7 @@
 
 	if (cubeScreen->paintOrder () == FTB)
 	{
-	    for (i = 0; i < vertexCount; i++)
+	    for (i = 0; i < vertexCount; ++i)
 	    {
 		x = (((v[0] + offX - sx1) / (float)sw) - 0.5);
 		y = (((v[1] + offY - sy1) / (float)sh) - 0.5);
@@ -1027,7 +1062,7 @@
 	}
 	else
 	{
-	    for (i = 0; i < vertexCount; i++)
+	    for (i = 0; i < vertexCount; ++i)
 	    {
 		x = (((v[0] + offX - sx1) / (float)sw) - 0.5);
 		y = (((v[1] + offY - sy1) / (float)sh) - 0.5);
@@ -1054,9 +1089,10 @@
 CubeaddonScreen::cubeShouldPaintAllViewports ()
 {
     bool status = cubeScreen->cubeShouldPaintAllViewports ();
-    return (!optionGetDrawTop () ||
+
+    return (!optionGetDrawTop ()    ||
 	    !optionGetDrawBottom () ||
-	    (mDeform > 0.0) ||
+	    (mDeform > 0.0)	    ||
 	    status);
 }
 
@@ -1067,16 +1103,16 @@
 					   CompOutput                *output,
 					   unsigned int              mask)
 {
-    GLMatrix       sTransform = transform;
-    float          cDist = cubeScreen->distance ();
-    float          cDist2 = cubeScreen->distance () * cubeScreen->distance ();
+    GLMatrix sTransform = transform;
+    float    cDist      = cubeScreen->distance ();
+    float    cDist2     = cDist * cDist;
 
-    if (optionGetDeformation () != DeformationNone && 
-	screen->vpSize ().width () * cubeScreen->nOutput () > 2 && 
-	screen->desktopWindowCount () &&
+    if (optionGetDeformation () != DeformationNone		&&
+	screen->vpSize ().width () * cubeScreen->nOutput () > 2 &&
+	screen->desktopWindowCount ()				&&
 	(cubeScreen->rotationState () == CubeScreen::RotationManual ||
 	(cubeScreen->rotationState () == CubeScreen::RotationChange &&
-	!optionGetCylinderManualOnly ()) || mWasDeformed) &&
+	!optionGetCylinderManualOnly ()) || mWasDeformed)	&&
         (!cubeScreen->unfolded () || optionGetUnfoldDeformation ()))
     {
 	float x, progress;
@@ -1087,26 +1123,26 @@
 	if (optionGetSphereAspect () > 0.0 && cubeScreen->invert () == 1 &&
 	    optionGetDeformation () == DeformationSphere)
 	{
-	    float scale, val = optionGetSphereAspect () * mDeform;
+	    float scale, val   = optionGetSphereAspect () * mDeform;
+	    float outputWidth  = static_cast <float> (output->width ());
+	    float outputHeight = static_cast <float> (output->height ());
 
-	    if (output->width () > output->height ())
+	    if (outputWidth > outputHeight)
 	    {
-		scale = (float)output->height () / (float)output->width ();
+		scale = outputHeight / outputWidth;
 		scale = (scale * val) + 1.0 - val;
 		sTransform.scale (scale, 1.0, 1.0);
 	    }
 	    else
 	    {
-		scale = (float)output->width () / (float)output->height ();
+		scale = outputWidth / outputHeight;
 		scale = (scale * val) + 1.0 - val;
 		sTransform.scale (1.0, scale, 1.0);
 	    }
 	}
     }
     else
-    {
 	mDeform = 0.0;
-    }
 
     cubeScreen->cubeShouldPaintAllViewportsSetEnabled (this, true);
 
@@ -1116,40 +1152,42 @@
 	changeCap (false, 0);
     }
 
-    if (mDeform != mCapDeform || mCapDistance != cDist ||
-        mCapDeformType != optionGetDeformation ())
+    if (mDeform        != mCapDeform	||
+	mCapDistance   != cDist		||
+	mCapDeformType != optionGetDeformation ())
     {
-	float       *quad;
-	int         j;
-	float       rS, r, x, y, z;
+	float *quad;
+	int   j, jPlus1;
+	float rS = cDist2 + 0.5;
+	float r, x, y, z;
+
 	if (optionGetDeformation () != DeformationSphere ||
 	    !optionGetDeformCaps ())
 	{
-	    rS = cDist2 + 0.5;
-
 	    mCapFill[0] = 0.0;
 	    mCapFill[1] = 0.5;
 	    mCapFill[2] = 0.0;
-	    mCapFillNorm[0] = 0.0;
+	    mCapFillNorm[0] =  0.0;
 	    mCapFillNorm[1] = -1.0;
-	    mCapFillNorm[2] = 0.0;
+	    mCapFillNorm[2] =  0.0;
 
+	    y = 0.5;
 	    z = cDist;
 	    r = 0.25 + cDist2;
 
-	    for (j = 0; j <= CAP_ELEMENTS; j++)
+	    for (j = 0; j <= CAP_ELEMENTS; ++j)
 	    {
-		x = -0.5 + ((float)j / (float)CAP_ELEMENTS);
-		z = ((sqrtf(r - (x * x)) - cDist) * mDeform) + cDist;
-		y = 0.5;
+		x      = -0.5 + ((float)j / (float)CAP_ELEMENTS);
+		z      = ((sqrtf(r - (x * x)) - cDist) * mDeform) + cDist;
+		jPlus1 = j + 1;
 
-		quad = &mCapFill[(1 + j) * 3];
+		quad = &mCapFill[jPlus1 * 3];
 
 		quad[0] = x;
 		quad[1] = y;
 		quad[2] = z;
 
-		quad = &mCapFillNorm[(1 + j) * 3];
+		quad = &mCapFillNorm[jPlus1 * 3];
 
 		quad[0] = -x;
 		quad[1] = -y;
@@ -1158,35 +1196,40 @@
 	}
 	else
 	{
-	    float w;
-	    rS = cDist2 + 0.5;
+	    float w, halfW, xSq, cDistW, rMinusXSq;
+	    int   iCapElem;
 
 	    mCapFill[0] = 0.0;
 	    mCapFill[1] = ((sqrtf (rS) - 0.5) * mDeform) + 0.5;
 	    mCapFill[2] = 0.0;
-	    mCapFillNorm[0] = 0.0;
+	    mCapFillNorm[0] =  0.0;
 	    mCapFillNorm[1] = -1.0;
-	    mCapFillNorm[2] = 0.0;
+	    mCapFillNorm[2] =  0.0;
 
-	    for (int i = 0; i < CAP_ELEMENTS; i++)
+	    for (int i = 0; i < CAP_ELEMENTS; ++i)
 	    {
-		w = (float)(i + 1) / (float)CAP_ELEMENTS;
-
-		r = (((w / 2.0) * (w / 2.0)) + (cDist2 * w * w));
-
-		for (j = 0; j <= CAP_ELEMENTS; j++)
+		w     = (float)(i + 1) / (float)CAP_ELEMENTS;
+		halfW = w / 2.0f;
+		r     = (halfW * halfW) + (cDist2 * w * w);
+
+		for (j = 0; j <= CAP_ELEMENTS; ++j)
 		{
-		    x = - (w / 2.0) + ((float)j * w / (float)CAP_ELEMENTS);
-		    z = ((sqrtf(r - (x * x)) - (cDist * w)) * mDeform) + (cDist * w);
-		    y = ((sqrtf(rS - (x * x) - (r - (x * x))) - 0.5) * mDeform) + 0.5;
+		    x         = -halfW + ((float)j * w / (float)CAP_ELEMENTS);
+		    xSq       = x * x;
+		    cDistW    = cDist * w;
+		    rMinusXSq = r - xSq;
+		    z         = ((sqrtf(rMinusXSq) - cDistW) * mDeform) + cDistW;
+		    y         = ((sqrtf(rS - xSq - rMinusXSq) - 0.5) * mDeform) + 0.5;
+		    iCapElem  = i * (CAP_ELEMENTS + 1);
+		    jPlus1    = j + 1;
 
-		    quad = &mCapFill[(1 + (i * (CAP_ELEMENTS + 1)) + j) * 3];
+		    quad = &mCapFill[(jPlus1 + iCapElem) * 3];
 
 		    quad[0] = x;
 		    quad[1] = y;
 		    quad[2] = z;
 
-		    quad = &mCapFillNorm[(1 + (i * (CAP_ELEMENTS + 1)) + j) * 3];
+		    quad = &mCapFillNorm[(jPlus1 + iCapElem) * 3];
 
 		    quad[0] = -x;
 		    quad[1] = -y;
@@ -1202,7 +1245,7 @@
 
     if (cubeScreen->invert () == 1 && mFirst && optionGetReflection ())
     {
-	mFirst = false;
+	mFirst      = false;
 	mReflection = true;
 
 	if (screen->grabExist ("cube"))
@@ -1221,62 +1264,68 @@
 	}
 	else
 	{
-	    GLMatrix      rTransform = sTransform;
-	    GLMatrix      pTransform;
-	    float         angle = 360.0 / ((float) screen->vpSize ().width () * 
-				  cubeScreen->nOutput ());
-	    float         xRot, vRot, xRotate, xRotate2, vRotate, p;
-	    float         rYTrans;
-	    GLVector      point (-0.5, -0.5, cDist, 1.0);
-	    GLVector      point2 (-0.5,  0.5, cDist, 1.0);
-	    float         deform = 0.0f;
+	    GLMatrix rTransform = sTransform;
 
+	    float xRot, vRot, p;
 	    cubeScreen->cubeGetRotation (xRot, vRot, p);
 
 	    mBackVRotate = 0.0;
 
-	    xRotate  = xRot;
-	    xRotate2 = xRot;
-	    vRotate  = vRot;
+	    float xRotate  = xRot;
+	    float xRotate2 = xRot;
+	    float vRotate  = vRot;
 
 	    if (vRotate < 0.0)
 		xRotate += 180;
 
-	    vRotate = fmod (fabs (vRotate), 180.0);
-	    xRotate = fmod (fabs (xRotate), angle);
-	    xRotate2 = fmod (fabs (xRotate2), angle);
+	    float angle = 360.0 / ((float) screen->vpSize ().width () *
+				   cubeScreen->nOutput ());
+	    float halfAngle = angle / 2.0f;
+	    float degToRad  = M_PI / 180.0f;
+
+	    vRotate     = fmod (fabs (vRotate),  180.0);
+	    xRotate     = fmod (fabs (xRotate),  angle);
+	    xRotate2    = fmod (fabs (xRotate2), angle);
 
 	    if (vRotate >= 90.0)
 		vRotate = 180.0 - vRotate;
 
-	    if (xRotate >= angle / 2.0)
+	    if (xRotate >= halfAngle)
 		xRotate = angle - xRotate;
 
-	    if (xRotate2 >= angle / 2.0)
+	    if (xRotate2 >= halfAngle)
 		xRotate2 = angle - xRotate2;
 
-	    xRotate = (mDeform * angle * 0.5) +
+	    xRotate = (mDeform * halfAngle) +
 		      ((1.0 - mDeform) * xRotate);
-	    xRotate2 = (mDeform * angle * 0.5) +
+	    xRotate2 = (mDeform * halfAngle) +
 		       ((1.0 - mDeform) * xRotate2);
 
+	    GLVector point  (-0.5, -0.5, cDist, 1.0);
+	    GLVector point2 (-0.5,  0.5, cDist, 1.0);
+	    GLMatrix pTransform;
+
 	    pTransform.reset ();
 	    pTransform.rotate (xRotate, 0.0f, 1.0f, 0.0f);
-	    pTransform.rotate (vRotate, cosf (xRotate * (M_PI / 180.0f)),
-			       0.0f, sinf (xRotate * (M_PI / 180.0f)));
+	    pTransform.rotate (vRotate, cosf (xRotate * degToRad),
+			       0.0f, sinf (xRotate * degToRad));
 
 	    point = pTransform * point;
 
 	    pTransform.reset ();
 	    pTransform.rotate (xRotate2, 0.0f, 1.0f, 0.0f);
-	    pTransform.rotate (vRotate, cosf (xRotate2 * (M_PI / 180.0f)),
-			       0.0f, sinf (xRotate2 * (M_PI / 180.0f)));
+	    pTransform.rotate (vRotate, cosf (xRotate2 * degToRad),
+			       0.0f, sinf (xRotate2 * degToRad));
 
 	    point2 = pTransform * point2;
 
-	    switch (optionGetMode ()) {
+	    float rYTrans;
+
+	    switch (optionGetMode ())
+	    {
 		case ModeJumpyReflection:
 		    mYTrans    = 0.0;
+
 		    if (optionGetDeformation () == DeformationSphere &&
 			optionGetDeformCaps () && optionGetDrawBottom ())
 			rYTrans = sqrt (0.5 + cDist2) * -2.0;
@@ -1295,19 +1344,20 @@
 			optionGetDeformCaps () && optionGetDrawBottom ())
 		    {
 			mYTrans =  mCapFill[1] - 0.5;
-			rYTrans = -mCapFill[1] - 0.5;
+			rYTrans = -mYTrans;
 		    }
 		    else if (optionGetDeformation () == DeformationSphere &&
-			     vRotate > atan (cDist * 2) / (M_PI / 180.0f))
+			     vRotate > atan (cDist * 2) / degToRad)
 		    {
-			mYTrans = sqrt (0.5 + cDist2) - 0.5;
-			rYTrans = -sqrt (0.5 + cDist2) - 0.5;
+			mYTrans =  sqrt (0.5 + cDist2) - 0.5;
+			rYTrans = -mYTrans;
 		    }
 		    else
 		    {
 			mYTrans = -point[1] - 0.5;
-			rYTrans =  point[1] - 0.5;
+			rYTrans = -mYTrans;
 		    }
+
 		    break;
 	    }
 
@@ -1321,17 +1371,20 @@
 	    if (optionGetMode () == ModeAbove)
 		mZTrans = 0.0;
 
+	    float deform = 0.0f;
+
 	    if (optionGetDeformation () == DeformationCylinder) 
 		deform = (sqrt (0.25 + cDist2) - cDist) * -mDeform;
 	    else if (optionGetDeformation () == DeformationSphere) 
-		deform = (sqrt (0.5 + cDist2) - cDist) * -mDeform;
+		deform = (sqrt (0.5  + cDist2) - cDist) * -mDeform;
 
 	    if (mDeform > 0.0)
-	        mZTrans = deform;
+		mZTrans = deform;
 
 	    if (optionGetMode () == ModeAbove && mVRot > 0.0)
 	    {
 		mBackVRotate = mVRot;
+
 		if (optionGetDeformation () == DeformationSphere &&
 		    optionGetDeformCaps () && optionGetDrawBottom ())
 		{
@@ -1340,7 +1393,7 @@
 		}
 		else
 		{
-		    mYTrans = 0.0;
+		    mYTrans =  0.0;
 		    rYTrans = -1.0;
 		}
 
@@ -1374,23 +1427,27 @@
 		unsigned short col1[4], col2[4];
 
 		GLVertexBuffer *streamingBuffer = GLVertexBuffer::streamingBuffer ();
-
-		GLMatrix gTransform;
-
-		glEnable (GL_BLEND);
+		GLMatrix       gTransform;
+		GLboolean      glBlendEnabled   = glIsEnabled (GL_BLEND);
+
+		if (!glBlendEnabled)
+		    glEnable (GL_BLEND);
+
 		glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
 		gTransform.translate (0, 0, -DEFAULT_Z_CAMERA);
 
-		float i = optionGetIntensity () * 2;
 		float c = optionGetIntensity ();
+		float i = c * 2;
+
+		GLfloat halfV = v / 2.0f;
 
 		GLfloat vertices[] =
 		{
-		    0.5f, v / 2.0f, 0.0f,
-		    -0.5f, v / 2.0f, 0.0f,
+		     0.5f, halfV, 0.0f,
+		    -0.5f, halfV, 0.0f,
 		    -0.5f, -0.5f, 0.0f,
-		    0.5f, -0.5f, 0.0f
+		     0.5f, -0.5f, 0.0f
 		};
 
 		unsigned short cMax = MAX (0.0, 1.0 - i) + (v * c);
@@ -1407,10 +1464,11 @@
 		streamingBuffer->begin (GL_TRIANGLE_STRIP);
 		streamingBuffer->addColors (4, colors);
 		streamingBuffer->addVertices (4, vertices);
+
 		if (streamingBuffer->end ())
 		    streamingBuffer->render (gTransform);
 
-		for (int j = 0; j < 4; j++)
+		for (int j = 0; j < 4; ++j)
 		{
 		    col1[j] = (1.0 - v) * optionGetGroundColor1 () [j] +
 			      (v * (optionGetGroundColor1 () [j] +
@@ -1422,14 +1480,14 @@
 
 		if (optionGetGroundSize () > 0.0)
 		{
+		    GLfloat gsf = -0.5f + static_cast <GLfloat> (((1 - v) *
+								  optionGetGroundSize ()) + v);
 		    GLfloat vertices[] =
 		    {
 			-0.5f, -0.5f, 0.0f,
-			0.5f, -0.5f, 0.0f,
-			0.5f, -0.5f +
-			static_cast <GLfloat> (((1 - v) * optionGetGroundSize ()) + v),
-			-0.5f, -0.5f +
-			static_cast <GLfloat> (((1 - v) * optionGetGroundSize ()) + v)
+			 0.5f, -0.5f, 0.0f,
+			 0.5f,   gsf,
+			-0.5f,   gsf
 		    };
 
 		    GLushort colors[] =
@@ -1449,7 +1507,9 @@
 		}
 
 		glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-		glDisable (GL_BLEND);
+
+		if (!glBlendEnabled)
+		    glDisable (GL_BLEND);
 	    }
 	    else
 		drawBasicGround ();
@@ -1516,19 +1576,18 @@
     mReflection (false),
     mFirst (true),
     mLast (0),
-    mYTrans (0.0),
-    mZTrans (0.0),
-    mDeform (0.0),
+    mYTrans (0.0f),
+    mZTrans (0.0f),
+    mDeform (0.0f),
     mWinNormals (0),
     mWinNormSize (0),
-    mCapDeform (-1.0),
+    mCapDeform (-1.0f),
     mCapDistance (cubeScreen->distance ())
 {
-    GLushort *idx;
+    GLushort *idx = mCapFillIdx;
 
-    idx = mCapFillIdx;
-    for (int i = 0; i < CAP_ELEMENTS - 1; i++)
-	for (int j = 0; j < CAP_ELEMENTS; j++)
+    for (int i = 0; i < CAP_ELEMENTS - 1; ++i)
+	for (int j = 0; j < CAP_ELEMENTS; ++j)
 	{
 	    idx[0] = 1 + (i * (CAP_ELEMENTS + 1)) + j;
 	    idx[1] = 1 + ((i + 1) * (CAP_ELEMENTS + 1)) + j;
@@ -1537,13 +1596,13 @@
 	    idx += 4;
 	}
 
-    mTopCap.mFiles = optionGetTopImages ();
+    mTopCap.mFiles    = optionGetTopImages ();
     mBottomCap.mFiles = optionGetBottomImages ();
-    
-    for (int i = 0; i < 1024; i++)
+
+    for (int i = 0; i < 1024; ++i)
     {
-	mSinT[i] = sinf(i / RAD2I1024);
-	mCosT[i] = cosf(i / RAD2I1024);
+	mSinT[i] = sinf (i / RAD2I1024);
+	mCosT[i] = cosf (i / RAD2I1024);
     }
 
     changeCap (true, 0);

=== modified file 'plugins/cubeaddon/src/cubeaddon.h'
--- plugins/cubeaddon/src/cubeaddon.h	2013-01-04 05:52:46 +0000
+++ plugins/cubeaddon/src/cubeaddon.h	2013-07-24 16:09:50 +0000
@@ -40,14 +40,14 @@
 #include "cubeaddon_options.h"
 
 const unsigned short CUBEADDON_GRID_SIZE = 100;
-const unsigned short CAP_ELEMENTS    = 15;
-const unsigned int   CAP_NVERTEX	    = (((CAP_ELEMENTS * (CAP_ELEMENTS + 1)) + 2) * 3);
-const unsigned int   CAP_NIDX	    = (CAP_ELEMENTS * (CAP_ELEMENTS - 1) * 4);
-
-const unsigned int   CAP_NIMGVERTEX  = (((CAP_ELEMENTS + 1) * (CAP_ELEMENTS + 1)) * 5);
-const unsigned int   CAP_NIMGIDX	    = (CAP_ELEMENTS * CAP_ELEMENTS * 4);
-
-const float RAD2I1024 = 162.9746617f;
+const unsigned short CAP_ELEMENTS        = 15;
+const unsigned int   CAP_NVERTEX         = (((CAP_ELEMENTS * (CAP_ELEMENTS + 1)) + 2) * 3);
+const unsigned int   CAP_NIDX            = (CAP_ELEMENTS * (CAP_ELEMENTS - 1) * 4);
+
+const unsigned int   CAP_NIMGVERTEX      = (((CAP_ELEMENTS + 1) * (CAP_ELEMENTS + 1)) * 5);
+const unsigned int   CAP_NIMGIDX         = (CAP_ELEMENTS * CAP_ELEMENTS * 4);
+
+const float          RAD2I1024           = 162.9746617f;
 
 class CubeaddonScreen :
     public CompositeScreenInterface,
@@ -57,36 +57,51 @@
     public CubeaddonOptions
 {
     public:
+
 	CubeaddonScreen (CompScreen *);
 	~CubeaddonScreen ();
 	
-	bool setOption (const CompString &name, CompOption::Value &value);
+	bool setOption (const CompString  &name,
+			CompOption::Value &value);
 
 	void donePaint ();
 
-	bool glPaintOutput (const GLScreenPaintAttrib&, const GLMatrix&,
-			    const CompRegion&, CompOutput *, unsigned int);
-	void glPaintTransformedOutput (const GLScreenPaintAttrib&,
-				       const GLMatrix&, const CompRegion&,
-				       CompOutput *, unsigned int);
-
-
-	void cubeGetRotation (float &x, float &v, float &progress);
-	void cubeClearTargetOutput (float xRotate, float vRotate);
+	bool glPaintOutput (const GLScreenPaintAttrib &,
+			    const GLMatrix            &,
+			    const CompRegion          &,
+			    CompOutput                *,
+			    unsigned int                );
+
+	void glPaintTransformedOutput (const GLScreenPaintAttrib &,
+				       const GLMatrix            &,
+				       const CompRegion          &,
+				       CompOutput                *,
+				       unsigned int                );
+
+	void cubeGetRotation (float &x,
+			      float &v,
+			      float &progress);
+
+	void cubeClearTargetOutput (float xRotate,
+				    float vRotate);
+
 	void cubePaintTop (const GLScreenPaintAttrib &sAttrib,
 			   const GLMatrix            &transform,
 			   CompOutput                *output,
 			   int                       size,
 			   const GLVector            &normal);
+
 	void cubePaintBottom (const GLScreenPaintAttrib &sAttrib,
 			      const GLMatrix            &transform,
 			      CompOutput                *output,
 			      int                       size,
 			      const GLVector            &normal);
+
 	bool cubeCheckOrientation (const GLScreenPaintAttrib &sAttrib,
 				   const GLMatrix            &transform,
 				   CompOutput                *output,
 				   std::vector<GLVector>     &points);
+
 	bool cubeShouldPaintViewport (const GLScreenPaintAttrib &sAttrib,
 				      const GLMatrix            &transform,
 				      CompOutput                *output,
@@ -97,24 +112,31 @@
 	class CubeCap
 	{
 	    public:
+
 		CubeCap ();
 		
-		void load (bool scale, bool aspect, bool clamp);
+		void load (bool scale,
+			   bool aspect,
+			   bool clamp);
 		
-		int                        mCurrent;
-		CompOption::Value::Vector  mFiles;
-
-		bool                       mLoaded;
-
-		GLTexture::List            mTexture;
-		GLMatrix                   mTexMat;
+		int                       mCurrent;
+		CompOption::Value::Vector mFiles;
+
+		bool                      mLoaded;
+
+		GLTexture::List           mTexture;
+		GLMatrix                  mTexMat;
 	};
 	
 	friend class CubeaddonWindow;
 	
     private:
-	bool changeCap (bool top, int change);
+
+	bool changeCap (bool top,
+			int change);
+
 	void drawBasicGround ();
+
 	void paintCap (const GLScreenPaintAttrib &sAttrib,
 		       const GLMatrix            &transform,
 		       CompOutput                *output,
@@ -129,35 +151,35 @@
 	CubeScreen      *cubeScreen;
 
 
-	bool mReflection;
-	bool mFirst;
-
-	CompOutput *mLast;
-
-	float mYTrans;
-	float mZTrans;
-
-	float mBackVRotate;
-	float mVRot;
-
-	float mDeform;
-	bool  mWasDeformed;
-
-	GLfloat      *mWinNormals;
-	unsigned int mWinNormSize;
-
-	GLfloat  mCapFill[CAP_NVERTEX];
-	GLfloat  mCapFillNorm[CAP_NVERTEX];
-	GLushort mCapFillIdx[CAP_NIDX];
-	float    mCapDeform;
-	float    mCapDistance;
-	int      mCapDeformType;
-
-	CubeCap mTopCap;
-	CubeCap mBottomCap;
+	bool            mReflection;
+	bool            mFirst;
+
+	CompOutput      *mLast;
+
+	float           mYTrans;
+	float           mZTrans;
+
+	float           mBackVRotate;
+	float           mVRot;
+
+	float           mDeform;
+	bool            mWasDeformed;
+
+	GLfloat         *mWinNormals;
+	unsigned int    mWinNormSize;
+
+	GLfloat         mCapFill[CAP_NVERTEX];
+	GLfloat         mCapFillNorm[CAP_NVERTEX];
+	GLushort        mCapFillIdx[CAP_NIDX];
+	float           mCapDeform;
+	float           mCapDistance;
+	int             mCapDeformType;
+
+	CubeCap         mTopCap;
+	CubeCap         mBottomCap;
 	
-	float mSinT[1024];
-	float mCosT[1024];
+	float           mSinT[1024];
+	float           mCosT[1024];
 };
 
 class CubeaddonWindow :
@@ -165,17 +187,24 @@
     public PluginClassHandler<CubeaddonWindow, CompWindow>
 {
     public:
+
 	CubeaddonWindow (CompWindow *);
 
-	bool glDraw (const GLMatrix&, const GLWindowPaintAttrib&,
-		     const CompRegion&, unsigned int);
-	void glAddGeometry (const GLTexture::MatrixList&,
-			    const CompRegion&, const CompRegion&,
-			    unsigned int, unsigned int);
-	void glDrawTexture (GLTexture *,
-			    const GLMatrix &matrix,
+	bool glDraw (const GLMatrix            &,
+		     const GLWindowPaintAttrib &,
+		     const CompRegion          &,
+		     unsigned int                );
+
+	void glAddGeometry (const GLTexture::MatrixList &,
+			    const CompRegion            &,
+			    const CompRegion            &,
+			    unsigned int                 ,
+			    unsigned int                  );
+
+	void glDrawTexture (GLTexture                  *,
+			    const GLMatrix             &matrix,
 			    const GLWindowPaintAttrib& attrib,
-			    unsigned int);
+			    unsigned int                      );
 
 	CompWindow      *window;
 	GLWindow        *gWindow;