Loading...
Logo
Processing Forum
Share your Work
bustup
bustup

Update method tip

in Share your Work  •  1 year ago  
Hi,

I see a lot of people doing calculations in the draw method, which in some cases is necessary (when working on opengl textures etc.), but in most it can be avoided and usually only slows down the drawing thread.

I thought I'd share how I make a separate thread to handle the calculations.

I have a class called CalculationThread which looks like this:
Copy code
  1. import java.lang.reflect.InvocationTargetException;
  2. import java.lang.reflect.Method;
  3. import java.util.ArrayList;

  5. public class CalculationThread implements Runnable {

  7.   private Thread t;
  8.   private int sleepTime;
  9.   private ArrayList<UpdateListener> updateListeners = new ArrayList<UpdateListener>();

  11.   public CalculationThread(int sleepTime) {
  12.     this.sleepTime = sleepTime;
  13.   }

  15.   public void addUpdateListener(Object object) {
  16.     try {
  17.       updateListeners.add(new UpdateListener(object, object.getClass().getMethod("update", new Class[] {
  18.       }
  19.       )));
  20.     } 
  21.     catch (SecurityException e) {
  22.       e.printStackTrace();
  23.     } 
  24.     catch (NoSuchMethodException e) {
  25.       System.err.println("No public update method in " + object.getClass().getSimpleName());
  26.     } 
  27.     catch (IllegalArgumentException e) {
  28.       System.err.println("Update method in " + object.getClass().getSimpleName() + " shouldn't have any arguments");
  29.     }
  30.   }

  32.     public void run() {
  33.     Thread me = Thread.currentThread();

  35.     while (t == me) {
  36.       for (int i = 0; i < updateListeners.size(); i++) {
  37.         UpdateListener ul = updateListeners.get(i);
  38.         try {
  39.           ul.getMethod().invoke(ul.getObject(), new Object[] {
  40.           }
  41.           );
  42.         } 
  43.         catch (IllegalArgumentException e) {
  44.           e.printStackTrace();
  45.         } 
  46.         catch (IllegalAccessException e) {
  47.           e.printStackTrace();
  48.         } 
  49.         catch (InvocationTargetException e) {
  50.           e.printStackTrace();
  51.         }
  52.       }

  54.       try {
  55.         Thread.sleep(sleepTime);
  56.       } 
  57.       catch (InterruptedException e) {
  58.         e.printStackTrace();
  59.       }
  60.     }
  61.     t = null;
  62.   }

  64.   public void start() {
  65.     if (t == null) {
  66.       t = new Thread(this);
  67.       t.start();
  68.     }
  69.   }

  71.   public void stop() {
  72.     if (t != null) {
  73.       t.interrupt();
  74.     }
  75.     t = null;
  76.   }

  78.   public void dispose() {
  79.     stop();
  80.   }

  82.   public class UpdateListener {

  84.     private Object object;
  85.     private Method method;

  87.     public UpdateListener(Object object, Method method) {
  88.       this.object = object;
  89.       this.method = method;
  90.     }

  92.     public Object getObject() {
  93.       return object;
  94.     }

  96.     public void setObject(Object object) {
  97.       this.object = object;
  98.     }

  100.     public Method getMethod() {
  101.       return method;
  102.     }

  104.     public void setMethod(Method method) {
  105.       this.method = method;
  106.     }
  107.   }
  108. }
What it does it looping all update methods added to the ArrayList  updateListeners.

This is how I use it.
Copy code
  1. public static CalculationThread CalcThread;
  2. private PVector position;

  4. public void setup() {
  5.   size(500, 500);
  6.   background(255);
  7.   
  8.   CalcThread = new CalculationThread(16);
  9.   CalcThread.start();
  10.   CalcThread.addUpdateListener(this);

  12.   position = new PVector(random(0, 450), random(0, 450));
  13. }

  15. public void update() {
  16.   position.x = random(0, 450);
  17.   position.y = random(0, 450);
  18. }

  20. public void draw() {
  21.   background(255);

  23.   fill(0);
  24.   rect(position.x, position.y, 50, 50);
  25. }
Hope someone finds this useful!

Replies(2)

PhiLho
PhiLho

Re: Update method tip

