3d graphics introduction part 2 n.
Skip this Video
Loading SlideShow in 5 Seconds..
3D Graphics Introduction Part 2 PowerPoint Presentation
Download Presentation
3D Graphics Introduction Part 2

Loading in 2 Seconds...

play fullscreen
1 / 36

3D Graphics Introduction Part 2 - PowerPoint PPT Presentation

  • Uploaded on

3D Graphics Introduction Part 2. CIS 488/588 Bruce R. Maxim UM-Dearborn. 3D Data Structures. Triangles Pros: very good, very fast Cons: need lots of them Quadrilaterals Pros: good, fast Cons: non-coplanar Polygons Pros: easy to model with them Cons: hard to draw, hard to clip.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about '3D Graphics Introduction Part 2' - omer

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
3d graphics introduction part 2

3D Graphics IntroductionPart 2

CIS 488/588

Bruce R. Maxim


3d data structures
3D Data Structures
  • Triangles
    • Pros: very good, very fast
    • Cons: need lots of them
  • Quadrilaterals
    • Pros: good, fast
    • Cons: non-coplanar
  • Polygons
    • Pros: easy to model with them
    • Cons: hard to draw, hard to clip
defining polygons 1
Defining Polygons - 1
  • Suppose we decide to model all polygons using triangles
  • Assume the rasterizer will clip triangles as needed as they are drawn (avoiding the use of 3D clipping in this chapter)
  • To avoid redundant listing of vertex information it is wise to use a vertex list to define 3D shapes
defining polygons 2
Defining Polygons – 2
  • For a cube the vertices might be

POINT3D vertex_list[NUM_VERTICES];

vertex_list[0] = {x0, y0, z0};

vertex_list[7] = {x7, y7, z7};

struct typedef POLY_EX_TYP_2


POINT3D_PTR vlist:

int vertices[3];


POLY_EX_2 face1 = {vertex_list, 0, 1, 2};

defining polygons 3
Defining Polygons – 3
  • One advantage of the vertex list method is that you avoid vertex drift that results when several copies of the same vertex are transformed independently (known as geometry cracking – as seen in Tomb Raider)
  • Sometimes you need to separate the polygons and vertex lists (esp. if you only need to render 1 of thousands of triangles in a surface)
defining polygons 4
Defining Polygons – 4
  • Another problem comes with clipping the vertex list without examining the polygons (you end up clipping any polygon the shares the clipped vertex)
  • To avoid this, you might need to adopt a hybrid approach that involves defining and transforming vertex lists and also convert them to single polygons when necessary
defining polygons 5
Defining Polygons - 5

// a polygon based on an external vertex list

typedef struct POLY4DV1_TYP


int state; // state information

int attr; // physical attributes of polygon

int color; // color of polygon

POINT4D_PTR vlist; // the vertex list itself

int vert[3]; // the indices into the vertex list


defining polygons 6
Defining Polygons - 6

// a self contained polygon used for the render list

typedef struct POLYF4DV1_TYP


int state; // state information

int attr; // physical attributes of polygon

int color; // color of polygon

POINT4D vlist[3]; // vertices of this triangle

POINT4D tvlist[3]; // vertices after transformation if needed

POLYF4DV1_TYP *next; // pointer to next polygon in link list

POLYF4DV1_TYP *prev; // pointer to previous polygon in LL


defining objects 1
Defining Objects - 1
  • Object contains everything needed for the 3D pipeline even transformed coordinates
  • Static arrays are used (they waste storage but avoid allocation and deallocation of storage)
  • Limited to 64 vertices and 128 polygons
  • Radius fields are used to assist in culling
  • “dir” is used to track rotations as local coordinates are overwritten
defining objects 2
Defining Objects - 2

typedef struct OBJECT4DV1_TYP


int id; // numeric id of this object

char name[64]; // ASCII name of object just for kicks

int state; // state of object

int attr; // attributes of object

float avg_radius; // average radius of object used for

//collision detection

float max_radius; // maximum radius of object

POINT4D world_pos; // position of object in world

VECTOR4D dir; // rotation angles of object in local

// cords or unit direction vector user

// defined???

defining objects 3
Defining Objects - 3

VECTOR4D ux,uy,uz; // local axes to track full orientation

// this is updated automatically during

// rotation calls

int num_vertices; // number of vertices of this object

POINT4D vlist_local[OBJECT4DV1_MAX_VERTICES]; // local vertices

POINT4D vlist_trans[OBJECT4DV1_MAX_VERTICES]; // transformed ver

int num_polys; // number of polygons in object mesh

POLY4DV1 plist[OBJECT4DV1_MAX_POLYS]; // array of polygons


representing worlds
Representing Worlds
  • Can’t just throw dozens or objects made up of hundreds of polygons into the graphics pipeline without taking a performance hit
  • In reality only a small portion of the game world will be visible from any given viewpoint
  • Terrain does not change much so its images could be left in world coordinates avoiding a local world transformation
  • More advanced techniques are discussed in later chapters
3d modeling tools
3D Modeling Tools
  • Calagari trueSpace
  • Maya
  • LightWave
  • 3D Studio Max
  • Blender
  • Moray coupled with a ray tracer like Persistence of Vision (POV)
plg file format 1
PLG File Format - 1
  • There are some modelers that produce PLG files and utilities to convert DXF to PLG files
  • Format
    • Header line

object_name num_vertices num_polygons

    • Vertex list (0 to n in x-y-z order)

x_coord y_coord z_coord

    • Polygon list

