joonsrenderer 1.1-java

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

@@ -0,0 +1,142 @@
+package org.sunflow.system;
+
+import org.codehaus.janino.ClassBodyEvaluator;
+import org.codehaus.commons.compiler.CompileException;
+import org.sunflow.system.UI.Module;
+import org.sunflow.util.FastHashMap;
+
+/**
+ * This class represents a list of plugins which implement a certain interface
+ * or extend a certain class. Many plugins may be registered and created at a
+ * later time by recalling their unique name only.
+ *
+ * @param <T> Default constructible type or interface all plugins will derive
+ * from or implement
+ */
+public final class Plugins<T> {
+
+    private final FastHashMap<String, Class<? extends T>> pluginClasses;
+    private final Class<T> baseClass;
+
+    /**
+     * Create an empty plugin list. You must specify <code>T.class</code> as an
+     * argument.
+     *
+     * @param baseClass
+     */
+    public Plugins(Class<T> baseClass) {
+        pluginClasses = new FastHashMap<>();
+        this.baseClass = baseClass;
+    }
+
+    /**
+     * Create an object from the specified type name. If this type name is
+     * unknown or invalid, <code>null</code> is returned.
+     *
+     * @param name plugin type name
+     * @return an instance of the specified plugin type, or <code>null</code> if
+     * not found or invalid
+     */
+    public T createObject(String name) {
+        if (name == null || name.equals("none")) {
+            return null;
+        }
+        Class<? extends T> c = pluginClasses.get(name);
+        if (c == null) {
+            // don't print an error, this will be handled by the caller
+            return null;
+        }
+        try {
+            return c.newInstance();
+        } catch (InstantiationException | IllegalAccessException e) {
+            UI.printError(Module.API, "Cannot create object of type \"%s\" - %s", name, e.getLocalizedMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Check this plugin list for the presence of the specified type name
+     *
+     * @param name plugin type name
+     * @return <code>true</code> if this name has been registered,
+     * <code>false</code> otherwise
+     */
+    public boolean hasType(String name) {
+        return pluginClasses.get(name) != null;
+    }
+
+    /**
+     * Generate a unique plugin type name which has not yet been registered.
+     * This is meant to be used when the actual type name is not crucial, but
+     * succesfully registration is.
+     *
+     * @param prefix a prefix to be used in generating the unique name
+     * @return a unique plugin type name not yet in use
+     */
+    public String generateUniqueName(String prefix) {
+        String type;
+        for (int i = 1; hasType(type = String.format("%s_%d", prefix, i)); i++) {
+        }
+        return type;
+    }
+
+    /**
+     * Define a new plugin type from java source code. The code string contains
+     * import declarations and a class body only. The implemented type is
+     * implicitly the one of the plugin list being registered against.If the
+     * plugin type name was previously associated with a different class, it
+     * will be overriden. This allows the behavior core classes to be modified
+     * at runtime.
+     *
+     * @param name plugin type name
+     * @param sourceCode Java source code definition for the plugin
+     * @return <code>true</code> if the code compiled and registered
+     * successfully, <code>false</code> otherwise
+     */
+    //  @SuppressWarnings("unchecked")
+    public boolean registerPlugin(String name, String sourceCode) {
+        try {
+            ClassBodyEvaluator cbe = new ClassBodyEvaluator();
+            cbe.setClassName(name);
+            cbe.setExtendedClass(baseClass);
+            cbe.cook(sourceCode);            
+            return registerPlugin(name, cbe.getClazz());
+        } catch (CompileException e) {
+            UI.printError(Module.API, "Plugin \"%s\" could not be declared - %s", name, e.getLocalizedMessage());
+            return false;
+        }
+    }
+
+    /**
+     * Define a new plugin type from an existing class. This checks to make sure
+     * the provided class is default constructible (ie: has a constructor with
+     * no parameters). If the plugin type name was previously associated with a
+     * different class, it will be overriden. This allows the behavior core
+     * classes to be modified at runtime.
+     *
+     * @param name plugin type name
+     * @param pluginClass class object for the plugin class
+     * @return <code>true</code> if the plugin registered successfully,
+     * <code>false</code> otherwise
+     */
+    public boolean registerPlugin(String name, Class<?> pluginClass) {
+        // check that the given class is compatible with the base class
+        try {
+            if (pluginClass.getConstructor() == null) {
+                UI.printError(Module.API, "Plugin \"%s\" could not be declared - default constructor was not found", name);
+                return false;
+            }
+        } catch (SecurityException e) {
+            UI.printError(Module.API, "Plugin \"%s\" could not be declared - default constructor is not visible (%s)", name, e.getLocalizedMessage());
+            return false;
+        } catch (NoSuchMethodException e) {
+            UI.printError(Module.API, "Plugin \"%s\" could not be declared - default constructor was not found (%s)", name, e.getLocalizedMessage());
+            return false;
+        }
+        if (pluginClasses.get(name) != null) {
+            UI.printWarning(Module.API, "Plugin \"%s\" was already defined - overwriting previous definition", name);
+        }
+        pluginClasses.put(name, (Class<? extends T>) pluginClass);
+        return true;
+    }
+}

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

@@ -0,0 +1,209 @@
+package org.sunflow.system;
+
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridLayout;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.swing.BorderFactory;
+import javax.swing.BoxLayout;
+import javax.swing.ComboBoxModel;
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JRadioButton;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.WindowConstants;
+import javax.swing.border.BevelBorder;
+import javax.swing.border.TitledBorder;
+
+/**
+ * This code was edited or generated using CloudGarden's Jigloo SWT/Swing GUI
+ * Builder, which is free for non-commercial use. If Jigloo is being used
+ * commercially (ie, by a corporation, company or business for any purpose
+ * whatever) then you should purchase a license for each developer using Jigloo.
+ * Please visit www.cloudgarden.com for details. Use of Jigloo implies
+ * acceptance of these licensing terms. A COMMERCIAL LICENSE HAS NOT BEEN
+ * PURCHASED FOR THIS MACHINE, SO JIGLOO OR THIS CODE CANNOT BE USED LEGALLY FOR
+ * ANY CORPORATE OR COMMERCIAL PURPOSE.
+ */
+@SuppressWarnings("serial")
+public class RenderGlobalsPanel extends JTabbedPane {
+
+    private JPanel generalPanel;
+    private JComboBox<String> maxSamplingComboxBox;
+    private JPanel samplingPanel;
+    private JComboBox<String> minSamplingComboBox;
+    private JLabel jLabel6;
+    private JLabel jLabel5;
+    private JRadioButton defaultRendererRadioButton;
+    private JRadioButton bucketRendererRadioButton;
+    private JPanel bucketRendererPanel;
+    private JLabel jLabel2;
+    private JPanel rendererPanel;
+    private JTextField threadTextField;
+    private JCheckBox threadCheckBox;
+    private JLabel jLabel3;
+    private JPanel threadsPanel;
+    private JLabel jLabel1;
+    private JPanel resolutionPanel;
+    private JTextField resolutionYTextField;
+    private JTextField resolutionXTextField;
+    private JCheckBox resolutionCheckBox;
+
+    /**
+     * This method initializes this
+     */
+    private void initialize() {
+    }
+
+    /**
+     * Auto-generated main method to display this JPanel inside a new JFrame.
+     */
+    public static void main(String[] args) {
+        JFrame frame = new JFrame();
+        frame.getContentPane().add(new RenderGlobalsPanel());
+        frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    public RenderGlobalsPanel() {
+        super();
+        initialize();
+        initGUI();
+    }
+
+    private void initGUI() {
+        try {
+            setPreferredSize(new Dimension(400, 300));
+            {
+                generalPanel = new JPanel();
+                FlowLayout generalPanelLayout = new FlowLayout();
+                generalPanelLayout.setAlignment(FlowLayout.LEFT);
+                generalPanel.setLayout(generalPanelLayout);
+                this.addTab("General", null, generalPanel, null);
+                {
+                    resolutionPanel = new JPanel();
+                    generalPanel.add(resolutionPanel);
+                    FlowLayout resolutionPanelLayout = new FlowLayout();
+                    resolutionPanel.setLayout(resolutionPanelLayout);
+                    resolutionPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(BevelBorder.LOWERED), "Resolution", TitledBorder.LEADING, TitledBorder.TOP));
+                    {
+                        resolutionCheckBox = new JCheckBox();
+                        resolutionPanel.add(resolutionCheckBox);
+                        resolutionCheckBox.setText("Override");
+                    }
+                    {
+                        jLabel1 = new JLabel();
+                        resolutionPanel.add(jLabel1);
+                        jLabel1.setText("Image Width:");
+                    }
+                    {
+                        resolutionXTextField = new JTextField();
+                        resolutionPanel.add(resolutionXTextField);
+                        resolutionXTextField.setText("640");
+                        resolutionXTextField.setPreferredSize(new java.awt.Dimension(50, 20));
+                    }
+                    {
+                        jLabel2 = new JLabel();
+                        resolutionPanel.add(jLabel2);
+                        jLabel2.setText("Image Height:");
+                    }
+                    {
+                        resolutionYTextField = new JTextField();
+                        resolutionPanel.add(resolutionYTextField);
+                        resolutionYTextField.setText("480");
+                        resolutionYTextField.setPreferredSize(new java.awt.Dimension(50, 20));
+                    }
+                }
+                {
+                    threadsPanel = new JPanel();
+                    generalPanel.add(threadsPanel);
+                    threadsPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(BevelBorder.LOWERED), "Threads", TitledBorder.LEADING, TitledBorder.TOP));
+                    {
+                        threadCheckBox = new JCheckBox();
+                        threadsPanel.add(threadCheckBox);
+                        threadCheckBox.setText("Use All Processors");
+                    }
+                    {
+                        jLabel3 = new JLabel();
+                        threadsPanel.add(jLabel3);
+                        jLabel3.setText("Threads:");
+                    }
+                    {
+                        threadTextField = new JTextField();
+                        threadsPanel.add(threadTextField);
+                        threadTextField.setText("1");
+                        threadTextField.setPreferredSize(new java.awt.Dimension(50, 20));
+                    }
+                }
+            }
+            {
+                rendererPanel = new JPanel();
+                FlowLayout rendererPanelLayout = new FlowLayout();
+                rendererPanelLayout.setAlignment(FlowLayout.LEFT);
+                rendererPanel.setLayout(rendererPanelLayout);
+                this.addTab("Renderer", null, rendererPanel, null);
+                {
+                    defaultRendererRadioButton = new JRadioButton();
+                    rendererPanel.add(defaultRendererRadioButton);
+                    defaultRendererRadioButton.setText("Default Renderer");
+                }
+                {
+                    bucketRendererPanel = new JPanel();
+                    BoxLayout bucketRendererPanelLayout = new BoxLayout(bucketRendererPanel, javax.swing.BoxLayout.Y_AXIS);
+                    bucketRendererPanel.setLayout(bucketRendererPanelLayout);
+                    rendererPanel.add(bucketRendererPanel);
+                    bucketRendererPanel.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(BevelBorder.LOWERED), "Bucket Renderer", TitledBorder.LEADING, TitledBorder.TOP));
+                    {
+                        bucketRendererRadioButton = new JRadioButton();
+                        bucketRendererPanel.add(bucketRendererRadioButton);
+                        bucketRendererRadioButton.setText("Enable");
+                    }
+                    {
+                        samplingPanel = new JPanel();
+                        GridLayout samplingPanelLayout = new GridLayout(2, 2);
+                        samplingPanelLayout.setColumns(2);
+                        samplingPanelLayout.setHgap(5);
+                        samplingPanelLayout.setVgap(5);
+                        samplingPanelLayout.setRows(2);
+                        samplingPanel.setLayout(samplingPanelLayout);
+                        bucketRendererPanel.add(samplingPanel);
+                        {
+                            jLabel5 = new JLabel();
+                            samplingPanel.add(jLabel5);
+                            jLabel5.setText("Min:");
+                        }
+                        {
+                            ComboBoxModel<String> minSamplingComboBoxModel = new DefaultComboBoxModel<String>(new String[]{
+                                "Item One", "Item Two"});
+                            minSamplingComboBox = new JComboBox<String>();
+                            samplingPanel.add(minSamplingComboBox);
+                            minSamplingComboBox.setModel(minSamplingComboBoxModel);
+                        }
+                        {
+                            jLabel6 = new JLabel();
+                            samplingPanel.add(jLabel6);
+                            jLabel6.setText("Max:");
+                        }
+                        {
+                            ComboBoxModel<String> maxSamplingComboxBoxModel = new DefaultComboBoxModel<String>(new String[]{
+                                "Item One", "Item Two"});
+                            maxSamplingComboxBox = new JComboBox<String>();
+                            samplingPanel.add(maxSamplingComboxBox);
+                            maxSamplingComboxBox.setModel(maxSamplingComboxBoxModel);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            Logger.getLogger(RenderGlobalsPanel.class.getName()).log(Level.SEVERE, null, e);
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+package org.sunflow.system;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.LinkedList;
+
+import org.sunflow.system.UI.Module;
+
+public class SearchPath {
+
+    private final LinkedList<String> searchPath;
+    private final String type;
+
+    public SearchPath(String type) {
+        this.type = type;
+        searchPath = new LinkedList<>();
+    }
+
+    public void resetSearchPath() {
+        searchPath.clear();
+    }
+
+    public void addSearchPath(String path) {
+        File f = new File(path);
+        if (f.exists() && f.isDirectory()) {
+            try {
+                path = f.getCanonicalPath();
+                for (String prefix : searchPath) {
+                    if (prefix.equals(path)) {
+                        return;
+                    }
+                }
+                UI.printInfo(Module.SYS, "Adding %s search path: \"%s\"", type, path);
+                searchPath.add(path);
+            } catch (IOException e) {
+                UI.printError(Module.SYS, "Invalid %s search path specification: \"%s\" - %s", type, path, e.getMessage());
+            }
+        } else {
+            UI.printError(Module.SYS, "Invalid %s search path specification: \"%s\" - invalid directory", type, path);
+        }
+    }
+
+    public String resolvePath(String filename) {
+        // account for relative naming schemes from 3rd party softwares
+        if (filename.startsWith("//")) {
+            filename = filename.substring(2);
+        }
+        UI.printDetailed(Module.SYS, "Resolving %s path \"%s\" ...", type, filename);
+        File f = new File(filename);
+        if (!f.isAbsolute()) {
+            for (String prefix : searchPath) {
+                UI.printDetailed(Module.SYS, "  * searching: \"%s\" ...", prefix);
+                if (prefix.endsWith(File.separator) || filename.startsWith(File.separator)) {
+                    f = new File(prefix + filename);
+                } else {
+                    f = new File(prefix + File.separator + filename);
+                }
+                if (f.exists()) {
+                    // suggested path exists - try it
+                    return f.getAbsolutePath();
+                }
+            }
+        }
+        // file was not found in the search paths - return the filename itself
+        return filename;
+    }
+}

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

@@ -0,0 +1,53 @@
+package org.sunflow.system;
+
+public class Timer {
+
+    private long startTime, endTime;
+
+    public Timer() {
+        startTime = endTime = 0;
+    }
+
+    public void start() {
+        startTime = endTime = System.nanoTime();
+    }
+
+    public void end() {
+        endTime = System.nanoTime();
+    }
+
+    public long nanos() {
+        return endTime - startTime;
+    }
+
+    public double seconds() {
+        return (endTime - startTime) * 1e-9;
+    }
+
+    public static String toString(long nanos) {
+        Timer t = new Timer();
+        t.endTime = nanos;
+        return t.toString();
+    }
+
+    public static String toString(double seconds) {
+        Timer t = new Timer();
+        t.endTime = (long) (seconds * 1e9);
+        return t.toString();
+    }
+
+    @Override
+    public String toString() {
+        long millis = nanos() / (1000 * 1000);
+        if (millis < 10000) {
+            return String.format("%dms", millis);
+        }
+        long hours = millis / (60 * 60 * 1000);
+        millis -= hours * 60 * 60 * 1000;
+        long minutes = millis / (60 * 1000);
+        millis -= minutes * 60 * 1000;
+        long seconds = millis / 1000;
+        millis -= seconds * 1000;
+        return String.format("%d:%02d:%02d.%1d", hours, minutes, seconds, millis / 100);
+    }
+}