Nice graphic software, i think i will use it on my articles also….

You made some good points there. I did a search on the super topic and found most people will agree with your blog Extra website Ezines Links Thanks!….

Have fun….!

REALLY MANY THANKS!!!

import com.sun.opengl.util.BufferUtil;
import javax.media.opengl.*;
import com.sun.opengl.util.texture.*;
import java.io.*;
import java.net.URL;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;

public class LocalizeFog {

private String path;
private float angle;
private IntBuffer indiceBuffer;
private Texture texture;
private FloatBuffer colorBuffer;
private FloatBuffer vertexBuffer;
private FloatBuffer test;
private boolean completed;
public Life particule[];
public static int tailleGlobal = 4000;
public static boolean negFog = false;
public static boolean show = true;
public Wind wind;
public static int nbtoDraw;

public LocalizeFog(GL gl, int numParticles) {
vertexCount = numParticles;
this.path = “images/ellipse.png”;
wind = new Wind();
loadTexture();
newList();
vertexPipe(gl);
texturePipe(gl);
indexPipe(gl);
colorPipe(gl);
completed = true;
}

public void updateXYZ() {
wind.updateWind();
for (int i = 0; i < nbtoDraw; i++) {
particule[i].update();
}
}

public void constrainNBDraw() {
if (nbtoDraw > vertexCount) {
nbtoDraw = vertexCount;
}
}

// GL_ONE_MINUS_SRC_ALPHA
// GL_CONSTANT_ALPHA
// GL_DST_ALPHA
public void drawPipe(GL gl) {
if (completed && show && nbtoDraw > 0) {
constrainNBDraw();
updateXYZ();
vertexPipe(gl);
colorPipe(gl);
gl.glEnable(GL.GL_TEXTURE_2D);
gl.glDisable(GL.GL_DEPTH_TEST);
gl.glEnable(GL.GL_BLEND);
gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_CONSTANT_ALPHA);
if (!negFog) {
gl.glBlendEquation(gl.GL_FUNC_REVERSE_SUBTRACT);
} else {
gl.glBlendEquation(gl.GL_FUNC_ADD);
}
gl.glEnableClientState(GL.GL_COLOR_ARRAY);
gl.glColorPointer(4, GL.GL_FLOAT, 0, 0);

/////////////////////////////////////////
gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER, VBOTexture[0]);
/////////////////////////////////////////
//gl.glTexEnvf(gl.GL_TEXTURE_2D, gl.GL_ALPHA_SCALE, 0.1f);
gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER, VBOVertices[0]);
/////////////////////////////////////////
//gl.glEnableClientState(GL.GL_COLOR_ARRAY);
//gl.glColorPointer(4, GL.GL_FLOAT, 0, 0);
/////////////////////////////////////////
gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
/////////////////////////////////////////
//gl.glAccum(gl.GL_ACCUM, 0.01f/i);
// Draw All Of The Triangles At Once
//gl.glDrawElements(GL.GL_POLYGON, 5, GL.GL_UNSIGNED_INT, indiceBuffer);
gl.glDrawArrays(GL.GL_QUADS, 0, nbtoDraw);
// Disable Texture Coord Arrays
/////////////////////////////////////////
gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);
gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
gl.glDisableClientState(GL.GL_COLOR_ARRAY);
/////////////////////////////////////////
gl.glDisable(GL.GL_BLEND);
gl.glEnable(gl.GL_DEPTH_TEST);
//gl.glDisable(GL.GL_TEXTURE_2D);
}
}
//////////////////////////////////////////////////////////////////////////////
private int[] VBOVertices;
private int[] VBOTexture;
private int[] VBOIndice;
private int[] VBOColor;
public int vertexCount;

public void newList() {
//nbtoDraw = vertexCount;
particule = new Life[vertexCount];
for (int i = 0; i < vertexCount; i++) {
particule[i] = new Life();
}
//////////////////////

}