1 year ago
Interesting. That's how Processing does as they don't want to force to use classes, etc. It is simpler for the users.
Otherwise, it is better to use the method I explain in the https://forum.processing.org/topic/noob-q-i-d-like-to-learn-more-about-callbacks thread, defining an interface for this update() method.
Both methods have their merits...
bustup
bustup

Re: Re: Update method tip

1 year ago
Yes that's true, that is how I do it when working in the Eclipse environment. But not having a class extending PApplet and being able to implement the interface with the update method in the Processing IDE makes it impossible, no?       

This is how it looks for me in the Eclipse environment
Copy code
  1. import java.lang.reflect.InvocationTargetException;
  2. import java.lang.reflect.Method;
  3. import java.util.ArrayList;

  5. public class CalculationThread implements Runnable {

  7.   private Thread t;
  8.   private int sleepTime;
  9.   private ArrayList<DrawObject> drawObjects = new ArrayList<DrawObject>();

  11.   public CalculationThread(int sleepTime, ArrayList<DrawObject> drawObjects) {
  12.     this.sleepTime = sleepTime;
  13.     this.drawObjects = drawObjects;
  14.   }

  16.   public void run() {
  17.     Thread me = Thread.currentThread();

  19.     while (t == me) {
  20.       for (int i = 0; i < drawObjects.size(); i++) {
  21.         DrawObject d = drawObjects.get(i);
  22.         try {
  23.           d.getClass().getMethod("update", new Class[] {
  24.           }
  25.           ).invoke(d, new Object[] {
  26.           }
  27.           );
  28.         } 
  29.         catch (IllegalArgumentException e) {
  30.           e.printStackTrace();
  31.         } 
  32.         catch (IllegalAccessException e) {
  33.           e.printStackTrace();
  34.         } 
  35.         catch (InvocationTargetException e) {
  36.           e.printStackTrace();
  37.         }
  38.         catch (NoSuchMethodException e) {
  39.           e.printStackTrace();
  40.         }
  41.       }

  43.       try {
  44.         Thread.sleep(sleepTime);
  45.       } 
  46.       catch (InterruptedException e) {
  47.         e.printStackTrace();
  48.       }
  49.     }
  50.     t = null;
  51.   }

  53.   public void start() {
  54.     if (t == null) {
  55.       t = new Thread(this);
  56.       t.start();
  57.     }
  58.   }

  60.   public void stop() {
  61.     if (t != null) {
  62.       t.interrupt();
  63.     }
  64.     t = null;
  65.   }

  67.   public void dispose() {
  68.     stop();
  69.   }
  70. }
And
Copy code
  1. public static CalculationThread CalcThread;
  2. private ArrayList<DrawObject> drawObjects;

  4. private C c;
  5. private R r;

  7. public void setup() {
  8.   size(500, 500);
  9.   background(255);
  10.   
  11.   drawObjects = new ArrayList<DrawObject>();
  12.   drawObjects.add(c = new C(20));
  13.   drawObjects.add(r = new R(30));

  15.   CalcThread = new CalculationThread(16, drawObjects);
  16.   CalcThread.start();
  17. }

  19. public void draw() {
  20.   background(255);

  22.   for (int i = 0; i < drawObjects.size(); i++) {
  23.     drawObjects.get(i).draw();
  24.   }
  25. }

  27. public interface DrawObject {
  28.   void update();
  29.   void draw();
  30. }

  32. public class C implements DrawObject
  33. {
  34.   int diam;

  36.   public C(int r)
  37.   {
  38.     diam = r;
  39.   }

  41.   void update()
  42.   {
  43.     diam += 2;
  44.   }

  46.   void draw()
  47.   {
  48.     fill(#55AA88);
  49.     ellipse(100, 100, diam, diam);
  50.   }
  51. }

  53. public class R implements DrawObject
  54. {
  55.   int size;

  57.   public R(int s)
  58.   {
  59.     size = s;
  60.   }

  62.   void update()
  63.   {
  64.     size += 1;
  65.   }

  67.   void draw()
  68.   {
  69.     fill(#3388AA);
  70.     rect(300, 300, size, size);
  71.   }
  72. }
Top Reply

Statistics

  • 2 Replies
  • 571  Views
  • 1 Followers

Tags

No tags available for this topic.

Actions