created mirror

Java/flob/Renderable.java

@@ -0,0 +1,88 @@
+/*   
+Renderable.java
+ *    
+ *    Copyright (c) 2000, Ted Nelson and Tuomas Lukka
+ *
+ *    You may use and distribute under the terms of either the GNU Lesser
+ *    General Public License, either version 2 of the license or,
+ *    at your choice, any later version. Alternatively, you may use and
+ *    distribute under the terms of the XPL.
+ *
+ *    See the LICENSE.lgpl and LICENSE.xpl files for the specific terms of 
+ *    the licenses.
+ *
+ *    This software is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the README
+ *    file for more details.
+ *
+ */
+/*
+ * Written by Tuomas Lukka
+ */
+package org.gzigzag;
+import java.util.*;
+import java.awt.*;
+
+
+public abstract class Renderable {
+public static final String rcsid = "$Id: Renderable.java,v 1.10 2001/03/17 20:13:08 bfallenstein Exp $";
+
+    public int d;
+
+    /** Render this thing.
+     */
+    abstract public void render(Graphics g);
+
+    /** Render this thing.
+     *  Simply calls render(g).
+     *  @param orig The top-level graphics object without translations,
+     *  	    clippings, rotations, etc.
+     */
+    public void render(Graphics g, Graphics orig) { render(g); }
+
+    /** Translate the coordinates of this Renderable by (x, y)
+     * I.e., add x from the x-coordinate and y from the y-coordinate.
+     * This is used to translate between coordinate systems.
+     * @returns False if translating is not supported.
+     */
+    public boolean translate(int x, int y) {
+	return false;
+    }
+
+
+    /** Do a stable depth-sort of renderables.
+     * Of two renderables on the same depth, the relative order remains.
+     * Uses radix sort for extreme speed.
+     */
+    static public void depthSort(Renderable[] it, int nit) {
+	Renderable[][] ftmp = new Renderable[][] { it, new Renderable[nit] };
+	Renderable[][] ftmp2 = new Renderable[2][nit];
+	Renderable[][] fs;
+	int[] n = new int[] { nit, 0 };
+	int[] newn = new int[2];
+	int[] nex = null;
+	int mx = 0;
+	for(int i=0; i<nit; i++) {
+	    if(it[i].d > mx) mx = it[i].d;
+	}
+	for(int bit = 1; mx >= bit && bit!=0; bit <<= 1) {
+	    for(int bin=0; bin<2; bin++) {
+		for(int i=0; i<n[bin]; i++) {
+		    if(ftmp[bin][i] == null) continue;
+		    int ind = (((ftmp[bin][i].d & bit) == 0) ? 0 : 1);
+		    ftmp2[ind][newn[ind]++] = ftmp[bin][i];
+		}
+	    }
+	    fs = ftmp2; ftmp2 = ftmp; ftmp = fs;
+	    nex = n; n = newn; newn = nex;
+	    newn[0] = newn[1] = 0;
+	}
+	for(int i=0; i<nit-n[0]; i++) 
+	    ftmp[0][n[0]+i] = ftmp[1][i];
+
+	if(it != ftmp[0]) {
+	    System.arraycopy(ftmp[0], 0, it, 0, nit);
+	}
+    }
+}