Prerequisites

Menus

Navigating with the Camera (mouse and keyboard)

Writing the Animation Script

udSetup(HWND hWnd, float *ud, float *pram, int *ct, char *dbug){
	SAVE_SETUP_POINTERS //this saves the parameters for use globally, they are read/write arrays
	//"g_hWnd" is the trace window handle so you can mimic key presses
	//SendMessage(g_hWnd,0x100,'X',0);//sends the stop capture key
	//"udef" is an array of 32 floats that are sent to the shaders. You define what these mean.
	//"param" is an array of floats from the app. There are #defines for each TIME, MAX_DEPTH etc.
	//"cnt" is an array of integers from the app. There are #defines for these as well WIDTH, HEIGHT etc. 
	//"debug" is a char array (MAX_PATH) for writing to the debug window
	sprintf(debug, "Hello World of Fractal Animation - the dimensions are %i %i",WIDTH, HEIGHT);
}
udPre(unsigned char *tex, float *replay){
	//CHECK tex!=NULL BEFORE USING. It is only available when a texture is assigned to this layer
	//tex - is a 32bit bitmap with BGRA values that can be accessed with a texture2D call in frag shader
	if(tex)tex[((TEX_HEIGHT/2)*TEX_WIDTH+TEX_WIDTH/2)*4+1]=255;//I just made a green dot in the middle of the screen.
	//replay - this is the camera position data and timing (ALL DATA POINTS)
	//replay[RP_POS+0],1,2=x,y,z,3=time,4-7=rotation quaternion
	replay[RP_POS+MNDT_FLOATS+1]+=sin(replay[cnt[2]+3]);//I am adding bumpiness to the next y value 
}
udPost(){
	//this is where you can read the color or depth values (see file autofocus.anim for an example)
}
udPostFrame(unsigned char *pix, int *cnt, char *debug){
	//pix is a 24 bit BGRA bitmap (NOTICE THE BIT DEPTH HAS CHANGED, NO ALPHA DATA AS THIS IS FOR OUTPUT)
	for(int y=0;y!=HEIGHT;y++)for(int x=0;x!=WIDTH;x++){
		int accum=pix[(y*WIDTH+x)*3];
		accum+=pix[(y*WIDTH+x)*3+1];
		accum+=pix[(y*WIDTH+x)*3+2];
		accum/=3;
		pix[(y*WIDTH+x)*3]=accum;
		pix[(y*WIDTH+x)*3+1]=accum;
		pix[(y*WIDTH+x)*3+2]=accum;//black and white now
	}
}
udResize(){
	//WIDTH=new width, HEIGHT=new height, resize any allocated buffers
}
//to pass variables between functions just make them global
unsigned char *myTextureBuffer=NULL;
udShutDown(){
	if(myTextureBuffer)free(myTextureBuffer);//this is only called once so don't need to set it to NULL
}

The predefined variables are:
(integers)
LAYER = The current layer being drawn.
WIDTH = The width of the output image.
HEIGHT = The height of the output image.
TEX_Width = The width of this layer's texture image.
TEX_HEIGHT = The height of this layer's texture image.
RP_START = The camera replay start index. (typically but not always zero)
RP_POS = The current camera replay position.
RP_END = The last camera replay position.
MNDT_FLOATS = The number of floats in each camera position (12) x,y,z,time,qrotx,qroty,qrotz,qrotw,udef0,udef1,udef2,udef3
SUPERSAMPLING = 0 if regular render, 1=second supersampled render (don't animate twice)
FPS = The number of frames per second for the output AVI. Time accordingly.
REBIND_TEXTURE = 1 tells the app you have changed the texture so it needs re-binding.
JUMP_LAYERS = Tells the app how many layers to skip over. -1=redo this layer. 0=proceed normally
(floats)
CAM = The x,y,z position of the camera.
CAM_QUAT = The quaternion rotation of the camera. See animandel.h for quaternion math.
TIME = The app timer (not in any real units, you determine the speed)
TIME_DELTA = The speed of the timer (how many ticks per frame)
DOF_SCALE = The highest depth of field mipmap level.
DOF_OFFSET = 0 - the dof starts at the camera, 0.5 dof starts half way to MAX_DEPTH
MAX_DEPTH = The maximum depth for DOF (also sent to shaders for use as a maximum depth of raytracing)
udef[0]..udef[31] = You decide what these are and use them in the shaders. 0-4 can be driven by the keybaord.
g_hWnd = The trace window handle.

Debugging

The Vertex Shader

The Fragment Shader

//slower
if(z<0.0){
	//work with positive z
}else{
	//work with negative z
}
//both code paths are run (the values are just tossed out)
//faster
float side = sign(z);
z = abs(z);
//work with positive z only
z*=side; 

float DE(vec3 z0){
	//this isn't a fractal so we are leaving out the fractal folding, rotations etc
	//we are stepping a ray into the screen and we are at the point z0. How far can we go
	//until we could possibly hit a sphere centered at the origin with a radius "radiusOfSphere"?
	//Answer:
	return length(z0)-radiusOfSphere;
}

Tutorials