The esay way to do this is to pass the offscreen-buffer reference to the render method of the class. I have done that below and now I have a red and blue circle.

1. PGraphics offScreenBuffer;
2. Circle myCircle;
3. int bufferDimensions;
4. 
   
5. void setup() {
6.   size(1000, 600, P3D);
7.   noStroke();
8.   smooth(5);
9.   bufferDimensions = 200;
10.   offScreenBuffer = createGraphics(bufferDimensions, bufferDimensions, P3D);
11.   offScreenBuffer.beginDraw();
12.   offScreenBuffer.noStroke();
13.   offScreenBuffer.smooth(5);
14.   myCircle = new Circle();
15.   offScreenBuffer.background(255, 128);
16.   offScreenBuffer.translate(bufferDimensions/2, bufferDimensions/2, 0);
17.   offScreenBuffer.fill(255, 0, 0);
18.   offScreenBuffer.ellipse(-50, 0, 40, 40);
19.   myCircle.render(offScreenBuffer);
20.   offScreenBuffer.endDraw();
21. }
22. 
    
23. void draw() {
24.   background(100, 100, 100);
25.   translate(width/2, height/2, 0);
26.   rotateY(mouseX/200.0);
27.   image(offScreenBuffer, -bufferDimensions/2, -bufferDimensions/2);
28. }
29. 
    
30. class Circle {
31. 
    
32.   Circle() {
33.   }
34. 
    
35.   void render(PGraphics pg) {
36.     pg.fill(0, 0, 255);
37.     pg.ellipse(50, 0, 40, 40);
38.   }
39. }

I was too slow! 
In my version I have 2 render() methods -> 1 normal usage and another for PGraphics drawing!
But anyways, here's my 1.5.1 compliance version:

import processing.opengl.*;

final static short bufferDimensions = 200;

final PGraphics offScreenBuffer = createGraphics(
bufferDimensions, bufferDimensions, P3D);

final Circle myCircle = new Circle();

void setup() {
    size(1000, 600, OPENGL);
    noStroke();
    smooth();

    offScreenBuffer.beginDraw();

    offScreenBuffer.noStroke();
    offScreenBuffer.smooth();
    offScreenBuffer.background(255, 0200);
    offScreenBuffer.fill(#FF0000);
    offScreenBuffer.translate(bufferDimensions>>1, bufferDimensions>>1, 0);

    offScreenBuffer.ellipse(-50, 0, 40, 40);

    myCircle.render(offScreenBuffer);

    offScreenBuffer.endDraw();
}

void draw() {
    background(100);
    translate(width>>1, height>>1, 0);
    rotateY(mouseX/100f);
    image(offScreenBuffer, -bufferDimensions>>1, -bufferDimensions>>1);
}

class Circle {
    void render() {
        fill(#0000FF);
        ellipse(50, 0, 40, 40);
    }

    void render(PGraphics buffer) {
        buffer.fill(#0000FF);
        buffer.ellipse(50, 0, 40, 40);
    }
}

Thanks both for the prompt and very helpful replies!

Calling

myCircle.render(this.g);

instead of 

myCircle.render(offScreenBuffer);

makes the parameterless render() method redundant.

Note that rendering to the buffer must be done between the beginDraw and endDraw

Hmmm, having implemented your original suggestion on passing through the PGraphics reference to the render method I ran into some weird alpha issues that I'm not sure are resolved by referencing 'this.g'

I noticed that at anything less than full opacity a small amount of white fringing was apparent around the circle and when I translated the circle vertically away from 0 some really strange thnigs started happening. See the below code but in summary:

• Negative vertical displacement meant the circle inherited the background alpha.
• Approaching 0 the circle displayed at full opacity but with an inverted mirror image that inherits the background colour (but not alpha).
• Further vertical displacement proportionally displaced the mirror image.

I've used triangles in the code below to make things clearer. If I update the buffer in the main draw function then the issue largely disappears but there is still some fringing apparent at 0 alpha which looks like the mirror image sitting 'behind' the correct coloured shape. More significantly I'd prefer not to have to update the buffer within the main draw function because in my project I'm using very complex geometry and the whole point of using the offscreen buffer was to render once and then use the resulting image as a texture on lower complexity geometry that is updated in the main draw function.

So I guess the question is: is there a way of resolving this strange alpha behaviour wihout resorting to rendering the buffer every time I iterate through draw()?

Thanks again for any help on this one

1. int bufferDimensions;
   int bufferAlpha;
   PGraphics offScreenBuffer;
   Triangle myTriangle;
   
   void setup() {
     size(1000, 600, P3D);
     noStroke();
     smooth(5);
   
     bufferDimensions = 200;
     bufferAlpha = 128;//try setting to 0 for noticeable fringes when updateBuffer is activated in draw()
     offScreenBuffer = createGraphics(bufferDimensions, bufferDimensions, P3D);
     myTriangle = new Triangle();
     updateBuffer();
   }
   
   void draw() {
     background(100, 100, 100);
     translate(width/2, height/2, 0);
     rotateY(mouseX/200.0);
       //updateBuffer(); //uncomment to display correctly but with noticeable fringes at low alpha settings
     image(offScreenBuffer, -bufferDimensions/2, -bufferDimensions/2);
   }
   
   void updateBuffer() {
     offScreenBuffer.beginDraw();
     offScreenBuffer.noStroke();
     offScreenBuffer.smooth(5);
     offScreenBuffer.background(255, bufferAlpha);
     offScreenBuffer.translate(bufferDimensions/2, bufferDimensions/2, 0);
     offScreenBuffer.translate(-50, -50);
     myTriangle.render(offScreenBuffer);
     offScreenBuffer.translate(50, 50);
     myTriangle.render(offScreenBuffer);
     offScreenBuffer.translate(50, 50);
     myTriangle.render(offScreenBuffer);
     offScreenBuffer.endDraw();
   }
   
   class Triangle {
   
     Triangle() {
     }
   
     void render(PGraphics inputBuffer) {
       inputBuffer.fill(0, 0, 255);
       inputBuffer.beginShape();
       inputBuffer.vertex(-30, 20, 0);
       inputBuffer.vertex(0, -30, 0);
       inputBuffer.vertex(30, 20, 0);
       inputBuffer.endShape();
     }
   }