Loading...
Logo
Processing Forum
Contributed Library Questions
aufsess
aufsess

Picker for processing 2.0

in Contributed Library Questions  •  1 year ago  
Has anyone had success getting a color buffer picker (for picking shapes) in processing 2.0 with open gl?  I'm trying to use my old scripts that employ the picker library.  I get this error:

The type processing.core.PGraphics3D cannot be resolved. It is indirectly referenced from required .class file.

Or use one of the other code snippets out there.  I get these errors when I use this library:


2012-05-23 11:20:23.585 java[2128:1f07] invalid drawable
OpenGL error 1286 at top beginDraw(): invalid framebuffer operation
OpenGL error 1286 at bot beginDraw(): invalid framebuffer operation
OpenGL error 1286 at top endDraw(): invalid framebuffer operation
java.lang.NullPointerException
at processing.mode.java.runner.Runner.findException(Runner.java:618)

Any luck with getting this to work?

Thanks!

Alex

Replies(18)

aufsess
aufsess

Re: Picker for processing 2.0

1 year ago
Anyone?  Thanks.
aufsess
aufsess

Re: Picker for processing 2.0

1 year ago
I've been trying to just import the library directly into processing, but I haven't figured out how to get around an error I get from "createGraphics":

"You need to use "Import Library" to add picking.Buffer to your sketch.

Here is the code:

