Fix TAB: Replace all TAB with 4 spaces

4 files changed, 468 insertions, 468 deletions

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;
+    }
 }