Rendering spheres (or points) in a particle system

Question

I am using the Three.JS library to display a point cloud in a web brower. The point cloud is generated once at start up and no further points are added or removed. But it do

Answer 1

When comparing my code to http://threejs.org/examples/#webgl_custom_attributes_particles3 I saw the only difference was:

vec4 outColor = texture2D( texture, gl_PointCoord );
if ( outColor.a < 0.5 ) discard;
gl_FragColor = outColor;

Added to the fragment shader, fixed this problem for me.

It wasn't z fighting because randomly, some corners would overlap distant particles. material.alphaTest = 0.5 didn't work and turning off depth writes/tests messed up the viewing order.

Answer 2

The problem with the image is that when you have thousands of points it seems they sometimes obscure each other around the edges. From what I can gather it seems like the black region in a point's png file blocks the image immediately behind the current point. (But it is transparent to points further behind)

You can get rid of the transparency overlapping problem of the underlying square structure by turning

depthTest:false

The problem then is, if you are adding additional objects to the scene the depth-testing will fail and the PointCloud will be rendered in front of the other objects, ignoring the actual order. To get around that you can additionally turn off

depthWrite:false

Answer 3

I don't think rendering a point cloud with spheres is very efficient. You should be able to get away with a particle system and use a texture or a small canvas program to draw a circle.

One of the first three.js sample uses a canvas program, here are the important bits:

var PI2 = Math.PI * 2;
var program = function ( context )
{
    context.beginPath();
    context.arc( 0, 0, 1, 0, PI2, true );
    context.closePath();
    context.fill();    
};
var particle = new THREE.Particle( new THREE.ParticleCanvasMaterial( {
    color: Math.random() * 0x808008 + 0x808080,
    program: program
} ) );

Feel free to adapt the code for the WebGL renderer.

Another clever solution I've seen in the examples is using an encoded webm video to store the data and pass that to a GLSL shader which is rendered through a particle system in three.js

If your point cloud comes from a Kinect, these resources might be useful:

1. DepthCam
2. KinectJS