joonsrenderer 1.1-java

data/src/main/java/org/sunflow/system/UI.java

@@ -0,0 +1,112 @@
+package org.sunflow.system;
+
+import java.util.Locale;
+
+import org.sunflow.system.ui.ConsoleInterface;
+import org.sunflow.system.ui.SilentInterface;
+
+/**
+ * Static singleton interface to a UserInterface object. This is set to a text
+ * console by default.
+ */
+public final class UI {
+
+    private static UserInterface ui = new ConsoleInterface();
+    private static boolean canceled = false;
+    private static int verbosity = 3;
+
+    public enum Module {
+
+        API, GEOM, HAIR, ACCEL, BCKT, IPR, LIGHT, GUI, SCENE, BENCH, TEX, IMG, DISP, QMC, SYS, USER, CAM,
+    }
+
+    public enum PrintLevel {
+
+        ERROR, WARN, INFO, DETAIL
+    }
+
+    private UI() {
+    }
+
+    /**
+     * Sets the active user interface implementation. Passing
+     * <code>null</code> silences printing completely.
+     *
+     * @param ui object to recieve all user interface calls
+     */
+    public final static void set(UserInterface ui) {
+        if (ui == null) {
+            ui = new SilentInterface();
+        }
+        UI.ui = ui;
+    }
+
+    public final static void verbosity(int verbosity) {
+        UI.verbosity = verbosity;
+    }
+
+    public final static String formatOutput(Module m, PrintLevel level, String s) {
+        return String.format("%-5s  %-6s: %s", m.name(), level.name().toLowerCase(Locale.ENGLISH), s);
+    }
+
+    public final static synchronized void printDetailed(Module m, String s, Object... args) {
+        if (verbosity > 3) {
+            ui.print(m, PrintLevel.DETAIL, String.format(s, args));
+        }
+    }
+
+    public final static synchronized void printInfo(Module m, String s, Object... args) {
+        if (verbosity > 2) {
+            ui.print(m, PrintLevel.INFO, String.format(s, args));
+        }
+    }
+
+    public final static synchronized void printWarning(Module m, String s, Object... args) {
+        if (verbosity > 1) {
+            ui.print(m, PrintLevel.WARN, String.format(s, args));
+        }
+    }
+
+    public final static synchronized void printError(Module m, String s, Object... args) {
+        if (verbosity > 0) {
+            ui.print(m, PrintLevel.ERROR, String.format(s, args));
+        }
+    }
+
+    public final static synchronized void taskStart(String s, int min, int max) {
+        ui.taskStart(s, min, max);
+    }
+
+    public final static synchronized void taskUpdate(int current) {
+        ui.taskUpdate(current);
+    }
+
+    public final static synchronized void taskStop() {
+        ui.taskStop();
+        // reset canceled status
+        // this assume the parent application will deal with it immediately
+        canceled = false;
+    }
+
+    /**
+     * Cancel the currently active task. This forces the application to abort as
+     * soon as possible.
+     */
+    public final static synchronized void taskCancel() {
+        printInfo(Module.GUI, "Abort requested by the user ...");
+        canceled = true;
+    }
+
+    /**
+     * Check to see if the current task should be aborted.
+     *
+     * @return <code>true</code> if the current task should be stopped,
+     * <code>false</code> otherwise
+     */
+    public final static synchronized boolean taskCanceled() {
+        if (canceled) {
+            printInfo(Module.GUI, "Abort request noticed by the current task");
+        }
+        return canceled;
+    }
+}

data/src/main/java/org/sunflow/system/UserInterface.java