Copy code
  2. public class Picker {
  3.   
  4.   /**
  5.    * Processing applet
  6.    */
  7.   protected PApplet parent;
  8.   
  9.   /**
  10.    * Main picking buffer
  11.    * Direct access to the buffer is allowed so you can draw shapes that
  12.    * you wouldn't like to draw on the main screen (like bounding boxes).
  13.    */
  14.   public Buffer buffer;
  15.   
  16.   public Picker(PApplet parent) {
  17.     this.parent = parent;
  18.     buffer = (Buffer) parent.createGraphics(parent.width, parent.height, "picking.Buffer");
  19.     buffer.callCheckSettings();
  20.     if (parent.recorder == null) {
  21.       parent.recorder = buffer;
  22.     }
  23.     buffer.background(0);
  24.     parent.registerPre(this);
  25.     parent.registerDraw(this);
  26.   }
  27.   
  28.   public void pre() {
  29.     buffer.beginDraw();
  30.     if (parent.recorder == null) {
  31.       parent.recorder = buffer;
  32.     }
  33.   }
  34.   
  35.   public void draw() {
  36.     buffer.endDraw();
  37.   }
  38.   
  39.   /**
  40.    * Begins recording object(s)
  41.    * 
  42.    * @param i Object ID
  43.    */
  44.   public void start(int i) {
  45.     if (i < 0 || i > 16777214) {
  46.       PApplet.println("[Picking error] start(): ID out of range");
  47.       return;
  48.     }
  49.     if (parent.recorder == null) {
  50.       parent.recorder = buffer;
  51.     }
  52.     buffer.setCurrentId(i);
  53.   }
  54.   
  55.   /**
  56.    * Stops/pauses recording object(s)
  57.    */
  58.   public void stop() {
  59.     parent.recorder = null;
  60.   }
  61.   
  62.   /**
  63.    * Resumes recording object(s)
  64.    */
  65.   public void resume() {
  66.     if (parent.recorder == null) {
  67.       parent.recorder = buffer;
  68.     }
  69.   }
  70.   
  71.   /**
  72.    * Reads the ID of the object at point (x, y)
  73.    * -1 means there is no object at this point
  74.    * @param x X coordinate
  75.    * @param y Y coordinate
  76.    * @return Object ID
  77.    */
  78.   public int get(int x, int y) {
  79.     return buffer.getId(x, y);
  80.   }
  81.   
  82.   /**
  83.    * Get the buffer
  84.    * @return Buffer
  85.    */
  86.   public PGraphics getBuffer() {
  87.     return buffer;
  88.   }
  89.   
  90. }

  92. public class Buffer extends PGraphics3D {
  93.   
  94.   protected int current_color = 0;
  95.   
  96.   public Buffer() {}
  97.   
  98.   public boolean displayable() { return true; }
  99.   
  100.   public  void callCheckSettings() { super.checkSettings(); }
  101.   
  102.   public void background(int arg) { super.background(0); }
  103.   public void background(float arg) { super.background(0); }
  104.   public void background(float arg, float arg_1) { super.background(0); }
  105.   public void background(int arg, float arg_1) { super.background(0); }
  106.   public void background(float arg, float arg_1, float arg_2) { super.background(0); }
  107.   public void background(float arg, float arg_1, float arg_2, float arg_3) { super.background(0); }
  108.   public void background(PImage arg) { super.background(0); }
  109.   
  110.   public void lights() {}
  111.   public void smooth() {}
  112.   public void fill(int arg) {}
  113.   public void fill(float arg) {}
  114.   public void fill(float arg, float arg_1) {}
  115.   public void fill(int arg, float arg_1) {}
  116.   public void fill(float arg, float arg_1, float arg_2) {}
  117.   public void fill(float arg, float arg_1, float arg_2, float arg_3) {}
  118.   
  119.   public void stroke(int arg) {}
  120.   public void stroke(float arg) {}
  121.   public void stroke(float arg, float arg_1) {}
  122.   public void stroke(int arg, float arg_1) {}
  123.   public void stroke(float arg, float arg_1, float arg_2) {}
  124.   public void stroke(float arg, float arg_1, float arg_2, float arg_3) {}
  125.   
  126.   public void textureMode(int arg) {}
  127.   public void texture(PImage arg) {}
  128.   public void vertex(float x, float y, float z, float u, float v) { super.vertex(x, y, z); }
  129.   
  130.   public void image(PImage arg, float arg_1, float arg_2) {}
  131.   public void image(PImage arg, float arg_1, float arg_2, float arg_3, float arg_4) {}
  132.   public void image(PImage arg, float arg_1, float arg_2, float arg_3, float arg_4, int arg_5, int arg_6, int arg_7, int arg_8) {}
  133.   
  134.   protected void imageImpl(PImage image,
  135.             float x1, float y1, float x2, float y2,
  136.             int u1, int v1, int u2, int v2) {}
  137.   
  138.   public void setCurrentId(int i) {
  139.     // ID 0 to 16777214  => COLOR -16777215 to -1 (white)
  140.     // -16777216 is black
  141.     current_color = i - 16777215;
  142.     super.fill(current_color);
  143.   }
  144.   
  145.   public int getId(int x, int y) {
  146.     super.loadPixels();
  147.     // COLOR -16777216 (black) to -1 => ID -1 (no object) to 16777214 
  148.     int id = pixels[y*width+x] + 16777215;
  149.     return id;
  150.   }
  151. }
aufsess
aufsess

Re: Picker for processing 2.0 // GLGraphics + Toxiclibs Implementation

