 http://www.intel-assembler.it/  (c)2019 intel-assembler.it   info@intel-assembler.it Search :  Index  Intel Platform Article & Guides Download Software

23/01/2009 Featured Article: How to remove Buzus Virus (permalink)

 :::4138666:::  Web www.intel-assembler.it Download Tell a friend

Perspective Transforms

A two page document with the perspective formulas

(by andre yew)

The basic formulas for handling perspective using matrixs.

+------------------------+
| Perspective Transforms |
+------------------------+

By Andre Yew (andrey@gluttony.ugcs.caltech.edu)

This is how I learned perspective transforms --- it was
intuitive and understandable to me, so perhaps it'll be to
others as well.  It does require knowledge of matrix math
and homogeneous coordinates.  IMO, if you want to write a
serious renderer, you need to know both.

First, let's look at what we're trying to do:
S (screen)
|    * P (y, z)
|   /|
|  / |
| /  |
|/   |
* R  |
/ |    |
/  |    |
/   |    |
E (eye)/    |    | W
---------*-----|----*-------------
<- d -><-z->

E is the eye, P is the point we're trying to project, and
R is its projected position on the screen S (this is the point
you want to draw on your monitor).  Z goes into the monitor (left-
handed coordinates), with X and Y being the width and height of the
screen.  So let's find where R is:

R = (xs, ys)

Using similar triangles (ERS and EPW)

xs/d = x/(z + d)
ys/d = y/(z + d)
(Use similar triangles to determine this)

So,

xs = x*d/(z + d)
ys = y*d/(z + d)

Express this homogeneously:

R = (xs, ys, zs, ws).

Make xs = x*d
ys = y*d
zs = 0 (the screen is a flat plane)
ws = z + d

and express this as a vector transformed by a matrix:

[x y z 1][ d 0 0 0 ]
[ 0 d 0 0 ]    =  R
[ 0 0 0 1 ]
[ 0 0 0 d ]

The matrix on the right side can be called a perspective transform.
But we aren't done yet.  See the zero in the 3rd column, 3rd row of
the matrix?  Make it a 1 so we retain the z value (perhaps for some
kind of Z-buffer).  Also, this isn't exactly what we want since we'd
also like to have the eye at the origin and we'd like to specify some
kind of field-of-view.  So, let's translate the matrix (we'll call
it M) by -d to move the eye to the origin:

[ 1 0 0  0 ][ d 0 0 0 ]
[ 0 1 0  0 ][ 0 d 0 0 ]
[ 0 0 1  0 ][ 0 0 1 1 ]  <--- Remember, we put a 1 in (3,3) to
[ 0 0 -d 1 ][ 0 0 0 d ]       retain the z part of the vector.

And we get:

[ d 0 0  0 ]
[ 0 d 0  0 ]
[ 0 0 1  1 ]
[ 0 0 -d 0 ]

Now parametrize d by the angle PEW, which is half the field-of-view
(FOV/2).  So we now want to pick a d such that ys = 1 always and we get
a nice relationship:

d = cot( FOV/2 )

Or, to put it another way, using this formula, ys = 1 always.

Replace all the d's in the last perspective matrix and multiply
through by sin's:

[ cos 0   0    0   ]
[ 0   cos 0    0   ]
[ 0   0   sin  sin ]
[ 0   0   -cos 0   ]

With all the trig functions taking FOV/2 as their arguments.
Let's refine this a little further and add near and far Z-clipping
planes.  Look at the lower right 2x2 matrix:

[ sin sin ]
[-cos 0   ]

and replace the first column by a and b:

[ a sin ]
[ b 0   ]
[ b 0   ]

Transform out near and far boundaries represented homogeneously
as (zn, 1), (zf, 1), respectively and we get:

(zn*a + b, zn*sin) and (zf*a + b, zf*sin).

We want the transformed boundaries to map to 0 and 1, respectively,
so divide out the homogeneous parts to get normal coordinates and equate:

(zn*a + b)/(zn*sin) = 0 (near plane)
(zf*a + b)/(zf*sin) = 1 (far plane)

Now solve for a and b and we get:

a = (zf*sin)/(zf - zn)
= sin/(1 - zn/zf)
b = -a*zn
b = -a*zn

At last we have the familiar looking perspective transform matrix:

[ cos( FOV/2 ) 0                        0            0 ]
[ 0            cos( FOV/2 )             0            0 ]
[ 0            0 sin( FOV/2 )/(1 - zn/zf) sin( FOV/2 ) ]
[ 0            0                    -a*zn            0 ]

There are some pretty neat properties of the matrix.  Perhaps
the most interesting is how it transforms objects that go through
the camera plane, and how coupled with a clipper set up the right
way, it does everything correctly.  What's interesting about this
is how it warps space into something called Moebius space, which
is kind of like a fortune-cookie except the folds pass through
each other to connect the lower folds --- you really have to see
it to understand it.  Try feeding it some vectors that go off to
infinity in various directions (ws = 0) and see where they come
out.

 TopDownload Tell a friend Similar Articles

2D/3D Rotation asm demos
Source code for 2D and 3D rotation
(by Ash [NLB/BD])

3D Rotating Cube Assembler source
An improved asm code for 3d graphics
(by Arno W. Brouwer)

3D Texture Mapping theory and asm code
a mid-length text about texture logic and coding
(by Sean Barrett)

4K 3D Asm Demo
4096 byte 3D assembler graphical demo
(by Jari Kytöjoki)

Basic Introduction to 3D Programming
A short doc about howto plot in 3D
(by Synergist)

Math.inc: General 3D math functions
A library with many math functions for 3d graphics
(by John McCarthy)

REFRACTION 4k intro
Assembler graphic demo, 3D chessboard
(by G.O.D.)

Star Field
3D Assembly star field
(by VLA)

Three Dimensional Rotations For Computer Graphics
A short document on 3D rotation
(by VLA)

Three Dimensional Shading In Computer Graphics
A brief intro on 3d shading theory
(by VLA)

VGA Trainer Program
A course for graphic programming in Pascal/ASM
(by Grant Smith Denthor of ASPHYXIA)

VGOPHONG Phong lighting and specular highlights
Theory, practice of phong lightnin and shade model
(by TimJ/Vertigo)

X-Sharp 3-D animation package v22
3D ball demo with zoom, share and move
(by Michael Abrash)

Zed3D programming guide
A compact reference for 3d computer graphics
(by Sébastien Loisel)

Tags: 3d

 webmaster jes writers rguru, tech-g, aiguru, drAxsite optimized for IE/Firefox/Chrome with 1024x768 resolution ALL TRADEMARKS ® ARE PROPERTY OF LEGITTIMATE OWNERS.© ALL RIGHTS RESERVED. hosting&web - www.accademia3.it find rguru on Code