@@ -0,0 +1,46 @@
+package org.sunflow.system;
+
+import org.sunflow.system.UI.Module;
+import org.sunflow.system.UI.PrintLevel;
+
+public interface UserInterface {
+
+    /**
+     * Displays some information to the user from the specified module with the
+     * specified print level. A user interface is free to show or ignore any
+     * message. Level filtering is done in the core and shouldn't be
+     * re-implemented by the user interface. All messages will be short enough
+     * to fit on one line.
+     *
+     * @param m module the message came from
+     * @param level seriousness of the message
+     * @param s string to display
+     */
+    void print(Module m, PrintLevel level, String s);
+
+    /**
+     * Prepare a progress bar representing a lengthy task. The actual progress
+     * is first shown by the call to update and closed when update is closed
+     * with the max value. It is currently not possible to nest calls to
+     * setTask, so only one task needs to be tracked at a time.
+     *
+     * @param s desriptive string
+     * @param min minimum value of the task
+     * @param max maximum value of the task
+     */
+    void taskStart(String s, int min, int max);
+
+    /**
+     * Updates the current progress bar to a value between the current min and
+     * max. When min or max are passed the progressed bar is shown or hidden
+     * respectively.
+     *
+     * @param current current value of the task in progress.
+     */
+    void taskUpdate(int current);
+
+    /**
+     * Closes the current progress bar to indicate the task is over
+     */
+    void taskStop();
+}

data/src/main/java/org/sunflow/system/ui/ConsoleInterface.java

@@ -0,0 +1,48 @@
+package org.sunflow.system.ui;
+
+import org.sunflow.system.UI;
+import org.sunflow.system.UserInterface;
+import org.sunflow.system.UI.Module;
+import org.sunflow.system.UI.PrintLevel;
+
+/**
+ * Basic console implementation of a user interface.
+ */
+public class ConsoleInterface implements UserInterface {
+
+    private int min;
+    private int max;
+    private float invP;
+    private String task;
+    private int lastP;
+
+    public ConsoleInterface() {
+    }
+
+    @Override
+    public void print(Module m, PrintLevel level, String s) {
+        System.err.println(UI.formatOutput(m, level, s));
+    }
+
+    @Override
+    public void taskStart(String s, int min, int max) {
+        task = s;
+        this.min = min;
+        this.max = max;
+        lastP = -1;
+        invP = 100.0f / (max - min);
+    }
+
+    @Override
+    public void taskUpdate(int current) {
+        int p = (min == max) ? 0 : (int) ((current - min) * invP);
+        if (p != lastP) {
+            System.err.print(task + " [" + (lastP = p) + "%]\r");
+        }
+    }
+
+    @Override
+    public void taskStop() {
+        System.err.print("                                                                      \r");
+    }
+}

data/src/main/java/org/sunflow/system/ui/SilentInterface.java

@@ -0,0 +1,28 @@
+package org.sunflow.system.ui;
+
+import org.sunflow.system.UserInterface;
+import org.sunflow.system.UI.Module;
+import org.sunflow.system.UI.PrintLevel;
+
+/**
+ * Null implementation of a user interface. This is usefull to silence the
+ * output.
+ */
+public class SilentInterface implements UserInterface {
+
+    @Override
+    public void print(Module m, PrintLevel level, String s) {
+    }
+
+    @Override
+    public void taskStart(String s, int min, int max) {
+    }
+
+    @Override
+    public void taskUpdate(int current) {
+    }
+
+    @Override
+    public void taskStop() {
+    }
+}

data/src/main/java/org/sunflow/util/FastHashMap.java