1 year ago
I never figured out how to implement the Picker in 2.0 (I'm staying in 1.5 for the time being), but I did figure out how to implement it with GLGraphics and use it for picking faces on a mesh.  Hope this is useful to someone. Hopefully will have time to make a stand alone example soon.

Copy code
  2. // CODE needs to be spliced into something else...

  4. import codeanticode.glgraphics.*;
  5. import toxi.geom.*;
  6. import toxi.geom.mesh.*;
  7. import toxi.processing.*;

  9. GLGraphicsOffScreen  pickerB = new GLGraphicsOffScreen(this, height, width, false, 4);
  10. PImage pickerI;
  11. GLTexture tex;

  13. public void initGLPicker() {

  15.   // CONVERT TO GL MODEL START
  16.   currentMesh.computeVertexNormals(); // <-- Insert your mesh here from TOXILIBS (or other GLModel Shape)

  18.   float[] verts=currentMesh.getMeshAsVertexArray();
  19.   // in the array each vertex has 4 entries (XYZ + 1 spacing)
  20.   int numV=verts.length/4;  
  21.   float[] norms=currentMesh.getVertexNormalsAsArray();

  23.   bSurf = new GLModel(me, numV, TRIANGLES, GLModel.STREAM);
  24.   bSurf.beginUpdateVertices();
  25.   for (int i = 0; i < numV; i++) bSurf.updateVertex(i, verts[4 * i], verts[4 * i + 1], verts[4 * i + 2]);
  26.   bSurf.endUpdateVertices(); 

  28.   bSurf.initNormals();
  29.   bSurf.beginUpdateNormals();
  30.   for (int i = 0; i < numV; i++) bSurf.updateNormal(i, norms[4 * i], norms[4 * i + 1], norms[4 * i + 2]);
  31.   bSurf.endUpdateNormals();  

  33.   bSurf.initColors();
  34.   bSurf.beginUpdateColors();

  36.   for (int fNum=0; fNum<currentMesh.faces.size(); fNum++) {
  37.     int currentColor = fNum - 16777215;
  38.     int vNum = fNum*3;
  39.     //    println("writing face # " + fNum + " vertice # " + vNum + " " + (vNum+1) + " " + (vNum+2) + " color # = " + currentColor);
  40.     if (vNum < bSurf.getSize()) {
  41.       bSurf.updateColor(vNum, currentColor, 255); 
  42.       bSurf.updateColor(vNum+1, currentColor, 255); 
  43.       bSurf.updateColor(vNum+2, currentColor, 255);
  44.     }
  45.     else
  46.       println("out of bounds with color vertices!");
  47.   }

  49.   bSurf.endUpdateColors(); 

  51.   println("Finished loading GLMODEL BUFFER");

  53.   // CONVERT TO GL MODEL END
  54. }

  56. public void  updateGLPickerBuffer() {
  57.   // GL START
  58.   pickerB.beginDraw();
  59.   pickerB.beginGL();
  60.   pickerB.background(0);
  61.   pickerB.model(bSurf);
  62.   pickerB.endGL();
  63.   pickerB.endDraw();

  65.   // UPDATE Picker Texture TODO: THIS IS SLOWEST PART...
  66.   tex = pickerB.getTexture();
  67.   tex.updateTexture();
  68.   //tex.save("smooth.tif");
  69.   //tex.getImage(pickerI);
  70. }

  72. public int getId(int x, int y) {
  73.   int arrayMax = int(width*PickerRez)*int(height*PickerRez);
  74.   int pixelNumber = min(arrayMax, int(y*PickerRez*tex.width+x*PickerRez));
  75.   // COLOR -16777216 (black) to -1 => ID -1 (no object) to 16777214 
  76.   int id = tex.pixels[pixelNumber] + 16777215; // 16777215
  77.   //int id = 10;
  78.   return id;
  79. }






andres
andres

Re: Picker for processing 2.0

1 year ago
Hi, I just tested the object picking code from the wiki using 2.0a6, and it works. Are you using an older alpha release?
aufsess
aufsess

Re: Picker for processing 2.0

1 year ago
Hi Andres,

I'm not sure exactly what release I was using, but I was having trouble with the Picker library, not the wiki. My sketch needs max performance from the picker to work, so I implemented the GL Graphics version.  I don't totally grasp how I will port all of these awesome GL Graphics library things to 2.0, so I'm holding off for now.

Now if only there was a way to grab one pixel from the GPU texture without having to use "loadtexture" command.  I guess that's just inherent to the process.

Copy code
  1.   tex = pickerB.getTexture();
  2.   tex.updateTexture();




andres
andres

Re: Picker for processing 2.0

1 year ago
If you are using a PGraphics object created with a P2D or P3D renderer in Processing 2.0, then you should be able to retrieve the pixels array just by calling pg.loadPixels().
aufsess
aufsess

Re: Picker for processing 2.0

1 year ago
My issues is that loadPixels takes some time as does updateTexture.  I'm going to see whether I can multithread some of these calls and avoid the lag in my main script. The stuff I'm doing requires me to do a loadPixels every frame to access it with the picker.  While it's definitely faster to run this with a glgraphics offscreen buffer the lag comes when I offload this buffer from my GPU to run a picker function on the array of pixels.  I've reduced the size of the buffer, but his creates other issues.

I'm not sure if there is a way to avoid this offloading and just access it pixel by pixel directly (to check the color) directly on the GPU? I suppose that is the same problem... 
andres
andres

Re: Picker for processing 2.0

1 year ago
If you only need to check the color value at a specific pixel location, you could do:
Copy code
  1. import java.nio.*;

  3. void setup() {
  4.   size(100, 100, P2D);
  5.   noSmooth();
  6. }

  8. void draw() {
  9.   background(0);
  10.   stroke(255, 0, 0);
  11.   strokeWeight(10);
  12.   strokeCap(RECT);
  13.   point(50, 50);

  15.   PGraphicsOpenGL pg = (PGraphicsOpenGL)g;

  17.   PGL pgl = pg.beginPGL();
  18.   int[] pixel = new int[1];
  19.   IntBuffer pixelBuffer = IntBuffer.wrap(pixel);  
  20.   pgl.glReadPixels(mouseX, mouseY - 1, 1, 1, PGL.GL_RGBA, PGL.GL_UNSIGNED_BYTE, pixelBuffer);
  21.   int col = PGL.nativeToJavaARGB(pixel[0]);
  22.   println(red(col) + " " + green(col) + " " + blue(col));
  23.   pg.endPGL();
  24. }
Copying all the pixels in the screen with a separate glReadPixels() call for each is going to be much slower than using loadPixels(), but if you need to check the color of only a few pixels per frame, then this should be faster.
Massimo
Massimo

Re: Picker for processing 2.0

1 year ago
Hi Andres,

I tried to create a color picking function for 2D sprites (PNGs converted into white masks and then tinted with the color ID) using 2.0a8 and strange things come up:

1) if I use P3D or P2D and call loadPixels() or get() the sketch slow down terribly

