From 324b85b0cc688f85a91e84b0b6d6a0378a79bea3 Mon Sep 17 00:00:00 2001
From: Sven Gothel <sgothel@jausoft.com>
Date: Fri, 8 Apr 2011 21:35:34 +0200
Subject: Fix TAB: Replace all TAB with 4 spaces

---
 .../com/jogamp/graph/curve/OutlineShape.java       | 408 ++++++-------
 .../classes/com/jogamp/graph/curve/Region.java     | 168 +++---
 .../com/jogamp/graph/curve/RegionFactory.java      |  36 +-
 .../jogamp/graph/curve/tess/CDTriangulator2D.java  | 324 +++++-----
 src/jogl/classes/com/jogamp/graph/font/Font.java   |  34 +-
 src/jogl/classes/com/jogamp/graph/geom/AABBox.java | 470 +++++++--------
 .../classes/com/jogamp/graph/geom/Outline.java     | 258 ++++----
 .../classes/com/jogamp/graph/geom/Triangle.java    |  84 +--
 src/jogl/classes/com/jogamp/graph/geom/Vertex.java |  62 +-
 .../com/jogamp/graph/geom/opengl/SVertex.java      | 278 ++++-----
 .../classes/com/jogamp/graph/math/Quaternion.java  | 668 ++++++++++-----------
 .../classes/com/jogamp/graph/math/VectorUtil.java  | 466 +++++++-------
 .../com/jogamp/opengl/util/FPSAnimator.java        |  18 +-
 .../classes/com/jogamp/opengl/util/Locator.java    |   2 +-
 .../com/jogamp/opengl/util/awt/TextRenderer.java   |   4 +-
 .../classes/com/jogamp/opengl/util/gl2/GLUT.java   |   8 +-
 .../com/jogamp/opengl/util/texture/Texture.java    |  24 +-
 .../com/jogamp/opengl/util/texture/TextureIO.java  |  26 +-
 .../opengl/util/texture/spi/LEDataInputStream.java |  92 +--
 .../jogamp/opengl/util/texture/spi/SGIImage.java   |  10 +-
 20 files changed, 1720 insertions(+), 1720 deletions(-)

(limited to 'src/jogl/classes/com')

diff --git a/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java b/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
index 827717aa5..724380f4a 100755
--- a/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
@@ -50,13 +50,13 @@ import com.jogamp.graph.curve.tess.CDTriangulator2D;
  * <br><br>
  * Example to creating an Outline Shape:
  * <pre>
-  	addVertex(...)
-  	addVertex(...)
-  	addVertex(...)
-  	addEnptyOutline()
-  	addVertex(...)
-  	addVertex(...)
-  	addVertex(...)
+      addVertex(...)
+      addVertex(...)
+      addVertex(...)
+      addEnptyOutline()
+      addVertex(...)
+      addVertex(...)
+      addVertex(...)
  * </pre>
  * 
  * The above will create two outlines each with three vertices. By adding these two outlines to 
@@ -72,10 +72,10 @@ import com.jogamp.graph.curve.tess.CDTriangulator2D;
  * 
  * <br>Example: <br>
  * <pre>
-  	addVertex(0,0, true);
-  	addVertex(0,1, false);
-  	addVertex(1,1, false);
-  	addVertex(1,0, true);
+      addVertex(0,0, true);
+      addVertex(0,1, false);
+      addVertex(1,1, false);
+      addVertex(1,0, true);
  * </pre>
  * 
  * The above snippet defines a cubic nurbs curve where (0,1 and 1,1) 
@@ -83,8 +83,8 @@ import com.jogamp.graph.curve.tess.CDTriangulator2D;
  *  
  * <i>Implementation Notes:</i><br>
  * <ul>
- *		<li> The first vertex of any outline belonging to the shape should be on-curve</li>
- *		<li> Intersections between off-curved parts of the outline is not handled</li>
+ *    <li> The first vertex of any outline belonging to the shape should be on-curve</li>
+ *    <li> Intersections between off-curved parts of the outline is not handled</li>
  * </ul>
  * 
  * @see Outline
