GLGraphics + Toxiclibs Volumeutils

toxmeister

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

Ricardo, no experience with GLModel, but having my own little VBO class (which is the same underlying mechanism to store meshes as used by GLGraphics). An adapted version (with comments) of the NoiseSurfaceDemo bundled with the library is below:

/*
* Copyright (c) 2010 Karsten Schmidt
*
* This demo & library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* http://creativecommons.org/licenses/LGPL/2.1/
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.volume.*;
import toxi.math.noise.*;
import processing.opengl.*;
import javax.media.opengl.*;
int DIMX=192;
int DIMY=64;
int DIMZ=64;
float ISO_THRESHOLD = 0.1;
float NS=0.03;
Vec3D SCALE=new Vec3D(3, 1, 1).scaleSelf(300);
float currScale=1;
TriangleMesh mesh;
PGraphicsOpenGL pgl;
GL gl;
// used to store mesh on GPU
VBO vbo;
void setup() {
size(1024, 768, OPENGL);
VolumetricSpace volume=new VolumetricSpaceArray(SCALE, DIMX, DIMY, DIMZ);
// fill volume with noise
for (int z=0; z<DIMZ; z++) {
for (int y=0; y<DIMY; y++) {
for (int x=0; x<DIMX; x++) {
volume.setVoxelAt(x, y, z, (float)SimplexNoise.noise(x*NS, y*NS, z*NS)*0.5);
}
}
}
volume.closeSides();
// store in IsoSurface and compute surface mesh for the given threshold value
mesh=new TriangleMesh("iso");
IsoSurface surface=new HashIsoSurface(volume, 0.333333);
surface.computeSurfaceMesh(mesh, ISO_THRESHOLD);
// get opengl related references
pgl=(PGraphicsOpenGL)g;
gl=pgl.gl;
// update lighting information
mesh.computeVertexNormals();
// get flattened vertex array
float[] verts=mesh.getMeshAsVertexArray();
// in the array each vertex has 4 entries (XYZ + 1 spacing)
int numV=verts.length/4;
// create a VBO instance and set buffers from mesh
vbo=new VBO(gl, numV);
vbo.updateVertices(verts);
vbo.updateNormals(mesh.getVertexNormalsAsArray());
}
void draw() {
background(128);
translate(width/2, height/2, 0);
rotateX(mouseY*0.01);
rotateY(mouseX*0.01);
scale(currScale);
// need to switch to pure OpenGL mode first
pgl.beginGL();
glLights();
// render mesh as triangle soup
vbo.render(GL.GL_TRIANGLES);
// back to processing
pgl.endGL();
}
// setup some lights/material for OpenGL
void glLights() {
Vec3D l = new Vec3D(-1000,600,2000);
gl.glEnable(GL.GL_LIGHTING);
gl.glEnable(GL.GL_LIGHT0);
gl.glEnable(GL.GL_COLOR_MATERIAL);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_AMBIENT, new float[]{0.1,0.1,0.1,1}, 0);
gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL.GL_DIFFUSE, new float[]{1,0,0,1}, 0);
gl.glMaterialf(GL.GL_FRONT_AND_BACK, GL.GL_SHININESS, 32);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[] { l.x, l.y, l.z, 0 }, 0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, new float[] { 1, 1, 1, 1 }, 0);
}
void keyPressed() {
if (key=='-') currScale=max(currScale-0.1, 0.5);
if (key=='=') currScale=min(currScale+0.1, 10);
if (key=='s') {
// save mesh as STL or OBJ file
mesh.saveAsSTL(sketchPath("noise.stl"));
}
}

The VBO class is standalone and best kept in its own PDE tab:

/**
* A reusable, barebones wrapper for OpenGL Vertex Buffer Objects. Only
* handles actual vertex, normal and color buffers and assumes they can be dynamically
* modified/updated.
*
* @author Karsten Schmidt <info at postspectacular.com>
*/
import com.sun.opengl.util.BufferUtil;
class VBO {
final int STRIDE = BufferUtil.SIZEOF_FLOAT * 4;
int numVertices;
int[] vertID = new int[] {-1};
int[] normID = new int[] {-1};
int[] colorID = new int[] {-1};
private GL gl;
public VBO(GL gl, int num) {
this.gl = gl;
numVertices = num;
}
public void cleanup() {
gl.glDeleteBuffers(1, vertID, 0);
gl.glDeleteBuffers(1, normID, 0);
gl.glDeleteBuffers(1, colorID, 0);
}
void initBuffer(int[] bufferID) {
gl.glGenBuffersARB(1, bufferID, 0);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, bufferID[0]);
gl.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB, numVertices * STRIDE, null,
GL.GL_DYNAMIC_DRAW_ARB);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, 0);
}
public void render(int shapeID) {
// gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
// check if we need to use normals?
if (normID[0] != -1) {
gl.glEnableClientState(GL.GL_NORMAL_ARRAY);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, normID[0]);
gl.glNormalPointer(GL.GL_FLOAT, STRIDE, 0);
}
// check if we need to use colors?
if (colorID[0] != -1) {
gl.glEnableClientState(GL.GL_COLOR_ARRAY);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, colorID[0]);
gl.glColorPointer(4, GL.GL_FLOAT, STRIDE, 0);
}
gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, vertID[0]);
gl.glVertexPointer(3, GL.GL_FLOAT, STRIDE, 0);
gl.glDrawArrays(shapeID, 0, numVertices);
gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
if (normID[0] != -1) {
gl.glDisableClientState(GL.GL_NORMAL_ARRAY);
}
if (colorID[0] != -1) {
gl.glDisableClientState(GL.GL_COLOR_ARRAY);
}
}
protected void updateBuffer(int id, float[] data) {
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, id);
gl.glMapBufferARB(GL.GL_ARRAY_BUFFER_ARB, GL.GL_WRITE_ONLY)
.asFloatBuffer().put(data);
gl.glUnmapBufferARB(GL.GL_ARRAY_BUFFER_ARB);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, 0);
}
public void updateColors(float[] colors) {
if (colorID[0] == -1) {
initBuffer(colorID);
}
updateBuffer(colorID[0], colors);
}
public void updateNormals(float[] normals) {
if (normID[0] == -1) {
initBuffer(normID);
}
updateBuffer(normID[0], normals);
}
public void updateVertices(float[] vertices) {
if (vertID[0] == -1) {
initBuffer(vertID);
}
updateBuffer(vertID[0], vertices);
}
}

