Hi,

I'm at the point of finishing a library that imports vector images and holds them in Processing objects.
It's a bit like yours but for 2D stuff.

I ran in to the same problem as you, and I chosed the following solution.

When we want to draw a model (or in my case a 2D vector image) what we really need to specify is what PGraphics object to draw it to.

So instead of your code I used:

Code:

Ex3D modelo = new Ex3D(filename);
modelo.draw(g);
 

this would be the case we want to draw our model in the applet's default graphics object or canvas.  But it would also allow us to draw our image in any graphics object we want, which I think gives us is more flexibility.  And I don't think this really is an overhead to newbies, since in any of the ways they must remember something (in your case to pass "this" as parameter and in my case to pass "g" as parameter).

This means when creating your library class you'll need to have a function that looks like the following:

Code:

import processing.core*;

public class Ex3D{

  public void draw(PGraphics gfx){
    // change colors, call smooth, draw tristrips or whatever, maybe something like this...
    gfx.beginShape(TRI_STRIP);
	// gfx.vertex() the points of your model ...
    gfx.endShape();
    // change back the colors to normal...
  }
 

I wouldn't call any specific methods of OPENGL as a requirement.  I would rather add those inside a "try catch statement" or by seeing if the gfx object passed as argument is of type PGraphicsGL.  And would try to keep the option of loading and drawing 3D models with the other 3D renderers.  Because maybe someday someone writes a 3D recorder and this would still be compatible with the Processing API. In my opinion this would give longer life and wider use to your library.

But of course these are just suggestions and any library you make is more than welcome!!!

thanks
ricard

Hi again,

Quote:


I think this is a good method when for example loading files that will be in the data folder. Since without the PApplet we cannot access such path.  So I still think it will be necessary in the Ex3D case.

On the other hand, you just gave me a good idea on what to do with my library.  I think it will be better to have the 'new Whatever(this)' format in all constructors, and have a draw() method without parameters when wanting to draw in the main canvas and a draw(PGraphics gfx) when wanting to draw on a specific canvas, we shouldn't limit the user.

Although a library with many different classes from very primitive to more high-level, it can mean a lot of overhead for the user (e.g. every time we want an instance of a point calling RPoint(this,x,y) can be a little bit cumbersome). I'm not really sure.

I still think that making a library for a specific specific renderer is very limiting, and there's always the possibility of checking (as JohnG says) if the PGraphics is instance of PGraphicsGL every time we want to use specific OpenGL functions, and try to have an alternative for the other renderers, even if the alternative is to throw an exception saying that the alternative is not yet implemented,

Hope this helps

Hey again,

I've researched this a bit more, and it turns out this library will be built for OpenGL alone. Too many problems would arise if I was to do it and try have all renderers support it, (or at least from what I can tell).

So with your help I made this very simple library to just draw some vertices onto Processing's existing gl object. However it just doesnt seem to do anything. Am I meant to call a redraw method or something similar?

My basic code for the library:
Code:

package ex3d;

/* import core processing libs */
import processing.core.*;
import processing.opengl.*;

/* standard includes */
import net.java.games.jogl.*;
// JOGL

public class Ex3D
{
  public PApplet parent;
  public GL gl;
  
  public Ex3D(PApplet _parent)
  {
    parent=_parent;

    this.gl = ((PGraphicsGL)parent.g).gl;
  }
  
  public void draw()
  {
// tried translate here and in P5

  this.gl.glTranslatef(1.5f,0.0f,-6.0f);

  

   this.gl.glBegin(GL.GL_QUADS);

     this.gl.glColor3f(1.0f,1.0f,-1.0f);

     this.gl.glVertex3f(1.0f,-1.0f,-1.0f);

     this.gl.glVertex3f(-1.0f,-1.0f,-1.0f);

     this.gl.glVertex3f(-1.0f,1.0f,-1.0f);

     this.gl.glVertex3f(1.0f,-1.0f,-1.0f);

   this.gl.glEnd(); 
  
  }
  
// just testing here to see if i needed to reset gl object :/
  public void end()
  {

  ((PGraphicsGL)parent.g).gl = this.gl;
  }
}
 

Example call from P5:
Code:

Ex3D my_x3d;

void setup()
{
...
  my_x3d = new Ex3D(this);
...
}

void draw()
{
  my_x3d.draw();
  //my_x3d.end();
}
 

I basically get a blank window, without the front face of a quad as should appear. I really appreciate any help anyone can give. Cheers

Oooook. That's not good news at all. I would have to use OpenGL commands if I was able to apply bump mapping / cel shading effects.

Has anyone any idea what I can do? Using the built in Processing functions will severely drop this projects functionality (and grade) :/

Or is my best chance now to make a new canvas or something? I don't know the core code in processing well enough to know this now, so if anyone has any ideas...

Having had a bit more thought, here's what I thin can/can't be used.

Anything that would change the position on screen something would be drawn, or glVertex, will either not work, or have an effect different to that you think it should.

Anything that requires any special GL capabilities may or may not work.

Other things, like glTexture may work, if you don't then specify a texture with the processing syntax. And you should be able to mix that with processing beginShape() and vertex etc.

using processing as an opengl (jogl) programming environment is likely to be really frustrating, since it's not designed that way, and we're not going to do anything to make it easier to program that way. if you really want to do a lot of opengl-oriented things, i recommend just using jogl with a regular java ide.

hey ben. that sounds really discouraging, a 'lack of color'. i think it is cool to use opengl in processing and there are a few things that can be done to make it a bit easier as i wrote on another tread. it just still might be an even hotter beverage

i always felt that it was the strength of processing to range from super-simple to hardcore. this notion is always worth encouraging, where possible.

the thing about opengl is that there is quite a lot to be learned about computergraphics and the related math before one can 'really' use it. that is not always obvious with opengl.