It looks like the lights value is set to a certain color instead of this color being added. This could fix yor problem.
If you can not add the lights color, try to use the alpha channel with a value arround 0.5

Light effects are usually not blended by using the source alpha blending, i.e. src_RGB * src_A + dst_RGB * ( 1 - src_A ). Instead, it uses additive blending as in src_RGB * src_A + dst_RGB (i.e. there is no weighting of the original destination color other than with 1.0). If possible (e.g. when using a texture) the source should be pre-multiplied, so that src_RGB + dst_RGB would be used.

Similarly, shadow effects are usually done by using dst_RGB - src_RGB * src_A (or else dst_RGB - src_RGB if the source is pre-multiplied).

As soon as you use dst_RGB * ( 1 - src_A ) you're canceling out (or at least weakening) the original lighting.

OK so now colors bleed into each other..but only the only problem is that the colors are all drawn in in a different layer than the shapes.
Its really weird and i cant really describe it.
[media]

[/media]

Colors from light sources merge but now there is only one light source with (multiple light sources inside) and for some reason my shapes disappear when my light source isn't near them.
This is really getting frustrating.


To me , it looks like i drew everything into one buffer and im only looking at a portion of it the entire image.
Is there anyway to blit the entire buffer to the screen?

Here is the source:

public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT |GL.GL_DEPTH_BUFFER_BIT );
gl.glEnable (GL.GL_BLEND);
gl.glBlendFunc (GL.GL_SRC_ALPHA, GL.GL_ONE);
//gl.glBlendFunc(GL.GL_DST_ALPHA, GL.GL_ONE);*/
gl.glDisable(GL.GL_CULL_FACE);
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glLoadIdentity();
gl.glMatrixMode(GL.GL_TEXTURE);
gl.glLoadIdentity();
//System.out.println(Distance);
setCamera(gl, glu,Distance);

for(int J = 0 ; J < ray.length ; J++){

//this.BlendON(gl);
ray[J].RenderLight(gl);
//this.BlendOFF(gl);
gl.glBlendFunc(GL.GL_DST_ALPHA, GL.GL_ONE);
for(int K = 0 ; K < shape.length;K++){
shape[K].RenderShape(gl,ray[J]);
caster.getCastPoints(shape[K], ray[J], gl);//<---CASTS SHADOWS
shape[K].ClearLists();// this is here because i was to lazy to do it inside class
}
for(int K = 0 ; K < shape.length;K++){
shape[K].RenderShape(gl,ray[J]);
shape[K].ClearLists();
}
}




//try {Thread.sleep(30);} catch (InterruptedException e) {e.printStackTrace();}

}


[font="verdana"]Multiply: X = 1/255 (U*L)[/font]
[font="verdana"] [/font]
[font="verdana"]Multiply mode multiplies the pixel values of the upper layer with those of the layer below it and then divides the result by 255. The result is usually a darker image. If either layer is white, the resulting image is the same as the other layer (1 * L = L). If either layer is black, the resulting image is completely black (0 * L = 0). Note: the mode is commutative; the order of the two layers doesn't matter.[/font]
[font="verdana"]
[/font]
[font="verdana"]In the next installment, we'll look at the Screen Blending Mode. Future postings will include a look at Soft Light and Difference Blending Modes as well as providing a list of references for further details on this complex subject.[/font]
[/quote][font="verdana"] [/font]
[font="verdana"] [/font]
[font="verdana"]Now I'm not an opengl programmer, but with Direct3d I've done this using shaders pretty easily.[/font]