This example produces a mesh of 185,824 triangles. Enjoy!

http://postspectacular.com | http://toxiclibs.org

nardove

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

PURE GOLD! the sketch runs very smooth

From this I guess it may be posible to use GLGraphics GLModel to render a TriangleMesh, I will try it out and report any progress, but this VBO class looks like it does a pretty damn good job

Thanks a lot

- rS

andres

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

Hi, the equivalent code to load the mesh into a GLModel object would be:

import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.volume.*;
import toxi.math.noise.*;
import processing.opengl.*;
import codeanticode.glgraphics.*;
int DIMX=192;
int DIMY=64;
int DIMZ=64;
float ISO_THRESHOLD = 0.1;
float NS=0.03;
Vec3D SCALE=new Vec3D(3, 1, 1).scaleSelf(300);
float currScale=1;
TriangleMesh mesh;
// used to store mesh on GPU
GLModel surf;
void setup() {
size(1024, 768, GLConstants.GLGRAPHICS);
VolumetricSpace volume=new VolumetricSpaceArray(SCALE, DIMX, DIMY, DIMZ);
// fill volume with noise
for (int z=0; z<DIMZ; z++) {
for (int y=0; y<DIMY; y++) {
for (int x=0; x<DIMX; x++) {
volume.setVoxelAt(x, y, z, (float)SimplexNoise.noise(x*NS, y*NS, z*NS)*0.5);
}
}
}
volume.closeSides();
// store in IsoSurface and compute surface mesh for the given threshold value
mesh=new TriangleMesh("iso");
IsoSurface surface=new HashIsoSurface(volume, 0.333333);
surface.computeSurfaceMesh(mesh, ISO_THRESHOLD);
// update lighting information
mesh.computeVertexNormals();
// get flattened vertex array
float[] verts=mesh.getMeshAsVertexArray();
// in the array each vertex has 4 entries (XYZ + 1 spacing)
int numV=verts.length/4;
float[] norms=mesh.getVertexNormalsAsArray();
surf = new GLModel(this, numV, TRIANGLES, GLModel.STATIC);
surf.beginUpdateVertices();
for (int i = 0; i < numV; i++) surf.updateVertex(i, verts[4 * i], verts[4 * i + 1], verts[4 * i + 2]);
surf.endUpdateVertices();
surf.initNormals();
surf.beginUpdateNormals();
for (int i = 0; i < numV; i++) surf.updateNormal(i, norms[4 * i], norms[4 * i + 1], norms[4 * i + 2]);
surf.endUpdateNormals();
surf.initColors();
surf.beginUpdateColors();
for (int i = 0; i < numV; i++) surf.updateColor(i, 255, 0, 0, 225);
surf.endUpdateColors();
}
void draw() {
background(128);
translate(width/2, height/2, 0);
rotateX(mouseY*0.01);
rotateY(mouseX*0.01);
scale(currScale);
// need to switch to pure OpenGL mode first
GLGraphics glg = (GLGraphics)g;
glg.beginGL();
pointLight(255, 0, 0, -1000, 600, 2000);
ambientLight(25, 25, 25);
lightSpecular(255, 255, 255);
glg.model(surf);
// back to processing
glg.endGL();
}
void keyPressed() {
if (key=='-') currScale=max(currScale-0.1, 0.5);
if (key=='=') currScale=min(currScale+0.1, 10);
if (key=='s') {
// save mesh as STL or OBJ file
mesh.saveAsSTL(sketchPath("noise.stl"));
}
}