surface_description n v1 v2 v3 … vn

plg file format 2
PLG File Format - 2
  • Surface description code – 16 bits (can be either hex or decimal)

H15 – 1 means interpret as bottom 14 bits as surface map index otherwise use table interpret to S13S12

R14 – reserved should be 0

S13S12 – 00 solid shaded, 01 flat shaded, 10 metallic, 11 transparent

C11C8 – one of 16 color hues

B7B0 – brightness of color

nff file format
NFF File Format
  • Neutral file format (virtual reality games)
  • Supports
    • Simple perspective frustrum
    • Background color descriptions
    • Positional light source description
    • Surface properties description
    • Polygon, polygon patch, cylinder/cone, and sphere descriptions (in vertex format)
nff example
NFF Example

v // viewport location

from 0 2.0 2.0

at 0 0 0

up 0 1 0

angle 40

hither 1

resolution 512 512

l 0 5 0 // positional lights

l 0 2.0 2.0

f 0.000000 0.000000 0.000000 1 0 0 0 0 // fill light

p 3 // polygon format

1.000000 -1.000000 -1.000000

-1.000000 -1.000000 -1.000000

-1.000000 -1.000000 -1.000000

dxf file format
DXF File Format
  • Binary and ACSCII versions originally supported by AutoCAD
  • Format
    • Header Section (general model info)
    • Tables Section (definitions of named objects)
    • Blocks Section (lists entities for each block)
    • Entities Section (contains actual model entities)
    • End of File Marker
other file formats
Other File Formats
  • 3DS
    • Binary format produced by 3D Studio Max also has an ASCII version
    • Largely a file header followed by vertex and face information
  • COB
    • Produced by Calagari trueSpace
    • Vertex based format similar to 3DS
  • .X
    • Microsoft Direct X format, contains everything Direct 3D handles importing
3d mesh translation
3D Mesh Translation
  • Simply adjust its position vector
  • To move an object by t=<tx, ty, tz>

object.world_pos.x = Object.world_pos.x + t.x;

object.world_pos.y = Object.world_pos.y + t.y;

object.world_pos.z = Object.world_pos.z + t.z;

  • To move in elliptical path parallel to x-z plane using absolute coordinates

x_pos = a * cos(angle);

y_pos = altitude;

z_pos = b * sin(angle);

3d mesh rotation
3D Mesh Rotation
  • Need to track orientation relative to the axis (to avoid problems like gimbal lock)
  • Should rotate an object’s local coordinates placing (0,0,0) at the object center
  • Need an orientation vector “dir” the is aligned pointing down the z+ axis
  • “dir” is update any time the object is rotated to keep track of its current orientation
3d mesh morphing
3D Mesh Morphing
  • Scaling and shearing done in real-time to make something look alive (e.g. breathing)

int up_down = 1;

float scale = 1;



if (up_down == 1)


Scale_Object(&object, 1.05);

scale = scale * 1.05;


3d mesh morphing1
3D Mesh Morphing



Scale_Object(&object, .95);

scale = scale * .95;


if ((scale < .75) || (scale > 1.25))

up_down = -up_down;


  • Note eventually errors (drift) will start creeping into the images and we will have to refer to the original copies of each mesh and apply the transformations to these instead
types of 3d engines
Types of 3D Engines
  • Space Engines (Star Wars:X-Wing)
  • Terrain Engines (Tread Marks)
  • FPS Indoor Engines (Unreal)
  • Ray Casters (Wolfenstein)
  • Voxel Engines (Medical Imaging)
  • Hybrid Engines (ray casting or polygons for worlds and sprites for objects)
painter s algorithm
Painter’s Algorithm
  • Basic idea
    • Sort surfaces and then draw so looks right.
    • If all surface are parallel to view plane, sort based on distance to viewer, and draw from back to front.
    • Worst-case is O(n^2)
    • Otherwise, have five tests applied to each pair to sort.
test 1 x overlap
Test 1: X overlap
  • If the x extents of two polygons do not overlap, then order doesn’t matter and go to next pair.
  • If x extents overlap, goto test 2.



test 2 y overlap
Test 2: Y Overlap
  • If the y extents of two polygons do not overlap, then order doesn’t matter.
  • If y extents overlap, goto test 3.



tests 3 4
Tests 3 & 4
  • Extend polygons to be a cutting plane
    • If a polygon can be contained within the cutting plane of the other, that polygon should be drawn first.
    • If neither can be contained, go to step 5.
tests 3 41
Tests 3 & 4

View direction

Polygon 1 is completely on one side of the two planes “cut” by polygon 2.

Polygon 2


Polygon 1


test 5
Test 5
  • Only needs to be consider if have concave polygons.
how to make it easier
How to make it easier
  • Use convex objects
  • Avoid long objects (like walls) that can overlap each other in multiple dimensions
  • Avoid intersecting objects and polygons
z buffer
  • Z-buffer holds the z-coordinate of every pixel
  • Initialize all values to maximum depth
  • Compute the z value of every point of every non-back facing polygon
    • Not too hard if all polygons are triangles or rectangles
    • Do this during the filling of the triangles
  • If z of point < z in Z-buffer
    • save the color of the current point and update Z-buffer
    • otherwise throw away point and move on
ray tracing
Ray Tracing
  • Image space technique that mimics physical processing of light
  • Extremely computationally intensive
    • Hidden surface removal
    • Transparency
    • Reflections
    • Refraction
    • Ambient lighting
    • Point source lighting
    • Shadows