Scribd
Upload
58 views

Free Direction Tunnel

Raytracing is used to create free-directional tunnels. Rays are cast through each pixel and checked for intersection with a cylinder representing the tunnel. This is done by solving the equation for the intersection of the ray and a circle at each z-coordinate. Texture coordinates are assigned based on the intersection point. Performance is improved by tracing fewer rays and interpolating between them.

Uploaded by

saiffyros
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
58 views

Free Direction Tunnel

Raytracing is used to create free-directional tunnels. Rays are cast through each pixel and checked for intersection with a cylinder representing the tunnel. This is done by solving the equation for the intersection of the ray and a circle at each z-coordinate. Texture coordinates are assigned based on the intersection point. Performance is improved by tracing fewer rays and interpolating between them.

Uploaded by

saiffyros
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 5

How to do free-directional tunnels

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
by BlackAxe / KoLOr 1997

In the latest demos (in almost every demo from Assembly97) you see those
funny free-directional tunnels, namely tunnels where you can move how you
want and perform complex camera movements.
Many people in iRC asked me how to do such a tunnel, so instead of wasting
phone costs and explaining it online i decided to write this little tute.
In fact, this effect is kinda easy to do, but unlike normal, old, silly
tubes it doesn't work with those silly lookup tables (darn, I hate lookup
tables :-)), but in fact it's realtime raytraycing. Realtime Raytraycing??
Isn't that slow? No, there are some tricks to make it possible in realtime.
Well, let's start with a little introduction to raytraycing.

1.) Raytraycing, the basics


~~~~~~~~~~~~~~~~~~~~~~~~~~~
In fact, raytraycing is a very easy algorithm, many people think it's hard
as hell, because one get's good quality pictures out of it, but the basics
are easy. Performing refractions, reflections and other complex things is a
bit more advanced, but the basics are very very easy, everyone that knows a
bit math should understand it.
Well, basically the algorithm consists of shooting a ray through each pixel
of the screen and check for intersections of this ray with objects in the
scene. Let's start with the equation of a ray. A ray is defined as

Origin + t*Direction
where Origin is the vector of the camera, and Direction a normalized direction
vector. t is a float that indicates a position on the ray. Now for shooting
a ray through a pixel, we do the following, if we consider the camera to be
at (0,0,-256)
Origin.x = 0;
Origin.y = 0;
Origin.z = -128;

now we shoot the ray through that pixel:


Direction.x = Pixel.X;
Direction.y = Pixel.Y;
Direction.z = 128;
Direction.Normalize();
of course you can take something different for Z, that's your decision.
Note: The midmost pixel of the screen muts be (0,0), so if you work in
320x200 you first have to substract 160 of X and 100 of Y (or 320 resp. 240
when you work in 640x480). And don't forget to normalize the Direction
(if you don't know how to normalize a vector, first check a vector tutorial
like ZED3D), hmm, well, here's the little function to normalize a vector for
all you dummies :-))

void Vector::Normalize()
{
float len = sqrt(x*x + y*y + z*z);
x /= len;
y /= len;
z /= len;
}

Now you have your ray, and you need to check for intersections. For that, you
need to find t (of course, because you know the rest :-)). Then you have
Intersection = Origin + t*Direction
how funny :-)
[Intersection is a vector ofcourse]

2.) Doing the raytraycing for the tunnel


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Think! What is a tunnel?? A tunnel is a cylinder, a simply silly cylinder.
And what is a cylinder??? A cylinder is a set of circles on a straight line.
Each Z coordinate has a circle. So it's just circles for each Z :-)
Now we have to find the intersection between our ray and the correct circle.
Recall the equation of a circle from your math course:

(x-a)^2 + (y-b)^2 = r^2


(a,b) is the center of the circle, and r is the radius. As we suppose the
circles are on (0,0) this becomes
x^2 + y^2 = r^2
easy huu :-)

Now we substitute the ray equation in this equation.


(Origin.x + t*Direction.x)^2 + (Origin.y + t*Direction.y)^2 = r^2
and we calculate this out

Origin.x^2 + 2*Origin.x*t*Direction.x + t^2*Direction.x^2 +


Origin.y^2 + 2*Origin.y*t*Direction.y + t^2*Direction.y^2 = r^2

now we group all terms that should be grouped :-)


t^2*(Direction.x^2 + Direction.y^2) + t*2*(Origin.x*Direction.x +
Origin.y*Direction.y) + Origin.x^2 + Origin.y^2 - r^2 = 0;
ain't this a nice quadratic equation? Hmm, let's write it like this

a*t^2 + b*t + c = 0

where:
a = Direction.x^2 + Direction.y^2
b = 2*(Origin.x*Direction.x + Origin.y*Direction.y)
c = Origin.x^2 + Origin.y^2 - r^2