public void vertexPipe(GL gl) {
vertexBuffer = BufferUtil.newFloatBuffer(3 * 4 * vertexCount);
for (int i = 0; i < vertexCount; i++) {
////////////////////////////
//Math.cos(xyz[i].x);
vertexBuffer.put(particule[i].x - particule[i].taille);
vertexBuffer.put(particule[i].y - particule[i].taille);
vertexBuffer.put(particule[i].z);
////////////////////////////
vertexBuffer.put(particule[i].x + particule[i].taille);
vertexBuffer.put(particule[i].y - particule[i].taille);
vertexBuffer.put(particule[i].z);
////////////////////////////
vertexBuffer.put(particule[i].x + particule[i].taille);
vertexBuffer.put(particule[i].y + particule[i].taille);
vertexBuffer.put(particule[i].z);
////////////////////////////
vertexBuffer.put(particule[i].x - particule[i].taille);
vertexBuffer.put(particule[i].y + particule[i].taille);
vertexBuffer.put(particule[i].z);
}
vertexBuffer.flip();
////////////////////////////////////////////
if (VBOVertices == null) {
VBOVertices = new int[1];
gl.glGenBuffersARB(1, VBOVertices, 0);
}
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER, VBOVertices[0]);
gl.glBufferDataARB(GL.GL_ARRAY_BUFFER, vertexCount * 3 * 4 * BufferUtil.SIZEOF_FLOAT, vertexBuffer, GL.GL_STREAM_DRAW);
/////
}

public void texturePipe(GL gl) {
FloatBuffer textureBuffer = BufferUtil.newFloatBuffer(4 * 2 * vertexCount);
for (int i = 0; i < vertexCount; i++) {
textureBuffer.put(0.2f);
textureBuffer.put(0.2f);
textureBuffer.put(0.8f);
textureBuffer.put(0.2f);
textureBuffer.put(0.8f);
textureBuffer.put(0.8f);
textureBuffer.put(0.2f);
textureBuffer.put(0.8f);
}
//////////////////////////////
textureBuffer.flip();
//////////////////////////////
if (VBOTexture == null) {
VBOTexture = new int[1];
gl.glGenBuffersARB(1, VBOTexture, 0);
}
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER, VBOTexture[0]);
gl.glBufferDataARB(GL.GL_ARRAY_BUFFER, vertexCount * 2 * 4 * BufferUtil.SIZEOF_FLOAT, textureBuffer, GL.GL_STATIC_DRAW);
//////
}

public void indexPipe(GL gl) {
indiceBuffer = BufferUtil.newIntBuffer(4 * vertexCount);
int count = 0;
for (int i = 0; i < vertexCount; i++) {
indiceBuffer.put(count++);
indiceBuffer.put(count++);
indiceBuffer.put(count++);
indiceBuffer.put(count++);
}
indiceBuffer.flip();
///////////////////////////////////
if (VBOIndice == null) {
VBOIndice = new int[1];
gl.glGenBuffersARB(1, VBOIndice, 0);
}
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER, VBOIndice[0]);
gl.glBufferDataARB(GL.GL_ARRAY_BUFFER, vertexCount * 4 * BufferUtil.SIZEOF_INT, indiceBuffer, GL.GL_STATIC_DRAW);

}

public void colorPipe(GL gl) {
colorBuffer = BufferUtil.newFloatBuffer(4 * 4 * vertexCount);
for (int i = 0; i < vertexCount; i++) {
for (int n = 0; n < 4; n++) {
colorBuffer.put(particule[i].getA());
colorBuffer.put(particule[i].getA());
colorBuffer.put(particule[i].getA());
colorBuffer.put(particule[i].getA());
}
}
colorBuffer.flip();
///////////////////////////////////
if (VBOColor == null) {
VBOColor = new int[1];
gl.glGenBuffersARB(1, VBOColor, 0);
}
gl.glBindBufferARB(GL.GL_ARRAY_BUFFER, VBOColor[0]);
gl.glBufferDataARB(GL.GL_ARRAY_BUFFER, vertexCount * 4 * 4 * BufferUtil.SIZEOF_FLOAT, colorBuffer, GL.GL_STREAM_DRAW);
}

public void loadTexture() {
try {
ClassLoader c1 = this.getClass().getClassLoader();
URL url = c1.getResource(path);
texture = TextureIO.newTexture(url, true, null);
System.out.println(”Texture as been loaded : ” + url.getPath());
} catch (IOException e) {
e.printStackTrace();
} catch (GLException e) {
e.printStackTrace();
}

}
// gl.glGenTextures(1, textureId, 0);
// gl.glBindTexture(GL.GL_TEXTURE_2D, textureId[0]);
// gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
///gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
//gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, 4, texture.getImageWidth(), texture.getImageHeight(), 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, texture.);
}

What really interests to me are the techniques you used to create this effect…
Did you use particle system with texture? Have you implemented a sort of metaball post effect ?!

I really wish you could tell more of post some code…

THANKS AND COMPLIMENTS !!!

Regards.

VERY NICE INDEED :)