Refactored graph: Reduce/remove data copy/recreation; Shader cleanup

- Pass the current GL context object where it's required

- Introduce RenderState (which has ShaderState) to acquire/change shader related data (Region)

- Shader Cleanup: User import for common stuff; use req. version

- Reduce/remove data copy/recreation in *Region implementation

- UI/RIButton: Use defaults I like :)

1 files changed, 71 insertions, 27 deletions

diff --git a/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRenderer.java b/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRenderer.java
index ee8dfb372..a955d5a88 100644
--- a/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRenderer.java
+++ b/src/jogl/classes/com/jogamp/graph/curve/opengl/TextRenderer.java
@@ -1,9 +1,37 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
 package com.jogamp.graph.curve.opengl;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 
+import javax.media.opengl.GL;
 import javax.media.opengl.GL2ES2;
 
 import jogamp.graph.curve.text.GlyphString;
@@ -12,20 +40,21 @@ import jogamp.graph.geom.plane.AffineTransform;
 import jogamp.graph.geom.plane.Path2D;
 
 import com.jogamp.graph.font.Font;
-import com.jogamp.graph.geom.Vertex;
 
 public abstract class TextRenderer extends Renderer {
     /** 
      * Create a Hardware accelerated Text Renderer.
-     * @param factory optional Point.Factory for Vertex construction. Default is Vertex.Factory.
+     * @param rs the used {@link RenderState} 
+     * @param renderType either {@link com.jogamp.graph.curve.Region#SINGLE_PASS} or {@link com.jogamp.graph.curve.Region#TWO_PASS}
      */
-    public static TextRenderer create(Vertex.Factory<? extends Vertex> factory, int type) {
-        return new jogamp.graph.curve.opengl.TextRendererImpl01(factory, type);
+    public static TextRenderer create(RenderState rs, int type) {
+        return new jogamp.graph.curve.opengl.TextRendererImpl01(rs, type);
     }
     
-    protected TextRenderer(Vertex.Factory<? extends Vertex> factory, int type) {
-        super(factory, type);
+    protected TextRenderer(RenderState rs, int type) {
+        super(rs, type);
     }
+    
 
     /** Render the String in 3D space wrt to the font provided at the position provided
      * the outlines will be generated, if not yet generated
@@ -45,30 +74,29 @@ public abstract class TextRenderer extends Renderer {
      * @param font {@link Font} to be used
      * @param size font size
      * @param str {@link String} to be created
-     * @param sharpness parameter for Region generation of the resulting GlyphString
      * @return the resulting GlyphString inclusive the generated region
      */
-    public GlyphString createString(GL2ES2 gl, Font font, int size, String str, float sharpness) {
-        if(DEBUG) {
+    public GlyphString createString(GL2ES2 gl, Font font, int size, String str) {
+        if(DEBUG_INSTANCE) {
             System.err.println("createString: "+getCacheSize()+"/"+getCacheLimit()+" - "+Font.NAME_UNIQUNAME + " - " + str + " - " + size);
         }
-        AffineTransform affineTransform = new AffineTransform(pointFactory);
+        AffineTransform affineTransform = new AffineTransform(rs.getPointFactory());
         
         Path2D[] paths = new Path2D[str.length()];
         ((FontInt)font).getOutline(str, size, affineTransform, paths);
         
-        GlyphString glyphString = new GlyphString(pointFactory, font.getName(Font.NAME_UNIQUNAME), str);
-        glyphString.createfromFontPath(paths, affineTransform);
-        glyphString.generateRegion(gl.getContext(), sharpness, st, renderType);
+        GlyphString glyphString = new GlyphString(font.getName(Font.NAME_UNIQUNAME), str);
+        glyphString.createfromFontPath(rs.getPointFactory(), paths, affineTransform);
+        glyphString.generateRegion(gl, rs, renderType);
         
         return glyphString;
     }
     
-   public void flushCache() {
+   public void flushCache(GL2ES2 gl) {
        Iterator<GlyphString> iterator = stringCacheMap.values().iterator();
        while(iterator.hasNext()){
            GlyphString glyphString = iterator.next();
-           glyphString.destroy();
+           glyphString.destroy(gl);
        }
        stringCacheMap.clear();    
        stringCacheArray.clear();
@@ -76,18 +104,34 @@ public abstract class TextRenderer extends Renderer {
    
    @Override
    protected void disposeImpl(GL2ES2 gl) {
-       flushCache();
+       // fluchCache(gl) already called
    }
    
    /**
-    * Sets the cache limit for reusing GlyphString's and their Region.
-    * Default is {@link #DEFAULT_CACHE_LIMIT}, -1 unlimited, 0 turns cache off, >0 limited
+    * <p>Sets the cache limit for reusing GlyphString's and their Region.
+    * Default is {@link #DEFAULT_CACHE_LIMIT}, -1 unlimited, 0 turns cache off, >0 limited </p>
+    * 
+    * <p>The cache will be validate when the next string rendering happens.</p>
     *  
     * @param newLimit new cache size
     * 
     * @see #DEFAULT_CACHE_LIMIT
     */
-   public final void setCacheLimit(int newLimit ) { stringCacheLimit = newLimit; validateCache(0); }
+   public final void setCacheLimit(int newLimit ) { stringCacheLimit = newLimit; }
+   
+   /**
+    * Sets the cache limit, see {@link #setCacheLimit(int)} and validates the cache.
+    * 
+    * @see #setCacheLimit(int)
+    * 
+    * @param gl current GL used to remove cached objects if required
+    * @param newLimit new cache size
+    */
+   public final void setCacheLimit(GL2ES2 gl, int newLimit ) { stringCacheLimit = newLimit; validateCache(gl, 0); }
+   
+   /**
+    * @return the current cache limit
+    */
    public final int getCacheLimit() { return stringCacheLimit; }
    
    /** 
@@ -95,10 +139,10 @@ public abstract class TextRenderer extends Renderer {
     */
    public final int getCacheSize() { return stringCacheArray.size(); }
    
-   protected final void validateCache(int space) {
+   protected final void validateCache(GL2ES2 gl, int space) {
        if ( getCacheLimit() > 0 ) {
            while ( getCacheSize() + space > getCacheLimit() ) {
-               removeCachedGlyphString(0);
+               removeCachedGlyphString(gl, 0);
            }
        }
    }
@@ -107,32 +151,32 @@ public abstract class TextRenderer extends Renderer {
        return stringCacheMap.get(getKey(font, str, fontSize));
    }
 
-   protected final void addCachedGlyphString(Font font, String str, int fontSize, GlyphString glyphString) {
+   protected final void addCachedGlyphString(GL2ES2 gl, Font font, String str, int fontSize, GlyphString glyphString) {
        if ( 0 != getCacheLimit() ) {
            final String key = getKey(font, str, fontSize);
            GlyphString oldGlyphString = stringCacheMap.put(key, glyphString);
            if ( null == oldGlyphString ) {
                // new entry ..
-               validateCache(1);
+               validateCache(gl, 1);
                stringCacheArray.add(stringCacheArray.size(), key);
            } /// else overwrite is nop ..
        }
    }
    
-   protected final void removeCachedGlyphString(Font font, String str, int fontSize) {
+   protected final void removeCachedGlyphString(GL2ES2 gl, Font font, String str, int fontSize) {
        final String key = getKey(font, str, fontSize);
        GlyphString glyphString = stringCacheMap.remove(key);
        if(null != glyphString) {
-           glyphString.destroy();
+           glyphString.destroy(gl);
        }       
        stringCacheArray.remove(key);
    }
 
-   protected final void removeCachedGlyphString(int idx) {
+   protected final void removeCachedGlyphString(GL2ES2 gl, int idx) {
        final String key = stringCacheArray.remove(idx);
        final GlyphString glyphString = stringCacheMap.remove(key);
        if(null != glyphString) {
-           glyphString.destroy();
+           glyphString.destroy(gl);
        }
    }