Menu
RENDERING PROCESS:
- Introduction
- Principles
- World structure
- Projection
- Finding walls
- Horizontal intersections
- Vertical intersections
MISCELLANEOUS:
Glossary
Alphabetised index:
- Coordinate definitions
- First person
- Geometric constraints
- ISR
- Look-Up-Tables (LUTs)
- Orthogonal
- Perspective
- Real-time
Coordinate definitions:
Within these pages, I use two types of coordinates; world and cell coordinates. Cell coordinates are (x,y) pairs as you'd expect, but they're indices into the array holding cell definitions (ie. coordinate (4,2) would be a reference to world_cells[2][4]). World coordinates, however, are absolute coordinates within the world (ie. the pair (19,66) would be 19 units in from the left of the first cell and 66 units from the top of the first cell, or somewhere in cell (0,1) assuming that cell widths and heights are 64 units).
First-person:
First-person perspective means that the projection (image) that's on the screen is similar to what you'd see if you were actually standing there yourself, in place of the character. It's as if the character's eyes are your eyes. Examples of such games are Wolfenstein 3D, DOOM, Quake etc.
Geometric constraints:
A geometric constraint is a limit put on the engine so that the data in a world/map has to adhere to certain rules. For example, all walls are perpendicular (at 90 degrees) to the floor. This means that no slopes are allowed, which simplifies the maths and increases performance. Most geometric constraints are either to speed up the engine or to simplify the mathematics behind rendering.
ISR:
An ISR, short for Interrupt Service Routine, is a routine that acknowledges interrupts. An interrupt (not surprisingly :) interrupts the CPU when something happens to the device that the interrupt is tied to. The CPU stops what it was processing and calls the device's ISR, which handles what changes the device went through. For example, you might press a key on the keyboard and a keyboard ISR is called to process it. Usually, the key code is stored in a buffer, waiting for another program to pick it up.
Look-Up-Tables (LUTs):
LUTs are used as an engine optimization. Instead of computing a value in an equation, formula or statement many times (when each time the value will be identical), the value is calculated once at the start of (or before) program execution, and placed into an array. Whenever the value is needed, it is simply retrieved from the array, which should be faster than re-computing it. A common example of using a LUT is to pre-calculate the values for the trigonometric (sine, cosine and tangent) functions, and place them into an array big enough for 360°. Then, instead of going `x = sin(22°)', requiring the processor to compute a value, you can use `x = sin_table[22°]', which in theory should be faster as it is a mere memory access.
Orthogonal:
Orthogonal walls are those that are at 90 degrees (perpendicular) to the floor and grid-lines. This means that the walls can't slope, nor can they go diagonally through a cell.
Perspective:
Perspective is how we actually see things when we look at them; how objects get smaller and darker the further away they are. The traditional example would be a perfectly straight road with identical houses on both sides, making the image symmetrical. The road strecthes for miles and miles with no bends or corners, so far that you see it disappearing into the horizon -- the further you look the more the road seems to get narrower and the houses seem to get smaller and smaller and smaller and smaller and smaller and ........ That's perspective.
Real-time:
Real-time means that the images projected onto the screen are produced dynamically (or 'on-the-fly') and are not drawn before the program is running. Real-time allows players to move anywhere within reason, and unlike non-real-time programs, you don't usually have to stick to a pre-determined path.
| Last updated: | 02/11/00 |
Best viewed with Netscape Navigator in a resolution of 1600x1200