commit da9b3f07942dda95dc0518c0bde5e20240aa9ba1
Author: Leszek Koltunski <leszek@distoretedandroid.org>
Date:   Fri Jun 9 14:27:52 2017 +0100

    Progress with support for Effect classes.
    
    The library compiles now!

diff --git a/src/main/java/org/distorted/library/effect/Effect.java b/src/main/java/org/distorted/library/effect/Effect.java
index 1a68c8d..4a5c5cf 100644
--- a/src/main/java/org/distorted/library/effect/Effect.java
+++ b/src/main/java/org/distorted/library/effect/Effect.java
@@ -23,24 +23,20 @@ package org.distorted.library.effect;
 
 public abstract class Effect
   {
+  private final static int MAX_UNITY_DIM = 4;
+  private final static int NUM_EFFECTS = EffectName.size();
+
   private final long mID;
-  private final int mType;
-  private final int mName;
+  private final EffectType mType;
+  private final EffectName mName;
   private final int mDimension;
   private final boolean mSupportsR;
   private final boolean mSupportsC;
-  private final String mStr;
 
   private static long mNextID = 0;
 
-  public static final int MATRIX      = 0;
-  public static final int VERTEX      = 1;
-  public static final int FRAGMENT    = 2;
-  public static final int POSTPROCESS = 3;
-
-  public static final int LENGTH = 4;           // The number of effect types above.
-  public static final int MASK= (1<<LENGTH)-1;  // Needed when we do bitwise operations on Effect Types.
-  static final int MAX_EFFECTS = 1000;          // The can be no more than MAX_EFFECTS effects of a given type.
+  private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
+  private final static int[]   mUnityDim = new int[NUM_EFFECTS];
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -55,31 +51,37 @@ public abstract class Effect
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static void reset(int[] maxtable)
+  public boolean isUnity(float[] buffer, int index)
     {
-    maxtable[0] = MatrixEffect.MAX;
-    maxtable[1] = VertexEffect.MAX;
-    maxtable[2] = FragmentEffect.MAX;
-    maxtable[3] = PostprocessEffect.MAX;
+    int name = mName.ordinal();
+
+    switch(mUnityDim[name])
+      {
+      case 0: return true;
+      case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];
+      case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
+                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];
+      case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
+                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
+                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];
+      case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
+                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
+                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&
+                     buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];
+      }
+
+    return false;
     }
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public static int getType(int name)
-    {
-    return name/MAX_EFFECTS;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public int getType()
+  public EffectType getType()
     {
     return mType;
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public int getName()
+  public EffectName getName()
     {
     return mName;
     }
@@ -95,7 +97,7 @@ public abstract class Effect
 
   public String getString()
     {
-    return mStr;
+    return mName.name();
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -121,7 +123,7 @@ public abstract class Effect
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  Effect(int type, int name, int dimension, boolean center, boolean region, final String str)
+  Effect(EffectType type, EffectName name, int dimension, boolean center, boolean region, float[] unity)
     {
     mID        = mNextID++;
 
@@ -130,6 +132,15 @@ public abstract class Effect
     mDimension = dimension;
     mSupportsC = center;
     mSupportsR = region;
-    mStr       = str;
+
+    int n = name.ordinal();
+    int l = unity.length;
+
+    for(int i=0; i<l; i++)
+      {
+      mUnity[n*MAX_UNITY_DIM+i] = unity[i];
+      }
+
+    mUnityDim[n] = l;
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/EffectName.java b/src/main/java/org/distorted/library/effect/EffectName.java
new file mode 100644
index 0000000..9e9e323
--- /dev/null
+++ b/src/main/java/org/distorted/library/effect/EffectName.java
@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2016 Leszek Koltunski                                                               //
+//                                                                                               //
+// This file is part of Distorted.                                                               //
+//                                                                                               //
+// Distorted 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.                                                           //
+//                                                                                               //
+// Distorted 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 Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+package org.distorted.library.effect;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ * Names of Effects one can add to the DistortedEffects queues.
+ * <p>
+ * Effect's 'Type' is one of the constants defined in {@link EffectType}.
+ */
+
+public enum EffectName
+  {
+  // EFFECT NAME /////// EFFECT TYPE
+  // MATRIX EFFECTS
+  ROTATE           ( EffectType.MATRIX ),
+  QUATERNION       ( EffectType.MATRIX ),
+  MOVE             ( EffectType.MATRIX ),
+  SCALE            ( EffectType.MATRIX ),
+  SHEAR            ( EffectType.MATRIX ),
+  // add new Matrix effects here...
+  // VERTEX EFFECTS
+  DISTORT          ( EffectType.VERTEX ),
+  DEFORM           ( EffectType.VERTEX ),
+  SINK             ( EffectType.VERTEX ),
+  PINCH            ( EffectType.VERTEX ),
+  SWIRL            ( EffectType.VERTEX ),
+  WAVE             ( EffectType.VERTEX ),
+  // add new Vertex Effects here...
+  // FRAGMENT EFFECTS
+  ALPHA            ( EffectType.FRAGMENT ),
+  SMOOTH_ALPHA     ( EffectType.FRAGMENT ),
+  CHROMA           ( EffectType.FRAGMENT ),
+  SMOOTH_CHROMA    ( EffectType.FRAGMENT ),
+  BRIGHTNESS       ( EffectType.FRAGMENT ),
+  SMOOTH_BRIGHTNESS( EffectType.FRAGMENT ),
+  SATURATION       ( EffectType.FRAGMENT ),
+  SMOOTH_SATURATION( EffectType.FRAGMENT ),
+  CONTRAST         ( EffectType.FRAGMENT ),
+  SMOOTH_CONTRAST  ( EffectType.FRAGMENT ),
+  // add new Fragment effects here...
+  // POSTPROCESSING EFFECTS.
+  BLUR             ( EffectType.POSTPROCESS ),
+  GLOW             ( EffectType.POSTPROCESS );
+  // add new Postprocess effects here...
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private final EffectType type;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  EffectName(EffectType type)
+    {
+    this.type = type;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  static int size()
+    {
+    return values().length;
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// PUBLIC API
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ * Returns the Type of an individual Effect. For example, EffectName.ROTATION.getType() will
+ * return EffectType.MATRIX.
+ * @return type of the effect.
+ */
+  public EffectType getType()
+    {
+    return type;
+    }
+  }
+
diff --git a/src/main/java/org/distorted/library/effect/EffectType.java b/src/main/java/org/distorted/library/effect/EffectType.java
new file mode 100644
index 0000000..bf0e142
--- /dev/null
+++ b/src/main/java/org/distorted/library/effect/EffectType.java
@@ -0,0 +1,67 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2016 Leszek Koltunski                                                               //
+//                                                                                               //
+// This file is part of Distorted.                                                               //
+//                                                                                               //
+// Distorted 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.                                                           //
+//                                                                                               //
+// Distorted 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 Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+package org.distorted.library.effect;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Types of Effects one can add to the DistortedEffects queues.
+ * <p>
+ * Each effect type goes to an independent queue; the queues get executed one-by-one
+ * and are each a class descendant from EffectQueue.
+ */
+
+public enum EffectType
+  {
+  /**
+   * Effects that change the ModelView matrix: Rotations, Moves, Shears, Scales.
+   */
+  MATRIX,
+  /**
+   * Effects that get executed in the Vertex shader: various distortions of the vertices.
+   */
+  VERTEX,
+  /**
+   * Effects executed in the Fragment shader: changes of color, hue, transparency levels, etc.
+   */
+  FRAGMENT,
+  /**
+   * Postprocessing effects done to the texture the first stage fragment shader created
+   */
+  POSTPROCESS;
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public static final int LENGTH = values().length;  // The number of effect types.
+  public static final int MASK= (1<<LENGTH)-1;       // Needed when we do bitwise operations on Effect Types.
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// called from EffectQueue
+
+  public static void reset(int[] maxtable)
+    {
+    maxtable[0] =10;  // By default, there can be a maximum 10 MATRIX effects in a single
+                      // EffectQueueMatrix at any given time. This can be changed with a call
+                      // to EffectQueueMatrix.setMax(int)
+    maxtable[1] = 5;  // Max 5 VERTEX Effects
+    maxtable[2] = 5;  // Max 5 FRAGMENT Effects
+    maxtable[3] = 5;  // Max 5 POSTPROCESSING Effects
+    }
+  }
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffect.java b/src/main/java/org/distorted/library/effect/FragmentEffect.java
index c0057c9..da2be0e 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffect.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffect.java
@@ -32,62 +32,15 @@ public abstract class FragmentEffect extends Effect
   {
   public static final int NUM_UNIFORMS = 8;
 
-  public static final int CHROMA            = MAX_EFFECTS*FRAGMENT    ;
-  public static final int SMOOTH_CHROMA     = MAX_EFFECTS*FRAGMENT + 1;
-  public static final int ALPHA             = MAX_EFFECTS*FRAGMENT + 2;
-  public static final int SMOOTH_ALPHA      = MAX_EFFECTS*FRAGMENT + 3;
-  public static final int BRIGHTNESS        = MAX_EFFECTS*FRAGMENT + 4;
-  public static final int SMOOTH_BRIGHTNESS = MAX_EFFECTS*FRAGMENT + 5;
-  public static final int CONTRAST          = MAX_EFFECTS*FRAGMENT + 6;
-  public static final int SMOOTH_CONTRAST   = MAX_EFFECTS*FRAGMENT + 7;
-  public static final int SATURATION        = MAX_EFFECTS*FRAGMENT + 8;
-  public static final int SMOOTH_SATURATION = MAX_EFFECTS*FRAGMENT + 9;
-  public static final int NUM_EFFECTS       = 10;
-
-  static final int MAX = 5;
-  private static final int MAX_UNITY_DIM = 1;
-
   Dynamic mDynamic0, mDynamic1;
   Static mStatic0, mStatic1;
   Dynamic4D mDynamicRegion;
   Static4D mStaticRegion;
 
-  private final static float[] mUnity    = new float[MAX_UNITY_DIM*NUM_EFFECTS];
-  private final static int[]   mUnityDim = new int[NUM_EFFECTS];
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public FragmentEffect(int name,float[] unity, int dimension, boolean center, boolean region, final String str)
+  public FragmentEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
     {
-    super(FRAGMENT,name,dimension,center,region,str);
-
-    for(int i=0; i<unity.length; i++)
-      {
-      mUnity[name*MAX_UNITY_DIM+i] = unity[i];
-      }
-
-    mUnityDim[name] = unity.length;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public static boolean isUnity(int name, float[] buffer, int index)
-    {
-    switch(mUnityDim[name])
-      {
-      case 0: return true;
-      case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];
-      case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];
-      case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];
-      case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&
-                     buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];
-      }
-
-    return false;
+    super(EffectType.FRAGMENT,name,dimension,center,region,unity);
     }
   }
\ No newline at end of file
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java b/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java
index b425c9e..5b25f3c 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectAlpha.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class FragmentEffectAlpha extends FragmentEffect
   {
-  private static final String NAME = "ALPHA";
-  private static final float[] UNITIES = new float[] {1.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {1.0f};
+  private static final int     DIMENSION       = 1;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -48,7 +47,7 @@ public class FragmentEffectAlpha extends FragmentEffect
  */
   public FragmentEffectAlpha(Data1D alpha, Data4D region, boolean smooth)
     {
-    super(smooth?SMOOTH_ALPHA:ALPHA ,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(smooth? EffectName.SMOOTH_ALPHA:EffectName.ALPHA ,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( alpha instanceof Dynamic1D )
       {
@@ -79,7 +78,7 @@ public class FragmentEffectAlpha extends FragmentEffect
  */
   public FragmentEffectAlpha(Data1D alpha)
     {
-    super(ALPHA,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.ALPHA,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( alpha instanceof Dynamic1D )
       {
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java b/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java
index c59c6ed..33cd52a 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectBrightness.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class FragmentEffectBrightness extends FragmentEffect
   {
-  private static final String NAME = "BRIGHTNESS";
-  private static final float[] UNITIES = new float[] {1.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {1.0f};
+  private static final int DIMENSION           = 1;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -47,7 +46,7 @@ public class FragmentEffectBrightness extends FragmentEffect
  */
   public FragmentEffectBrightness(Data1D brightness, Data4D region, boolean smooth)
     {
-    super(smooth?SMOOTH_BRIGHTNESS:BRIGHTNESS ,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(smooth?EffectName.SMOOTH_BRIGHTNESS:EffectName.BRIGHTNESS ,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( brightness instanceof Dynamic1D )
       {
@@ -77,7 +76,7 @@ public class FragmentEffectBrightness extends FragmentEffect
  */
   public FragmentEffectBrightness(Data1D brightness)
     {
-    super(BRIGHTNESS,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.BRIGHTNESS,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( brightness instanceof Dynamic1D )
       {
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java b/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java
index 5c1350c..e72553f 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectChroma.java
@@ -33,9 +33,8 @@ import org.distorted.library.type.Static4D;
 
 public class FragmentEffectChroma extends FragmentEffect
   {
-  private static final String NAME = "CHROMA";
-  private static final float[] UNITIES = new float[] {0.0f};
-  private static final int DIMENSION = 4;
+  private static final float[] UNITIES         = new float[] {0.0f};
+  private static final int DIMENSION           = 4;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -52,7 +51,7 @@ public class FragmentEffectChroma extends FragmentEffect
  */
   public FragmentEffectChroma(Data1D blend, Data3D color, Data4D region, boolean smooth)
     {
-    super(smooth?SMOOTH_CHROMA:CHROMA ,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(smooth?EffectName.SMOOTH_CHROMA:EffectName.CHROMA,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( blend instanceof Dynamic1D )
       {
@@ -93,7 +92,7 @@ public class FragmentEffectChroma extends FragmentEffect
  */
   public FragmentEffectChroma(Data1D blend, Data3D color)
     {
-    super(CHROMA,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.CHROMA,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( blend instanceof Dynamic1D )
       {
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java b/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java
index e314f7d..23bf50d 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectContrast.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class FragmentEffectContrast extends FragmentEffect
   {
-  private static final String NAME = "CONTRAST";
-  private static final float[] UNITIES = new float[] {1.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {1.0f};
+  private static final int DIMENSION           = 1;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -47,7 +46,7 @@ public class FragmentEffectContrast extends FragmentEffect
  */
   public FragmentEffectContrast(Data1D contrast, Data4D region, boolean smooth)
     {
-    super(smooth?SMOOTH_CONTRAST:CONTRAST ,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(smooth?EffectName.SMOOTH_CONTRAST:EffectName.CONTRAST,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( contrast instanceof Dynamic1D )
       {
@@ -77,7 +76,7 @@ public class FragmentEffectContrast extends FragmentEffect
  */
   public FragmentEffectContrast(Data1D contrast)
     {
-    super(CONTRAST,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.CONTRAST,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( contrast instanceof Dynamic1D )
       {
diff --git a/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java b/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java
index f5e7cad..eb9b9d5 100644
--- a/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java
+++ b/src/main/java/org/distorted/library/effect/FragmentEffectSaturation.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class FragmentEffectSaturation extends FragmentEffect
   {
-  private static final String NAME = "SATURATION";
-  private static final float[] UNITIES = new float[] {1.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {1.0f};
+  private static final int DIMENSION           = 1;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -47,7 +46,7 @@ public class FragmentEffectSaturation extends FragmentEffect
  */
   public FragmentEffectSaturation(Data1D saturation, Data4D region, boolean smooth)
     {
-    super(smooth?SMOOTH_SATURATION:SATURATION ,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(smooth?EffectName.SMOOTH_SATURATION:EffectName.SATURATION ,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( saturation instanceof Dynamic1D )
       {
@@ -77,7 +76,7 @@ public class FragmentEffectSaturation extends FragmentEffect
  */
   public FragmentEffectSaturation(Data1D saturation)
     {
-    super(SATURATION,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SATURATION,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( saturation instanceof Dynamic1D )
       {
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffect.java b/src/main/java/org/distorted/library/effect/MatrixEffect.java
index 9a8367e..a494bcb 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffect.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffect.java
@@ -29,57 +29,15 @@ public abstract class MatrixEffect extends Effect
   {
   public static final int NUM_UNIFORMS = 7;
 
-  public static final int MOVE       = MAX_EFFECTS*MATRIX    ;
-  public static final int SCALE      = MAX_EFFECTS*MATRIX + 1;
-  public static final int ROTATE     = MAX_EFFECTS*MATRIX + 2;
-  public static final int QUATERNION = MAX_EFFECTS*MATRIX + 3;
-  public static final int SHEAR      = MAX_EFFECTS*MATRIX + 4;
-  public static final int NUM_EFFECTS= 5;
-
-  static final int MAX = 5;
-  private static final int MAX_UNITY_DIM = 3;
-
   Dynamic mDynamic0,mDynamic1;
   Static  mStatic0 , mStatic1;
   Dynamic3D mDynamicCenter;
   Static3D mStaticCenter;
 
-  private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
-  private final static int[]   mUnityDim = new int[NUM_EFFECTS];
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public MatrixEffect(int name, float[] unity, int dimension, boolean center, boolean region, final String str)
+  public MatrixEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
     {
-    super(MATRIX,name,dimension,center,region,str);
-
-    for(int i=0; i<unity.length; i++)
-      {
-      mUnity[name*MAX_UNITY_DIM+i] = unity[i];
-      }
-
-    mUnityDim[name] = unity.length;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public static boolean isUnity(int name, float[] buffer, int index)
-    {
-    switch(mUnityDim[name])
-      {
-      case 0: return true;
-      case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];
-      case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];
-      case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];
-      case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&
-                     buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];
-      }
-
-    return false;
+    super(EffectType.MATRIX,name,dimension,center,region,unity);
     }
   }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectMove.java b/src/main/java/org/distorted/library/effect/MatrixEffectMove.java
index 4b4c9cb..877c74f 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectMove.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectMove.java
@@ -27,9 +27,8 @@ import org.distorted.library.type.Static3D;
 
 public class MatrixEffectMove extends MatrixEffect
   {
-  private static final String NAME = "MOVE";
-  private static final float[] UNITIES = new float[]{0.0f, 0.0f, 0.0f};
-  private static final int DIMENSION = 3;
+  private static final float[] UNITIES         = new float[]{0.0f, 0.0f, 0.0f};
+  private static final int DIMENSION           = 3;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -42,7 +41,7 @@ public class MatrixEffectMove extends MatrixEffect
  */
   public MatrixEffectMove(Data3D vector)
     {
-    super(MOVE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.MOVE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( vector instanceof Static3D)
       {
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java b/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java
index f445123..56f02fe 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectQuaternion.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class MatrixEffectQuaternion extends MatrixEffect
   {
-  private static final String NAME = "QUATERNION";
-  private static final float[] UNITIES = new float[]{0.0f, 0.0f, 0.0f};
-  private static final int DIMENSION = 4;
+  private static final float[] UNITIES         = new float[]{0.0f, 0.0f, 0.0f};
+  private static final int DIMENSION           = 4;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -45,7 +44,7 @@ public class MatrixEffectQuaternion extends MatrixEffect
  */
   public MatrixEffectQuaternion(Data4D quaternion, Data3D center )
     {
-    super(QUATERNION,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.QUATERNION,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( quaternion instanceof Static4D)
       {
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java b/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java
index 8ccc8a0..379cba6 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectRotate.java
@@ -33,9 +33,8 @@ import org.distorted.library.type.Static4D;
 
 public class MatrixEffectRotate extends MatrixEffect
   {
-  private static final String NAME = "ROTATE";
-  private static final float[] UNITIES = new float[]{0.0f};
-  private static final int DIMENSION = 4;
+  private static final float[] UNITIES         = new float[]{0.0f};
+  private static final int DIMENSION           = 4;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -50,7 +49,7 @@ public class MatrixEffectRotate extends MatrixEffect
  */
   public MatrixEffectRotate(Data1D angle, Static3D axis, Data3D center)
     {
-    super(ROTATE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.ROTATE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( angle instanceof Static1D )
       {
@@ -83,7 +82,7 @@ public class MatrixEffectRotate extends MatrixEffect
  */
   public MatrixEffectRotate(Data4D angleaxis, Data3D center)
     {
-    super(ROTATE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.ROTATE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( angleaxis instanceof Static4D)
       {
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectScale.java b/src/main/java/org/distorted/library/effect/MatrixEffectScale.java
index 25db43c..363c8e3 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectScale.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectScale.java
@@ -27,9 +27,8 @@ import org.distorted.library.type.Static3D;
 
 public class MatrixEffectScale extends MatrixEffect
   {
-  private static final String NAME = "SCALE";
-  private static final float[] UNITIES = new float[] {1.0f,1.0f,1.0f};
-  private static final int DIMENSION = 3;
+  private static final float[] UNITIES         = new float[] {1.0f,1.0f,1.0f};
+  private static final int DIMENSION           = 3;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -42,7 +41,7 @@ public class MatrixEffectScale extends MatrixEffect
  */
   public MatrixEffectScale(Data3D scale)
     {
-    super(SCALE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SCALE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( scale instanceof Static3D)
       {
@@ -62,7 +61,7 @@ public class MatrixEffectScale extends MatrixEffect
  */
   public MatrixEffectScale(float scale)
     {
-    super(SCALE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SCALE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     mStatic0 = new Static3D(scale,scale,scale);
     }
diff --git a/src/main/java/org/distorted/library/effect/MatrixEffectShear.java b/src/main/java/org/distorted/library/effect/MatrixEffectShear.java
index db5e62d..973e3b7 100644
--- a/src/main/java/org/distorted/library/effect/MatrixEffectShear.java
+++ b/src/main/java/org/distorted/library/effect/MatrixEffectShear.java
@@ -27,9 +27,8 @@ import org.distorted.library.type.Static3D;
 
 public class MatrixEffectShear extends MatrixEffect
   {
-  private static final String NAME = "SHEAR";
-  private static final float[] UNITIES = new float[] {0.0f,0.0f,0.0f};
-  private static final int DIMENSION = 3;
+  private static final float[] UNITIES         = new float[] {0.0f,0.0f,0.0f};
+  private static final int DIMENSION           = 3;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -45,7 +44,7 @@ public class MatrixEffectShear extends MatrixEffect
  */
   public MatrixEffectShear(Data3D shear, Data3D center)
     {
-    super(SHEAR,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SHEAR,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( shear instanceof Static3D)
       {
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffect.java b/src/main/java/org/distorted/library/effect/PostprocessEffect.java
index 133cc2d..72a5262 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffect.java
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffect.java
@@ -30,52 +30,13 @@ public abstract class PostprocessEffect extends Effect
   {
   public static final int NUM_UNIFORMS = 5;
 
-  public static final int BLUR       = MAX_EFFECTS*POSTPROCESS    ;
-  public static final int GLOW       = MAX_EFFECTS*POSTPROCESS + 1;
-  public static final int NUM_EFFECTS= 2;
-
-  static final int MAX = 5;
-  private static final int MAX_UNITY_DIM = 1;
-
   Dynamic mDynamic0, mDynamic1;
   Static mStatic0, mStatic1;
 
-  private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
-  private final static int[]   mUnityDim = new int[NUM_EFFECTS];
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public PostprocessEffect(int name, float[] unity, int dimension, boolean center, boolean region, final String str)
+  public PostprocessEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
     {
-    super(POSTPROCESS,name,dimension,center,region,str);
-
-    for(int i=0; i<unity.length; i++)
-      {
-      mUnity[name*MAX_UNITY_DIM+i] = unity[i];
-      }
-
-    mUnityDim[name] = unity.length;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public static boolean isUnity(int name, float[] buffer, int index)
-    {
-    switch(mUnityDim[name])
-      {
-      case 0: return true;
-      case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];
-      case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];
-      case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];
-      case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&
-                     buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];
-      }
-
-    return false;
+    super(EffectType.POSTPROCESS,name,dimension,center,region,unity);
     }
   }
\ No newline at end of file
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java b/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java
index e8fe00f..104ed6f 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectBlur.java
@@ -27,9 +27,8 @@ import org.distorted.library.type.Static1D;
 
 public class PostprocessEffectBlur extends PostprocessEffect
   {
-  private static final String NAME = "BLUR";
-  private static final float[] UNITIES = new float[] {0.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {0.0f};
+  private static final int DIMENSION           = 1;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -42,7 +41,7 @@ public class PostprocessEffectBlur extends PostprocessEffect
  */
   public PostprocessEffectBlur(Data1D radius)
     {
-    super(BLUR,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.BLUR,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( radius instanceof Dynamic1D)
       {
diff --git a/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java b/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java
index 0be37e4..b95a486 100644
--- a/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java
+++ b/src/main/java/org/distorted/library/effect/PostprocessEffectGlow.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class PostprocessEffectGlow extends PostprocessEffect
   {
-  private static final String NAME = "GLOW";
-  private static final float[] UNITIES = new float[] {0.0f};
-  private static final int DIMENSION = 5;
+  private static final float[] UNITIES         = new float[] {0.0f};
+  private static final int DIMENSION           = 5;
   private static final boolean SUPPORTS_CENTER = false;
   private static final boolean SUPPORTS_REGION = false;
 
@@ -46,7 +45,7 @@ public class PostprocessEffectGlow extends PostprocessEffect
  */
   public PostprocessEffectGlow(Data1D radius, Data4D color)
     {
-    super(GLOW,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.GLOW,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( radius instanceof Dynamic1D)
       {
diff --git a/src/main/java/org/distorted/library/effect/VertexEffect.java b/src/main/java/org/distorted/library/effect/VertexEffect.java
index 7946a6a..573f710 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffect.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffect.java
@@ -34,17 +34,6 @@ public abstract class VertexEffect extends Effect
   {
   public static final int NUM_UNIFORMS = 12;
 
-  public static final int DISTORT    = MAX_EFFECTS*VERTEX    ;
-  public static final int DEFORM     = MAX_EFFECTS*VERTEX + 1;
-  public static final int SINK       = MAX_EFFECTS*VERTEX + 2;
-  public static final int PINCH      = MAX_EFFECTS*VERTEX + 3;
-  public static final int SWIRL      = MAX_EFFECTS*VERTEX + 4;
-  public static final int WAVE       = MAX_EFFECTS*VERTEX + 5;
-  public static final int NUM_EFFECTS= 6;
-
-  static final int MAX = 5;
-  private static final int MAX_UNITY_DIM = 3;
-
   Dynamic mDynamic0;
   Static mStatic0;
   Dynamic3D mDynamicCenter;
@@ -52,42 +41,10 @@ public abstract class VertexEffect extends Effect
   Dynamic4D mDynamicRegion;
   Static4D  mStaticRegion;
 
-  private final static float[] mUnity= new float[MAX_UNITY_DIM*NUM_EFFECTS];
-  private final static int[]   mUnityDim = new int[NUM_EFFECTS];
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  public VertexEffect(int name, float[] unity, int dimension, boolean center, boolean region, final String str)
+  public VertexEffect(EffectName name, int dimension, boolean center, boolean region, float[] unity)
     {
-    super(VERTEX,name,dimension,center,region,str);
-
-    for(int i=0; i<unity.length; i++)
-      {
-      mUnity[name*MAX_UNITY_DIM+i] = unity[i];
-      }
-
-    mUnityDim[name] = unity.length;
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-  public static boolean isUnity(int name, float[] buffer, int index)
-    {
-    switch(mUnityDim[name])
-      {
-      case 0: return true;
-      case 1: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ];
-      case 2: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1];
-      case 3: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2];
-      case 4: return buffer[index  ]==mUnity[MAX_UNITY_DIM*name  ] &&
-                     buffer[index+1]==mUnity[MAX_UNITY_DIM*name+1] &&
-                     buffer[index+2]==mUnity[MAX_UNITY_DIM*name+2] &&
-                     buffer[index+3]==mUnity[MAX_UNITY_DIM*name+3];
-      }
-
-    return false;
+    super(EffectType.VERTEX,name,dimension,center,region,unity);
     }
   }
\ No newline at end of file
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDeform.java b/src/main/java/org/distorted/library/effect/VertexEffectDeform.java
index d4fb791..3a36b33 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDeform.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDeform.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class VertexEffectDeform extends VertexEffect
   {
-  private static final String NAME = "DEFORM";
-  private static final float[] UNITIES = new float[] {0.0f,0.0f,0.0f};
-  private static final int DIMENSION = 3;
+  private static final float[] UNITIES         = new float[] {0.0f,0.0f,0.0f};
+  private static final int DIMENSION           = 3;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -47,7 +46,7 @@ public class VertexEffectDeform extends VertexEffect
  */
   public VertexEffectDeform(Data3D vector, Data3D center, Data4D region)
     {
-    super(DEFORM,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.DEFORM,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( vector instanceof Dynamic3D )
       {
@@ -87,7 +86,7 @@ public class VertexEffectDeform extends VertexEffect
  */
   public VertexEffectDeform(Data3D vector, Data3D center)
     {
-    super(DEFORM,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.DEFORM,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( vector instanceof Dynamic3D )
       {
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectDistort.java b/src/main/java/org/distorted/library/effect/VertexEffectDistort.java
index 755c90f..8e81213 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectDistort.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectDistort.java
@@ -30,9 +30,8 @@ import org.distorted.library.type.Static4D;
 
 public class VertexEffectDistort extends VertexEffect
   {
-  private static final String NAME = "DISORT";
-  private static final float[] UNITIES = new float[] {0.0f,0.0f,0.0f};
-  private static final int DIMENSION = 3;
+  private static final float[] UNITIES         = new float[] {0.0f,0.0f,0.0f};
+  private static final int DIMENSION           = 3;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -47,7 +46,7 @@ public class VertexEffectDistort extends VertexEffect
  */
   public VertexEffectDistort(Data3D vector, Data3D center, Data4D region)
     {
-    super(DISTORT,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.DISTORT,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( vector instanceof Dynamic3D )
       {
@@ -87,7 +86,7 @@ public class VertexEffectDistort extends VertexEffect
  */
   public VertexEffectDistort(Data3D vector, Data3D center)
     {
-    super(DISTORT,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.DISTORT,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( vector instanceof Dynamic3D )
       {
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectPinch.java b/src/main/java/org/distorted/library/effect/VertexEffectPinch.java
index 6182e1a..d9c0977 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectPinch.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectPinch.java
@@ -33,9 +33,8 @@ import org.distorted.library.type.Static4D;
 
 public class VertexEffectPinch extends VertexEffect
   {
-  private static final String NAME = "PINCH";
-  private static final float[] UNITIES = new float[] {1.0f};
-  private static final int DIMENSION = 2;
+  private static final float[] UNITIES         = new float[] {1.0f};
+  private static final int     DIMENSION       = 2;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -50,7 +49,7 @@ public class VertexEffectPinch extends VertexEffect
  */
   public VertexEffectPinch(Data2D pinch, Data3D center, Data4D region)
     {
-    super(PINCH,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.PINCH,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( pinch instanceof Dynamic2D)
       {
@@ -90,7 +89,7 @@ public class VertexEffectPinch extends VertexEffect
  */
   public VertexEffectPinch(Data2D pinch, Data3D center)
     {
-    super(PINCH,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.PINCH,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( pinch instanceof Dynamic2D)
       {
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectSink.java b/src/main/java/org/distorted/library/effect/VertexEffectSink.java
index f5f3b50..6d5e22f 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectSink.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectSink.java
@@ -33,9 +33,8 @@ import org.distorted.library.type.Static4D;
 
 public class VertexEffectSink extends VertexEffect
   {
-  private static final String NAME = "SINK";
-  private static final float[] UNITIES = new float[] {1.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {1.0f};
+  private static final int     DIMENSION       = 1;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -50,7 +49,7 @@ public class VertexEffectSink extends VertexEffect
  */
   public VertexEffectSink(Data1D sink, Data3D center, Data4D region)
     {
-    super(SINK,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SINK,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( sink instanceof Dynamic1D)
       {
@@ -90,7 +89,7 @@ public class VertexEffectSink extends VertexEffect
  */
   public VertexEffectSink(Data1D sink, Data3D center)
     {
-    super(SINK,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SINK,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( sink instanceof Dynamic1D)
       {
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java b/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java
index 139e834..67e6ef9 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectSwirl.java
@@ -33,9 +33,8 @@ import org.distorted.library.type.Static4D;
 
 public class VertexEffectSwirl extends VertexEffect
   {
-  private static final String NAME = "SWIRL";
-  private static final float[] UNITIES = new float[] {0.0f};
-  private static final int DIMENSION = 1;
+  private static final float[] UNITIES         = new float[] {0.0f};
+  private static final int     DIMENSION       = 1;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -49,7 +48,7 @@ public class VertexEffectSwirl extends VertexEffect
  */
   public VertexEffectSwirl(Data1D swirl, Data3D center, Data4D region)
     {
-    super(SWIRL,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SWIRL,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( swirl instanceof Dynamic1D)
       {
@@ -88,7 +87,7 @@ public class VertexEffectSwirl extends VertexEffect
  */
   public VertexEffectSwirl(Data1D swirl, Data3D center)
     {
-    super(SWIRL,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.SWIRL,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( swirl instanceof Dynamic1D)
       {
diff --git a/src/main/java/org/distorted/library/effect/VertexEffectWave.java b/src/main/java/org/distorted/library/effect/VertexEffectWave.java
index e9b9925..ca9e2ca 100644
--- a/src/main/java/org/distorted/library/effect/VertexEffectWave.java
+++ b/src/main/java/org/distorted/library/effect/VertexEffectWave.java
@@ -33,9 +33,8 @@ import org.distorted.library.type.Static5D;
 
 public class VertexEffectWave extends VertexEffect
   {
-  private static final String NAME = "WAVE";
-  private static final float[] UNITIES = new float[] {0.0f};
-  private static final int DIMENSION = 5;
+  private static final float[] UNITIES         = new float[] {0.0f};
+  private static final int     DIMENSION       = 5;
   private static final boolean SUPPORTS_CENTER = true;
   private static final boolean SUPPORTS_REGION = true;
 
@@ -69,7 +68,7 @@ public class VertexEffectWave extends VertexEffect
  */
   public VertexEffectWave(Data5D wave, Data3D center)
     {
-    super(WAVE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.WAVE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( wave instanceof Dynamic5D)
       {
@@ -102,7 +101,7 @@ public class VertexEffectWave extends VertexEffect
  */
   public VertexEffectWave(Data5D wave, Data3D center, Data4D region)
     {
-    super(WAVE,UNITIES,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,NAME);
+    super(EffectName.WAVE,DIMENSION,SUPPORTS_CENTER,SUPPORTS_REGION,UNITIES);
 
     if( wave instanceof Dynamic5D)
       {
diff --git a/src/main/java/org/distorted/library/main/DistortedEffects.java b/src/main/java/org/distorted/library/main/DistortedEffects.java
index 11b968f..d666dea 100644
--- a/src/main/java/org/distorted/library/main/DistortedEffects.java
+++ b/src/main/java/org/distorted/library/main/DistortedEffects.java
@@ -24,6 +24,8 @@ import android.opengl.GLES30;
 
 import org.distorted.library.R;
 import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectName;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.message.EffectListener;
 import org.distorted.library.program.DistortedProgram;
 import org.distorted.library.program.FragmentCompilationException;
@@ -50,7 +52,7 @@ public class DistortedEffects
   /// MAIN PROGRAM ///
   private static DistortedProgram mMainProgram;
   private static int mMainTextureH;
-  private static ArrayList<Effect> mEnabledEffects = new ArrayList<>();
+  private static ArrayList<EffectName> mEnabledEffects = new ArrayList<>();
 
   /// BLIT PROGRAM ///
   private static DistortedProgram mBlitProgram;
@@ -99,22 +101,23 @@ public class DistortedEffects
 
     boolean foundF = false;
     boolean foundV = false;
-    int type, effects = mEnabledEffects.size();
-    Effect effect;
+    int effects = mEnabledEffects.size();
+    EffectName effect;
+    EffectType type;
 
     for(int i=0; i<effects; i++)
       {
       effect = mEnabledEffects.remove(0);
       type   = effect.getType();
 
-      if( type == Effect.VERTEX )
+      if( type == EffectType.VERTEX )
         {
-        mainVertHeader += ("#define "+effect.getString()+" "+effect.getName()+"\n");
+        mainVertHeader += ("#define "+effect.name()+" "+effect.ordinal()+"\n");
         foundV = true;
         }
-      else if( type == Effect.FRAGMENT )
+      else if( type == EffectType.FRAGMENT )
         {
-        mainFragHeader += ("#define "+effect.getString()+" "+effect.getName()+"\n");
+        mainFragHeader += ("#define "+effect.name()+" "+effect.ordinal()+"\n");
         foundF = true;
         }
       }
@@ -433,18 +436,18 @@ public class DistortedEffects
 /**
  * Aborts all Effects of a given type, for example all MATRIX Effects.
  * 
- * @param type one of the constants defined in {@link Effect}
+ * @param type one of the constants defined in {@link EffectType}
  * @return Number of effects aborted.
  */
-  public int abortByType(int type)
+  public int abortByType(EffectType type)
     {
     switch(type)
       {
-      case Effect.MATRIX     : return mM.abortAll(true);
-      case Effect.VERTEX     : return mV.abortAll(true);
-      case Effect.FRAGMENT   : return mF.abortAll(true);
-  //  case Effect.POSTPROCESS: return mP.abortAll(true);
-      default                : return 0;
+      case MATRIX     : return mM.abortAll(true);
+      case VERTEX     : return mV.abortAll(true);
+      case FRAGMENT   : return mF.abortAll(true);
+  //  case POSTPROCESS: return mP.abortAll(true);
+      default         : return 0;
       }
     }
     
@@ -459,11 +462,11 @@ public class DistortedEffects
     {
     switch(effect.getType())
       {
-      case Effect.MATRIX     : return mM.removeEffect(effect);
-      case Effect.VERTEX     : return mV.removeEffect(effect);
-      case Effect.FRAGMENT   : return mF.removeEffect(effect);
-  //  case Effect.POSTPROCESS: return mP.removeEffect(effect);
-      default                : return 0;
+      case MATRIX     : return mM.removeEffect(effect);
+      case VERTEX     : return mV.removeEffect(effect);
+      case FRAGMENT   : return mF.removeEffect(effect);
+  //  case POSTPROCESS: return mP.removeEffect(effect);
+      default         : return 0;
       }
     }
 
@@ -471,21 +474,17 @@ public class DistortedEffects
 /**
  * Abort all Effects of a given name, for example all rotations.
  * 
- * @param name one of the constants defined in
- *             {@link org.distorted.library.effect.MatrixEffect},
- *             {@link org.distorted.library.effect.VertexEffect},
- *             {@link org.distorted.library.effect.FragmentEffect} or
- *             {@link org.distorted.library.effect.PostprocessEffect}
+ * @param name one of the constants defined in {@link EffectName}
  * @return number of Effects aborted.
  */
-  public int abortByName(int name)
+  public int abortByName(EffectName name)
     {
-    switch(Effect.getType(name))
+    switch(name.getType())
       {
-      case Effect.MATRIX     : return mM.removeByName(name);
-      case Effect.VERTEX     : return mV.removeByName(name);
-      case Effect.FRAGMENT   : return mF.removeByName(name);
-  //  case Effect.POSTPROCESS: return mP.removeByName(name);
+      case MATRIX     : return mM.removeByName(name);
+      case VERTEX     : return mV.removeByName(name);
+      case FRAGMENT   : return mF.removeByName(name);
+  //  case POSTPROCESS: return mP.removeByName(name);
       default                : return 0;
       }
     }
@@ -498,15 +497,11 @@ public class DistortedEffects
  * This needs to be called BEFORE shaders get compiled, i.e. before the call to Distorted.onCreate().
  * The point: by enabling only the effects we need, we can optimize the shaders.
  *
- * @param name one of the constants defined in
- *             {@link org.distorted.library.effect.MatrixEffect},
- *             {@link org.distorted.library.effect.VertexEffect},
- *             {@link org.distorted.library.effect.FragmentEffect} or
- *             {@link org.distorted.library.effect.PostprocessEffect}
+ * @param name one of the constants defined in {@link EffectName}
  */
-  public static void enableEffect(int name)
+  public static void enableEffect(EffectName name)
     {
-    mEffectEnabled[name] = true;
+    mEnabledEffects.add(name);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -518,7 +513,7 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public static int getMaxMatrix()
     {
-    return EffectQueue.getMax(Effect.MATRIX);
+    return EffectQueue.getMax(EffectType.MATRIX.ordinal());
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -530,7 +525,7 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public static int getMaxVertex()
     {
-    return EffectQueue.getMax(Effect.VERTEX);
+    return EffectQueue.getMax(EffectType.VERTEX.ordinal());
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -542,7 +537,7 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public static int getMaxFragment()
     {
-    return EffectQueue.getMax(Effect.FRAGMENT);
+    return EffectQueue.getMax(EffectType.FRAGMENT.ordinal());
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -564,7 +559,7 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public static boolean setMaxMatrix(int max)
     {
-    return EffectQueue.setMax(Effect.MATRIX,max);
+    return EffectQueue.setMax(EffectType.MATRIX.ordinal(),max);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -586,7 +581,7 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public static boolean setMaxVertex(int max)
     {
-    return EffectQueue.setMax(Effect.VERTEX,max);
+    return EffectQueue.setMax(EffectType.VERTEX.ordinal(),max);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -608,7 +603,7 @@ public class DistortedEffects
   @SuppressWarnings("unused")
   public static boolean setMaxFragment(int max)
     {
-    return EffectQueue.setMax(Effect.FRAGMENT,max);
+    return EffectQueue.setMax(EffectType.FRAGMENT.ordinal(),max);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -621,10 +616,10 @@ public class DistortedEffects
     {
     switch(effect.getType())
       {
-      case Effect.VERTEX      : mV.add(effect); break;
-      case Effect.FRAGMENT    : mF.add(effect); break;
-      case Effect.MATRIX      : mM.add(effect); break;
-   // case Effect.POSTPROCESS : mP.add(effect); break;
+      case VERTEX      : mV.add(effect); break;
+      case FRAGMENT    : mF.add(effect); break;
+      case MATRIX      : mM.add(effect); break;
+   // case POSTPROCESS : mP.add(effect); break;
       }
     }
   }
diff --git a/src/main/java/org/distorted/library/main/DistortedEffectsPostprocess.java b/src/main/java/org/distorted/library/main/DistortedEffectsPostprocess.java
index 460ebd4..6374181 100644
--- a/src/main/java/org/distorted/library/main/DistortedEffectsPostprocess.java
+++ b/src/main/java/org/distorted/library/main/DistortedEffectsPostprocess.java
@@ -20,6 +20,7 @@
 package org.distorted.library.main;
 
 import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.message.EffectListener;
 
 import java.util.ArrayList;
@@ -240,15 +241,15 @@ public class DistortedEffectsPostprocess implements DistortedSlave
 /**
  * Aborts all Effects of a given type, for example all POSTPROCESS Effects.
  *
- * @param type one of the constants defined in {@link Effect}
+ * @param type one of the constants defined in {@link EffectType}
  * @return Number of effects aborted.
  */
-  public int abortByType(int type)
+  public int abortByType(EffectType type)
     {
     switch(type)
       {
-      case Effect.POSTPROCESS: return mP.abortAll(true);
-      default                : return 0;
+      case POSTPROCESS: return mP.abortAll(true);
+      default         : return 0;
       }
     }
 
@@ -263,8 +264,8 @@ public class DistortedEffectsPostprocess implements DistortedSlave
     {
     switch(effect.getType())
       {
-      case Effect.POSTPROCESS: return mP.removeEffect(effect);
-      default                : return 0;
+      case POSTPROCESS: return mP.removeEffect(effect);
+      default         : return 0;
       }
     }
 
@@ -277,7 +278,7 @@ public class DistortedEffectsPostprocess implements DistortedSlave
   @SuppressWarnings("unused")
   public static int getMaxPostprocess()
     {
-    return EffectQueue.getMax(Effect.POSTPROCESS);
+    return EffectQueue.getMax(EffectType.POSTPROCESS.ordinal());
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -299,7 +300,7 @@ public class DistortedEffectsPostprocess implements DistortedSlave
   @SuppressWarnings("unused")
   public static boolean setMaxPostprocess(int max)
     {
-    return EffectQueue.setMax(Effect.POSTPROCESS,max);
+    return EffectQueue.setMax(EffectType.POSTPROCESS.ordinal(),max);
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -328,7 +329,7 @@ public class DistortedEffectsPostprocess implements DistortedSlave
     {
     switch(effect.getType())
       {
-      case Effect.POSTPROCESS : mP.add(effect); break;
+      case POSTPROCESS : mP.add(effect); break;
       }
     }
   }
diff --git a/src/main/java/org/distorted/library/main/EffectQueue.java b/src/main/java/org/distorted/library/main/EffectQueue.java
index dfc576b..a46b33f 100644
--- a/src/main/java/org/distorted/library/main/EffectQueue.java
+++ b/src/main/java/org/distorted/library/main/EffectQueue.java
@@ -20,6 +20,8 @@
 package org.distorted.library.main;
 
 import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectName;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.message.EffectListener;
 import org.distorted.library.message.EffectMessage;
 
@@ -35,7 +37,7 @@ abstract class EffectQueue
   protected Effect[] mEffects;
   protected int[] mName;
   protected long mTime=0;
-  protected static int[] mMax = new int[Effect.LENGTH];
+  protected static int[] mMax = new int[EffectType.LENGTH];
   protected Vector<EffectListener> mListeners =null;
   protected int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added
   protected long mID;
@@ -132,13 +134,13 @@ abstract class EffectQueue
 
   static void onDestroy()
     {
-    Effect.reset(mMax);
+    EffectType.reset(mMax);
     mCreated = false;  
     }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-  synchronized int removeByName(int name)
+  synchronized int removeByName(EffectName name)
     {
     int ret = 0;
 
@@ -231,7 +233,7 @@ abstract class EffectQueue
       {
       mCurrentDuration[mNumEffects] = 0;
       mEffects[mNumEffects] = effect;
-      mName[mNumEffects] = effect.getName();
+      mName[mNumEffects] = effect.getName().ordinal();
       mNumEffects++;
       }
     }
diff --git a/src/main/java/org/distorted/library/main/EffectQueueFragment.java b/src/main/java/org/distorted/library/main/EffectQueueFragment.java
index e7dfb2b..dbcb7db 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueFragment.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueFragment.java
@@ -21,7 +21,7 @@ package org.distorted.library.main;
 
 import android.opengl.GLES30;
 
-import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.effect.FragmentEffect;
 import org.distorted.library.message.EffectMessage;
 
@@ -30,7 +30,7 @@ import org.distorted.library.message.EffectMessage;
 class EffectQueueFragment extends EffectQueue
   {
   private static final int NUM_UNIFORMS = FragmentEffect.NUM_UNIFORMS;
-  private static final int INDEX = Effect.FRAGMENT;
+  private static final int INDEX = EffectType.FRAGMENT.ordinal();
   private static int mNumEffectsH;
   private static int mNameH;
   private static int mUniformsH;
@@ -68,7 +68,7 @@ class EffectQueueFragment extends EffectQueue
         for(int j=0; j<mNumListeners; j++)
           EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-        if( FragmentEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+        if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           remove(i--);
         }
       }
diff --git a/src/main/java/org/distorted/library/main/EffectQueueMatrix.java b/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
index fa2cdfa..15a270f 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueMatrix.java
@@ -22,7 +22,7 @@ package org.distorted.library.main;
 import android.opengl.GLES30;
 import android.opengl.Matrix;
 
-import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.effect.MatrixEffect;
 import org.distorted.library.message.EffectMessage;
 
@@ -31,7 +31,7 @@ import org.distorted.library.message.EffectMessage;
 class EffectQueueMatrix extends EffectQueue
   {   
   private static final int NUM_UNIFORMS = MatrixEffect.NUM_UNIFORMS;
-  private static final int INDEX = Effect.MATRIX;
+  private static final int INDEX = EffectType.MATRIX.ordinal();
 
   private static float[] mMVPMatrix = new float[16];
   private static float[] mTmpMatrix = new float[16];
@@ -210,61 +210,61 @@ class EffectQueueMatrix extends EffectQueue
       {
       switch( mEffects[i].getName() )
         {
-        case MatrixEffect.ROTATE     : x = mUniforms[NUM_UNIFORMS*i+4];
-                                       y = mUniforms[NUM_UNIFORMS*i+5];
-                                       z = mUniforms[NUM_UNIFORMS*i+6];
-
-                                       Matrix.translateM(mViewMatrix, 0, x,-y, z);
-                                       Matrix.rotateM( mViewMatrix, 0, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
-                                       Matrix.translateM(mViewMatrix, 0,-x, y,-z);
-                                       break;
-        case MatrixEffect.QUATERNION : x = mUniforms[NUM_UNIFORMS*i+4];
-                                       y = mUniforms[NUM_UNIFORMS*i+5];
-                                       z = mUniforms[NUM_UNIFORMS*i+6];
-
-                                       Matrix.translateM(mViewMatrix, 0, x,-y, z);
-                                       multiplyByQuat(mViewMatrix, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
-                                       Matrix.translateM(mViewMatrix, 0,-x, y,-z);
-                                       break;
-        case MatrixEffect.MOVE       : sx = mUniforms[NUM_UNIFORMS*i  ];
-                                       sy = mUniforms[NUM_UNIFORMS*i+1];
-                                       sz = mUniforms[NUM_UNIFORMS*i+2];
-
-                                       Matrix.translateM(mViewMatrix, 0, sx,-sy, sz);
-                                       break;
-        case MatrixEffect.SCALE      : sx = mUniforms[NUM_UNIFORMS*i  ];
-                                       sy = mUniforms[NUM_UNIFORMS*i+1];
-                                       sz = mUniforms[NUM_UNIFORMS*i+2];
-
-                                       Matrix.scaleM(mViewMatrix, 0, sx, sy, sz);
-                                       break;
-        case MatrixEffect.SHEAR      : sx = mUniforms[NUM_UNIFORMS*i  ];
-                                       sy = mUniforms[NUM_UNIFORMS*i+1];
-                                       sz = mUniforms[NUM_UNIFORMS*i+2];
-
-                                       x  = mUniforms[NUM_UNIFORMS*i+4];
-                                       y  = mUniforms[NUM_UNIFORMS*i+5];
-                                       z  = mUniforms[NUM_UNIFORMS*i+6];
-
-                                       Matrix.translateM(mViewMatrix, 0, x,-y, z);
-
-                                       mViewMatrix[4] += sx*mViewMatrix[0]; // Multiply viewMatrix by 1 x 0 0 , i.e. X-shear.
-                                       mViewMatrix[5] += sx*mViewMatrix[1]; //                        0 1 0 0
-                                       mViewMatrix[6] += sx*mViewMatrix[2]; //                        0 0 1 0
-                                       mViewMatrix[7] += sx*mViewMatrix[3]; //                        0 0 0 1
-
-                                       mViewMatrix[0] += sy*mViewMatrix[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. Y-shear.
-                                       mViewMatrix[1] += sy*mViewMatrix[5]; //                        y 1 0 0
-                                       mViewMatrix[2] += sy*mViewMatrix[6]; //                        0 0 1 0
-                                       mViewMatrix[3] += sy*mViewMatrix[7]; //                        0 0 0 1
-
-                                       mViewMatrix[4] += sz*mViewMatrix[8]; // Multiply viewMatrix by 1 0 0 0 , i.e. Z-shear.
-                                       mViewMatrix[5] += sz*mViewMatrix[9]; //                        0 1 0 0
-                                       mViewMatrix[6] += sz*mViewMatrix[10];//                        0 z 1 0
-                                       mViewMatrix[7] += sz*mViewMatrix[11];//                        0 0 0 1
-
-                                       Matrix.translateM(mViewMatrix, 0,-x, y, -z);
-                                       break;
+        case ROTATE     : x = mUniforms[NUM_UNIFORMS*i+4];
+                          y = mUniforms[NUM_UNIFORMS*i+5];
+                          z = mUniforms[NUM_UNIFORMS*i+6];
+
+                          Matrix.translateM(mViewMatrix, 0, x,-y, z);
+                          Matrix.rotateM( mViewMatrix, 0, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
+                          Matrix.translateM(mViewMatrix, 0,-x, y,-z);
+                          break;
+        case QUATERNION : x = mUniforms[NUM_UNIFORMS*i+4];
+                          y = mUniforms[NUM_UNIFORMS*i+5];
+                          z = mUniforms[NUM_UNIFORMS*i+6];
+
+                          Matrix.translateM(mViewMatrix, 0, x,-y, z);
+                          multiplyByQuat(mViewMatrix, mUniforms[NUM_UNIFORMS*i], mUniforms[NUM_UNIFORMS*i+1], mUniforms[NUM_UNIFORMS*i+2], mUniforms[NUM_UNIFORMS*i+3]);
+                          Matrix.translateM(mViewMatrix, 0,-x, y,-z);
+                          break;
+        case MOVE       : sx = mUniforms[NUM_UNIFORMS*i  ];
+                          sy = mUniforms[NUM_UNIFORMS*i+1];
+                          sz = mUniforms[NUM_UNIFORMS*i+2];
+
+                          Matrix.translateM(mViewMatrix, 0, sx,-sy, sz);
+                          break;
+        case SCALE      : sx = mUniforms[NUM_UNIFORMS*i  ];
+                          sy = mUniforms[NUM_UNIFORMS*i+1];
+                          sz = mUniforms[NUM_UNIFORMS*i+2];
+
+                          Matrix.scaleM(mViewMatrix, 0, sx, sy, sz);
+                          break;
+        case SHEAR      : sx = mUniforms[NUM_UNIFORMS*i  ];
+                          sy = mUniforms[NUM_UNIFORMS*i+1];
+                          sz = mUniforms[NUM_UNIFORMS*i+2];
+
+                          x  = mUniforms[NUM_UNIFORMS*i+4];
+                          y  = mUniforms[NUM_UNIFORMS*i+5];
+                          z  = mUniforms[NUM_UNIFORMS*i+6];
+
+                          Matrix.translateM(mViewMatrix, 0, x,-y, z);
+
+                          mViewMatrix[4] += sx*mViewMatrix[0]; // Multiply viewMatrix by 1 x 0 0 , i.e. X-shear.
+                          mViewMatrix[5] += sx*mViewMatrix[1]; //                        0 1 0 0
+                          mViewMatrix[6] += sx*mViewMatrix[2]; //                        0 0 1 0
+                          mViewMatrix[7] += sx*mViewMatrix[3]; //                        0 0 0 1
+
+                          mViewMatrix[0] += sy*mViewMatrix[4]; // Multiply viewMatrix by 1 0 0 0 , i.e. Y-shear.
+                          mViewMatrix[1] += sy*mViewMatrix[5]; //                        y 1 0 0
+                          mViewMatrix[2] += sy*mViewMatrix[6]; //                        0 0 1 0
+                          mViewMatrix[3] += sy*mViewMatrix[7]; //                        0 0 0 1
+
+                          mViewMatrix[4] += sz*mViewMatrix[8]; // Multiply viewMatrix by 1 0 0 0 , i.e. Z-shear.
+                          mViewMatrix[5] += sz*mViewMatrix[9]; //                        0 1 0 0
+                          mViewMatrix[6] += sz*mViewMatrix[10];//                        0 z 1 0
+                          mViewMatrix[7] += sz*mViewMatrix[11];//                        0 0 0 1
+
+                          Matrix.translateM(mViewMatrix, 0,-x, y, -z);
+                          break;
         }
       }
 
@@ -301,7 +301,7 @@ class EffectQueueMatrix extends EffectQueue
         for(int j=0; j<mNumListeners; j++)
           EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-        if( MatrixEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+        if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           remove(i--);
         }
       }
diff --git a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
index fe5bfc4..e981b03 100644
--- a/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
+++ b/src/main/java/org/distorted/library/main/EffectQueuePostprocess.java
@@ -22,7 +22,8 @@ package org.distorted.library.main;
 import android.content.res.Resources;
 import android.opengl.GLES30;
 
-import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectName;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.effect.PostprocessEffect;
 import org.distorted.library.R;
 import org.distorted.library.message.EffectMessage;
@@ -48,7 +49,7 @@ class EffectQueuePostprocess extends EffectQueue
   private static final int TEX_DATA_SIZE= 2; // Post Program: size of the texture coordinate data in elements.
 
   private static final int NUM_UNIFORMS = PostprocessEffect.NUM_UNIFORMS;
-  private static final int INDEX = Effect.POSTPROCESS;
+  private static final int INDEX = EffectType.POSTPROCESS.ordinal();
 
   private static final FloatBuffer mQuadPositions, mQuadTexture, mQuadTextureInv;
 
@@ -188,7 +189,7 @@ class EffectQueuePostprocess extends EffectQueue
         for(int j=0; j<mNumListeners; j++)
           EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-        if( PostprocessEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+        if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           {
           remove(i--);
           continue;
@@ -268,12 +269,12 @@ class EffectQueuePostprocess extends EffectQueue
 
       for(int i=0; i<mNumEffects; i++)
         {
-        if (mName[i] == PostprocessEffect.BLUR )
+        if (mName[i] == EffectName.BLUR.ordinal() )
           {
           blur(NUM_UNIFORMS*i,surface);
           numRenders += 2;
           }
-        else if (mName[i] == PostprocessEffect.GLOW )
+        else if (mName[i] == EffectName.GLOW.ordinal() )
           {
           glow(NUM_UNIFORMS*i,surface);
           numRenders += 2;
diff --git a/src/main/java/org/distorted/library/main/EffectQueueVertex.java b/src/main/java/org/distorted/library/main/EffectQueueVertex.java
index ae11468..0798ddb 100644
--- a/src/main/java/org/distorted/library/main/EffectQueueVertex.java
+++ b/src/main/java/org/distorted/library/main/EffectQueueVertex.java
@@ -21,7 +21,7 @@ package org.distorted.library.main;
 
 import android.opengl.GLES30;
 
-import org.distorted.library.effect.Effect;
+import org.distorted.library.effect.EffectType;
 import org.distorted.library.effect.VertexEffect;
 import org.distorted.library.message.EffectMessage;
 
@@ -30,7 +30,7 @@ import org.distorted.library.message.EffectMessage;
 class EffectQueueVertex extends EffectQueue
   { 
   private static final int NUM_UNIFORMS = VertexEffect.NUM_UNIFORMS;
-  private static final int INDEX = Effect.VERTEX;
+  private static final int INDEX = EffectType.VERTEX.ordinal();
   private static int mNumEffectsH;
   private static int mNameH;
   private static int mUniformsH;
@@ -68,7 +68,7 @@ class EffectQueueVertex extends EffectQueue
         for(int j=0; j<mNumListeners; j++)
           EffectMessageSender.newMessage( mListeners.elementAt(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mID);
 
-        if( VertexEffect.isUnity( mEffects[i].getName(), mUniforms, NUM_UNIFORMS*i) )
+        if( mEffects[i].isUnity( mUniforms, NUM_UNIFORMS*i) )
           remove(i--);
         }
       }