Radial VDM, Sobel Normalmap

OK, time for some explanation:
These are meshes created using ‘Vertex Displacement Mapping’. The displacement image used to create the distorted sphere form is behind each mesh. I’ve experimented with this technique before (and been less-than-impressed by the resulting framerates), but this time I’ve tried to add lighting by using a normal map in the Fragment shader. Normal map creation is also something I’ve tried before, but this time I tried a different method of creating it, based on modified Sobel filter code Desaxismundi very kindly sent me. I’m not altogether pleased with the results, which show a lot of ’stepping’, but it’s an interesting experiment.

The first set of five snaps use simple, diffuse-only lighting. With the others, I’ve implemented the velvet lighting effect I mentioned in a previous post. Looks a bit odd on a ’spiky’ form. More crystalline than soft and velvetty, I think, but it’s still a nice look. I’ll try a version with Phong lighting too, but I want to produce a set of portable, generalised Phong lighting Vertex and Fragment shader functions that I can easily apply to other projects, rather than just hacking-together something that works for this specific case.

Accidental Niceness

I was experimenting with a adding surface texture to the Paraboloid Spread shader, and pushed one of the parameters further than I usually would. The result was really cool!

What’s actually happening is that I’ve added a repeating pattern to the surface of each individual mesh strip. There’s a control for the size of each texture ’tile’, and in this case, I’ve set this all the way up to 1.0. This stretches the tile image (in this case a blurry circle) to fill the whole area of the mesh, blurring it in the process. Setting the mesh blending mode to Add melds the meshes together, giving this fiery, explosion-like effect.

The fifth pic there was the result of another happy accident, when I set the tiling surface pattern for the mesh to an image input, but neglected to connect anything to it, resulting in a really nice glitchy noise-type effect, that flashes on and off in a really cool way.

Kineme SuperGLSLGrid

I’ve been helping test an exciting new Quartz Composer plugin for Christopher Wright of Kineme.net.

The concept is very simple:
What it does, is allow you to set uniform variables in a GLSL shader on a per-mesh basis. Usually, uniforms are identical for every mesh inside a GLSL Shader patch, but with this plugin, you can do all kinds of cool stuff- for example, you can create 64 separate meshes, with individual Color, Scale and Position properties. This is how I managed to create the ‘Pseudospreads’ screenshots.

Currently, there’s only one ‘Super’ plugin- a VBO-based grid, similar to the builtin GLSL Grid patch. The plan is to eventually add other primitives (Sphere, Cube, Cylinder, Cone etc.).

It’s still in beta at the moment, but so far it seems very stable. As soon as it’s publicly available, I’ll post a link to it, and also post some of my experimental QTZs that make use of it.

Pseudospreads, Steinbach Screw

Pseudospreads, Helicoid

Pseudospreads, Paraboloid

Same technique, different surface formula:

Patching Marathon (Pt.x)

It turns out the builtin Iterator patch is ridiculously inefficient, necessitating this kind of nonsense to get decent performance-
64 identical macros.

You can see why I was anxious to develop a way of connecting all the controls inside each macro with a single cable…!

Each macro has one connection, and has to have one unique ID number set, so even with structure-based one-cable connection, it takes a good ten RSI-risking minutes or so to set all 64 up.

Hope Apple sort out the issues with the Iterator patch soon! Currently I get about twice the framerate doing things this way.

JavaScript & Single-Cable Connection

While messing around with the composition that generated the screenshots below, I decided I needed a way of connecting macro modules together using a single virtual cable, rather than a separate one for each parameter I needed to pass in. JavaScript seemed the best way to do this. The code below takes 2 inputs, and creates an output structure.

function (__structure outputStruct) main (__number parameter0, __number parameter1)
{
	var result = new Object();
	__structure params = new Object();

	if(!_testMode) {
		params["param0"]=parameter0;
		params["param1"]=parameter1;
	}

	result.outputStruct = params;
	return result;
}

This single output can then be passed to multiple Structure Key Member patches in the destination macro, to extract the parameter values from the structure. Saves a lot of patching time when you’re wiring up, for example, 64 identical macros.

I’ve added a little example composition to my Box.net download widget. Very unexciting, I’m afraid, but you may find it useful….

More Pseudospreads

Still, as ever, playing catchup with the geniuses of the VVVV community, so this is nothing you can’t do MUCH more easily with VVVV. Quite pleased with the results so far though….

The challenge now is to create a set of controls that make sense. As it is, there are too many different parameters, and the way they interact with each other isn’t entirely obvious.

I’ve also been trying to modularise things as much as possible, so I can more easily plug-in different vertex-displacement formulae (this one is called ‘The Bow’). I’ll probably eventually get around to trying it with the SuperFormula and Spherical Harmonics vertex shaders, just to catch up with where Sanch and co. were two years ago!

Maths Surfaces Lighting

I’ve just realised something that’s been blindingly obvious all along- namely that the lighting on the Maths Surfaces shaders (all 55 of them) goes the wrong way (ie, it’s DARKER, rather than lighter nearer the position of the light-source).

This is a bit annoying, because now I’ve finally spotted it, I’ll have to fix it….

I’m not sure whether to go for just fixing the current simple shading model (as above), or to go for the whole lookup table and surface texture tiling setup, as used on the Spherical Harmonics shader.

The second option is probably best, but does require an awful lot of copying, pasting, input-publishing and patching, unfortunately.