@@ -92,216 +92,216 @@ import com.jogamp.graph.curve.tess.CDTriangulator2D;
  */
 public class OutlineShape {
 
-	public static final int QUADRATIC_NURBS = 10;
-	private final Vertex.Factory<? extends Vertex> vertexFactory;
+    public static final int QUADRATIC_NURBS = 10;
+    private final Vertex.Factory<? extends Vertex> vertexFactory;
 
-	/** The list of {@link Outline}s that are part of this 
-	 *  outline shape.
-	 */
-	private ArrayList<Outline> outlines = new ArrayList<Outline>(3);
+    /** The list of {@link Outline}s that are part of this 
+     *  outline shape.
+     */
+    private ArrayList<Outline> outlines = new ArrayList<Outline>(3);
 
-	/** Create a new Outline based Shape
-	 */
-	public OutlineShape(Vertex.Factory<? extends Vertex> factory) {
-		vertexFactory = factory;
-		outlines.add(new Outline());
-	}
+    /** Create a new Outline based Shape
+     */
+    public OutlineShape(Vertex.Factory<? extends Vertex> factory) {
+        vertexFactory = factory;
+        outlines.add(new Outline());
+    }
 
-	/** Returns the associated vertex factory of this outline shape
-	 * @return Vertex.Factory object
-	 */
-	public final Vertex.Factory<? extends Vertex> vertexFactory() { return vertexFactory; }
+    /** Returns the associated vertex factory of this outline shape
+     * @return Vertex.Factory object
+     */
+    public final Vertex.Factory<? extends Vertex> vertexFactory() { return vertexFactory; }
 
-	/** Add a new empty {@link Outline} 
-	 * to the shape, this new outline will
-	 * be placed at the end of the outline list.
-	 * 
-	 * After a call to this function all new vertices added
-	 * will belong to the new outline
-	 */
-	public void addEmptyOutline(){
-		outlines.add(new Outline());
-	}
+    /** Add a new empty {@link Outline} 
+     * to the shape, this new outline will
+     * be placed at the end of the outline list.
+     * 
+     * After a call to this function all new vertices added
+     * will belong to the new outline
+     */
+    public void addEmptyOutline(){
+        outlines.add(new Outline());
+    }
 
-	/** Adds an {@link Outline} to the OutlineShape object
-	 * if last outline of the shape is empty, it will replace
-	 * that last Outline with the new one. If outline is empty,
-	 * it will do nothing.
-	 * @param outline an Outline object
-	 */
-	public void addOutline(Outline outline){
-		if(outline.isEmpty()){
-			return;
-		}
-		if(getLastOutline().isEmpty()){
-			outlines.remove(getLastOutline());
-		}
-		outlines.add(outline);
-	}
+    /** Adds an {@link Outline} to the OutlineShape object
+     * if last outline of the shape is empty, it will replace
+     * that last Outline with the new one. If outline is empty,
+     * it will do nothing.
+     * @param outline an Outline object
+     */
+    public void addOutline(Outline outline){
+        if(outline.isEmpty()){
+            return;
+        }
+        if(getLastOutline().isEmpty()){
+            outlines.remove(getLastOutline());
+        }
+        outlines.add(outline);
+    }
 
-	/** Adds a vertex to the last open outline in the
-	 *  shape. 
-	 * @param v the vertex to be added to the OutlineShape
-	 */
-	public final void addVertex(Vertex v){
-		getLastOutline().addVertex(v);
-	}
+    /** Adds a vertex to the last open outline in the
+     *  shape. 
+     * @param v the vertex to be added to the OutlineShape
+     */
+    public final void addVertex(Vertex v){
+        getLastOutline().addVertex(v);
+    }
 
-	/** Add a 2D {@link Vertex} to the last outline by defining the coordniate attribute
-	 * of the vertex. The 2D vertex will be represented as Z=0.
-	 * 
-	 * @param x the x coordinate
-	 * @param y the y coordniate
-	 * @param onCurve flag if this vertex is on the final curve or defines a curved region
-	 * of the shape around this vertex.
-	 */
-	public final void addVertex(float x, float y, boolean onCurve) {
-		getLastOutline().addVertex(vertexFactory, x, y, onCurve);
-	}
+    /** Add a 2D {@link Vertex} to the last outline by defining the coordniate attribute
+     * of the vertex. The 2D vertex will be represented as Z=0.
+     * 
+     * @param x the x coordinate
+     * @param y the y coordniate
+     * @param onCurve flag if this vertex is on the final curve or defines a curved region
+     * of the shape around this vertex.
+     */
+    public final void addVertex(float x, float y, boolean onCurve) {
+        getLastOutline().addVertex(vertexFactory, x, y, onCurve);
+    }
 
-	/** Add a 3D {@link Vertex} to the last outline by defining the coordniate attribute
-	 * of the vertex.
-	 * @param x the x coordinate
-	 * @param y the y coordniate
-	 * @param z the z coordniate
-	 * @param onCurve flag if this vertex is on the final curve or defines a curved region
-	 * of the shape around this vertex.
-	 */
-	public final void addVertex(float x, float y, float z, boolean onCurve) {
-		getLastOutline().addVertex(vertexFactory, x, y, z, onCurve);
-	}
+    /** Add a 3D {@link Vertex} to the last outline by defining the coordniate attribute
+     * of the vertex.
+     * @param x the x coordinate
+     * @param y the y coordniate
+     * @param z the z coordniate
+     * @param onCurve flag if this vertex is on the final curve or defines a curved region
+     * of the shape around this vertex.
+     */
+    public final void addVertex(float x, float y, float z, boolean onCurve) {
+        getLastOutline().addVertex(vertexFactory, x, y, z, onCurve);
+    }
 
-	/** Add a vertex to the last outline by passing a float array and specifying the 
-	 * offset and length in which. The attributes of the vertex are located. 
-	 * The attributes should be continuous (stride = 0).
-	 * Attributes which value are not set (when length less than 3) 
-	 * are set implicitly to zero.
-	 * @param coordsBuffer the coordinate array where the vertex attributes are to be picked from
-	 * @param offset the offset in the buffer to the x coordinate
-	 * @param length the number of attributes to pick from the buffer (maximum 3)
-	 * @param onCurve flag if this vertex is on the final curve or defines a curved region
-	 * of the shape around this vertex.
-	 */
-	public final void addVertex(float[] coordsBuffer, int offset, int length, boolean onCurve) {
-		getLastOutline().addVertex(vertexFactory, coordsBuffer, offset, length, onCurve);
-	}	
+    /** Add a vertex to the last outline by passing a float array and specifying the 
+     * offset and length in which. The attributes of the vertex are located. 
+     * The attributes should be continuous (stride = 0).
+     * Attributes which value are not set (when length less than 3) 
+     * are set implicitly to zero.
+     * @param coordsBuffer the coordinate array where the vertex attributes are to be picked from
+     * @param offset the offset in the buffer to the x coordinate
+     * @param length the number of attributes to pick from the buffer (maximum 3)
+     * @param onCurve flag if this vertex is on the final curve or defines a curved region
+     * of the shape around this vertex.
+     */
+    public final void addVertex(float[] coordsBuffer, int offset, int length, boolean onCurve) {
+        getLastOutline().addVertex(vertexFactory, coordsBuffer, offset, length, onCurve);
+    }    
 
-	/** Closes the last outline in the shape
-	 * if last vertex is not equal to first vertex.
-	 * A new temp vertex is added at the end which 
-	 * is equal to the first.
-	 */
-	public void closeLastOutline(){
-		getLastOutline().setClosed(true);
-	}
+    /** Closes the last outline in the shape
+     * if last vertex is not equal to first vertex.
+     * A new temp vertex is added at the end which 
+     * is equal to the first.
+     */
+    public void closeLastOutline(){
+        getLastOutline().setClosed(true);
+    }
 
-	/** Get the last added outline to the list
-	 * of outlines that define the shape
-	 * @return the last outline
-	 */
-	public final Outline getLastOutline(){
-		return outlines.get(outlines.size()-1);
-	}
-	/** Make sure that the outlines represent
-	 * the specified destinationType, if not
-	 * transform outlines to destination type.
-	 * @param destinationType The curve type needed
-	 */
-	public void transformOutlines(int destinationType){
-		if(destinationType == QUADRATIC_NURBS){
-			transformOutlinesQuadratic();
-		}
-	}
+    /** Get the last added outline to the list
+     * of outlines that define the shape
+     * @return the last outline
+     */
+    public final Outline getLastOutline(){
+        return outlines.get(outlines.size()-1);
+    }
+    /** Make sure that the outlines represent
+     * the specified destinationType, if not
+     * transform outlines to destination type.
+     * @param destinationType The curve type needed
+     */
+    public void transformOutlines(int destinationType){
+        if(destinationType == QUADRATIC_NURBS){
+            transformOutlinesQuadratic();
+        }
+    }
 
-	private void transformOutlinesQuadratic(){
-		ArrayList<Outline> newOutlines = new ArrayList<Outline>(3);
+    private void transformOutlinesQuadratic(){
+        ArrayList<Outline> newOutlines = new ArrayList<Outline>(3);
 
-		/**loop over the outlines and make sure no
-		 * adj off-curve vertices
-		 */
-		for(Outline outline:outlines){
-			Outline newOutline = new Outline();
+        /**loop over the outlines and make sure no
+         * adj off-curve vertices
+         */
+        for(Outline outline:outlines){
+            Outline newOutline = new Outline();
 
-			ArrayList<Vertex> vertices = outline.getVertices();
-			int size =vertices.size()-1;
-			for(int i=0;i<size;i++){
-				Vertex currentVertex = vertices.get(i);
-				Vertex nextVertex = vertices.get((i+1)%size);
-				if(!(currentVertex.isOnCurve()) && !(nextVertex.isOnCurve())) {
-					newOutline.addVertex(currentVertex);
+            ArrayList<Vertex> vertices = outline.getVertices();
+            int size =vertices.size()-1;
+            for(int i=0;i<size;i++){
+                Vertex currentVertex = vertices.get(i);
+                Vertex nextVertex = vertices.get((i+1)%size);
+                if(!(currentVertex.isOnCurve()) && !(nextVertex.isOnCurve())) {
+                    newOutline.addVertex(currentVertex);
 
-					float[] newCoords = VectorUtil.mid(currentVertex.getCoord(), nextVertex.getCoord());
-					newOutline.addVertex(vertexFactory, newCoords, 0, 3, true);
-				}
-				else {
-					newOutline.addVertex(currentVertex);
-				}
-			}
-			newOutlines.add(newOutline);
-		}
-		outlines = newOutlines;
-	}
+                    float[] newCoords = VectorUtil.mid(currentVertex.getCoord(), nextVertex.getCoord());
+                    newOutline.addVertex(vertexFactory, newCoords, 0, 3, true);
+                }
+                else {
+                    newOutline.addVertex(currentVertex);
+                }
+            }
+            newOutlines.add(newOutline);
+        }
+        outlines = newOutlines;
+    }
 
-	private void generateVertexIds(){
-		int maxVertexId = 0;
-		for(Outline outline:outlines){
-			ArrayList<Vertex> vertices = outline.getVertices();
-			for(Vertex vert:vertices){
-				vert.setId(maxVertexId);
-				maxVertexId++;
-			}
-		}
-	}
+    private void generateVertexIds(){
+        int maxVertexId = 0;
+        for(Outline outline:outlines){
+            ArrayList<Vertex> vertices = outline.getVertices();
+            for(Vertex vert:vertices){
+                vert.setId(maxVertexId);
+                maxVertexId++;
+            }
+        }
+    }
 
-	/** @return the list of vertices associated with the 
-	 * {@code Outline} list of this object
-	 */
-	public ArrayList<Vertex> getVertices(){
-		ArrayList<Vertex> vertices = new ArrayList<Vertex>();
-		for(Outline polyline:outlines){
-			vertices.addAll(polyline.getVertices());
-		}
-		return vertices;
-	}
+    /** @return the list of vertices associated with the 
+     * {@code Outline} list of this object
+     */
+    public ArrayList<Vertex> getVertices(){
+        ArrayList<Vertex> vertices = new ArrayList<Vertex>();
+        for(Outline polyline:outlines){
+            vertices.addAll(polyline.getVertices());
+        }
+        return vertices;
+    }
 
-	/** Triangulate the outline shape generating a list of triangles
-	 * @return an arraylist of triangles representing the filled region
-	 * which is produced by the combination of the outlines 
-	 */
-	public ArrayList<Triangle> triangulate(){
-		return triangulate(0.5f);
-	}
+    /** Triangulate the outline shape generating a list of triangles
+     * @return an arraylist of triangles representing the filled region
+     * which is produced by the combination of the outlines 
+     */
+    public ArrayList<Triangle> triangulate(){
+        return triangulate(0.5f);
+    }
 
-	/**Triangulate the {@link OutlineShape} generating a list of triangles
-	 * @param sharpness defines the curvature strength around the off-curve vertices.
-	 * defaults to 0.5f
-	 * @return an arraylist of triangles representing the filled region
-	 * which is produced by the combination of the outlines
-	 */
-	public ArrayList<Triangle> triangulate(float sharpness){
-		if(outlines.size() == 0){
-			return null;
-		}
-		sortOutlines();
-		generateVertexIds();
-		
-		CDTriangulator2D triangulator2d = new CDTriangulator2D(sharpness);
-		for(int index = 0; index< outlines.size();index++){
-			Outline outline = outlines.get(index);
-			triangulator2d.addCurve(outline);
-		}
-		
-		ArrayList<Triangle> triangles = triangulator2d.generateTriangulation();
-		triangulator2d.reset();
+    /**Triangulate the {@link OutlineShape} generating a list of triangles
+     * @param sharpness defines the curvature strength around the off-curve vertices.
+     * defaults to 0.5f
+     * @return an arraylist of triangles representing the filled region
+     * which is produced by the combination of the outlines
+     */
+    public ArrayList<Triangle> triangulate(float sharpness){
+        if(outlines.size() == 0){
+            return null;
+        }
+        sortOutlines();
+        generateVertexIds();
+        
+        CDTriangulator2D triangulator2d = new CDTriangulator2D(sharpness);
+        for(int index = 0; index< outlines.size();index++){
+            Outline outline = outlines.get(index);
+            triangulator2d.addCurve(outline);
+        }
+        
+        ArrayList<Triangle> triangles = triangulator2d.generateTriangulation();
+        triangulator2d.reset();
 
-		return triangles;
-	}
+        return triangles;
+    }
 
-	/** Sort the outlines from large
-	 *  to small depending on the AABox
-	 */
-	private void sortOutlines() {
-		Collections.sort(outlines);
-		Collections.reverse(outlines);
-	}
+    /** Sort the outlines from large
+     *  to small depending on the AABox
+     */
+    private void sortOutlines() {
+        Collections.sort(outlines);
+        Collections.reverse(outlines);
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/curve/Region.java b/src/jogl/classes/com/jogamp/graph/curve/Region.java
index cc21af859..926ab5467 100755
--- a/src/jogl/classes/com/jogamp/graph/curve/Region.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/Region.java
@@ -49,94 +49,94 @@ import com.jogamp.opengl.util.PMVMatrix;
 public interface Region {
     public static final boolean DEBUG = Debug.debug("graph.curve");
     
-	/** The vertices index in an OGL object
-	 */
-	public static int VERTEX_ATTR_IDX = 0;
-	public static String VERTEX_ATTR_NAME = "v_position";
+    /** The vertices index in an OGL object
+     */
+    public static int VERTEX_ATTR_IDX = 0;
+    public static String VERTEX_ATTR_NAME = "v_position";
 
-	/** The Texture Coord index in an OGL object
-	 */
-	public static int TEXCOORD_ATTR_IDX = 1;
-	public static String TEXCOORD_ATTR_NAME = "texCoord";
-	
+    /** The Texture Coord index in an OGL object
+     */
+    public static int TEXCOORD_ATTR_IDX = 1;
+    public static String TEXCOORD_ATTR_NAME = "texCoord";
+    
     /** The color index in an OGL object
      */
     public static int COLOR_ATTR_IDX = 2;
     public static String COLOR_ATTR_NAME = "v_color";
     
-	/** single pass rendering, fast, but AA might not be perfect */
-	public static int SINGLE_PASS = 1;
-	
-	/** two pass rendering, slower and more resource hungry (FBO), but AA is perfect */
-	public static int TWO_PASS    = 2;
-	
-	/** Updates a graph region by updating the ogl related
-	 *  objects for use in rendering. if called for the first time
-	 *  it initialize the objects. 
-	 */
-	public void update();
-	
-	/** Renders the associated OGL objects specifying
-	 * current width/hight of window for multi pass rendering
-	 * of the region.
-	 * @param matrix current {@link PMVMatrix}.
-	 * @param vp_width current screen width
-	 * @param vp_height current screen height
-	 * @param width texture width for mp rendering
-	 * 
-	 * @see update()
-	 */
-	public void render(PMVMatrix matrix, int vp_width, int vp_height, int width);
-	
-	/** Adds a list of {@link Triangle} objects to the Region
-	 * These triangles are to be binded to OGL objects 
-	 * on the next call to {@code update}
-	 * @param tris an arraylist of triangle objects
-	 * 
-	 * @see update()
-	 */
-	public void addTriangles(ArrayList<Triangle> tris);
-	
-	/** Get the current number of vertices associated
-	 * with this region. This number is not necessary equal to 
-	 * the OGL binded number of vertices.
-	 * @return vertices count
-	 * 
-	 * @see isDirty()
-	 */
-	public int getNumVertices();
-	
-	/** Adds a list of {@link Vertex} objects to the Region
-	 * These vertices are to be binded to OGL objects 
-	 * on the next call to {@code update}
-	 * @param verts an arraylist of vertex objects
-	 * 
-	 * @see update()
-	 */
-	public void addVertices(ArrayList<Vertex> verts);
-	
-	/** Check if this region is dirty. A region is marked dirty
-	 * when new Vertices, Triangles, and or Lines are added after a 
-	 * call to update()
-	 * @return true if region is Dirty, false otherwise
-	 * 
-	 * @see update();
-	 */
-	public boolean isDirty();
-	
-	/** Delete and clean the associated OGL
-	 *  objects
-	 */
-	public void destroy();
-	
-	public AABBox getBounds(); 
-	
-	public boolean isFlipped();
-	
-	/** Set if the y coordinate of the region should be flipped
-	 *  {@code y=-y} used mainly for fonts since they use opposite vertex
-	 *  as origion
-	 * @param flipped flag if the coordinate is flipped defaults to false.
-	 */
-	public void setFlipped(boolean flipped);
+    /** single pass rendering, fast, but AA might not be perfect */
+    public static int SINGLE_PASS = 1;
+    
+    /** two pass rendering, slower and more resource hungry (FBO), but AA is perfect */
+    public static int TWO_PASS    = 2;
+    
+    /** Updates a graph region by updating the ogl related
+     *  objects for use in rendering. if called for the first time
+     *  it initialize the objects. 
+     */
+    public void update();
+    
+    /** Renders the associated OGL objects specifying
+     * current width/hight of window for multi pass rendering
+     * of the region.
+     * @param matrix current {@link PMVMatrix}.
+     * @param vp_width current screen width
+     * @param vp_height current screen height
+     * @param width texture width for mp rendering
+     * 
+     * @see update()
+     */
+    public void render(PMVMatrix matrix, int vp_width, int vp_height, int width);
+    
+    /** Adds a list of {@link Triangle} objects to the Region
+     * These triangles are to be binded to OGL objects 
+     * on the next call to {@code update}
+     * @param tris an arraylist of triangle objects
+     * 
+     * @see update()
+     */
+    public void addTriangles(ArrayList<Triangle> tris);
+    
+    /** Get the current number of vertices associated
+     * with this region. This number is not necessary equal to 
+     * the OGL binded number of vertices.
+     * @return vertices count
+     * 
+     * @see isDirty()
+     */
+    public int getNumVertices();
+    
+    /** Adds a list of {@link Vertex} objects to the Region
+     * These vertices are to be binded to OGL objects 
+     * on the next call to {@code update}
+     * @param verts an arraylist of vertex objects
+     * 
+     * @see update()
+     */
+    public void addVertices(ArrayList<Vertex> verts);
+    
+    /** Check if this region is dirty. A region is marked dirty
+     * when new Vertices, Triangles, and or Lines are added after a 
+     * call to update()
+     * @return true if region is Dirty, false otherwise
+     * 
+     * @see update();
+     */
+    public boolean isDirty();
+    
+    /** Delete and clean the associated OGL
+     *  objects
+     */
+    public void destroy();
+    
+    public AABBox getBounds(); 
+    
+    public boolean isFlipped();
+    
+    /** Set if the y coordinate of the region should be flipped
+     *  {@code y=-y} used mainly for fonts since they use opposite vertex
+     *  as origion
+     * @param flipped flag if the coordinate is flipped defaults to false.
+     */
+    public void setFlipped(boolean flipped);
 }
diff --git a/src/jogl/classes/com/jogamp/graph/curve/RegionFactory.java b/src/jogl/classes/com/jogamp/graph/curve/RegionFactory.java
index d3b978b8a..91bbbd787 100755
--- a/src/jogl/classes/com/jogamp/graph/curve/RegionFactory.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/RegionFactory.java
@@ -41,22 +41,22 @@ import jogamp.graph.curve.opengl.VBORegion2PES2;
  * @see Region
  */
 public class RegionFactory {
-	
-	/**Create a Region based on the GLContext attached
-	 * @param context the current {@link GLContext}
-	 * @param st the {@link ShaderState} object
-	 * @param type can be one of Region.SINGLE_PASS or Region.TWO_PASS
-	 * @return region 
-	 */
-	public static Region create(GLContext context, ShaderState st, int type){
-	    if( !context.isGL2ES2() ) {
-	        throw new GLException("At least a GL2ES2 GL context is required. Given: " + context);
-	    }
-		if( Region.TWO_PASS == type ){
-			return new VBORegion2PES2(context, st);
-		}
-		else{
-			return new VBORegionSPES2(context);
-		}
-	}
+    
+    /**Create a Region based on the GLContext attached
+     * @param context the current {@link GLContext}
+     * @param st the {@link ShaderState} object
+     * @param type can be one of Region.SINGLE_PASS or Region.TWO_PASS
+     * @return region 
+     */
+    public static Region create(GLContext context, ShaderState st, int type){
+        if( !context.isGL2ES2() ) {
+            throw new GLException("At least a GL2ES2 GL context is required. Given: " + context);
+        }
+        if( Region.TWO_PASS == type ){
+            return new VBORegion2PES2(context, st);
+        }
+        else{
+            return new VBORegionSPES2(context);
+        }
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/curve/tess/CDTriangulator2D.java b/src/jogl/classes/com/jogamp/graph/curve/tess/CDTriangulator2D.java
index a2e4ca50f..42eebf7a8 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/tess/CDTriangulator2D.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/tess/CDTriangulator2D.java
@@ -48,169 +48,169 @@ import jogamp.opengl.Debug;
  */
 public class CDTriangulator2D {
 
-	protected static final boolean DEBUG = Debug.debug("Triangulation");
-	
-	private float sharpness = 0.5f;
-	private ArrayList<Loop> loops;
-	private ArrayList<Vertex> vertices;
-	
-	private ArrayList<Triangle> triangles;
-	private int maxTriID = 0;
+    protected static final boolean DEBUG = Debug.debug("Triangulation");
+    
+    private float sharpness = 0.5f;
+    private ArrayList<Loop> loops;
+    private ArrayList<Vertex> vertices;
+    
+    private ArrayList<Triangle> triangles;
+    private int maxTriID = 0;
 
-	
-	public CDTriangulator2D() {
-		this(0.5f);
-	}
-	
-	/** Constructor for a new Delaunay triangulator
-	 * @param curveSharpness the curvature around
-	 *  the off-curve vertices
-	 */
-	public CDTriangulator2D(float curveSharpness) {
-		this.sharpness = curveSharpness;
-		reset();
-	}
-	
-	/** Reset the triangulation to initial state
-	 *  Clearing cached data
-	 */
-	public void reset() {
-		maxTriID = 0;
-		vertices = new ArrayList<Vertex>();
-		triangles = new ArrayList<Triangle>(3);
-		loops = new ArrayList<Loop>();
-	}
-	
-	/** Add a curve to the list of profiles provided
-	 * @param polyline a bounding {@link Outline}
-	 */
-	public void addCurve(Outline polyline){
-		Loop loop = null;
-		
-		if(!loops.isEmpty()){
-			loop = getContainerLoop(polyline);
-		}
-		
-		if(loop == null) {
-			GraphOutline outline = new GraphOutline(polyline);
-			GraphOutline innerPoly = extractBoundaryTriangles(outline, false);
-			vertices.addAll(polyline.getVertices());
-			loop = new Loop(innerPoly, VectorUtil.CCW);
-			loops.add(loop);
-		}
-		else {
-			GraphOutline outline = new GraphOutline(polyline);
-			GraphOutline innerPoly = extractBoundaryTriangles(outline, true);
-			vertices.addAll(innerPoly.getPoints());
-			loop.addConstraintCurve(innerPoly);
-		}
-	}
-	
-	/** Generate the triangulation of the provided 
-	 *  List of {@link Outline}s
-	 */
-	public ArrayList<Triangle> generateTriangulation(){	
-		for(int i=0;i<loops.size();i++) {
-			Loop loop = loops.get(i);
-			int numTries = 0;
-			int size = loop.computeLoopSize();
-			while(!loop.isSimplex()){
-				Triangle tri = null;
-				if(numTries > size){
-					tri = loop.cut(false);
-				}
-				else{
-					tri = loop.cut(true);
-				}
-				numTries++;
+    
+    public CDTriangulator2D() {
+        this(0.5f);
+    }
+    
+    /** Constructor for a new Delaunay triangulator
+     * @param curveSharpness the curvature around
+     *  the off-curve vertices
+     */
+    public CDTriangulator2D(float curveSharpness) {
+        this.sharpness = curveSharpness;
+        reset();
+    }
+    
+    /** Reset the triangulation to initial state
+     *  Clearing cached data
+     */
+    public void reset() {
+        maxTriID = 0;
+        vertices = new ArrayList<Vertex>();
+        triangles = new ArrayList<Triangle>(3);
+        loops = new ArrayList<Loop>();
+    }
+    
+    /** Add a curve to the list of profiles provided
+     * @param polyline a bounding {@link Outline}
+     */
+    public void addCurve(Outline polyline){
+        Loop loop = null;
+        
+        if(!loops.isEmpty()){
+            loop = getContainerLoop(polyline);
+        }
+        
+        if(loop == null) {
+            GraphOutline outline = new GraphOutline(polyline);
+            GraphOutline innerPoly = extractBoundaryTriangles(outline, false);
+            vertices.addAll(polyline.getVertices());
+            loop = new Loop(innerPoly, VectorUtil.CCW);
+            loops.add(loop);
+        }
+        else {
+            GraphOutline outline = new GraphOutline(polyline);
+            GraphOutline innerPoly = extractBoundaryTriangles(outline, true);
+            vertices.addAll(innerPoly.getPoints());
+            loop.addConstraintCurve(innerPoly);
+        }
+    }
+    
+    /** Generate the triangulation of the provided 
+     *  List of {@link Outline}s
+     */
+    public ArrayList<Triangle> generateTriangulation(){    
+        for(int i=0;i<loops.size();i++) {
+            Loop loop = loops.get(i);
+            int numTries = 0;
+            int size = loop.computeLoopSize();
+            while(!loop.isSimplex()){
+                Triangle tri = null;
+                if(numTries > size){
+                    tri = loop.cut(false);
+                }
+                else{
+                    tri = loop.cut(true);
+                }
+                numTries++;
 
-				if(tri != null) {
-					numTries = 0;
-					size--;
-					tri.setId(maxTriID++);
-					triangles.add(tri);
-					if(DEBUG){
-						System.err.println(tri);
-					}
-				}
-				if(numTries > size*2){
-					if(DEBUG){
-						System.err.println("Triangulation not complete!");
-					}
-					break;
-				}
-			}
-			Triangle tri = loop.cut(true);
-			if(tri != null)
-				triangles.add(tri);
-		}
-		return triangles;
-	}
+                if(tri != null) {
+                    numTries = 0;
+                    size--;
+                    tri.setId(maxTriID++);
+                    triangles.add(tri);
+                    if(DEBUG){
+                        System.err.println(tri);
+                    }
+                }
+                if(numTries > size*2){
+                    if(DEBUG){
+                        System.err.println("Triangulation not complete!");
+                    }
+                    break;
+                }
+            }
+            Triangle tri = loop.cut(true);
+            if(tri != null)
+                triangles.add(tri);
+        }
+        return triangles;
+    }
 
-	private GraphOutline extractBoundaryTriangles(GraphOutline outline, boolean hole){
-		GraphOutline innerOutline = new GraphOutline();
-		ArrayList<GraphVertex> outVertices = outline.getGraphPoint();
-		int size = outVertices.size();
-		for(int i=0; i < size; i++) {
-			GraphVertex currentVertex = outVertices.get(i);
-			GraphVertex gv0 = outVertices.get((i+size-1)%size);
-			GraphVertex gv2 = outVertices.get((i+1)%size);
-			GraphVertex gv1 = currentVertex;
-			
-			if(!currentVertex.getPoint().isOnCurve()) {
-			    Vertex v0 = gv0.getPoint().clone();
-			    Vertex v2 = gv2.getPoint().clone();
-			    Vertex v1 = gv1.getPoint().clone();
-				
-				gv0.setBoundaryContained(true);
-				gv1.setBoundaryContained(true);
-				gv2.setBoundaryContained(true);
-				
-				Triangle t= null;
-				boolean holeLike = false;
-				if(VectorUtil.ccw(v0,v1,v2)){
-					t = new Triangle(v0, v1, v2);
-				}
-				else {
-					holeLike = true;
-					t = new Triangle(v2, v1, v0);
-				}
-				t.setId(maxTriID++);
-				triangles.add(t);
-				if(DEBUG){
-					System.err.println(t);
-				}
-				if(hole || holeLike) {
-					v0.setTexCoord(0, -0.1f);
-					v2.setTexCoord(1, -0.1f);
-					v1.setTexCoord(0.5f, -1*sharpness -0.1f);
-					innerOutline.addVertex(currentVertex);
-				}
-				else {
-					v0.setTexCoord(0, 0.1f);
-					v2.setTexCoord(1, 0.1f);
-					v1.setTexCoord(0.5f, sharpness+0.1f);
-				}
-			}
-			else {
-				if(!gv2.getPoint().isOnCurve() || !gv0.getPoint().isOnCurve()){
-					currentVertex.setBoundaryContained(true);
-				}
-				innerOutline.addVertex(currentVertex);
-			}
-		}
-		return innerOutline;
-	}
-	
-	private Loop getContainerLoop(Outline polyline){
-	    ArrayList<Vertex> vertices = polyline.getVertices();
-	    for(Vertex vert: vertices){
-			for (Loop loop:loops){
-				if(loop.checkInside(vert)){
-					return loop;
-				}
-			}
-	    }
-		return null;
-	}
+    private GraphOutline extractBoundaryTriangles(GraphOutline outline, boolean hole){
+        GraphOutline innerOutline = new GraphOutline();
+        ArrayList<GraphVertex> outVertices = outline.getGraphPoint();
+        int size = outVertices.size();
+        for(int i=0; i < size; i++) {
+            GraphVertex currentVertex = outVertices.get(i);
+            GraphVertex gv0 = outVertices.get((i+size-1)%size);
+            GraphVertex gv2 = outVertices.get((i+1)%size);
+            GraphVertex gv1 = currentVertex;
+            
+            if(!currentVertex.getPoint().isOnCurve()) {
+                Vertex v0 = gv0.getPoint().clone();
+                Vertex v2 = gv2.getPoint().clone();
+                Vertex v1 = gv1.getPoint().clone();
+                
+                gv0.setBoundaryContained(true);
+                gv1.setBoundaryContained(true);
+                gv2.setBoundaryContained(true);
+                
+                Triangle t= null;
+                boolean holeLike = false;
+                if(VectorUtil.ccw(v0,v1,v2)){
+                    t = new Triangle(v0, v1, v2);
+                }
+                else {
+                    holeLike = true;
+                    t = new Triangle(v2, v1, v0);
+                }
+                t.setId(maxTriID++);
+                triangles.add(t);
+                if(DEBUG){
+                    System.err.println(t);
+                }
+                if(hole || holeLike) {
+                    v0.setTexCoord(0, -0.1f);
+                    v2.setTexCoord(1, -0.1f);
+                    v1.setTexCoord(0.5f, -1*sharpness -0.1f);
+                    innerOutline.addVertex(currentVertex);
+                }
+                else {
+                    v0.setTexCoord(0, 0.1f);
+                    v2.setTexCoord(1, 0.1f);
+                    v1.setTexCoord(0.5f, sharpness+0.1f);
+                }
+            }
+            else {
+                if(!gv2.getPoint().isOnCurve() || !gv0.getPoint().isOnCurve()){
+                    currentVertex.setBoundaryContained(true);
+                }
+                innerOutline.addVertex(currentVertex);
+            }
+        }
+        return innerOutline;
+    }
+    
+    private Loop getContainerLoop(Outline polyline){
+        ArrayList<Vertex> vertices = polyline.getVertices();
+        for(Vertex vert: vertices){
+            for (Loop loop:loops){
+                if(loop.checkInside(vert)){
+                    return loop;
+                }
+            }
+        }
+        return null;
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/font/Font.java b/src/jogl/classes/com/jogamp/graph/font/Font.java
index d8c30c61b..1010d4f1a 100644
--- a/src/jogl/classes/com/jogamp/graph/font/Font.java
+++ b/src/jogl/classes/com/jogamp/graph/font/Font.java
@@ -52,27 +52,27 @@ public interface Font {
     public static final int NAME_DESIGNER = 9;
     
     
-	/**
-	 * Metrics for font
-	 * 
-	 * Depending on the font's direction, horizontal or vertical,
-	 * the following tables shall be used:
-	 * 
-	 * Vertical http://developer.apple.com/fonts/TTRefMan/RM06/Chap6vhea.html
+    /**
+     * Metrics for font
+     * 
+     * Depending on the font's direction, horizontal or vertical,
+     * the following tables shall be used:
+     * 
+     * Vertical http://developer.apple.com/fonts/TTRefMan/RM06/Chap6vhea.html
      * Horizontal http://developer.apple.com/fonts/TTRefMan/RM06/Chap6hhea.html
-	 */
+     */
     public interface Metrics {  
-	    float getAscent(float pixelSize);
-	    float getDescent(float pixelSize);
-	    float getLineGap(float pixelSize);
-	    float getMaxExtend(float pixelSize);	    
-	    float getScale(float pixelSize);
-	    AABBox getBBox(float pixelSize);
+        float getAscent(float pixelSize);
+        float getDescent(float pixelSize);
+        float getLineGap(float pixelSize);
+        float getMaxExtend(float pixelSize);        
+        float getScale(float pixelSize);
+        AABBox getBBox(float pixelSize);
     }
 
-	/**
-	 * Glyph for font
-	 */
+    /**
+     * Glyph for font
+     */
     public interface Glyph {
         public Font getFont();
         public char getSymbol();
diff --git a/src/jogl/classes/com/jogamp/graph/geom/AABBox.java b/src/jogl/classes/com/jogamp/graph/geom/AABBox.java
index 17a805b31..8a604eccd 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/AABBox.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/AABBox.java
@@ -36,176 +36,176 @@ import com.jogamp.graph.math.VectorUtil;
  * 
  */
 public class AABBox {
-	private float[] low = {Float.MAX_VALUE,Float.MAX_VALUE,Float.MAX_VALUE};
-	private float[] high = {-1*Float.MAX_VALUE,-1*Float.MAX_VALUE,-1*Float.MAX_VALUE};
-	private float[] center = new float[3];
+    private float[] low = {Float.MAX_VALUE,Float.MAX_VALUE,Float.MAX_VALUE};
+    private float[] high = {-1*Float.MAX_VALUE,-1*Float.MAX_VALUE,-1*Float.MAX_VALUE};
+    private float[] center = new float[3];
 
-	/** Create a Axis Aligned bounding box (AABBox) 
-	 * where the low and and high MAX float Values.
-	 */
-	public AABBox() {}
+    /** Create a Axis Aligned bounding box (AABBox) 
+     * where the low and and high MAX float Values.
+     */
+    public AABBox() {}
 
-	/** Create an AABBox specifying the coordinates 
-	 * of the low and high
-	 * @param lx min x-coordinate
-	 * @param ly min y-coordnate
-	 * @param lz min z-coordinate
-	 * @param hx max x-coordinate
-	 * @param hy max y-coordinate
-	 * @param hz max z-coordinate
-	 */
-	public AABBox(float lx, float ly, float lz,
-			float hx, float hy, float hz)
-	{
-		resize(lx, ly, lz);
-		resize(hx, hy, hz);
+    /** Create an AABBox specifying the coordinates 
+     * of the low and high
+     * @param lx min x-coordinate
+     * @param ly min y-coordnate
+     * @param lz min z-coordinate
+     * @param hx max x-coordinate
+     * @param hy max y-coordinate
+     * @param hz max z-coordinate
+     */
+    public AABBox(float lx, float ly, float lz,
+            float hx, float hy, float hz)
+    {
+        resize(lx, ly, lz);
+        resize(hx, hy, hz);
 
-		computeCenter();
-	}
-	
-	/** Create a AABBox defining the low and high
-	 * @param low min xyz-coordinates
-	 * @param high max xyz-coordinates
-	 */
-	public AABBox(float[] low, float[] high)
-	{
-		resize(low[0],low[1],low[2]);
-		resize(high[0],high[1],high[2]);
+        computeCenter();
+    }
+    
+    /** Create a AABBox defining the low and high
+     * @param low min xyz-coordinates
+     * @param high max xyz-coordinates
+     */
+    public AABBox(float[] low, float[] high)
+    {
+        resize(low[0],low[1],low[2]);
+        resize(high[0],high[1],high[2]);
 
-		computeCenter();
-	}
-	
-	/** Get the max xyz-coordinates
-	 * @return a float array containing the max xyz coordinates
-	 */
-	public float[] getHigh() 
-	{
-		return high;
-	}
-	
-	private void setHigh(float hx, float hy, float hz) 
-	{
-		this.high[0] = hx;
-		this.high[1] = hy;
-		this.high[2] = hz;
-	}
-	
-	/** Get the min xyz-coordinates
-	 * @return a float array containing the min xyz coordinates
-	 */
-	public float[] getLow() 
-	{
-		return low;
-	}
-	
-	private void setLow(float lx, float ly, float lz) 
-	{
-		this.low[0] = lx;
-		this.low[1] = ly;
-		this.low[2] = lz;
-	}
+        computeCenter();
+    }
+    
+    /** Get the max xyz-coordinates
+     * @return a float array containing the max xyz coordinates
+     */
+    public float[] getHigh() 
+    {
+        return high;
+    }
+    
+    private void setHigh(float hx, float hy, float hz) 
+    {
+        this.high[0] = hx;
+        this.high[1] = hy;
+        this.high[2] = hz;
+    }
+    
+    /** Get the min xyz-coordinates
+     * @return a float array containing the min xyz coordinates
+     */
+    public float[] getLow() 
+    {
+        return low;
+    }
+    
+    private void setLow(float lx, float ly, float lz) 
+    {
+        this.low[0] = lx;
+        this.low[1] = ly;
+        this.low[2] = lz;
+    }
 
-	/** Resize the AABBox to encapsulate another AABox
-	 * @param newBox AABBox to be encapsulated in
-	 */
-	public void resize(AABBox newBox)
-	{
-		float[] newLow = newBox.getLow();
-		float[] newHigh = newBox.getHigh();
+    /** Resize the AABBox to encapsulate another AABox
+     * @param newBox AABBox to be encapsulated in
+     */
+    public void resize(AABBox newBox)
+    {
+        float[] newLow = newBox.getLow();
+        float[] newHigh = newBox.getHigh();
 
-		/** test low */
-		if (newLow[0] < low[0])
-			low[0] = newLow[0];
-		if (newLow[1] < low[1])
-			low[1] = newLow[1];
-		if (newLow[2] < low[2])
-			low[2] = newLow[2];
+        /** test low */
+        if (newLow[0] < low[0])
+            low[0] = newLow[0];
+        if (newLow[1] < low[1])
+            low[1] = newLow[1];
+        if (newLow[2] < low[2])
+            low[2] = newLow[2];
 
-		/** test high */
-		if (newHigh[0] > high[0])
-			high[0] = newHigh[0];
-		if (newHigh[1] > high[1])
-			high[1] = newHigh[1];
-		if (newHigh[2] > high[2])
-			high[2] = newHigh[2];
+        /** test high */
+        if (newHigh[0] > high[0])
+            high[0] = newHigh[0];
+        if (newHigh[1] > high[1])
+            high[1] = newHigh[1];
+        if (newHigh[2] > high[2])
+            high[2] = newHigh[2];
 
-		computeCenter();
-	}
+        computeCenter();
+    }
 
-	private void computeCenter()
-	{
-		center[0] = (high[0] + low[0])/2;
-		center[1] = (high[1] + low[1])/2;
-		center[2] = (high[2] + low[2])/2;
-	}
+    private void computeCenter()
+    {
+        center[0] = (high[0] + low[0])/2;
+        center[1] = (high[1] + low[1])/2;
+        center[2] = (high[2] + low[2])/2;
+    }
 
-	/** Resize the AABBox to encapsulate the passed
-	 * xyz-coordinates. 
-	 * @param x x-axis coordinate value
-	 * @param y y-axis coordinate value
-	 * @param z z-axis coordinate value
-	 */
-	public void resize(float x, float y, float z)
-	{	
-		/** test low */
-		if (x < low[0])
-			low[0] = x;
-		if (y < low[1])
-			low[1] = y;
-		if (z < low[2])
-			low[2] = z;
+    /** Resize the AABBox to encapsulate the passed
+     * xyz-coordinates. 
+     * @param x x-axis coordinate value
+     * @param y y-axis coordinate value
+     * @param z z-axis coordinate value
+     */
+    public void resize(float x, float y, float z)
+    {    
+        /** test low */
+        if (x < low[0])
+            low[0] = x;
+        if (y < low[1])
+            low[1] = y;
+        if (z < low[2])
+            low[2] = z;
 
-		/** test high */
-		if (x > high[0])
-			high[0] = x;
-		if (y > high[1])
-			high[1] = y;
-		if (z > high[2])
-			high[2] = z;
-		
-		computeCenter();
-	}
+        /** test high */
+        if (x > high[0])
+            high[0] = x;
+        if (y > high[1])
+            high[1] = y;
+        if (z > high[2])
+            high[2] = z;
+        
+        computeCenter();
+    }
 
-	/** Check if the x & y coordinates are bounded/contained
-	 *  by this AABBox
-	 * @param x  x-axis coordinate value
-	 * @param y  y-axis coordinate value
-	 * @return true if  x belong to (low.x, high.x) and
-	 * y belong to (low.y, high.y)
-	 */
-	public boolean contains(float x, float y){
-		if(x<low[0] || x>high[0]){
-			return false;
-		}
-		if(y<low[1]|| y>high[1]){
-			return false;
-		}
-		return true;
-	}
-	
-	/** Check if the xyz coordinates are bounded/contained
-	 *  by this AABBox.
-	 * @param x x-axis coordinate value
-	 * @param y y-axis coordinate value
-	 * @param z z-axis coordinate value
-	 * @return true if  x belong to (low.x, high.x) and
-	 * y belong to (low.y, high.y) and  z belong to (low.z, high.z)
-	 */
-	public boolean contains(float x, float y, float z){
-		if(x<low[0] || x>high[0]){
-			return false;
-		}
-		if(y<low[1]|| y>high[1]){
-			return false;
-		}
-		if(z<low[2] || z>high[2]){
-			return false;
-		}
-		return true;
-	}
-	
+    /** Check if the x & y coordinates are bounded/contained
+     *  by this AABBox
+     * @param x  x-axis coordinate value
+     * @param y  y-axis coordinate value
+     * @return true if  x belong to (low.x, high.x) and
+     * y belong to (low.y, high.y)
+     */
+    public boolean contains(float x, float y){
+        if(x<low[0] || x>high[0]){
+            return false;
+        }
+        if(y<low[1]|| y>high[1]){
+            return false;
+        }
+        return true;
+    }
+    
+    /** Check if the xyz coordinates are bounded/contained
+     *  by this AABBox.
+     * @param x x-axis coordinate value
+     * @param y y-axis coordinate value
+     * @param z z-axis coordinate value
+     * @return true if  x belong to (low.x, high.x) and
+     * y belong to (low.y, high.y) and  z belong to (low.z, high.z)
+     */
+    public boolean contains(float x, float y, float z){
+        if(x<low[0] || x>high[0]){
+            return false;
+        }
+        if(y<low[1]|| y>high[1]){
+            return false;
+        }
+        if(z<low[2] || z>high[2]){
+            return false;
+        }
+        return true;
+    }
+    
     /** Check if there is a common region between this AABBox and the passed
-     * 	2D region irrespective of z range
+     *     2D region irrespective of z range
      * @param x lower left x-coord
      * @param y lower left y-coord
      * @param w width
@@ -213,87 +213,87 @@ public class AABBox {
      * @return true if this AABBox might have a common region with this 2D region
      */
     public boolean intersects(float x, float y, float w, float h) {
-    	if (w <= 0 || h <= 0) {
-    	    return false;
-    	}
-    	
-    	final float _w = getWidth();
-    	final float _h = getHeight();    	
-    	if (_w <= 0 || _h <= 0) {
-    	    return false;
-    	}
-    	
-    	final float x0 = getMinX();
-    	final float y0 = getMinY();
-    	return (x + w > x0 &&
-    		    y + h > y0 &&
-    		    x < x0 + _w &&
-    	        y < y0 + _h);
+        if (w <= 0 || h <= 0) {
+            return false;
+        }
+        
+        final float _w = getWidth();
+        final float _h = getHeight();        
+        if (_w <= 0 || _h <= 0) {
+            return false;
+        }
+        
+        final float x0 = getMinX();
+        final float y0 = getMinY();
+        return (x + w > x0 &&
+                y + h > y0 &&
+                x < x0 + _w &&
+                y < y0 + _h);
     }
 
-	
-	/** Get the size of the Box where the size is represented by the 
-	 * length of the vector between low and high.
-	 * @return a float representing the size of the AABBox
-	 */
-	public float getSize(){
-		return VectorUtil.computeLength(low, high);
-	}
+    
+    /** Get the size of the Box where the size is represented by the 
+     * length of the vector between low and high.
+     * @return a float representing the size of the AABBox
+     */
+    public float getSize(){
+        return VectorUtil.computeLength(low, high);
+    }
 
-	/**Get the Center of the AABBox
-	 * @return the xyz-coordinates of the center of the AABBox
-	 */
-	public float[] getCenter() {
-		return center;
-	}
+    /**Get the Center of the AABBox
+     * @return the xyz-coordinates of the center of the AABBox
+     */
+    public float[] getCenter() {
+        return center;
+    }
 
-	/** Scale the AABBox by a constant
-	 * @param size a constant float value
-	 */
-	public void scale(float size) {
-		float[] diffH = new float[3];
-		diffH[0] = high[0] - center[0];
-		diffH[1] = high[1] - center[1];
-		diffH[2] = high[2] - center[2];
-		
-		diffH = VectorUtil.scale(diffH, size);
-		
-		float[] diffL = new float[3];
-		diffL[0] = low[0] - center[0];
-		diffL[1] = low[1] - center[1];
-		diffL[2] = low[2] - center[2];
-		
-		diffL = VectorUtil.scale(diffL, size);
-		
-		high = VectorUtil.vectorAdd(center, diffH);
-		low = VectorUtil.vectorAdd(center, diffL);
-	}
+    /** Scale the AABBox by a constant
+     * @param size a constant float value
+     */
+    public void scale(float size) {
+        float[] diffH = new float[3];
+        diffH[0] = high[0] - center[0];
+        diffH[1] = high[1] - center[1];
+        diffH[2] = high[2] - center[2];
+        
+        diffH = VectorUtil.scale(diffH, size);
+        
+        float[] diffL = new float[3];
+        diffL[0] = low[0] - center[0];
+        diffL[1] = low[1] - center[1];
+        diffL[2] = low[2] - center[2];
+        
+        diffL = VectorUtil.scale(diffL, size);
+        
+        high = VectorUtil.vectorAdd(center, diffH);
+        low = VectorUtil.vectorAdd(center, diffL);
+    }
 
-	public float getMinX() {
-		return low[0];
-	}
-	
-	public float getMinY() {
-		return low[1];
-	}
-	
-	public float getWidth(){
-		return high[0] - low[0];
-	}
-	
-	public float getHeight() {
-		return high[1] - low[1];
-	}
-	
-	public float getDepth() {
-		return high[2] - low[2];
-	}
-	public AABBox clone(){
-		return new AABBox(this.low, this.high);
-	}
-	
-	public String toString() {
-	    return "[ "+low[0]+"/"+low[1]+"/"+low[1]+" .. "+high[0]+"/"+high[0]+"/"+high[0]+", ctr "+
-	                center[0]+"/"+center[1]+"/"+center[1]+" ]";
-	}
+    public float getMinX() {
+        return low[0];
+    }
+    
+    public float getMinY() {
+        return low[1];
+    }
+    
+    public float getWidth(){
+        return high[0] - low[0];
+    }
+    
+    public float getHeight() {
+        return high[1] - low[1];
+    }
+    
+    public float getDepth() {
+        return high[2] - low[2];
+    }
+    public AABBox clone(){
+        return new AABBox(this.low, this.high);
+    }
+    
+    public String toString() {
+        return "[ "+low[0]+"/"+low[1]+"/"+low[1]+" .. "+high[0]+"/"+high[0]+"/"+high[0]+", ctr "+
+                    center[0]+"/"+center[1]+"/"+center[1]+" ]";
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/geom/Outline.java b/src/jogl/classes/com/jogamp/graph/geom/Outline.java
index a805adf6c..315be002f 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/Outline.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/Outline.java
@@ -44,133 +44,133 @@ import com.jogamp.graph.math.VectorUtil;
  *  @see OutlineShape, Region
  */
 public class Outline implements Comparable<Outline> {
-	
-	private ArrayList<Vertex> vertices = new ArrayList<Vertex>(3);
-	private boolean closed = false;
-	private AABBox box = new AABBox();
-	
-	/**Create an outline defined by control vertices.
-	 * An outline can contain off Curve vertices which define curved
-	 * regions in the outline.
-	 */
-	public Outline(){
-		
-	}
-	
-	/** Add a vertex to the outline. The {@link Vertex} is added at the 
-	 * end of the outline loop/strip.
-	 * @param vertex Vertex to be added
-	 */
-	public final void addVertex(Vertex vertex) {
-		vertices.add(vertex);
-		box.resize(vertex.getX(), vertex.getY(), vertex.getZ());
-	}
-	
-	/**  Add a {@link Vertex} by specifying its 2D attributes to the outline. 
-	 * The {@link Vertex} is added at the 
-	 * end of the outline loop/strip. 
-	 * @param factory a {@link Factory} to get the required Vertex impl
-	 * @param x the x coordinate
-	 * @param y the y coordinate
-	 * @param onCurve flag if this vertex is on the final curve or defines a curved region
-	 * of the shape around this vertex.
-	 */
-	public final void addVertex(Vertex.Factory<? extends Vertex> factory, float x, float y, boolean onCurve) {
-		addVertex(factory, x, y, 0f, onCurve);
-	}
-	
-	/** Add a {@link Vertex} by specifying its 3D attributes to the outline. 
-	 * The {@link Vertex} is added at the 
-	 * end of the outline loop/strip. 
-	 * @param factory  a {@link Factory} to get the required Vertex impl
-	 * @param x the x coordinate
-	 * @param y the y coordinate
-	 * @param z the z coordinate
-	 * @param onCurve flag if this vertex is on the final curve or defines a curved region
-	 * of the shape around this vertex.
-	 */
-	public final void addVertex(Vertex.Factory<? extends Vertex> factory, float x, float y, float z, boolean onCurve) {
-		Vertex v = factory.create(x, y, z);
-		v.setOnCurve(onCurve);
-		addVertex(v);
-	}
-	
-	/** Add a vertex to the outline by passing a float array and specifying the 
-	 * offset and length in which. The attributes of the vertex are located. 
-	 * The attributes should be continuous (stride = 0).
-	 * Attributes which value are not set (when length less than 3) 
-	 * are set implicitly to zero.
-	 * @param factory  a {@link Factory} to get the required Vertex impl
-	 * @param coordsBuffer the coordinate array where the vertex attributes are to be picked from
-	 * @param offset the offset in the buffer to the x coordinate
-	 * @param length the number of attributes to pick from the buffer (maximum 3)
-	 * @param onCurve flag if this vertex is on the final curve or defines a curved region
-	 * of the shape around this vertex.
-	 */
-	public final void addVertex(Vertex.Factory<? extends Vertex> factory, float[] coordsBuffer, int offset, int length, boolean onCurve) {
-		Vertex v = factory.create(coordsBuffer, offset, length);
-		v.setOnCurve(onCurve);
-		addVertex(v);
-	}
-	
-	public Vertex getVertex(int index){
-		return vertices.get(index);
-	}
-	
-	public boolean isEmpty(){
-		return (vertices.size() == 0);
-	}
-	public Vertex getLastVertex(){
-		if(isEmpty()){
-			return null;
-		}
-		return vertices.get(vertices.size()-1);
-	}
-	
-	public ArrayList<Vertex> getVertices() {
-		return vertices;
-	}
-	public void setVertices(ArrayList<Vertex> vertices) {
-		this.vertices = vertices;
-	}
-	public AABBox getBox() {
-		return box;
-	}
-	public boolean isClosed() {
-		return closed;
-	}
-	
-	/** define if this outline is closed or not.
-	 * if set to closed, checks if the last vertex is 
-	 * equal to the first vertex. If not Equal adds a
-	 * vertex at the end to the list.
-	 * @param closed
-	 */
-	public void setClosed(boolean closed) {
-		this.closed = closed;
-		if(closed){
-		    Vertex first = vertices.get(0);
-		    Vertex last = getLastVertex();
-			if(!VectorUtil.checkEquality(first.getCoord(), last.getCoord())){
-				Vertex v = first.clone();
-				vertices.add(v);
-			}
-		}
-	}
-	
-	/** Compare two outlines with Bounding Box area
-	 * as criteria. 
-	 * @see java.lang.Comparable#compareTo(java.lang.Object)
-	 */
-	public int compareTo(Outline outline) {
-		float size = box.getSize();
-		float newSize = outline.getBox().getSize();
-		if(size < newSize){
-			return -1;
-		}
-		else if(size > newSize){
-			return 1;
-		}
-		return 0;
-	}
+    
+    private ArrayList<Vertex> vertices = new ArrayList<Vertex>(3);
+    private boolean closed = false;
+    private AABBox box = new AABBox();
+    
+    /**Create an outline defined by control vertices.
+     * An outline can contain off Curve vertices which define curved
+     * regions in the outline.
+     */
+    public Outline(){
+        
+    }
+    
+    /** Add a vertex to the outline. The {@link Vertex} is added at the 
+     * end of the outline loop/strip.
+     * @param vertex Vertex to be added
+     */
+    public final void addVertex(Vertex vertex) {
+        vertices.add(vertex);
+        box.resize(vertex.getX(), vertex.getY(), vertex.getZ());
+    }
+    
+    /**  Add a {@link Vertex} by specifying its 2D attributes to the outline. 
+     * The {@link Vertex} is added at the 
+     * end of the outline loop/strip. 
+     * @param factory a {@link Factory} to get the required Vertex impl
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param onCurve flag if this vertex is on the final curve or defines a curved region
+     * of the shape around this vertex.
+     */
+    public final void addVertex(Vertex.Factory<? extends Vertex> factory, float x, float y, boolean onCurve) {
+        addVertex(factory, x, y, 0f, onCurve);
+    }
+    
+    /** Add a {@link Vertex} by specifying its 3D attributes to the outline. 
+     * The {@link Vertex} is added at the 
+     * end of the outline loop/strip. 
+     * @param factory  a {@link Factory} to get the required Vertex impl
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param z the z coordinate
+     * @param onCurve flag if this vertex is on the final curve or defines a curved region
+     * of the shape around this vertex.
+     */
+    public final void addVertex(Vertex.Factory<? extends Vertex> factory, float x, float y, float z, boolean onCurve) {
+        Vertex v = factory.create(x, y, z);
+        v.setOnCurve(onCurve);
+        addVertex(v);
+    }
+    
+    /** Add a vertex to the outline by passing a float array and specifying the 
+     * offset and length in which. The attributes of the vertex are located. 
+     * The attributes should be continuous (stride = 0).
+     * Attributes which value are not set (when length less than 3) 
+     * are set implicitly to zero.
+     * @param factory  a {@link Factory} to get the required Vertex impl
+     * @param coordsBuffer the coordinate array where the vertex attributes are to be picked from
+     * @param offset the offset in the buffer to the x coordinate
+     * @param length the number of attributes to pick from the buffer (maximum 3)
+     * @param onCurve flag if this vertex is on the final curve or defines a curved region
+     * of the shape around this vertex.
+     */
+    public final void addVertex(Vertex.Factory<? extends Vertex> factory, float[] coordsBuffer, int offset, int length, boolean onCurve) {
+        Vertex v = factory.create(coordsBuffer, offset, length);
+        v.setOnCurve(onCurve);
+        addVertex(v);
+    }
+    
+    public Vertex getVertex(int index){
+        return vertices.get(index);
+    }
+    
+    public boolean isEmpty(){
+        return (vertices.size() == 0);
+    }
+    public Vertex getLastVertex(){
+        if(isEmpty()){
+            return null;
+        }
+        return vertices.get(vertices.size()-1);
+    }
+    
+    public ArrayList<Vertex> getVertices() {
+        return vertices;
+    }
+    public void setVertices(ArrayList<Vertex> vertices) {
+        this.vertices = vertices;
+    }
+    public AABBox getBox() {
+        return box;
+    }
+    public boolean isClosed() {
+        return closed;
+    }
+    
+    /** define if this outline is closed or not.
+     * if set to closed, checks if the last vertex is 
+     * equal to the first vertex. If not Equal adds a
+     * vertex at the end to the list.
+     * @param closed
+     */
+    public void setClosed(boolean closed) {
+        this.closed = closed;
+        if(closed){
+            Vertex first = vertices.get(0);
+            Vertex last = getLastVertex();
+            if(!VectorUtil.checkEquality(first.getCoord(), last.getCoord())){
+                Vertex v = first.clone();
+                vertices.add(v);
+            }
+        }
+    }
+    
+    /** Compare two outlines with Bounding Box area
+     * as criteria. 
+     * @see java.lang.Comparable#compareTo(java.lang.Object)
+     */
+    public int compareTo(Outline outline) {
+        float size = box.getSize();
+        float newSize = outline.getBox().getSize();
+        if(size < newSize){
+            return -1;
+        }
+        else if(size > newSize){
+            return 1;
+        }
+        return 0;
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/geom/Triangle.java b/src/jogl/classes/com/jogamp/graph/geom/Triangle.java
index d13e8ddb1..fb34de221 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/Triangle.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/Triangle.java
@@ -28,52 +28,52 @@
 package com.jogamp.graph.geom;
 
 public class Triangle {
-	private int id = Integer.MAX_VALUE;
-	final private Vertex[] vertices;
-	private boolean[] boundaryEdges = new boolean[3];
-	private boolean[] boundaryVertices = null;
+    private int id = Integer.MAX_VALUE;
+    final private Vertex[] vertices;
+    private boolean[] boundaryEdges = new boolean[3];
+    private boolean[] boundaryVertices = null;
 
-	public Triangle(Vertex ... v123){
-		vertices = v123;
-	}
+    public Triangle(Vertex ... v123){
+        vertices = v123;
+    }
 
-	public int getId() {
-		return id;
-	}
+    public int getId() {
+        return id;
+    }
 
-	public void setId(int id) {
-		this.id = id;
-	}
+    public void setId(int id) {
+        this.id = id;
+    }
 
-	public Vertex[] getVertices() {
-		return vertices;
-	}
-	
-	public boolean isEdgesBoundary() {
-		return boundaryEdges[0] || boundaryEdges[1] || boundaryEdges[2];
-	}
-	
-	public boolean isVerticesBoundary() {
-		return boundaryVertices[0] || boundaryVertices[1] || boundaryVertices[2];
-	}
+    public Vertex[] getVertices() {
+        return vertices;
+    }
+    
+    public boolean isEdgesBoundary() {
+        return boundaryEdges[0] || boundaryEdges[1] || boundaryEdges[2];
+    }
+    
+    public boolean isVerticesBoundary() {
+        return boundaryVertices[0] || boundaryVertices[1] || boundaryVertices[2];
+    }
 
-	public void setEdgesBoundary(boolean[] boundary) {
-		this.boundaryEdges = boundary;
-	}
-	
-	public boolean[] getEdgeBoundary() {
-		return boundaryEdges;
-	}
-	
-	public boolean[] getVerticesBoundary() {
-		return boundaryVertices;
-	}
+    public void setEdgesBoundary(boolean[] boundary) {
+        this.boundaryEdges = boundary;
+    }
+    
+    public boolean[] getEdgeBoundary() {
+        return boundaryEdges;
+    }
+    
+    public boolean[] getVerticesBoundary() {
+        return boundaryVertices;
+    }
 
-	public void setVerticesBoundary(boolean[] boundaryVertices) {
-		this.boundaryVertices = boundaryVertices;
-	}
-	
-	public String toString() {
-		return "Tri ID: " + id + "\n" +  vertices[0]  + "\n" +  vertices[1] + "\n" +  vertices[2];
-	}
+    public void setVerticesBoundary(boolean[] boundaryVertices) {
+        this.boundaryVertices = boundaryVertices;
+    }
+    
+    public String toString() {
+        return "Tri ID: " + id + "\n" +  vertices[0]  + "\n" +  vertices[1] + "\n" +  vertices[2];
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/geom/Vertex.java b/src/jogl/classes/com/jogamp/graph/geom/Vertex.java
index 0e4e5e8df..859add943 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/Vertex.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/Vertex.java
@@ -32,49 +32,49 @@ package com.jogamp.graph.geom;
  */
 public interface Vertex extends Comparable<Vertex>, Cloneable {
 
-	public static interface Factory <T extends Vertex> {
-		T create();
+    public static interface Factory <T extends Vertex> {
+        T create();
 
-		T create(float x, float y);
+        T create(float x, float y);
 
-		T create(float x, float y, float z);
+        T create(float x, float y, float z);
 
-		T create(float[] coordsBuffer, int offset, int length);	
-	}
-	
-	void setCoord(float x, float y);
+        T create(float[] coordsBuffer, int offset, int length);    
+    }
+    
+    void setCoord(float x, float y);
 
-	void setCoord(float x, float y, float z);
+    void setCoord(float x, float y, float z);
 
-	void setCoord(float[] coordsBuffer, int offset, int length);
-	
-	float[] getCoord();
+    void setCoord(float[] coordsBuffer, int offset, int length);
+    
+    float[] getCoord();
 
-	void setX(float x);
+    void setX(float x);
 
-	void setY(float y);
+    void setY(float y);
 
-	void setZ(float z);
+    void setZ(float z);
 
-	float getX();
+    float getX();
 
-	float getY();
+    float getY();
 
-	float getZ();
+    float getZ();
 
-	boolean isOnCurve();
+    boolean isOnCurve();
 
-	void setOnCurve(boolean onCurve);
+    void setOnCurve(boolean onCurve);
 
-	int getId();
-	
-	void setId(int id);
-	
-	int compareTo(Vertex p);
-	
-	float[] getTexCoord();
-	
-	void setTexCoord(float s, float t);
-	
-	Vertex clone();
+    int getId();
+    
+    void setId(int id);
+    
+    int compareTo(Vertex p);
+    
+    float[] getTexCoord();
+    
+    void setTexCoord(float s, float t);
+    
+    Vertex clone();
 }
diff --git a/src/jogl/classes/com/jogamp/graph/geom/opengl/SVertex.java b/src/jogl/classes/com/jogamp/graph/geom/opengl/SVertex.java
index 681067e40..6241d60df 100644
--- a/src/jogl/classes/com/jogamp/graph/geom/opengl/SVertex.java
+++ b/src/jogl/classes/com/jogamp/graph/geom/opengl/SVertex.java
@@ -36,143 +36,143 @@ import com.jogamp.graph.math.VectorUtil;
  *
  */
 public class SVertex implements Vertex {
-	private int id = Integer.MAX_VALUE;
-	protected float[] coord = new float[3];
-	protected boolean onCurve = true;
-	private float[] texCoord = new float[2];
-	
-	static final Factory factory = new Factory();
-	
-	public static Factory factory() { return factory; } 
-	
-	public static class Factory implements Vertex.Factory<SVertex> {
-		@Override
-		public SVertex create() {
-			return new SVertex();
-		}
-
-		@Override
-		public SVertex create(float x, float y) {
-			return new SVertex(x, y);
-		}
-
-		@Override
-		public SVertex create(float x, float y, float z) {
-			return new SVertex(x, y, z);
-		}
-
-		@Override
-		public SVertex create(float[] coordsBuffer, int offset, int length) {
-			return new SVertex(coordsBuffer, offset, length);
-		}		
-	}
-	
-	public SVertex() {
-	}
-
-	public SVertex(float x, float y) {
-		setCoord(x, y);
-	}
-	public SVertex(float x, float y, float z) {
-		setCoord(x, y, z);
-	}	
-	public SVertex(float[] coordsBuffer, int offset, int length) {
-		setCoord(coordsBuffer, offset, length);
-	}
-		
-	public void setCoord(float x, float y) {
-		this.coord[0] = x;
-		this.coord[1] = y;
-		this.coord[2] = 0f;
-	}
-
-	public void setCoord(float x, float y, float z) {
-		this.coord[0] = x;
-		this.coord[1] = y;
-		this.coord[2] = z;
-	}
-
-	public void setCoord(float[] coordsBuffer, int offset, int length) {
-		if(length > coordsBuffer.length - offset) {
-			throw new IndexOutOfBoundsException("coordsBuffer too small: "+coordsBuffer.length+" - "+offset+" < "+length);
-		}
-		if(length > 3) {
-			throw new IndexOutOfBoundsException("length too big: "+length+" > "+3);
-		}		
-		int i=0;
-		while(i<length) {
-			this.coord[i++] = coordsBuffer[offset++];
-		}
-	}
-		
-	public float[] getCoord() {
-		return coord;
-	}
-
-	public void setX(float x) {
-		this.coord[0] = x;
-	}
-
-	public void setY(float y) {
-		this.coord[1] = y;
-	}
-
-	public void setZ(float z) {
-		this.coord[2] = z;
-	}
-
-	public float getX() {
-		return this.coord[0];
-	}
-
-	public float getY() {
-		return this.coord[1];
-	}
-
-	public float getZ() {
-		return this.coord[2];
-	}
-
-	public boolean isOnCurve() {
-		return onCurve;
-	}
-
-	public void setOnCurve(boolean onCurve) {
-		this.onCurve = onCurve;
-	}
-
-	public int getId(){
-		return id;
-	}
-	
-	public void setId(int id){
-		this.id = id;
-	}
-	
-	public int compareTo(Vertex p) {
-		if(VectorUtil.checkEquality(coord, p.getCoord())) {
-			return 0;
-		}
-		return -1;
-	}
-	
-	public float[] getTexCoord() {
-		return texCoord;
-	}
-
-	public void setTexCoord(float s, float t) {
-		this.texCoord[0] = s;
-		this.texCoord[1] = t;
-	}
-	
-	public SVertex clone(){
-		SVertex v = new SVertex(this.coord, 0, 3);
-		v.setOnCurve(this.onCurve);
-		return v;
-	}
-	
-	public String toString() {
-		return "[ID: " + id + " X: " + coord[0]
-		        + " Y: " + coord[1] + " Z: " + coord[2] + "]";
-	}
+    private int id = Integer.MAX_VALUE;
+    protected float[] coord = new float[3];
+    protected boolean onCurve = true;
+    private float[] texCoord = new float[2];
+    
+    static final Factory factory = new Factory();
+    
+    public static Factory factory() { return factory; } 
+    
+    public static class Factory implements Vertex.Factory<SVertex> {
+        @Override
+        public SVertex create() {
+            return new SVertex();
+        }
+
+        @Override
+        public SVertex create(float x, float y) {
+            return new SVertex(x, y);
+        }
+
+        @Override
+        public SVertex create(float x, float y, float z) {
+            return new SVertex(x, y, z);
+        }
+
+        @Override
+        public SVertex create(float[] coordsBuffer, int offset, int length) {
+            return new SVertex(coordsBuffer, offset, length);
+        }        
+    }
+    
+    public SVertex() {
+    }
+
+    public SVertex(float x, float y) {
+        setCoord(x, y);
+    }
+    public SVertex(float x, float y, float z) {
+        setCoord(x, y, z);
+    }    
+    public SVertex(float[] coordsBuffer, int offset, int length) {
+        setCoord(coordsBuffer, offset, length);
+    }
+        
+    public void setCoord(float x, float y) {
+        this.coord[0] = x;
+        this.coord[1] = y;
+        this.coord[2] = 0f;
+    }
+
+    public void setCoord(float x, float y, float z) {
+        this.coord[0] = x;
+        this.coord[1] = y;
+        this.coord[2] = z;
+    }
+
+    public void setCoord(float[] coordsBuffer, int offset, int length) {
+        if(length > coordsBuffer.length - offset) {
+            throw new IndexOutOfBoundsException("coordsBuffer too small: "+coordsBuffer.length+" - "+offset+" < "+length);
+        }
+        if(length > 3) {
+            throw new IndexOutOfBoundsException("length too big: "+length+" > "+3);
+        }        
+        int i=0;
+        while(i<length) {
+            this.coord[i++] = coordsBuffer[offset++];
+        }
+    }
+        
+    public float[] getCoord() {
+        return coord;
+    }
+
+    public void setX(float x) {
+        this.coord[0] = x;
+    }
+
+    public void setY(float y) {
+        this.coord[1] = y;
+    }
+
+    public void setZ(float z) {
+        this.coord[2] = z;
+    }
+
+    public float getX() {
+        return this.coord[0];
+    }
+
+    public float getY() {
+        return this.coord[1];
+    }
+
+    public float getZ() {
+        return this.coord[2];
+    }
+
+    public boolean isOnCurve() {
+        return onCurve;
+    }
+
+    public void setOnCurve(boolean onCurve) {
+        this.onCurve = onCurve;
+    }
+
+    public int getId(){
+        return id;
+    }
+    
+    public void setId(int id){
+        this.id = id;
+    }
+    
+    public int compareTo(Vertex p) {
+        if(VectorUtil.checkEquality(coord, p.getCoord())) {
+            return 0;
+        }
+        return -1;
+    }
+    
+    public float[] getTexCoord() {
+        return texCoord;
+    }
+
+    public void setTexCoord(float s, float t) {
+        this.texCoord[0] = s;
+        this.texCoord[1] = t;
+    }
+    
+    public SVertex clone(){
+        SVertex v = new SVertex(this.coord, 0, 3);
+        v.setOnCurve(this.onCurve);
+        return v;
+    }
+    
+    public String toString() {
+        return "[ID: " + id + " X: " + coord[0]
+                + " Y: " + coord[1] + " Z: " + coord[2] + "]";
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/math/Quaternion.java b/src/jogl/classes/com/jogamp/graph/math/Quaternion.java
index b77a5fa08..38638dc5a 100755
--- a/src/jogl/classes/com/jogamp/graph/math/Quaternion.java
+++ b/src/jogl/classes/com/jogamp/graph/math/Quaternion.java
@@ -30,353 +30,353 @@ package com.jogamp.graph.math;
 import jogamp.graph.math.MathFloat;
 
 public class Quaternion {
-	protected float x,y,z,w;
+    protected float x,y,z,w;
 
-	public Quaternion(){
+    public Quaternion(){
 
-	}
-	
-	public Quaternion(float x, float y, float z, float w) {
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		this.w = w;
-	}
-	
-	/** Constructor to create a rotation based quaternion from two vectors
-	 * @param vector1
-	 * @param vector2
-	 */
-	public Quaternion(float[] vector1, float[] vector2) 
-	{
-		float theta = (float)MathFloat.acos(dot(vector1, vector2));
-		float[] cross = cross(vector1,vector2);
-		cross = normalizeVec(cross);
+    }
+    
+    public Quaternion(float x, float y, float z, float w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    
+    /** Constructor to create a rotation based quaternion from two vectors
+     * @param vector1
+     * @param vector2
+     */
+    public Quaternion(float[] vector1, float[] vector2) 
+    {
+        float theta = (float)MathFloat.acos(dot(vector1, vector2));
+        float[] cross = cross(vector1,vector2);
+        cross = normalizeVec(cross);
 
-		this.x = (float)MathFloat.sin(theta/2)*cross[0];
-		this.y = (float)MathFloat.sin(theta/2)*cross[1];
-		this.z = (float)MathFloat.sin(theta/2)*cross[2];
-		this.w = (float)MathFloat.cos(theta/2);
-		this.normalize();
-	}
-	
-	/** Transform the rotational quaternion to axis based rotation angles
-	 * @return new float[4] with ,theta,Rx,Ry,Rz
-	 */
-	public float[] toAxis()
-	{
-		float[] vec = new float[4];
-		float scale = (float)MathFloat.sqrt(x * x + y * y + z * z);
-		vec[0] =(float) MathFloat.acos(w) * 2.0f;
-		vec[1] = x / scale;
-		vec[2] = y / scale;
-		vec[3] = z / scale;
-		return vec;
-	}
-	
-	/** Normalize a vector
-	 * @param vector input vector
-	 * @return normalized vector
-	 */
-	private float[] normalizeVec(float[] vector)
-	{
-		float[] newVector = new float[3];
+        this.x = (float)MathFloat.sin(theta/2)*cross[0];
+        this.y = (float)MathFloat.sin(theta/2)*cross[1];
+        this.z = (float)MathFloat.sin(theta/2)*cross[2];
+        this.w = (float)MathFloat.cos(theta/2);
+        this.normalize();
+    }
+    
+    /** Transform the rotational quaternion to axis based rotation angles
+     * @return new float[4] with ,theta,Rx,Ry,Rz
+     */
+    public float[] toAxis()
+    {
+        float[] vec = new float[4];
+        float scale = (float)MathFloat.sqrt(x * x + y * y + z * z);
+        vec[0] =(float) MathFloat.acos(w) * 2.0f;
+        vec[1] = x / scale;
+        vec[2] = y / scale;
+        vec[3] = z / scale;
+        return vec;
+    }
+    
+    /** Normalize a vector
+     * @param vector input vector
+     * @return normalized vector
+     */
+    private float[] normalizeVec(float[] vector)
+    {
+        float[] newVector = new float[3];
 
-		float d = MathFloat.sqrt(vector[0]*vector[0] + vector[1]*vector[1] + vector[2]*vector[2]);
-		if(d> 0.0f)
-		{
-			newVector[0] = vector[0]/d;
-			newVector[1] = vector[1]/d;
-			newVector[2] = vector[2]/d;
-		}
-		return newVector;
-	}
-	/** compute the dot product of two points
-	 * @param vec1 vector 1
-	 * @param vec2 vector 2
-	 * @return the dot product as float
-	 */
-	private float dot(float[] vec1, float[] vec2)
-	{
-		return (vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2]);
-	}
-	/** cross product vec1 x vec2
-	 * @param vec1 vector 1
-	 * @param vec2 vecttor 2
-	 * @return the resulting vector
-	 */
-	private float[] cross(float[] vec1, float[] vec2)
-	{
-		float[] out = new float[3];
+        float d = MathFloat.sqrt(vector[0]*vector[0] + vector[1]*vector[1] + vector[2]*vector[2]);
+        if(d> 0.0f)
+        {
+            newVector[0] = vector[0]/d;
+            newVector[1] = vector[1]/d;
+            newVector[2] = vector[2]/d;
+        }
+        return newVector;
+    }
+    /** compute the dot product of two points
+     * @param vec1 vector 1
+     * @param vec2 vector 2
+     * @return the dot product as float
+     */
+    private float dot(float[] vec1, float[] vec2)
+    {
+        return (vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2]);
+    }
+    /** cross product vec1 x vec2
+     * @param vec1 vector 1
+     * @param vec2 vecttor 2
+     * @return the resulting vector
+     */
+    private float[] cross(float[] vec1, float[] vec2)
+    {
+        float[] out = new float[3];
 
-		out[0] = vec2[2]*vec1[1] - vec2[1]*vec1[2];
-		out[1] = vec2[0]*vec1[2] - vec2[2]*vec1[0];
-		out[2] = vec2[1]*vec1[0] - vec2[0]*vec1[1];
+        out[0] = vec2[2]*vec1[1] - vec2[1]*vec1[2];
+        out[1] = vec2[0]*vec1[2] - vec2[2]*vec1[0];
+        out[2] = vec2[1]*vec1[0] - vec2[0]*vec1[1];
 
-		return out;
-	}
-	public float getW() {
-		return w;
-	}
-	public void setW(float w) {
-		this.w = w;
-	}
-	public float getX() {
-		return x;
-	}
-	public void setX(float x) {
-		this.x = x;
-	}
-	public float getY() {
-		return y;
-	}
-	public void setY(float y) {
-		this.y = y;
-	}
-	public float getZ() {
-		return z;
-	}
-	public void setZ(float z) {
-		this.z = z;
-	}
+        return out;
+    }
+    public float getW() {
+        return w;
+    }
+    public void setW(float w) {
+        this.w = w;
+    }
+    public float getX() {
+        return x;
+    }
+    public void setX(float x) {
+        this.x = x;
+    }
+    public float getY() {
+        return y;
+    }
+    public void setY(float y) {
+        this.y = y;
+    }
+    public float getZ() {
+        return z;
+    }
+    public void setZ(float z) {
+        this.z = z;
+    }
 
-	/** Add a quaternion
-	 * @param q quaternion
-	 */
-	public void add(Quaternion q)
-	{
-		x+=q.x;
-		y+=q.y;
-		z+=q.z;
-	}
-	
-	/** Subtract a quaternion
-	 * @param q quaternion
-	 */
-	public void subtract(Quaternion q)
-	{
-		x-=q.x;
-		y-=q.y;
-		z-=q.z;
-	}
-	
-	/** Divide a quaternion by a constant
-	 * @param n a float to divide by
-	 */
-	public void divide(float n)
-	{
-		x/=n;
-		y/=n;
-		z/=n;
-	}
-	
-	/** Multiply this quaternion by 
-	 * the param quaternion
-	 * @param q a quaternion to multiply with
-	 */
-	public void mult(Quaternion q)
-	{
-		float w1 = w*q.w - (x*q.x + y*q.y + z*q.z);
+    /** Add a quaternion
+     * @param q quaternion
+     */
+    public void add(Quaternion q)
+    {
+        x+=q.x;
+        y+=q.y;
+        z+=q.z;
+    }
+    
+    /** Subtract a quaternion
+     * @param q quaternion
+     */
+    public void subtract(Quaternion q)
+    {
+        x-=q.x;
+        y-=q.y;
+        z-=q.z;
+    }
+    
+    /** Divide a quaternion by a constant
+     * @param n a float to divide by
+     */
+    public void divide(float n)
+    {
+        x/=n;
+        y/=n;
+        z/=n;
+    }
+    
+    /** Multiply this quaternion by 
+     * the param quaternion
+     * @param q a quaternion to multiply with
+     */
+    public void mult(Quaternion q)
+    {
+        float w1 = w*q.w - (x*q.x + y*q.y + z*q.z);
 
-		float x1 = w*q.z + q.w*z + y*q.z - z*q.y;
-		float y1 = w*q.x + q.w*x + z*q.x - x*q.z;
-		float z1 = w*q.y + q.w*y + x*q.y - y*q.x;
+        float x1 = w*q.z + q.w*z + y*q.z - z*q.y;
+        float y1 = w*q.x + q.w*x + z*q.x - x*q.z;
+        float z1 = w*q.y + q.w*y + x*q.y - y*q.x;
 
-		w = w1;
-		x = x1;
-		y = y1;
-		z = z1; 
-	}
-	
-	/** Multiply a quaternion by a constant
-	 * @param n a float constant
-	 */
-	public void mult(float n)
-	{
-		x*=n;
-		y*=n;
-		z*=n;
-	}
-	
-	/** Normalize a quaternion required if  
-	 *  to be used as a rotational quaternion
-	 */
-	public void normalize()
-	{
-		float norme = (float)MathFloat.sqrt(w*w + x*x + y*y + z*z);
-		if (norme == 0.0f)
-		{
-			w = 1.0f; 
-			x = y = z = 0.0f;
-		}
-		else
-		{
-			float recip = 1.0f/norme;
+        w = w1;
+        x = x1;
+        y = y1;
+        z = z1; 
+    }
+    
+    /** Multiply a quaternion by a constant
+     * @param n a float constant
+     */
+    public void mult(float n)
+    {
+        x*=n;
+        y*=n;
+        z*=n;
+    }
+    
+    /** Normalize a quaternion required if  
+     *  to be used as a rotational quaternion
+     */
+    public void normalize()
+    {
+        float norme = (float)MathFloat.sqrt(w*w + x*x + y*y + z*z);
+        if (norme == 0.0f)
+        {
+            w = 1.0f; 
+            x = y = z = 0.0f;
+        }
+        else
+        {
+            float recip = 1.0f/norme;
 
-			w *= recip;
-			x *= recip;
-			y *= recip;
-			z *= recip;
-		}
-	}
-	
-	/** Invert the quaternion If rotational, 
-	 * will produce a the inverse rotation
-	 */
-	public void inverse()
-	{
-		float norm = w*w + x*x + y*y + z*z;
+            w *= recip;
+            x *= recip;
+            y *= recip;
+            z *= recip;
+        }
+    }
+    
+    /** Invert the quaternion If rotational, 
+     * will produce a the inverse rotation
+     */
+    public void inverse()
+    {
+        float norm = w*w + x*x + y*y + z*z;
 
-		float recip = 1.0f/norm;
+        float recip = 1.0f/norm;
 
-		w *= recip;
-		x = -1*x*recip;
-		y = -1*y*recip;
-		z = -1*z*recip;
-	}
-	
-	/** Transform this quaternion to a
-	 * 4x4 column matrix representing the rotation
-	 * @return new float[16] column matrix 4x4 
-	 */
-	public float[] toMatrix()
-	{
-		float[] matrix = new float[16];
-		matrix[0] = 1.0f - 2*y*y - 2*z*z;
-		matrix[1] = 2*x*y + 2*w*z;
-		matrix[2] = 2*x*z - 2*w*y;
-		matrix[3] = 0;
+        w *= recip;
+        x = -1*x*recip;
+        y = -1*y*recip;
+        z = -1*z*recip;
+    }
+    
+    /** Transform this quaternion to a
+     * 4x4 column matrix representing the rotation
+     * @return new float[16] column matrix 4x4 
+     */
+    public float[] toMatrix()
+    {
+        float[] matrix = new float[16];
+        matrix[0] = 1.0f - 2*y*y - 2*z*z;
+        matrix[1] = 2*x*y + 2*w*z;
+        matrix[2] = 2*x*z - 2*w*y;
+        matrix[3] = 0;
 
-		matrix[4] = 2*x*y - 2*w*z;
-		matrix[5] = 1.0f - 2*x*x - 2*z*z;
-		matrix[6] = 2*y*z + 2*w*x;
-		matrix[7] = 0;
+        matrix[4] = 2*x*y - 2*w*z;
+        matrix[5] = 1.0f - 2*x*x - 2*z*z;
+        matrix[6] = 2*y*z + 2*w*x;
+        matrix[7] = 0;
 
-		matrix[8]  = 2*x*z + 2*w*y;
-		matrix[9]  = 2*y*z - 2*w*x;
-		matrix[10] = 1.0f - 2*x*x - 2*y*y;
-		matrix[11] = 0;
+        matrix[8]  = 2*x*z + 2*w*y;
+        matrix[9]  = 2*y*z - 2*w*x;
+        matrix[10] = 1.0f - 2*x*x - 2*y*y;
+        matrix[11] = 0;
 
-		matrix[12] = 0;
-		matrix[13] = 0;
-		matrix[14] = 0;
-		matrix[15] = 1;
-		return matrix;
-	}
-	
-	/** Set this quaternion from a Sphereical interpolation
-	 *  of two param quaternion, used mostly for rotational animation
-	 * @param a initial quaternion
-	 * @param b target quaternion
-	 * @param t float between 0 and 1 representing interp.
-	 */
-	public void slerp(Quaternion a,Quaternion b, float t)
-	{
-		float omega, cosom, sinom, sclp, sclq;
-		cosom = a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
-		if ((1.0f+cosom) > MathFloat.E) {
-			if ((1.0f-cosom) > MathFloat.E) {
-				omega = (float)MathFloat.acos(cosom);
-				sinom = (float)MathFloat.sin(omega);
-				sclp = (float)MathFloat.sin((1.0f-t)*omega) / sinom;
-				sclq = (float)MathFloat.sin(t*omega) / sinom;
-			}
-			else {
-				sclp = 1.0f - t;
-				sclq = t;
-			}
-			x = sclp*a.x + sclq*b.x;
-			y = sclp*a.y + sclq*b.y;
-			z = sclp*a.z + sclq*b.z;
-			w = sclp*a.w + sclq*b.w;
-		}
-		else {
-			x =-a.y;
-			y = a.x;
-			z =-a.w;
-			w = a.z;
-			sclp = MathFloat.sin((1.0f-t) * MathFloat.PI * 0.5f);
-			sclq = MathFloat.sin(t * MathFloat.PI * 0.5f);
-			x = sclp*a.x + sclq*b.x;
-			y = sclp*a.y + sclq*b.y;
-			z = sclp*a.z + sclq*b.z;
-		}
-	}
-	
-	/** Check if this quaternion is empty, ie (0,0,0,1)
-	 * @return true if empty, false otherwise
-	 */
-	public boolean isEmpty()
-	{
-		if (w==1 && x==0 && y==0 && z==0)
-			return true;
-		return false;
-	}
-	
-	/** Check if this quaternion represents an identity
-	 * matrix, for rotation.
-	 * @return true if it is an identity rep., false otherwise
-	 */
-	public boolean isIdentity()
-	{
-		if (w==0 && x==0 && y==0 && z==0)
-			return true;
-		return false;
-	}
-	
-	/** compute the quaternion from a 3x3 column matrix
-	 * @param m 3x3 column matrix 
-	 */
-	public void setFromMatrix(float[] m) {
-		float T= m[0] + m[4] + m[8] + 1;
-		if (T>0){
-			float S = 0.5f / (float)MathFloat.sqrt(T);
-			w = 0.25f / S;
-			x = ( m[5] - m[7]) * S;
-			y = ( m[6] - m[2]) * S;
-			z = ( m[1] - m[3] ) * S;
-		}
-		else{
-			if ((m[0] > m[4])&(m[0] > m[8])) { 
-				float S = MathFloat.sqrt( 1.0f + m[0] - m[4] - m[8] ) * 2f; // S=4*qx 
-				w = (m[7] - m[5]) / S;
-				x = 0.25f * S;
-				y = (m[3] + m[1]) / S; 
-				z = (m[6] + m[2]) / S; 
-			} 
-			else if (m[4] > m[8]) { 
-				float S = MathFloat.sqrt( 1.0f + m[4] - m[0] - m[8] ) * 2f; // S=4*qy
-				w = (m[6] - m[2]) / S;
-				x = (m[3] + m[1]) / S; 
-				y = 0.25f * S;
-				z = (m[7] + m[5]) / S; 
-			} 
-			else { 
-				float S = MathFloat.sqrt( 1.0f + m[8] - m[0] - m[4] ) * 2f; // S=4*qz
-				w = (m[3] - m[1]) / S;
-				x = (m[6] + m[2]) / S; 
-				y = (m[7] + m[5]) / S; 
-				z = 0.25f * S;
-			} 
-		}
-	}
-	
-	/** Check if the the 3x3 matrix (param) is in fact 
-	 * an affine rotational matrix
-	 * @param m 3x3 column matrix
-	 * @return true if representing a rotational matrix, false otherwise
-	 */
-	public boolean isRotationMatrix(float[] m) {
-		double epsilon = 0.01; // margin to allow for rounding errors
-		if (MathFloat.abs(m[0]*m[3] + m[3]*m[4] + m[6]*m[7]) > epsilon) return false;
-		if (MathFloat.abs(m[0]*m[2] + m[3]*m[5] + m[6]*m[8]) > epsilon) return false;
-		if (MathFloat.abs(m[1]*m[2] + m[4]*m[5] + m[7]*m[8]) > epsilon) return false;
-		if (MathFloat.abs(m[0]*m[0] + m[3]*m[3] + m[6]*m[6] - 1) > epsilon) return false;
-		if (MathFloat.abs(m[1]*m[1] + m[4]*m[4] + m[7]*m[7] - 1) > epsilon) return false;
-		if (MathFloat.abs(m[2]*m[2] + m[5]*m[5] + m[8]*m[8] - 1) > epsilon) return false;
-		return (MathFloat.abs(determinant(m)-1) < epsilon);
-	}
-	private float determinant(float[] m) {
-	      return m[0]*m[4]*m[8] + m[3]*m[7]*m[2] + m[6]*m[1]*m[5] - m[0]*m[7]*m[5] - m[3]*m[1]*m[8] - m[6]*m[4]*m[2];
-	}
+        matrix[12] = 0;
+        matrix[13] = 0;
+        matrix[14] = 0;
+        matrix[15] = 1;
+        return matrix;
+    }
+    
+    /** Set this quaternion from a Sphereical interpolation
+     *  of two param quaternion, used mostly for rotational animation
+     * @param a initial quaternion
+     * @param b target quaternion
+     * @param t float between 0 and 1 representing interp.
+     */
+    public void slerp(Quaternion a,Quaternion b, float t)
+    {
+        float omega, cosom, sinom, sclp, sclq;
+        cosom = a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
+        if ((1.0f+cosom) > MathFloat.E) {
+            if ((1.0f-cosom) > MathFloat.E) {
+                omega = (float)MathFloat.acos(cosom);
+                sinom = (float)MathFloat.sin(omega);
+                sclp = (float)MathFloat.sin((1.0f-t)*omega) / sinom;
+                sclq = (float)MathFloat.sin(t*omega) / sinom;
+            }
+            else {
+                sclp = 1.0f - t;
+                sclq = t;
+            }
+            x = sclp*a.x + sclq*b.x;
+            y = sclp*a.y + sclq*b.y;
+            z = sclp*a.z + sclq*b.z;
+            w = sclp*a.w + sclq*b.w;
+        }
+        else {
+            x =-a.y;
+            y = a.x;
+            z =-a.w;
+            w = a.z;
+            sclp = MathFloat.sin((1.0f-t) * MathFloat.PI * 0.5f);
+            sclq = MathFloat.sin(t * MathFloat.PI * 0.5f);
+            x = sclp*a.x + sclq*b.x;
+            y = sclp*a.y + sclq*b.y;
+            z = sclp*a.z + sclq*b.z;
+        }
+    }
+    
+    /** Check if this quaternion is empty, ie (0,0,0,1)
+     * @return true if empty, false otherwise
+     */
+    public boolean isEmpty()
+    {
+        if (w==1 && x==0 && y==0 && z==0)
+            return true;
+        return false;
+    }
+    
+    /** Check if this quaternion represents an identity
+     * matrix, for rotation.
+     * @return true if it is an identity rep., false otherwise
+     */
+    public boolean isIdentity()
+    {
+        if (w==0 && x==0 && y==0 && z==0)
+            return true;
+        return false;
+    }
+    
+    /** compute the quaternion from a 3x3 column matrix
+     * @param m 3x3 column matrix 
+     */
+    public void setFromMatrix(float[] m) {
+        float T= m[0] + m[4] + m[8] + 1;
+        if (T>0){
+            float S = 0.5f / (float)MathFloat.sqrt(T);
+            w = 0.25f / S;
+            x = ( m[5] - m[7]) * S;
+            y = ( m[6] - m[2]) * S;
+            z = ( m[1] - m[3] ) * S;
+        }
+        else{
+            if ((m[0] > m[4])&(m[0] > m[8])) { 
+                float S = MathFloat.sqrt( 1.0f + m[0] - m[4] - m[8] ) * 2f; // S=4*qx 
+                w = (m[7] - m[5]) / S;
+                x = 0.25f * S;
+                y = (m[3] + m[1]) / S; 
+                z = (m[6] + m[2]) / S; 
+            } 
+            else if (m[4] > m[8]) { 
+                float S = MathFloat.sqrt( 1.0f + m[4] - m[0] - m[8] ) * 2f; // S=4*qy
+                w = (m[6] - m[2]) / S;
+                x = (m[3] + m[1]) / S; 
+                y = 0.25f * S;
+                z = (m[7] + m[5]) / S; 
+            } 
+            else { 
+                float S = MathFloat.sqrt( 1.0f + m[8] - m[0] - m[4] ) * 2f; // S=4*qz
+                w = (m[3] - m[1]) / S;
+                x = (m[6] + m[2]) / S; 
+                y = (m[7] + m[5]) / S; 
+                z = 0.25f * S;
+            } 
+        }
+    }
+    
+    /** Check if the the 3x3 matrix (param) is in fact 
+     * an affine rotational matrix
+     * @param m 3x3 column matrix
+     * @return true if representing a rotational matrix, false otherwise
+     */
+    public boolean isRotationMatrix(float[] m) {
+        double epsilon = 0.01; // margin to allow for rounding errors
+        if (MathFloat.abs(m[0]*m[3] + m[3]*m[4] + m[6]*m[7]) > epsilon) return false;
+        if (MathFloat.abs(m[0]*m[2] + m[3]*m[5] + m[6]*m[8]) > epsilon) return false;
+        if (MathFloat.abs(m[1]*m[2] + m[4]*m[5] + m[7]*m[8]) > epsilon) return false;
+        if (MathFloat.abs(m[0]*m[0] + m[3]*m[3] + m[6]*m[6] - 1) > epsilon) return false;
+        if (MathFloat.abs(m[1]*m[1] + m[4]*m[4] + m[7]*m[7] - 1) > epsilon) return false;
+        if (MathFloat.abs(m[2]*m[2] + m[5]*m[5] + m[8]*m[8] - 1) > epsilon) return false;
+        return (MathFloat.abs(determinant(m)-1) < epsilon);
+    }
+    private float determinant(float[] m) {
+          return m[0]*m[4]*m[8] + m[3]*m[7]*m[2] + m[6]*m[1]*m[5] - m[0]*m[7]*m[5] - m[3]*m[1]*m[8] - m[6]*m[4]*m[2];
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/graph/math/VectorUtil.java b/src/jogl/classes/com/jogamp/graph/math/VectorUtil.java
index cca9a454f..7cbb742e5 100755
--- a/src/jogl/classes/com/jogamp/graph/math/VectorUtil.java
+++ b/src/jogl/classes/com/jogamp/graph/math/VectorUtil.java
@@ -35,261 +35,261 @@ import com.jogamp.graph.geom.Vertex;
 
 public class VectorUtil {
 
-	public static final int CW = -1;
-	public static final int CCW = 1;
-	public static final int COLLINEAR = 0;
+    public static final int CW = -1;
+    public static final int CCW = 1;
+    public static final int COLLINEAR = 0;
 
-	/** compute the dot product of two points
-	 * @param vec1 vector 1
-	 * @param vec2 vector 2
-	 * @return the dot product as float
-	 */
-	public static float dot(float[] vec1, float[] vec2)
-	{
-		return (vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2]);
-	}
-	/** Normalize a vector
-	 * @param vector input vector
-	 * @return normalized vector
-	 */
-	public static float[] normalize(float[] vector)
-	{
-		float[] newVector = new float[3];
+    /** compute the dot product of two points
+     * @param vec1 vector 1
+     * @param vec2 vector 2
+     * @return the dot product as float
+     */
+    public static float dot(float[] vec1, float[] vec2)
+    {
+        return (vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2]);
+    }
+    /** Normalize a vector
+     * @param vector input vector
+     * @return normalized vector
+     */
+    public static float[] normalize(float[] vector)
+    {
+        float[] newVector = new float[3];
 
-		float d = MathFloat.sqrt(vector[0]*vector[0] + vector[1]*vector[1] + vector[2]*vector[2]);
-		if(d> 0.0f)
-		{
-			newVector[0] = vector[0]/d;
-			newVector[1] = vector[1]/d;
-			newVector[2] = vector[2]/d;
-		}
-		return newVector;
-	}
+        float d = MathFloat.sqrt(vector[0]*vector[0] + vector[1]*vector[1] + vector[2]*vector[2]);
+        if(d> 0.0f)
+        {
+            newVector[0] = vector[0]/d;
+            newVector[1] = vector[1]/d;
+            newVector[2] = vector[2]/d;
+        }
+        return newVector;
+    }
 
-	/** Scales a vector by param
-	 * @param vector input vector
-	 * @param scale constant to scale by
-	 * @return scaled vector
-	 */
-	public static float[] scale(float[] vector, float scale)
-	{
-		float[] newVector = new float[3];
+    /** Scales a vector by param
+     * @param vector input vector
+     * @param scale constant to scale by
+     * @return scaled vector
+     */
+    public static float[] scale(float[] vector, float scale)
+    {
+        float[] newVector = new float[3];
 
-		newVector[0] = vector[0]*scale;
-		newVector[1] = vector[1]*scale;
-		newVector[2] = vector[2]*scale;
-		return newVector;
-	}
-	
-	/** Adds to vectors
-	 * @param v1 vector 1
-	 * @param v2 vector 2
-	 * @return v1 + v2
-	 */
-	public static float[] vectorAdd(float[] v1, float[] v2)
-	{
-		float[] newVector = new float[3];
+        newVector[0] = vector[0]*scale;
+        newVector[1] = vector[1]*scale;
+        newVector[2] = vector[2]*scale;
+        return newVector;
+    }
+    
+    /** Adds to vectors
+     * @param v1 vector 1
+     * @param v2 vector 2
+     * @return v1 + v2
+     */
+    public static float[] vectorAdd(float[] v1, float[] v2)
+    {
+        float[] newVector = new float[3];
 
-		newVector[0] = v1[0] + v2[0];
-		newVector[1] = v1[1] + v2[1];
-		newVector[2] = v1[2] + v2[2];
-		return newVector;
-	}
+        newVector[0] = v1[0] + v2[0];
+        newVector[1] = v1[1] + v2[1];
+        newVector[2] = v1[2] + v2[2];
+        return newVector;
+    }
 
-	/** cross product vec1 x vec2
-	 * @param vec1 vector 1
-	 * @param vec2 vecttor 2
-	 * @return the resulting vector
-	 */
-	public static float[] cross(float[] vec1, float[] vec2)
-	{
-		float[] out = new float[3];
+    /** cross product vec1 x vec2
+     * @param vec1 vector 1
+     * @param vec2 vecttor 2
+     * @return the resulting vector
+     */
+    public static float[] cross(float[] vec1, float[] vec2)
+    {
+        float[] out = new float[3];
 
-		out[0] = vec2[2]*vec1[1] - vec2[1]*vec1[2];
-		out[1] = vec2[0]*vec1[2] - vec2[2]*vec1[0];
-		out[2] = vec2[1]*vec1[0] - vec2[0]*vec1[1];
+        out[0] = vec2[2]*vec1[1] - vec2[1]*vec1[2];
+        out[1] = vec2[0]*vec1[2] - vec2[2]*vec1[0];
+        out[2] = vec2[1]*vec1[0] - vec2[0]*vec1[1];
 
-		return out;
-	}
+        return out;
+    }
 
-	/** Column Matrix Vector multiplication
-	 * @param colMatrix column matrix (4x4)
-	 * @param vec vector(x,y,z)
-	 * @return result new float[3] 
-	 */
-	public static float[] colMatrixVectorMult(float[] colMatrix, float[] vec)
-	{
-		float[] out = new float[3];
+    /** Column Matrix Vector multiplication
+     * @param colMatrix column matrix (4x4)
+     * @param vec vector(x,y,z)
+     * @return result new float[3] 
+     */
+    public static float[] colMatrixVectorMult(float[] colMatrix, float[] vec)
+    {
+        float[] out = new float[3];
 
-		out[0] = vec[0]*colMatrix[0] + vec[1]*colMatrix[4] + vec[2]*colMatrix[8] + colMatrix[12]; 
-		out[1] = vec[0]*colMatrix[1] + vec[1]*colMatrix[5] + vec[2]*colMatrix[9] + colMatrix[13]; 
-		out[2] = vec[0]*colMatrix[2] + vec[1]*colMatrix[6] + vec[2]*colMatrix[10] + colMatrix[14]; 
+        out[0] = vec[0]*colMatrix[0] + vec[1]*colMatrix[4] + vec[2]*colMatrix[8] + colMatrix[12]; 
+        out[1] = vec[0]*colMatrix[1] + vec[1]*colMatrix[5] + vec[2]*colMatrix[9] + colMatrix[13]; 
+        out[2] = vec[0]*colMatrix[2] + vec[1]*colMatrix[6] + vec[2]*colMatrix[10] + colMatrix[14]; 
 
-		return out;
-	}
-	
-	/** Matrix Vector multiplication
-	 * @param rawMatrix column matrix (4x4)
-	 * @param vec vector(x,y,z)
-	 * @return result new float[3] 
-	 */
-	public static float[] rowMatrixVectorMult(float[] rawMatrix, float[] vec)
-	{
-		float[] out = new float[3];
+        return out;
+    }
+    
+    /** Matrix Vector multiplication
+     * @param rawMatrix column matrix (4x4)
+     * @param vec vector(x,y,z)
+     * @return result new float[3] 
+     */
+    public static float[] rowMatrixVectorMult(float[] rawMatrix, float[] vec)
+    {
+        float[] out = new float[3];
 
-		out[0] = vec[0]*rawMatrix[0] + vec[1]*rawMatrix[1] + vec[2]*rawMatrix[2] + rawMatrix[3]; 
-		out[1] = vec[0]*rawMatrix[4] + vec[1]*rawMatrix[5] + vec[2]*rawMatrix[6] + rawMatrix[7]; 
-		out[2] = vec[0]*rawMatrix[8] + vec[1]*rawMatrix[9] + vec[2]*rawMatrix[10] + rawMatrix[11]; 
+        out[0] = vec[0]*rawMatrix[0] + vec[1]*rawMatrix[1] + vec[2]*rawMatrix[2] + rawMatrix[3]; 
+        out[1] = vec[0]*rawMatrix[4] + vec[1]*rawMatrix[5] + vec[2]*rawMatrix[6] + rawMatrix[7]; 
+        out[2] = vec[0]*rawMatrix[8] + vec[1]*rawMatrix[9] + vec[2]*rawMatrix[10] + rawMatrix[11]; 
 
-		return out;
-	}
-	
-	/** Calculate the midpoint of two values
-	 * @param p1 first value
-	 * @param p2 second vale
-	 * @return midpoint
-	 */
-	public static float mid(float p1, float p2)
-	{
-		return (p1+p2)/2.0f;
-	}
-	/** Calculate the midpoint of two points
-	 * @param p1 first point
-	 * @param p2 second point
-	 * @return midpoint
-	 */
-	public static float[] mid(float[] p1, float[] p2)
-	{
-		float[] midPoint = new float[3];
-		midPoint[0] = (p1[0] + p2[0])/2.0f;
-		midPoint[1] = (p1[1] + p2[1])/2.0f;
-		midPoint[2] = (p1[2] + p2[2])/2.0f;
+        return out;
+    }
+    
+    /** Calculate the midpoint of two values
+     * @param p1 first value
+     * @param p2 second vale
+     * @return midpoint
+     */
+    public static float mid(float p1, float p2)
+    {
+        return (p1+p2)/2.0f;
+    }
+    /** Calculate the midpoint of two points
+     * @param p1 first point
+     * @param p2 second point
+     * @return midpoint
+     */
+    public static float[] mid(float[] p1, float[] p2)
+    {
+        float[] midPoint = new float[3];
+        midPoint[0] = (p1[0] + p2[0])/2.0f;
+        midPoint[1] = (p1[1] + p2[1])/2.0f;
+        midPoint[2] = (p1[2] + p2[2])/2.0f;
 
-		return midPoint;
-	}
-	/** Compute the norm of a vector
-	 * @param vec vector
-	 * @return vorm
-	 */
-	public static float norm(float[] vec)
-	{
-		return MathFloat.sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
-	}
-	/** Compute distance between 2 points
-	 * @param p0 a ref point on the line
-	 * @param vec vector representing the direction of the line
-	 * @param point the point to compute the relative distance of
-	 * @return distance float
-	 */
-	public static float computeLength(float[] p0, float[] point)
-	{
-		float[] w = new float[]{point[0]-p0[0],point[1]-p0[1],point[2]-p0[2]};
+        return midPoint;
+    }
+    /** Compute the norm of a vector
+     * @param vec vector
+     * @return vorm
+     */
+    public static float norm(float[] vec)
+    {
+        return MathFloat.sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
+    }
+    /** Compute distance between 2 points
+     * @param p0 a ref point on the line
+     * @param vec vector representing the direction of the line
+     * @param point the point to compute the relative distance of
+     * @return distance float
+     */
+    public static float computeLength(float[] p0, float[] point)
+    {
+        float[] w = new float[]{point[0]-p0[0],point[1]-p0[1],point[2]-p0[2]};
 
-		float distance = MathFloat.sqrt(w[0]*w[0] + w[1]*w[1] + w[2]*w[2]);
+        float distance = MathFloat.sqrt(w[0]*w[0] + w[1]*w[1] + w[2]*w[2]);
 
-		return distance;
-	}
+        return distance;
+    }
 
-	/**Check equality of 2 vec3 vectors
-	 * @param v1 vertex 1
-	 * @param v2 vertex 2
-	 * @return
-	 */
-	public static boolean checkEquality(float[] v1, float[] v2)
-	{
-		if(Float.compare(v1[0], v2[0]) == 0 
-				&& Float.compare(v1[1] , v2[1]) == 0
-				&& Float.compare(v1[2], v2[2]) == 0 )
-			return true;
-		return false;
-	}
+    /**Check equality of 2 vec3 vectors
+     * @param v1 vertex 1
+     * @param v2 vertex 2
+     * @return
+     */
+    public static boolean checkEquality(float[] v1, float[] v2)
+    {
+        if(Float.compare(v1[0], v2[0]) == 0 
+                && Float.compare(v1[1] , v2[1]) == 0
+                && Float.compare(v1[2], v2[2]) == 0 )
+            return true;
+        return false;
+    }
 
-	/** Compute the determinant of 3 vectors
-	 * @param a vector 1
-	 * @param b vector 2
-	 * @param c vector 3
-	 * @return the determinant value
-	 */
-	public static float computeDeterminant(float[] a, float[] b, float[] c)
-	{
-		float area = a[0]*b[1]*c[2] + a[1]*b[2]*c[0] + a[2]*b[0]*c[1] - a[0]*b[2]*c[1] - a[1]*b[0]*c[2] - a[2]*b[1]*c[0];
-		return area;
-	}
+    /** Compute the determinant of 3 vectors
+     * @param a vector 1
+     * @param b vector 2
+     * @param c vector 3
+     * @return the determinant value
+     */
+    public static float computeDeterminant(float[] a, float[] b, float[] c)
+    {
+        float area = a[0]*b[1]*c[2] + a[1]*b[2]*c[0] + a[2]*b[0]*c[1] - a[0]*b[2]*c[1] - a[1]*b[0]*c[2] - a[2]*b[1]*c[0];
+        return area;
+    }
 
-	/** Check if three vertices are colliniear
-	 * @param v1 vertex 1
-	 * @param v2 vertex 2
-	 * @param v3 vertex 3
-	 * @return true if collinear, false otherwise
-	 */
-	public static boolean checkCollinear(float[] v1, float[] v2, float[] v3)
-	{
-		return (computeDeterminant(v1, v2, v3) == VectorUtil.COLLINEAR);
-	}
+    /** Check if three vertices are colliniear
+     * @param v1 vertex 1
+     * @param v2 vertex 2
+     * @param v3 vertex 3
+     * @return true if collinear, false otherwise
+     */
+    public static boolean checkCollinear(float[] v1, float[] v2, float[] v3)
+    {
+        return (computeDeterminant(v1, v2, v3) == VectorUtil.COLLINEAR);
+    }
 
-	/** Compute Vector
-	 * @param v1 vertex 1
-	 * @param v2 vertex2 2
-	 * @return Vector V1V2
-	 */
-	public static float[] computeVector(float[] v1, float[] v2)
-	{
-		float[] vector = new float[3];
-		vector[0] = v2[0] - v1[0];
-		vector[1] = v2[1] - v1[1];
-		vector[2] = v2[2] - v1[2];
-		return vector;
-	}
+    /** Compute Vector
+     * @param v1 vertex 1
+     * @param v2 vertex2 2
+     * @return Vector V1V2
+     */
+    public static float[] computeVector(float[] v1, float[] v2)
+    {
+        float[] vector = new float[3];
+        vector[0] = v2[0] - v1[0];
+        vector[1] = v2[1] - v1[1];
+        vector[2] = v2[2] - v1[2];
+        return vector;
+    }
 
-	/** Check if vertices in triangle circumcircle
-	 * @param a triangle vertex 1
-	 * @param b triangle vertex 2
-	 * @param c triangle vertex 3
-	 * @param d vertex in question
-	 * @return true if the vertex d is inside the circle defined by the 
-	 * vertices a, b, c. from paper by Guibas and Stolfi (1985).
-	 */
-	public static boolean inCircle(Vertex a, Vertex b, Vertex c, Vertex d){
-		return (a.getX() * a.getX() + a.getY() * a.getY()) * triArea(b, c, d) -
-		(b.getX() * b.getX() + b.getY() * b.getY()) * triArea(a, c, d) +
-		(c.getX() * c.getX() + c.getY() * c.getY()) * triArea(a, b, d) -
-		(d.getX() * d.getX() + d.getY() * d.getY()) * triArea(a, b, c) > 0;
-	}
+    /** Check if vertices in triangle circumcircle
+     * @param a triangle vertex 1
+     * @param b triangle vertex 2
+     * @param c triangle vertex 3
+     * @param d vertex in question
+     * @return true if the vertex d is inside the circle defined by the 
+     * vertices a, b, c. from paper by Guibas and Stolfi (1985).
+     */
+    public static boolean inCircle(Vertex a, Vertex b, Vertex c, Vertex d){
+        return (a.getX() * a.getX() + a.getY() * a.getY()) * triArea(b, c, d) -
+        (b.getX() * b.getX() + b.getY() * b.getY()) * triArea(a, c, d) +
+        (c.getX() * c.getX() + c.getY() * c.getY()) * triArea(a, b, d) -
+        (d.getX() * d.getX() + d.getY() * d.getY()) * triArea(a, b, c) > 0;
+    }
 
-	/** Computes oriented area of a triangle
-	 * @param a first vertex
-	 * @param b second vertex
-	 * @param c third vertex
-	 * @return compute twice the area of the oriented triangle (a,b,c), the area
-	 * is positive if the triangle is oriented counterclockwise.
-	 */
-	public static float triArea(Vertex a, Vertex b, Vertex c){
-		return (b.getX() - a.getX()) * (c.getY() - a.getY()) - (b.getY() - a.getY())*(c.getX() - a.getX());
-	}
+    /** Computes oriented area of a triangle
+     * @param a first vertex
+     * @param b second vertex
+     * @param c third vertex
+     * @return compute twice the area of the oriented triangle (a,b,c), the area
+     * is positive if the triangle is oriented counterclockwise.
+     */
+    public static float triArea(Vertex a, Vertex b, Vertex c){
+        return (b.getX() - a.getX()) * (c.getY() - a.getY()) - (b.getY() - a.getY())*(c.getX() - a.getX());
+    }
 
-	/** Check if points are in ccw order
-	 * @param a first vertex
-	 * @param b second vertex
-	 * @param c third vertex
-	 * @return true if the points a,b,c are in a ccw order
-	 */
-	public static boolean ccw(Vertex a, Vertex b, Vertex c){
-		return triArea(a,b,c) > 0;
-	}
+    /** Check if points are in ccw order
+     * @param a first vertex
+     * @param b second vertex
+     * @param c third vertex
+     * @return true if the points a,b,c are in a ccw order
+     */
+    public static boolean ccw(Vertex a, Vertex b, Vertex c){
+        return triArea(a,b,c) > 0;
+    }
 
-	/** Computes the area of a list of vertices to check if ccw
-	 * @param vertices
-	 * @return positve area if ccw else negative area value
-	 */
-	public static float area(ArrayList<Vertex> vertices) {
-		int n = vertices.size();
-		float area = 0.0f;
-		for (int p = n - 1, q = 0; q < n; p = q++)
-		{
-			float[] pCoord = vertices.get(p).getCoord();
-			float[] qCoord = vertices.get(q).getCoord();
-			area += pCoord[0] * qCoord[1] - qCoord[0] * pCoord[1];
-		}
-		return area;
-	}
+    /** Computes the area of a list of vertices to check if ccw
+     * @param vertices
+     * @return positve area if ccw else negative area value
+     */
+    public static float area(ArrayList<Vertex> vertices) {
+        int n = vertices.size();
+        float area = 0.0f;
+        for (int p = n - 1, q = 0; q < n; p = q++)
+        {
+            float[] pCoord = vertices.get(p).getCoord();
+            float[] qCoord = vertices.get(q).getCoord();
+            area += pCoord[0] * qCoord[1] - qCoord[0] * pCoord[1];
+        }
+        return area;
+    }
 }
diff --git a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
index fc364b67a..f59351ad8 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
@@ -116,9 +116,9 @@ public class FPSAnimator extends AnimatorBase {
     }
 
     private void startTask() {
-    	if(null != task) {
-    		return;
-    	}
+        if(null != task) {
+            return;
+        }
         long delay = (long) (1000.0f / (float) fps);
         task = new TimerTask() {
             public void run() {
@@ -165,12 +165,12 @@ public class FPSAnimator extends AnimatorBase {
         try {
             shouldRun = false;
             if(null != task) {
-	            task.cancel();
-	            task = null;
+                task.cancel();
+                task = null;
             }
             if(null != timer) {
-	            timer.cancel();
-	            timer = null;
+                timer.cancel();
+                timer = null;
             }
             animThread = null;
             try {
@@ -190,8 +190,8 @@ public class FPSAnimator extends AnimatorBase {
         try {
             shouldRun = false;
             if(null != task) {
-	            task.cancel();
-	            task = null;
+                task.cancel();
+                task = null;
             }
             animThread = null;
             try {
diff --git a/src/jogl/classes/com/jogamp/opengl/util/Locator.java b/src/jogl/classes/com/jogamp/opengl/util/Locator.java
index 8dbd7cd93..291cd770c 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/Locator.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/Locator.java
@@ -109,7 +109,7 @@ public class Locator {
         }
         if (file != null) {
             String res = new File(file, relativeFile).getPath();
-	        // Handle things on Windows
+            // Handle things on Windows
             return res.replace('\\', '/');
         } else {
             return relativeFile;
diff --git a/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java
index 86882176a..de28dc70a 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java
@@ -1590,7 +1590,7 @@ public class TextRenderer {
             int lengthInGlyphs = fullRunGlyphVector.getNumGlyphs();
             int i = 0;
             while (i < lengthInGlyphs) {
-            	Character letter = CharacterCache.valueOf(inString.charAt(i));
+                Character letter = CharacterCache.valueOf(inString.charAt(i));
                 GlyphMetrics metrics = (GlyphMetrics) glyphMetricsCache.get(letter);
                 if (metrics == null) {
                     metrics = fullRunGlyphVector.getGlyphMetrics(i);
@@ -1656,7 +1656,7 @@ public class TextRenderer {
         // if the unicode or glyph ID would be out of bounds of the
         // glyph cache.
         private Glyph getGlyph(CharSequence inString,
-        		               GlyphMetrics glyphMetrics,
+                               GlyphMetrics glyphMetrics,
                                int index) {
             char unicodeID = inString.charAt(index);
 
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java
index 8befc13ba..010ce6699 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java
@@ -163,7 +163,7 @@ public class GLUT {
 
   public void glutSolidCylinder(double radius, double height, int slices, int stacks) {
     GL2 gl = GLUgl2.getCurrentGL2();
-  	
+      
     // Prepare table of points for drawing end caps
     double [] x = new double[slices];
     double [] y = new double[slices];
@@ -174,7 +174,7 @@ public class GLUT {
       x[i] = Math.cos(angle) * radius;
       y[i] = Math.sin(angle) * radius;
     }
-  	
+      
     // Draw bottom cap
     gl.glBegin(GL2.GL_TRIANGLE_FAN);
     gl.glNormal3d(0,0,-1);
@@ -184,7 +184,7 @@ public class GLUT {
     }
     gl.glVertex3d(x[0], y[0], 0);
     gl.glEnd();
-  	
+      
     // Draw top cap
     gl.glBegin(GL2.GL_TRIANGLE_FAN);
     gl.glNormal3d(0,0,1);
@@ -194,7 +194,7 @@ public class GLUT {
     }
     gl.glVertex3d(x[0], y[0], height);
     gl.glEnd();
-  	
+      
     // Draw walls
     quadObjInit(glu);
     glu.gluQuadricDrawStyle(quadObj, GLU.GLU_FILL);
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java b/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java
index 38f8ff974..c067e5c22 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java
@@ -193,18 +193,18 @@ public class Texture {
     // Package-private constructor for creating a texture object which wraps
     // an existing texture ID from another package
     Texture(int textureID,
-	    int target,
-	    int texWidth,
-	    int texHeight,
-	    int imgWidth,
-	    int imgHeight,
-	    boolean mustFlipVertically) {
-	this.texID = textureID;
-	this.target = target;
-	this.mustFlipVertically = mustFlipVertically;
-	this.texWidth = texWidth;
-	this.texHeight = texHeight;
-	setImageSize(imgWidth, imgHeight, target);
+        int target,
+        int texWidth,
+        int texHeight,
+        int imgWidth,
+        int imgHeight,
+        boolean mustFlipVertically) {
+    this.texID = textureID;
+    this.target = target;
+    this.mustFlipVertically = mustFlipVertically;
+    this.texWidth = texWidth;
+    this.texHeight = texHeight;
+    setImageSize(imgWidth, imgHeight, target);
     }
 
     /**
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java
index e86ff161b..d21e9c577 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java
@@ -528,19 +528,19 @@ public class TextureIO {
      *                           texture
      */
     public static Texture newTexture(int textureID,
-				     int target,
-				     int texWidth,
-				     int texHeight,
-				     int imgWidth,
-				     int imgHeight,
-				     boolean mustFlipVertically) {
-	return new Texture(textureID,
-			   target,
-			   texWidth,
-			   texHeight,
-			   imgWidth,
-			   imgHeight,
-			   mustFlipVertically);
+                     int target,
+                     int texWidth,
+                     int texHeight,
+                     int imgWidth,
+                     int imgHeight,
+                     boolean mustFlipVertically) {
+    return new Texture(textureID,
+               target,
+               texWidth,
+               texHeight,
+               imgWidth,
+               imgHeight,
+               mustFlipVertically);
     }
 
     /**
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java
index d5f49599c..37dbc54df 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java
@@ -37,7 +37,7 @@
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
 
-package	com.jogamp.opengl.util.texture.spi;
+package    com.jogamp.opengl.util.texture.spi;
 
 import java.io.DataInput;
 import java.io.DataInputStream;
@@ -65,16 +65,16 @@ import java.io.IOException;
  * for that functionality. It is not clear if it is ever going to be
  * functionally required to be able to read UTF data in a LittleEndianManner<p>
  *
- * @author	Robin Luiten
- * @version	1.1	15/Dec/1997
+ * @author    Robin Luiten
+ * @version    1.1    15/Dec/1997
  */
 public class LEDataInputStream extends FilterInputStream implements DataInput
 {
     /**
-     * To reuse	some of	the	non	endian dependent methods from
-     * DataInputStreams	methods.
+     * To reuse    some of    the    non    endian dependent methods from
+     * DataInputStreams    methods.
      */
-    DataInputStream	dataIn;
+    DataInputStream    dataIn;
 
     public LEDataInputStream(InputStream in)
     {
@@ -84,29 +84,29 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
 
     public void close() throws IOException
     {
-        dataIn.close();		// better close as we create it.
+        dataIn.close();        // better close as we create it.
         // this will close underlying as well.
     }
 
-    public synchronized	final int read(byte	b[]) throws	IOException
+    public synchronized    final int read(byte    b[]) throws    IOException
     {
         return dataIn.read(b, 0, b.length);
     }
 
-    public synchronized	final int read(byte	b[], int off, int len) throws IOException
+    public synchronized    final int read(byte    b[], int off, int len) throws IOException
     {
-        int	rl = dataIn.read(b,	off, len);
+        int    rl = dataIn.read(b,    off, len);
         return rl;
     }
 
     public final void readFully(byte b[]) throws IOException
     {
-        dataIn.readFully(b,	0, b.length);
+        dataIn.readFully(b,    0, b.length);
     }
 
-    public final void readFully(byte b[], int off, int len)	throws IOException
+    public final void readFully(byte b[], int off, int len)    throws IOException
     {
-        dataIn.readFully(b,	off, len);
+        dataIn.readFully(b,    off, len);
     }
 
     public final int skipBytes(int n) throws IOException
@@ -116,23 +116,23 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
 
     public final boolean readBoolean() throws IOException
     {
-        int	ch = dataIn.read();
+        int    ch = dataIn.read();
         if (ch < 0)
             throw new EOFException();
         return (ch != 0);
     }
 
-    public final byte readByte() throws	IOException
+    public final byte readByte() throws    IOException
     {
-        int	ch = dataIn.read();
+        int    ch = dataIn.read();
         if (ch < 0)
             throw new EOFException();
         return (byte)(ch);
     }
 
-    public final int readUnsignedByte()	throws IOException
+    public final int readUnsignedByte()    throws IOException
     {
-        int	ch = dataIn.read();
+        int    ch = dataIn.read();
         if (ch < 0)
             throw new EOFException();
         return ch;
@@ -140,47 +140,47 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
 
     public final short readShort() throws IOException
     {
-        int	ch1	= dataIn.read();
-        int	ch2	= dataIn.read();
-        if ((ch1 | ch2)	< 0)
+        int    ch1    = dataIn.read();
+        int    ch2    = dataIn.read();
+        if ((ch1 | ch2)    < 0)
             throw new EOFException();
-        return (short)((ch1	<< 0) +	(ch2 <<	8));
+        return (short)((ch1    << 0) +    (ch2 <<    8));
     }
 
-    public final int readUnsignedShort() throws	IOException
+    public final int readUnsignedShort() throws    IOException
     { 
-        int	ch1	= dataIn.read();
-        int	ch2	= dataIn.read();
-        if ((ch1 | ch2)	< 0)
+        int    ch1    = dataIn.read();
+        int    ch2    = dataIn.read();
+        if ((ch1 | ch2)    < 0)
             throw new EOFException();
-        return (ch1	<< 0) +	(ch2 <<	8);
+        return (ch1    << 0) +    (ch2 <<    8);
     }
 
-    public final char readChar() throws	IOException
+    public final char readChar() throws    IOException
     {
-        int	ch1	= dataIn.read();
-        int	ch2	= dataIn.read();
-        if ((ch1 | ch2)	< 0)
+        int    ch1    = dataIn.read();
+        int    ch2    = dataIn.read();
+        if ((ch1 | ch2)    < 0)
             throw new EOFException();
-        return (char)((ch1 << 0) + (ch2	<< 8));
+        return (char)((ch1 << 0) + (ch2    << 8));
     }
 
     public final int readInt() throws IOException
     {
-        int	ch1	= dataIn.read();
-        int	ch2	= dataIn.read();
-        int	ch3	= dataIn.read();
-        int	ch4	= dataIn.read();
-        if ((ch1 | ch2 | ch3 | ch4)	< 0)
+        int    ch1    = dataIn.read();
+        int    ch2    = dataIn.read();
+        int    ch3    = dataIn.read();
+        int    ch4    = dataIn.read();
+        if ((ch1 | ch2 | ch3 | ch4)    < 0)
             throw new EOFException();
-        return ((ch1 <<	0) + (ch2 << 8)	+ (ch3 << 16) +	(ch4 <<	24));
+        return ((ch1 <<    0) + (ch2 << 8)    + (ch3 << 16) +    (ch4 <<    24));
     }
 
-    public final long readLong() throws	IOException
+    public final long readLong() throws    IOException
     {
-        int	i1 = readInt();
-        int	i2 = readInt();
-        return ((long)(i1) & 0xFFFFFFFFL) +	(i2	<< 32);
+        int    i1 = readInt();
+        int    i2 = readInt();
+        return ((long)(i1) & 0xFFFFFFFFL) +    (i2    << 32);
     }
 
     public final float readFloat() throws IOException
@@ -188,7 +188,7 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
         return Float.intBitsToFloat(readInt());
     }
 
-    public final double	readDouble() throws	IOException
+    public final double    readDouble() throws    IOException
     {
         return Double.longBitsToDouble(readLong());
     }
@@ -197,7 +197,7 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
      * dont call this it is not implemented.
      * @return empty new string 
      **/
-    public final String	readLine() throws IOException
+    public final String    readLine() throws IOException
     {
         return new String();
     }
@@ -206,7 +206,7 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
      * dont call this it is not implemented
      * @return empty new string 
      **/
-    public final String	readUTF() throws IOException
+    public final String    readUTF() throws IOException
     {
         return new String();
     }
@@ -215,7 +215,7 @@ public class LEDataInputStream extends FilterInputStream implements DataInput
      * dont call this it is not implemented
      * @return empty new string 
      **/
-    public final static	String readUTF(DataInput in) throws	IOException
+    public final static    String readUTF(DataInput in) throws    IOException
     {
         return new String();
     }
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java
index bb5040a31..c60c91bda 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java
@@ -477,7 +477,7 @@ public class SGIImage {
         for (int z = 0; z < zsize; z++) {
             for (int y = ystart; y != yend; y += yincr) {
                 // RLE-compress each row.
-	  
+      
                 int x = 0;
                 byte count = 0;
                 boolean repeat_mode = false;
@@ -485,7 +485,7 @@ public class SGIImage {
                 int start_ptr = ptr;
                 int num_ptr = ptr++;
                 byte repeat_val = 0;
-	  
+      
                 while (x < xsize) {
                     // see if we should switch modes
                     should_switch = false;
@@ -502,7 +502,7 @@ public class SGIImage {
                                 if (DEBUG)
                                     System.err.println("left side was " + ((int) imgref(data, x, y, z, xsize, ysize, zsize)) +
                                                        ", right side was " + (int)imgref(data, x+i, y, z, xsize, ysize, zsize));
-			  
+              
                                 if (imgref(data, x, y, z, xsize, ysize, zsize) !=
                                     imgref(data, x+i, y, z, xsize, ysize, zsize))
                                     should_switch = false;
@@ -530,7 +530,7 @@ public class SGIImage {
                                 repeat_mode = true;
                             repeat_val = imgref(data, x, y, z, xsize, ysize, zsize);
                         }
-		  
+          
                         if (x > 0) {
                             // reset the number pointer
                             num_ptr = ptr++;
@@ -538,7 +538,7 @@ public class SGIImage {
                             count = 0;
                         }
                     }
-		    
+            
                     // if not in repeat mode, copy element to ptr
                     if (!repeat_mode) {
                         rlebuf[ptr++] = imgref(data, x, y, z, xsize, ysize, zsize);
-- 
cgit v1.2.3