toxiclibs 0.2-java → 0.5.0-java

data/src/com/toxi/nio/UDPClient.java

@@ -0,0 +1,121 @@
+package com.toxi.nio;
+
+import java.net.*;
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import java.nio.channels.spi.SelectorProvider;
+import java.util.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ *
+ * @author tux
+ */
+public class UDPClient {
+
+    /**
+     *
+     */
+    public final static int DEFAULT_PORT = 9876;
+
+    int port = DEFAULT_PORT;
+    SocketAddress remote;
+    DatagramChannel channel;
+    Selector selector;
+    ByteBuffer buffer1;
+    ByteBuffer buffer2;
+
+    int clientID;
+
+    /**
+     *
+     * @param clientID
+     */
+    public UDPClient(int clientID) {
+        this.clientID = clientID;
+        System.out.println("new client ID: " + clientID);
+        try {
+            remote = new InetSocketAddress("192.168.1.64", port);
+            channel = DatagramChannel.open();
+            channel.configureBlocking(false);
+            channel.connect(remote);
+            selector = SelectorProvider.provider().openSelector();
+            channel.register(selector, SelectionKey.OP_READ
+                    | SelectionKey.OP_WRITE);
+            buffer1 = ByteBuffer.allocate(4);
+            buffer2 = ByteBuffer.allocate(4);
+        } catch (IOException ex) {
+            System.err.println(ex);
+        }
+    }
+
+    /**
+     *
+     * @param command
+     */
+    public void send(int command) {
+        try {
+            selector.select(clientID);
+            Set readyKeys = selector.selectedKeys();
+            Iterator iterator = readyKeys.iterator();
+            if (iterator.hasNext()) {
+                SelectionKey key = (SelectionKey) iterator.next();
+                iterator.remove();
+                if (key.isWritable()) {
+                    buffer1.clear();
+                    buffer1.putInt(command);
+                    buffer1.flip();
+                    channel.write(buffer1);
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println(ex);
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int receive() {
+        int r = 0;
+        try {
+            selector.select(clientID);
+            Set readyKeys2 = selector.selectedKeys();
+            Iterator iterator2 = readyKeys2.iterator();
+            if (iterator2.hasNext()) {
+                SelectionKey key2 = (SelectionKey) iterator2.next();
+                iterator2.remove();
+                if (key2.isReadable()) {
+                    buffer2.clear();
+                    channel.read(buffer2);
+                    buffer2.flip();
+                    int command = buffer2.getInt();
+                    r = command;
+                }
+            }
+        } catch (IOException ex) {
+            System.err.println(ex);
+        }
+        return r;
+    }
+
+    /**
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        UDPClient client = new UDPClient(Integer.parseInt(args[0]));
+        client.send(1);
+        while (true) {
+            System.out.println(client.receive());
+            try {
+                Thread.sleep(33);
+            } catch (InterruptedException ex) {
+                Logger.getLogger(UDPClient.class.getName()).log(Level.SEVERE, null, ex);
+            }
+        }
+    }
+}

data/src/com/toxi/nio/UDPClientState.java

@@ -0,0 +1,32 @@
+package com.toxi.nio;
+
+import java.net.SocketAddress;
+
+/**
+ *
+ * @author tux
+ */
+public class UDPClientState {
+    SocketAddress addr;
+    boolean isReady;
+    long lastUpdate;
+
+    /**
+     *
+     * @param a
+     */
+    public UDPClientState(SocketAddress a) {
+        addr = a;
+        isReady = true;
+        lastUpdate = System.currentTimeMillis();
+        System.out.println("new client: " + addr);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public SocketAddress getAddress() {
+        return addr;
+    }
+}

data/src/com/toxi/nio/UDPServer.java

@@ -0,0 +1,129 @@
+package com.toxi.nio;
+
+import java.net.*;
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ *
+ * @author tux
+ */
+public class UDPServer extends Thread {
+
+    /**
+     *
+     */
+    public final static int DEFAULT_PORT = 9876;
+
+    /**
+     *
+     */
+    public final static int MAX_PACKET_SIZE = 32;
+
+    private int port;
+    private int packetSize;
+    private int numClients;
+
+    ArrayList<UDPClientState> clients;
+    private int frameCount = 0;
+    private int frameDuration;
+
+    /**
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        new UDPServer(1, 25).start();
+        try {
+            while (true) {
+                Thread.sleep(1000);
+                // System.out.println("running.");
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     *
+     * @param numClients
+     * @param fps
+     */
+    public UDPServer(int numClients, int fps) {
+        this(DEFAULT_PORT, numClients, MAX_PACKET_SIZE, fps);
+    }
+
+    /**
+     *
+     * @param port
+     * @param numClients
+     * @param maxPacketSize
+     * @param fps
+     */
+    public UDPServer(int port, int numClients, int maxPacketSize, int fps) {
+        this.port = port;
+        this.numClients = numClients;
+        this.packetSize = maxPacketSize;
+        frameDuration = 1000 / fps;
+        clients = new ArrayList<UDPClientState>();
+    }
+
+    /**
+     *
+     */
+    public void run() {
+        DatagramChannel channel = null;
+        DatagramSocket socket = null;
+        ByteBuffer buffer = null;
+        try {
+            channel = DatagramChannel.open();
+            socket = channel.socket();
+            SocketAddress address = new InetSocketAddress(
+                    InetAddress.getLocalHost(), port);
+            socket.bind(address);
+            buffer = ByteBuffer.allocateDirect(packetSize);
+            System.out.println("Server running: " + address);
+            System.out.println("Heartbeat interval: " + frameDuration);
+            System.out.println("waiting for clients...");
+
+            // get the addresses-initialisation phase
+            while (clients.size() < numClients) {
+                clients.add(new UDPClientState(channel.receive(buffer)));
+                buffer.flip();
+                buffer.clear();
+            }
+            // server now knows the clients
+
+            // MAIN LOOP-server is working for the clients
+            while (true) {
+                long beginSynch = System.currentTimeMillis();
+                buffer.clear();
+                buffer.putInt(frameCount++);
+                buffer.flip();
+                Iterator<UDPClientState> iter = clients.iterator();
+                while (iter.hasNext()) {
+                    channel.send(buffer, iter.next().getAddress());
+                }
+                long endSynch = System.currentTimeMillis();
+                if (endSynch - beginSynch < frameDuration) {
+                    int sleep = frameDuration - (int) (endSynch - beginSynch);
+                    // System.out.println("sleeping: " + sleep);
+                    Thread.sleep(sleep);
+                } else {
+                    Thread.sleep(2);
+                }
+            }
+        } catch (Exception ex) {
+            System.err.println(ex);
+        } finally {
+            if (socket != null)
+                socket.close();
+            if (buffer != null)
+                buffer = null;
+            System.out.println("server shutdown.");
+        }
+    }
+}

data/src/toxi/color/AccessCriteria.java

@@ -0,0 +1,114 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library 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 GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+package toxi.color;
+
+import java.util.Comparator;
+
+/**
+ * Defines standard color component access criterias and associated comparators
+ * used to sort colors based on component values. If a new custom accessor is
+ * needed (e.g. for sub-classes TColor's), then simply sub-class this class and
+ * implement the {@link Comparator} interface and the 2 abstract getter & setter
+ * methods defined by this class.
+ */
+public abstract class AccessCriteria implements Comparator<ReadonlyTColor> {
+
+    /**
+     *
+     */
+    public static final AccessCriteria HUE = new HSVAccessor(0);
+
+    /**
+     *
+     */
+    public static final AccessCriteria SATURATION = new HSVAccessor(1);
+
+    /**
+     *
+     */
+    public static final AccessCriteria BRIGHTNESS = new HSVAccessor(2);
+
+    /**
+     *
+     */
+    public static final AccessCriteria RED = new RGBAccessor(0);
+
+    /**
+     *
+     */
+    public static final AccessCriteria GREEN = new RGBAccessor(1);
+
+    /**
+     *
+     */
+    public static final AccessCriteria BLUE = new RGBAccessor(2);
+
+    /**
+     *
+     */
+    public static final AccessCriteria CYAN = new CMYKAccessor(0);
+
+    /**
+     *
+     */
+    public static final AccessCriteria MAGENTA = new CMYKAccessor(1);
+
+    /**
+     *
+     */
+    public static final AccessCriteria YELLOW = new CMYKAccessor(2);
+
+    /**
+     *
+     */
+    public static final AccessCriteria BLACK = new CMYKAccessor(3);
+
+    /**
+     *
+     */
+    public static final AccessCriteria ALPHA = new AlphaAccessor();
+
+    /**
+     *
+     */
+    public static final AccessCriteria LUMINANCE = new LuminanceAccessor();
+
+    /**
+     *
+     * @param col
+     * @return
+     */
+    public abstract float getComponentValueFor(ReadonlyTColor col);
+
+    /**
+     *
+     * @param col
+     * @param value
+     */
+    public abstract void setComponentValueFor(TColor col, float value);
+}

data/src/toxi/color/AlphaAccessor.java

@@ -0,0 +1,67 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library 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 GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+package toxi.color;
+
+/**
+ * Compares 2 colors by their alpha value.
+ */
+public class AlphaAccessor extends AccessCriteria {
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @return
+     */
+    @Override
+    public int compare(ReadonlyTColor a, ReadonlyTColor b) {
+        float aa = a.alpha();
+        float ba = b.alpha();
+        return aa < ba ? -1 : aa > ba ? 1 : 0;
+    }
+
+    /**
+     *
+     * @param col
+     * @return
+     */
+    @Override
+    public float getComponentValueFor(ReadonlyTColor col) {
+        return col.alpha();
+    }
+
+    /**
+     *
+     * @param col
+     * @param value
+     */
+    @Override
+    public void setComponentValueFor(TColor col, float value) {
+        col.setAlpha(value);
+    }
+}