One limitation at this point in GLGraphics is the light/material configuration. I was not able to reproduce the surface material from the original example, only using the functions available in GLGraphics/GLModel. I'll let you know if there is an update on this.

andres

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

The issues with lighting are basically due to some constraints built into the implementation of the lighting API in GLGraphics. I thought for a while about this, and for the time being, the best solution is just to override Processing/GLGraphics lighting altogether and use OpenGL calls to setup lights and material properties.

I uploaded a new test release of GLGraphics that includes a Toxiclibs integration example, showing how to properly set the lights to get the correct material appearance. Some more details in this post.

nardove

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

AWESOME! you just save me a few headaches, I will make a more dynamic example, something that change the geometry over time and post it here later

Many thanks

- rS

nardove

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

Hi Andres,

In your example sketch you build the GLModel surf in setup from static values, but I wonder how can I do it for a dynamic surf like in the toxi.volume.AnimatedNoise Demo, I see I can create the GLModel like

// compute volume mesh values first then do
surf = new GLModel( this, numV, GLModel.TRIANGLES, GLModel.STREAM );
surf.beginUpdateVertices();
...

I believe this has to be done in the draw() method of course but I wonder if there is something else I need to do to the surf GLModel object to avoid I dont know memory leaks, or framerate overkill?

What would you recommend?

Thanks

- rS

andres

Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

Creating the GLModel object as GLModel.STREAM (in setup(), not in draw()) should be all you need to do. Everything else is the same.

pixelpush..

Re: Re: GLGraphics + Toxiclibs Volumeutils

2 years ago

Thanks for the code, very helpful, but poking around I found an issue here - the reference for getMeshAsVertexArray() is:

"Creates an array of unravelled vertex coordinates for all faces using a stride setting of 3, resulting in a gap-less serialized version of all mesh vertex coordinates."

but looking at the code it is actually a stride setting of 4?

Also please look at this follow-up post:
https://forum.processing.org/topic/trianglemesh-and-glmodel-problems

Many thanks,
Evan

nootropic..

Re: GLGraphics + Toxiclibs Volumeutils

1 year ago

i've tried with this VBO class to reproduce "standard" light system.. the same that you obtain with lights() command in processing. but i didn't manage to do it correclty. someone can point me some advices?

aufsess

Re: GLGraphics + Toxiclibs Volumeutils

1 year ago

Thanks for the great info in this thread and both of these libraries.

Will porting my sketch to 2.0 give me the some performance benefits as GL Graphics?

I'm trying to find some advice about how to proceed to access some of the performance improvements that GL Graphics provides. Basically I'm rendering colored and textured meshes with high face counts and was wondering whether porting to processing 2.0 will give me the same performance benefits as implementing GL Graphics in 1.5? I'm also using the offscreen buffer to create a second window.

Furthermore, also using Toxiclibs, Control P5, Syphon (which I know has issues in 2.0 with my graphics card) or Keystone.

Any advice is appreciated.

Thanks!

andres

Re: GLGraphics + Toxiclibs Volumeutils

1 year ago

Most of the performance improvements in GLGraphics due to the GLModel class should be available through PShape (take a look at the retained examples in the opengl/Performance category) in Processing 2.0.