This is a pixelshader that takes depth and outputs a new depth and normals that represent the scene made up of voxels. This can be useful for giving bone-animated objects a voxel style look. (animating with voxels is bothersome). It could also be applied to complete scenes. The “popping” that is visible at the silhouette of the object is hard to hide with a rotating perspective camera. It would be absent seen trough an orthographic non-rotating camera. I still have to fix the black separation lines that are sometimes visible.

It roughly works like this:
-Every screen pixel will belong to a cube (a cube can contain multiple pixels).
-Each cube needs to be completely drawn (the tricky part- because the silhouette of the object(s) will change).
-a pixel samples a number of pixels in an area that should be about as big as the biggest cube you would expect.
-since the screen-area of a cube can be very large (say 64 * 64 = 4096 pixels) it is impossible to sample all pixels in that area to search for a cube that could be occluding the current pixel. So for a single pixel there is a high error rate (it misses cubes that would be occluding itself), but this is solved later.
-It is sampling with a grid with a spacing of 16 pixels. (in one axis 1 out of 16 pixels is sampled)
-it does a ray-cast against every samples containing cube. The front-most hit is used as the new depth.
-at this moment a lot of cubes are only half drawn, or are represented by a few floating pixels.
-then a pass is run a number of times (the number depends on the spacing of the sampling grid in the first pass) which grows the cubes.
-1 pixel could become 3*3 pixels in 1 pass, if it is part of the front-most cube along that pixels ray.
-because this step is repeated, a cube which was only represented by a few pixels can grow to a complete cube.
-after this pass, all holes are filled, and the silhouette of the object has been changed.

This is a shader that mimics boolean mesh operations in the pixel shader. It is very fast ( ~ 200 subtractive meshes @ 60+ fps on my system).
The result of the operations is not completely correct, but looks believable enough. Best results are obtained when the operands are convex. Because it runs on the pixel-shader, the system is not influenced by mesh topology, polygon density, etc.

It roughly works like this:
For each mesh do:

1st pass:
-render front-face depth to rendertarget texture y-channel
-render back-face depth to rendertarget texture x-channel
(with culling off and additive blending, this can be done in 1 pass)

2nd pass:
-send a boolean variable to the hlsl code, indicating if the current object is additive or not.
-render the object again. (this time with culling on ) This is done because the pixelshader doesn’t need a full-screen quad, but only the coverage of the mesh. This is a big speed-gain.
-compare xy to zw of the rendertarget texture (zw is empty the first iteration of the loop)
-do the boolean operations, and write the result to the zw channels. See code below.

repeat.

When all meshes are processed, the w-channel represents the depth of the front-face of the resulting object, and the z channel represents the depth of the back-face, but that is only needed for the boolean operations.

The first pass of the hlsl code:


float4 PS_Depth(VSOut In, float faceValue : VFACE) : COLOR
{
float depth = In.color.x; //the vertex-shader outputs depth in the color channel

if (faceValue < 0){ //faceValue < 0 means backfacing, > 0 means front-facing
return float4 (depth , 0,0,1);
}else{
return float4 (0, depth ,0,1);
}
}


The second pass of the hlsl code :


float4 PS_Boolean(VSOut In, float2 pixelPos:VPOS) : COLOR
{
float2 ScreenUV = (pixelPos.xy * uvStep) + (uvStep * 0.5f); //get the screen-space texture-coordinates
float4 currentState = tex2D(resultSampler, ScreenUV); //read from the output of the previous pass

if (isSubstractive){
//-----back face--------------
if (operand.y > currentState.z){
if (operand.x < currentState.z){
sum.x = operand.y;
}
}
//-----front face--------------
if (operand.y > currentState.w){
if (operand.x < currentState.w){
if (operand.x < currentState.z){
sum.y = 0;
}else{
sum.y = operand.x;
}
}
}
}else{
sum.y = max (currentState.w, operand.y);
if (currentState.z > 0){
sum.x = min (currentState.z, operand.x);
}else{
sum.x = operand.x;
}
}
return float4 (0,0,sum);
}


The biggest caveat with this method, is that the texture containing the resulting shape, only stores the front-face and the back-face, so all information between these two is lost.

angular extrude from johan holwerda on Vimeo.

shader based sphere renderer from johan holwerda on Vimeo.

This is a pixelshader that draws spheres on pointsprites. This allows the spheres to be perfectly round, and to have a lot of them in view in realtime.
They intersect as though they are spheres (and not like the planes which they are drawn on). This is done by rendering the sprites to the depth-buffer as though they were spheres.

Here’s the pixel-shader code :
-first render point-sprites, and let the vertex-shader pass their depth to the pixel-shader.


void PS_ShowDepth(VS_OUTPUT input, out float4 color: COLOR0,out float depth : DEPTH)
{
float dist = length (input.uv - float2 (0.5f, 0.5f)); //get the distance form the center of the point-sprite
float alpha = saturate(sign (0.5f - dist));
sphereDepth = cos (dist * 3.14159) * sphereThickness * particleSize; //calculate how thick the sphere should be; sphereThickness is a variable.

depth = saturate (sphereDepth + input.color.w); //input.color.w represents the depth value of the pixel on the point-sprite
color = float4 (depth.xxx ,alpha ); //or anything else you might need in future passes
}


particle glitch from johan holwerda on Vimeo.

Pretty error.

XNA3Editor 2010-12-10 11-02-28-92 from johan holwerda on Vimeo.