2) If I implement offscreen surface using JAVA2D I get wrong color results

My friend Erika opened 2 issues about those bugs:

Issue with tint and JAVA2D
Issue with loadPixels

In the mean while I tried your sketch in this thread but something is missing:

Copy code
  1.       PGL pgl = pg.beginPGL();
This method doesn't exist anymore.

Do you think is better to wait for 2.0 or do you have other suggestions about this problem?

Thank you in advance,
Massimo
andres
andres

Re: Picker for processing 2.0

1 year ago
Hello Massimo,

Thanks for reporting the issues, I will look into them soon.

As for the  beginPGL() function, it got renamed back to beginGL() in the latest alpha releases. However, the PGL class is still undergoing changes, and it is very likely that it will become beginPGL() again (and definitely) for the beta.
Massimo
Massimo

Re: Re: Picker for processing 2.0

1 year ago
Thank you andres for your constant work on Processing!

Also your suggestion seems to solve my color picking problem!
Massimo
Massimo

Re: Picker for processing 2.0

1 year ago
I was wrong: your suggestion works fine if you draw on main PGraphics (g) but I tried to implement an offscreen buffer and, instead of reading the offscreen pixel, it get it from displayed pixels :-(

Copy code
  1. import java.nio.*;
  2. PGraphics offscreen;
  3. void setup() {
  4.   size(100, 100, P2D);
  5.   offscreen = createGraphics(100, 100, P2D);
  6.   offscreen.noSmooth();
  7.   //offscreen.hint(ENABLE_ACCURATE_2D); //is it better to include this?
  8. }
  9. void draw() {
  10.  
  11.   offscreen.beginDraw();
  12.   offscreen.background(0);
  13.   offscreen.stroke(255, 0, 0);
  14.   offscreen.strokeWeight(10);
  15.   offscreen.strokeCap(RECT);
  16.   offscreen.point(50, 50);
  17.   offscreen.endDraw();
  18.   PGraphicsOpenGL pg = (PGraphicsOpenGL) offscreen;
  19.   PGL pgl = pg.beginGL();
  20.   int[] pixel = new int[1];
  21.   IntBuffer pixelBuffer = IntBuffer.wrap(pixel); 
  22.   pgl.glReadPixels(mouseX, mouseY - 1, 1, 1, PGL.GL_RGBA, PGL.GL_UNSIGNED_BYTE, pixelBuffer);
  23.   int col = PGL.nativeToJavaARGB(pixel[0]);
  24.   println(red(col) + " " + green(col) + " " + blue(col));
  25.   pg.endGL();
  26. }
This offscreen version of your sketch should work but it does not. Am I missing something?

I'm not so confident with GL related stuff and I hadn't the time to study your latest committed code deeply but after a small travel inside opengl PGraphics implementation I found something that confused me a bit:

Copy code
  1.     if (primarySurface) {
  2.       pgl.updatePrimary();
  3.       if (pgl.primaryIsDoubleBuffered()) {
  4.         pgl.drawBuffer(PGL.BACK);
  5.       }
  6.     } else {
  7.       if (!pgl.initialized) {
  8.         initOffscreen();
  9.       } else {
  10.         boolean outdated = offscreenFramebuffer != null && offscreenFramebuffer.contextIsOutdated();
  11.         boolean outdatedMulti = offscreenFramebufferMultisample != null && offscreenFramebufferMultisample.contextIsOutdated();
  12.         if (outdated || outdatedMulti) {
  13.           pgl.initialized = false;
  14.           initOffscreen();
  15.         }
  16.       }
  17.       pushFramebuffer();
  18.       if (offscreenMultisample) {
  19.         setFramebuffer(offscreenFramebufferMultisample);
  20.       } else {
  21.         setFramebuffer(offscreenFramebuffer);
  22.       }
  23.       pgl.updateOffscreen(pgPrimary.pgl);
  24.       pgl.drawBuffer(PGL.COLOR_ATTACHMENT0);
  25.     }
  26.     // We are ready to go!
This snippet is from beginDraw method inside PGraphicsOpenGL.java... my question is should I declare somehow that the offscreen PGraphics object is the FrameBuffer?

Thank you in advance,
Massimo

andres
andres

Re: Picker for processing 2.0

1 year ago
Hello, even if you only want to do low-level operations on the offscreen surface, you still need to enclose them between beginDraw/endDraw:
Copy code
  1.   PGraphicsOpenGL pg = (PGraphicsOpenGL) offscreen;
  2.   offscreen.beginDraw();
  3.   PGL pgl = pg.beginGL();
  4.   int[] pixel = new int[1];
  5.   IntBuffer pixelBuffer = IntBuffer.wrap(pixel);  
  6.   pgl.glReadPixels(mouseX, mouseY - 1, 1, 1, PGL.GL_RGBA, PGL.GL_UNSIGNED_BYTE, pixelBuffer);
  7.   int col = PGL.nativeToJavaARGB(pixel[0]);
  8.   println(red(col) + " " + green(col) + " " + blue(col));
  9.   pg.endGL();
  10.   offscreen.endDraw();
Massimo
Massimo

Re: Re: Picker for processing 2.0

8 months ago
Hi Andres,

I'm trying to recreate this snippet with new Processing 2.0b7 version but with no luck.

If I use main buffer it works as color picking method but if I use it with offscreen it will return always 0
Copy code
  2. import java.nio.*;

  4. PGraphics offscreenb;
  5. int currentColor = 0;


  8. void setup() {
  9.   size(640, 480, P3D);
  10.   offscreenb = createGraphics(width, height, P3D);
  11. }

  13. void draw() {
  14.   
  15.   //draw a green box in the center
  16.   translate(width / 2, height / 2);
  17.   fill(0, 128, 0);
  18.   stroke(0, 200, 0);
  19.   box(80);
  20.   
  21.   drawOffscreen();
  22.   currentColor = getPixel();
  23. }

  25. void mousePressed() {
  26.   println(red(currentColor) + "," + green(currentColor) + "," + blue(currentColor) + ",");
  27. }

  29. void drawOffscreen() {
  30.  
  31.   //draw a red box in the center of offscreen
  32.   offscreenb.beginDraw();
  33.   offscreenb.translate(width / 2, height / 2);
  34.   offscreenb.fill(255, 0, 0);
  35.   offscreenb.noStroke();
  36.   offscreenb.box(80);
  37.   offscreenb.endDraw(); 
  38. }

  40. int getPixel() {
  41.   PGraphicsOpenGL pg = (PGraphicsOpenGL) offscreenb; //change this with g and it works... :-(
  42.   
  43.   offscreenb.beginDraw();
  44.   PGL pgl = pg.beginPGL();
  45.   IntBuffer pixelBuffer = IntBuffer.allocate(1);
  46.   pgl.readPixels(mouseX, mouseY -1, 1, 1, PGL.RGBA, PGL.UNSIGNED_BYTE, pixelBuffer);
  47.   pg.endPGL();
  48.   offscreenb.endDraw();
  49.   return pixelBuffer.get();
  50. }



How are you folks getting color of pixels when using offscreen buffer and opengl?

Why  getColorValue() is protected? :-(

Thank you in advance,
Massimo
chicoatomo
chicoatomo

Re: Picker for processing 2.0

8 months ago
Hello

I've modified the library picking (Nicolas Clavaud) to work with processing version 2.0.b7.

You can also define class Buffer and Picker, directly on your processing editor

Buffer Class


Copy code
  2. public class Buffer extends PGraphics3D
  3. {
  4.   protected int current_color = 0;
  5.     
  6.   public Buffer(PApplet parent)
  7.   {
  8.     setParent(parent);
  9.     setSize(parent.width, parent.height);    
  10.   }

  12.   @Override
  13.   public boolean displayable() { return true; }
  14.   
  15.   public void callCheckSettings() { super.checkSettings(); }
  16.   
  17.   @Override
  18.   public void lights() {}
  19.   
  20.   @Override
  21.   public void smooth() {}
  22.   
  23.   @Override
  24.   public void fill(int arg) {}
  25.   
  26.   @Override
  27.   public void fill(float arg) {}
  28.   
  29.   @Override
  30.   public void fill(float arg, float arg_1) {}
  31.   
  32.   @Override
  33.   public void fill(int arg, float arg_1) {}
  34.   
  35.   @Override
  36.   public void fill(float arg, float arg_1, float arg_2) {}
  37.   
  38.   @Override
  39.   public void fill(float arg, float arg_1, float arg_2, float arg_3) {}
  40.   
  41.   @Override
  42.   public void stroke(int arg) {}
  43.   
  44.   @Override
  45.   public void stroke(float arg) {}
  46.   
  47.   @Override
  48.   public void stroke(float arg, float arg_1) {}
  49.   
  50.   @Override
  51.   public void stroke(int arg, float arg_1) {}
  52.   
  53.   @Override
  54.   public void stroke(float arg, float arg_1, float arg_2) {}
  55.   
  56.   @Override
  57.   public void stroke(float arg, float arg_1, float arg_2, float arg_3) {}
  58.   
  59.   @Override
  60.   public void textureMode(int arg) {}
  61.   
  62.   @Override
  63.   public void texture(PImage arg) {}
  64.   
  65.   @Override
  66.   public void vertex(float x, float y, float z, float u, float v) { super.vertex(x, y, z); }
  67.   
  68.   @Override
  69.   public void image(PImage arg, float arg_1, float arg_2) {}
  70.   
  71.   @Override
  72.   public void image(PImage arg, float arg_1, float arg_2, float arg_3, float arg_4) {}
  73.   
  74.   @Override
  75.   public void image(PImage arg, float arg_1, float arg_2, float arg_3, float arg_4, int arg_5, int arg_6, int arg_7, int arg_8) {}
  76.   
  77.   @Override
  78.   protected void imageImpl(PImage image, float x1, float y1, float x2, float y2, int u1, int v1, int u2, int v2) {}
  79.   
  80.   public void setCurrentId(int i) 
  81.   {
  82.       // ID 0 to 16777214  => COLOR -16777215 to -1 (white)
  83.       // -16777216 is black
  84.       current_color = i - 16777215;
  85.       super.fill(current_color);      
  86.   }
  87.   
  88.   public int getId(int x, int y)
  89.   {
  90.       super.loadPixels();
  91.       // COLOR -16777216 (black) to -1 => ID -1 (no object) to 16777214 
  92.       int id = pixels[y*width+x] + 16777215;
  93.       return id;
  94.   }
  95. }
Picker Class

Copy code
  2. public class Picker 
  3. {
  4.   protected PApplet parent;
  5.   public Buffer buffer;
  6.   
  7.   public Picker(PApplet parent) 
  8.   {
  9.     this.parent = parent;
  10.     buffer = new Buffer(parent);     
  11.     //parent.registerMethod("pre",this);
  12.     //parent.registerMethod("draw",this);
  13.   }      
  14.   
  15.   public void begin() 
  16.   {
  17.     if(parent.recorder == null)
  18.     {
  19.       parent.recorder = buffer; 
  20.       buffer.beginDraw();           
  21.     }
  22.   }
  23.   
  24.   public void end() 
  25.   {
  26.     buffer.endDraw();  
  27.     parent.recorder = null;
  28.   }

  30.   public void start(int i)
  31.   {
  32.     if (i < 0 || i > 16777214)
  33.     {
  34.       PApplet.println("[Picking error] start(): ID out of range");
  35.       return;
  36.     }
  37.     buffer.setCurrentId(i);            
  38.   }
  39.   
  40.   public void stop() 
  41.         {
  42.     parent.recorder = null;
  43.   }
  44.   
  45.   public void resume() 
  46.         {
  47.     parent.recorder = buffer;
  48.   }
  49.   
  50.   public int get(int x, int y)
  51.   {
  52.     return buffer.getId(x, y);
  53.   }
  54.   
  55.   public PGraphics getBuffer()
  56.   {
  57.     return buffer;
  58.   }    
  59. }
Example


Copy code
  2. Picker picker;
  3. float a = 0.0;

  5. void setup() 
  6. {  
  7.   size(200,200, P3D);  
  8.   picker = new Picker(this);
  9. }

  11. void draw() 
  12. {    
  13.   background(0,128,0);
  14.   a += 0.01;

  16.   picker.begin();
  17.   
  18.   picker.start(0);
  19.   pushMatrix();
  20.   translate(80, 75);
  21.   rotateX(a);
  22.   rotateY(a);
  23.   fill(200,40,60);
  24.   box(50);
  25.   popMatrix();
  26.   
  27.   picker.start(1);
  28.   pushMatrix();
  29.   translate(140, 75);
  30.   rotateX(a);
  31.   rotateY(a);
  32.   fill(60,40,200);
  33.   box(20);
  34.   popMatrix();
  35.   
  36.   picker.end();
  37.   
  38. }

  40. void mousePressed()
  41. {
  42.   println(picker.get(mouseX, mouseY));
  43. }
I hope that helps somewhat
chicoatomo
chicoatomo

Re: Picker for processing 2.0

8 months ago
Important Note: 

I don't know exactly why, but for some reason background can't be correctly overloaded, so is very important to call picker.begin() after the background() instruction
chicoatomo
chicoatomo

Re: Picker for processing 2.0

8 months ago
chicoatomo
chicoatomo

Re: Picker for processing 2.0

8 months ago
Hi all

I`ve found a important error in my solution.
the background is not managed properly in the recorder object

I'll try to find a solution
Sorry
Top Reply

Statistics

  • 18 Replies
  • 1920  Views
  • 4 Followers

Tags

No tags available for this topic.

Actions

Related Posts