This is about a Libraries Authoring. How could I have acces to the PAplet methods inside a Library? To express the problem, I give an example of a class:

Here, the proto-class require a PApplet to draw() an ellipse for each points.
Code:

public class Vertex{
  PApplet p5;
  float x,y,z;

  Vertex(PApplet p5){this.p5=p5;}
  Vertex(float _x, float _y, float _z, PApplet p5){
    x=_x;
    y=_y;
    z=_z;
    this.p5=p5;
  }

  public void add(float k){ x+=k; y+=k; z+=k;}
  public void add(float k, float l){ x+=k; y+=l; }
  public void add(float k, float l, float m){ x+=k; y+=l;  z+=l;}  

  //...

  public void draw(){
    p5.ellipse(x,y,z);    //Will use PApplet to draw an ellipse.
  }

}
 

Here's would be an example of use:
Code:

Vertex[] v = new Vertex[100];

for(int i=0; i<v.length; i++)
   {
	v[i] = new Vertex(i,i,i,this);
	v[i].draw();
   }
 

But, how should I setup the class to have acces to the PApplet methods without explicitly passing the PApplet to each objects? Like in this example:
Code:

Vertex[] v = new Vertex[100];

for(int i=0; i<v.length; i++)
   {
	v[i] = new Vertex(i,i,i); //note'this' have been removed.
	v[i].draw();		  //where could I access draw() now?
   }
 

I'm trying to figure a way to do this. Extends PApplet? I don't see how, but passing PApplet each time seems that I'm missing something.

Hi Marius! Nice to see you... I remember that we had a talk about this in Barcelona. I did work on a sceneGraph. I still have problems on some basic elements, on how you link the Library with the PApplet, so it's hard to start to put the things all together.

The problem is that I'll have to pass PApplet to every constructor. I'm not fine with this way to declare objects. I know that the first solution above will work, but I want to remove the PApplet reference each time I create Object. It might seems too much esthetic, but I can't imagine working with this in design.

Code:

	  Vertex(x,y,z,this);
	  Face(Vertex[], this);
	  Cube(x,y,z,dx,dy,dz,this);
	  Pyramid(x,y,z,dx,dy,dz,this);
	  Scene(this);

	  //....
	  //so on, this, this, this...
 

I would prefer something like:
Code:

	  Vertex(x,y,z);
	  Face(Vertex[]);
	  Cube(x,y,z,dx,dy,dz);
	  Pyramid(x,y,z,dx,dy,dz);
	  Scene();

	  //or, at least, myGeo.Vertex(x,y,z);
 

As you know PovRAY, you probably remember great things with the pseudoCode like:
Code:

Vertex a,b;
Vertex c = a+b;
 

I'm still thinking that it's more easy to read that way. At the end, I left that way to do it in Java, but I might still be nostalgic. Again, passing PApplet on every new object, since I don't have a 'this' key on my keyboard yet, I won't be happy with this Library for everyday design.

There's an anonther way to do it?


...
I tried something else (Make a superClass where you pass PApplet only once and where everything would be inner, but again, I feel that it's a wrong way:
Code:

public class SuperGeo {

public PApplet p5;

public SuperGeo(PApplet p5){
this.p5 = p5;
}


public class Vertex{

  float x,y,z;

  Vertex(){}

  Vertex(float _x, float _y, float _z){
    x=_x;
    y=_y;
    z=_z;
  } 

  public void add(float k){ x+=k; y+=k; z+=k;}
  public void add(float k, float l){ x+=k; y+=l; }
  public void add(float k, float l, float m){ x+=k; y+=l;  z+=l;}  
  //...

  public void draw(){
    p5.ellipse(x,y,3,3);    //Will use PApplet to draw an ellipse.
  }
} 


}
 

using "static" is even uglier and should be avoided. this will cause conflicts if you have multiple applets running at a time and is generally bad practice.

the other model is to pass the PApplet object to the draw() methods of each of the objects. this is often much cleaner. if it's a scene graph, you'll only need to call draw(this) on the topmost object, which can then call draw(parent) on each of its children in the scene graph.

this also prevents the other objects from calling PApplet methods when they're not allowed to (i.e. outside the draw() method, which can cause problems for renderers like opengl).

as marius says, this is indeed simply how oop is done. in the p5 code we get around this (somewhat) by using createImage() and createGraphics(), but it's still frustrating for libraries that we have to pass "this" to the constructor of, say, the Camera or Movie classes.

regarding the createXxxx() method, you could also have a base class that handles creation:

Scene s = new Scene(this);
Vertex c = s.createVertex(x, y, z);
Group gr = s.createGroup();
gr.createBox(x, y, z);
gr.createEllipse(x, y, w, h);
...etc

under this model, this also helps you specify the hierarchy of your objects, where createBox(), having been created by the "Group" object, is a child of that item in the tree.

If I get this right, "Vertex" implies there will always be more than one of these objects created by the user. The user will logically contain them in an array or linked-list for house-keeping if you don't already provide a wrapper for that array.

Why not provide a class which manages the drawing to which a reference of the collection of Vertexes is passed, and let that be the ugly one, freeing up Vertex to be a purer idea.