Now we need to solve this equation. From your math course you should now how
to solve quadratic equations:
we first have to calculate the discriminent delta
delta = b^2 - 4*a*c

Now if delta < 0, there are no real solutions, only complex ones, if this
case happens, there's no Intersection and we can draw a background colour.
If delta = 0, there's ONE intersection, that is calculated as follows
-b
t = -----
2*a

If delta > 0, there are TWO real intersections:

-b - sqrt(delta)
t1 = ----------------
2*a

-b + sqrt(delta)
t2 = ----------------
2*a

We are only interested in the nearer of those intersections, so we do


t = min(t1, t2);

Now you have your intersection between the ray and the cylinder :-)
Intersection = Origin + t*Direction

One thing rests: we need to texturemap the tunnel. This is easy to, we just
apply cylindric mapping to the Intersection point.

we just do:

u = abs(Intersection.z)*0.2;
v = abs(atan2(Intersection.y, Intersection.x)*256/PI);

that's it :-) you can combine that with depth cue too, i.e. taking the Z into
account to get a shade-level, but i leave that to you.
That's already it. If you do that for each pixel, you get a nice tunnel :-)

3.) Moving the camera


~~~~~~~~~~~~~~~~~~~~~
You want to move your camera ofcourse :-)
That's easy, change your Origin vector's x,y of you want to move your camera,
and if you want to to rotate, just rotate your Direction vector using a matrix
or normal 12 mul rotation. I won't go any further into this, as it's really
basic stuff, see the source below to check how it works.

4.) Doing it in realtime


~~~~~~~~~~~~~~~~~~~~~~~~
I hear you cry, this is IMPOSSIBLE in realtime. Well in fact it is, tracing
rays for each pixel :-) But you won't do that, won't you. In fact you just trace
rays for some pixel and interpolate between. I take a 40x25 grid (that is 8x8
pixels large) shoot a ray for each grid, i.e. getting (u,v) for each grid
position, and interpolate between, that way i get a full 320x200 screen by only
calculating 1000 intersections, and it's precise enough. That method can be used
for other 2d effects too, kinda great for bitmap distortions.

5.) Some example source for the lazy ones


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
u,v are an index to a 256x256 texturemap, and as Radius I take 256

virtual void FreeTunnel::GetUV(int x,int y, int &u, int &v)


{
Vector Direction(x-160, y-100, 256);
Direction *= RotationMatrix;
Direction.Normalize(); // normalize Direction vector

Vector Origin(100, 100, -256);

// calculate the stuff :-)


float a = fsqr(Direction.x) + fsqr(Direction.y);
float b = 2*(Origin.x*Direction.x + Origin.y*Direction.y);
float c = fsqr(Origin.x) + fsqr(Origin.y) - fsqr(Radius);
// calculate discriminent delta
float delta = fsqr(b) - 4*a*c;

// if there's no real solution


if (delta < 0)
{
u = 128;
v = 128;
return;
}

float t,t1,t2;
// there are 2 solutions, get the nearest ... this case should never happen
t1 = (-b + sqrt(delta))/(2*a);
t2 = (-b - sqrt(delta))/(2*a);
t = min(t1, t2); // min here

// finnally the intersection


Vector Intersection = Origin + t*Direction;

// do the mapping
u = (int)(fabs(Intersection.z)*0.2);
v = (int)(fabs(atan2(Intersection.y, Intersection.x)*256/PI));
}

Again, i call that for 40x25 and interpolate between the (u,v) set.
As you can see, i used OOP massively, e.g for Vectors and Matrices.
OOP really helps you alot, you should try it.
If you take an 80x50 grid (4x4 interpolation) you might get better results, but
this works fine for me.

That's pretty much it, now go ahead and code yourself a killer-tunnel.
If you want to see this tunnel in action, get our Evoke97 demo (1st place)
the archive is called KWISSEN.ZIP and you should find it on cdrom.com.

6.) Greets
~~~~~~~~~~
Greets fly to (no order):
Tomh, Climax, Shiva, Fontex, Raytrayza, Noize, LordChaos, Red13, kb, DrYes,
Siriuz, Crest, Gaffer, Trickster, Houlq, Screamager, LoneWolf, Magic, Unreal,
Aap, Cirion, Kyp, Assign, and the rest i have forgotten in some way.

If you feel the need to contact me, do so :-)


In the moment i don't have any e-mail, but i'll get one soon. Try to catch me
on iRC (channel #coders and #coders.ger on IRCNET and #luxusbuerg on UnderNet)
Or snail-mail me
Laurent Schmalen
6, rue Tony Schmit
L-9081 Ettelbruck
G.D. Luxembourg

have fun and stay trippy dudes!

You might also like