@@ -0,0 +1,220 @@
+package org.sunflow.util;
+
+import java.util.Iterator;
+
+/**
+ * Fast hash map implementation which uses array storage along with quadratic
+ * probing to resolve collisions. The capacity is doubled when the load goes
+ * beyond 50% and is halved when the load drops below 20%.
+ *
+ * @param <K>
+ * @param <V>
+ */
+public class FastHashMap<K, V> implements Iterable<FastHashMap.Entry<K, V>> {
+
+    private static final int MIN_SIZE = 4;
+
+    public static class Entry<K, V> {
+
+        private final K k;
+        private V v;
+
+        private Entry(K k, V v) {
+            this.k = k;
+            this.v = v;
+        }
+
+        private boolean isRemoved() {
+            return v == null;
+        }
+
+        private void remove() {
+            v = null;
+        }
+
+        public K getKey() {
+            return k;
+        }
+
+        public V getValue() {
+            return v;
+        }
+    }
+    private Entry<K, V>[] entries;
+    private int size;
+
+    public FastHashMap() {
+        clear();
+    }
+
+    public final void clear() {
+        size = 0;
+        entries = alloc(MIN_SIZE);
+    }
+
+    public V put(K k, V v) {
+        int hash = k.hashCode(), t = 0;
+        int pos = entries.length; // mark invalid position
+        for (;;) {
+            hash &= entries.length - 1;
+            if (entries[hash] == null) {
+                break; // done probing
+            } else if (entries[hash].isRemoved() && pos == entries.length) {
+                pos = hash; // store, but keep searching
+            } else if (entries[hash].k.equals(k)) {
+                // update entry
+                V old = entries[hash].v;
+                entries[hash].v = v;
+                return old;
+            }
+            t++;
+            hash += t;
+        }
+        // did we find a spot for insertion among the deleted values ?
+        if (pos < entries.length) {
+            hash = pos;
+        }
+        entries[hash] = new Entry<>(k, v);
+        size++;
+        if (size * 2 > entries.length) {
+            resize(entries.length * 2);
+        }
+        return null;
+    }
+
+    public V get(K k) {
+        int hash = k.hashCode(), t = 0;
+        for (;;) {
+            hash &= entries.length - 1;
+            if (entries[hash] == null) {
+                return null;
+            } else if (!entries[hash].isRemoved() && entries[hash].k.equals(k)) {
+                return entries[hash].v;
+            }
+            t++;
+            hash += t;
+        }
+    }
+
+    public boolean containsKey(K k) {
+        int hash = k.hashCode(), t = 0;
+        for (;;) {
+            hash &= entries.length - 1;
+            if (entries[hash] == null) {
+                return false;
+            } else if (!entries[hash].isRemoved() && entries[hash].k.equals(k)) {
+                return true;
+            }
+            t++;
+            hash += t;
+        }
+    }
+
+    public void remove(K k) {
+        int hash = k.hashCode(), t = 0;
+        for (;;) {
+            hash &= entries.length - 1;
+            if (entries[hash] == null) {
+                return; // not found, return
+            } else if (!entries[hash].isRemoved() && entries[hash].k.equals(k)) {
+                entries[hash].remove(); // flag as removed
+                size--;
+                break;
+            }
+            t++;
+            hash += t;
+        }
+        // do we need to shrink?
+        if (entries.length > MIN_SIZE && size * 10 < 2 * entries.length) {
+            resize(entries.length / 2);
+        }
+    }
+
+    /**
+     * Resize internal storage to the specified capacity. The capacity must be a
+     * power of two.
+     *
+     * @param capacity new capacity for the internal array
+     */
+    private void resize(int capacity) {
+        assert (capacity & (capacity - 1)) == 0;
+        assert capacity >= MIN_SIZE;
+        Entry<K, V>[] newentries = alloc(capacity);
+        for (Entry<K, V> e : entries) {
+            if (e == null || e.isRemoved()) {
+                continue;
+            }
+            int hash = e.k.hashCode(), t = 0;
+            for (;;) {
+                hash &= newentries.length - 1;
+                if (newentries[hash] == null) {
+                    break;
+                }
+                assert !newentries[hash].k.equals(e.k);
+                t++;
+                hash += t;
+            }
+            newentries[hash] = new Entry<>(e.k, e.v);
+        }
+        // copy new entries over old ones
+        entries = newentries;
+    }
+
+    /**
+     * Wrap the entry array allocation because it requires silencing some
+     * generics warnings.
+     *
+     * @param size number of elements to allocate
+     * @return
+     */
+    @SuppressWarnings("unchecked")
+    private Entry<K, V>[] alloc(int size) {
+        return new Entry[size];
+    }
+
+    private class EntryIterator implements Iterator<Entry<K, V>> {
+
+        private int index;
+
+        private EntryIterator() {
+            index = 0;
+            if (!readable()) {
+                inc();
+            }
+        }
+
+        private boolean readable() {
+            return !(entries[index] == null || entries[index].isRemoved());
+        }
+
+        private void inc() {
+            do {
+                index++;
+            } while (hasNext() && !readable());
+        }
+
+        @Override
+        public boolean hasNext() {
+            return index < entries.length;
+        }
+
+        @Override
+        public Entry<K, V> next() {
+            try {
+                return entries[index];
+            } finally {
+                inc();
+            }
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override
+    public Iterator<Entry<K, V>> iterator() {
+        return new EntryIterator();
+    }
+}