//This voxel raycast/pixel-traversal algorithm based on:
//	<a rel="nofollow" href="http://www.cse.yorku.ca/~amana/research/grid.pdf">http://www.cse.yorku.ca/~amana/research/grid.pdf</a>
//returns either the collision point, or null if no collisions within max_len pixel checks
function RaycastVoxel(Array voxels, Point origin, Point target,int max_len) returns Point
{	
	//XYZ Pixel start
	int X=floor(origin.X);
	int Y=floor(origin.Y);
	int Z=floor(origin.Z);
	
	//if you are casting from a filled pixel, STOP and return it
	if(voxels[X,Y,Z] is not empty)
		return new Point(X,Y,Z);
		
	//do we increase or decrease on step?
	float stepX = 1; if(origin.X > target.X) stepX = -1;
	float stepY = 1; if(origin.Y > target.Y) stepY = -1;
	float stepZ = 1; if(origin.Z > target.Z) stepZ = -1;
	
	//position along "ray" at each boundary
	float tMaxX = 0;
	float tMaxY = 0;
	float tMaxZ = 0;
	
	//set up initial position - basically "where is origin.X/Y/Z in the pixel?"
	if (stepX == 1)
		tMaxX = ceil(origin.X) - origin.X;
	else
		tMaxX = origin.X - floor(origin.X);
	if (stepY == 1)
		tMaxY = ceil(origin.Y) - origin.Y;
	else
		tMaxY = origin.Y - floor(origin.Y);
	if (stepZ == 1)
		tMaxZ = ceil(origin.Z) - origin.Z;
	else
		tMaxZ = origin.Z - floor(origin.Z);
		
	//origin-to-target length
	float tDelta=sqrt(
		(target.X-origin.X) * (target.X-origin.X)
		+ (target.Y-origin.Y) * (target.Y-origin.Y)
		+ (target.Z-origin.Z) * (target.Z-origin.Z)
		);

	//tDeltaN = tDelta/(target.N - origin.N);
	[b]tDeltaX = tDelta/abs(target.X - origin.X);
	tMaxX = tDeltaX * tMaxX;
	tDeltaY = tDelta/abs(target.Y - origin.Y);
	tMaxY = tDeltaY * tMaxY;
	tDeltaZ = tDelta/abs(target.Z - origin.Z);
	tMaxZ = tDeltaZ * tMaxZ;[/b]
	
	//if ray origin in right on boundary, assume its in the pixel
	//that is further/greater along that axis
	if(origin.X==X)//on X boundary between points
	{
		tMaxX = tDeltaX;
		if (stepX == -1)
			tMaxX = 0;
	}
	if(origin.Y==Y)//on Y boundary between points
	{
		tMaxY = tDeltaY;
		if (stepY == -1)
			tMaxY = 0;
	}
	if(origin.Z==Z)//on Z boundary between points
	{
		tMaxZ = tDeltaZ;
		if (stepZ == -1)
			tMaxZ = 0;
	}
	
	//unless (target.N - origin.N) is zero (DIVIDE BY ZERO ANYONE?)
	//in which case, tDeltaN = 0 and tMaxN = infinity (or 9999999 for numeric sake)
	
	[b]if(origin.X == target.X)//X/Y/Z delta is zero
	{
		tDeltaX=0;		
		tMaxX=999999;
	}
	if(origin.Y == target.Y)
	{
		tDeltaX=0;		
		tMaxX=999999;
	}
	if(origin.Z == target.Z)
	{
		tDeltaZ=0;	
		tMaxZ=999999;		
	}[/b]
	
	//traverse pixels, checking a maximum of max_len pixels
	for (int i = 0; i < max_len; i++)
	{
		if(tMaxX < tMaxY && tMaxX < tMaxZ) {
			tMaxX = tMaxX + tDeltaX;
			X = X + stepX;
		}
		else if (tMaxY < tMaxX && tMaxY < tMaxZ)
		{
			tMaxY = tMaxY + tDeltaY;
			Y = Y + stepY;
		}
		else
		{
			tMaxZ = tMaxZ + tDeltaZ;
			Z = Z + stepZ;
		}
		
		if (voxels[X,Y,Z] is not empty)
			return new Point(X,Y,Z);
	}
	return null;//no collision within max_len pixel checks	
}