TweetFollow Us on Twitter

3D Graphic Tools
Volume Number:8
Issue Number:1
Column Tag:Tools of the trade

Related Info: Quickdraw Color Quickdraw

3D Graphic Tools

High-performance 3D drawing & rendering in your programs

By David Harr, Alhambra, California

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

Introduction

The Macintosh Toolbox provides good support for doing 2 dimensional computer graphics in the form of QuickDraw. Basic QuickDraw (B&W) provides 6 geometric primitives: line, rectangle, round-cornered rectangle, and circle, a polygon data structure, and a region data structure, which allows the programmer to deal with arbitrary areas and shapes. All of these can be drawn, outlined, filled, pattern filled, resized and used as masks. Color QuickDraw adds the capabilities of drawing in color, filling in color, using color patterns, palette animation, color masking, and provides support for photo-realistic color and double-buffered on-screen animation.

With all of this attention to 2 dimensional graphics, however, Apple has been lax in supporting the needs of those who are interested in doing 3 dimensional graphics and modeling. The only support that Apple gives is in the form of a set of slow, buggy library routines collectively known as Graf3D supplied in object form with MPW. The “documentation” of Graf3D consists of eleven pages in an appendix at the back of the MPW reference manual, Volume 1. This is a bare-bones listing of the routines and a short explanation of the calling conventions, parameters and purpose of each routine. Graf3D itself is a minimal effort in supporting 3d graphics. It provides only rotation, scaling, translation, clipping, and 2d projection. There are no provisions for hidden line removal, polygon fills, z-buffer rendering, light sources, or shading. It can be used, at best, for wire-frame drawings.

3D Graphic Tools version 3.0, published by Micro System Options of Seattle, Washington, is a set of routines written for programmers who wish to use high-performance 3 dimensional drawing and rendering in their programs. The package contains the source code for over 100 routines for 3D graphics. It provides a set of tools for graphics programmers, and is a good basis for someone interested in writing their own software for custom graphics applications.

This review discusses the C version of the package, which supports MPW C version 3.0 and later, and THINK C version 4.05 and later. There is also a Pascal version which is functionally identical to the C version and supports MPW Pascal version 3.0 and later, and THINK Pascal version 3.01 and later.

Rendering Environment

All of the drawing in 3D Graphic Tools is done in a three dimensional extension of the normal QuickDraw coordinate space. In other words, while most QuickDraw operations take place in a plane with (-32000, -32000) in the top, left corner and (32000, 32000) in the bottom, right corner, the coordinate space in 3D Graphic Tools is a cube that is 64000 units on a side. This gives a space that is large enough for most purposes, yet is small enough to allow the arithmetic operations to be carried out using high speed integer mathematics.

Figure 1

By convention, the three axes of the coordinate system are labeled the x, y, and z axes. The x and y axes are perpendicular to each other and lie in a horizontal plane, while the z-axis is perpendicular to them both, and runs straight up and down. Each axis runs from approximately -32000 to 32000, and each point in space has a unique coordinate given by (x, y, z), where x, y, and z each represent the respective coordinate of the three axes.

Mathematical Basis

Three dimensional rotations, transformations and scalings all involve considerable linear algebra, so they require a lot of multiplication. In order to speed the rendering of images and to make image manipulation as rapid as possible, it is common to use fixed-point, or integer mathematics in the calculations, with some loss in accuracy. 3D Graphic Tools supports a complete set of mathematical functions using both the Fixed and Fract data types, as described in Inside Macintosh volumes I and IV. These routines are not the routines included in the Macintosh ROMs, however. They are hand-crafted assembly language routines that have been optimized for speed. On average, the fixed math routines in 3D Graphic Tools are between 40% to 50% faster than the Toolbox routines. This makes 3D Graphic Tools significantly faster than Graf3D when performing line and point manipulation in three dimensions. In addition, many of the conversion routines between types, such as frac2fix or fix2frac are implemented as macros in 3D Graphic Tools, removing the overhead of a function call, again adding to the speed of the package. In those situations where accuracy is paramount, such as in zbuffer rendering, the routines revert to floating-point mathematics, which is slower (especially in those machines without a 68881/68882 FPU), but is more accurate.

Rendering Attributes

3D Graphic Tools has a full range of functions for performing three dimensional image manipulation and rendering. These include basic operations such as rotations, scalings, translations, and projections onto the two dimensional screen. In addition, once a three dimensional scene has been constructed, it can be rendered to almost any desired level of realism, from wire-frame drawings with no hidden line removal, to an image incorporating such sophisticated techniques as multiple inde-pendent light sources, shadows, specular highlighting, and texturing of objects. The only effort required of the programmer is that they set the appropriate global variables.

The basic data unit in 3D Graphic Tools is the patch. A patch is a set of vertices and facets that determines the shape of the object that the patch represents [see listing 1]. In addition to this shape information, however, the patch also contains an extensive set of rendering attributes that are needed when making use of the more sophisticated rendering options in the package. The rendering information associated with a patch is used to determine the effect of illumination on the object. Some of the information is also used to add texture and supply visual effects to the surface of the object.

Each vertex is defined by the coordinate (x, y, z) that it occupies in space and a number in the vertex list. Thus, vertex 7 might be at (17, 23, 48). Each facet is defined by a list of vertices, which are referenced by number, not by coordinate. This list is arranged so that the vertices are listed counterclockwise in order. The reason that each vertex is addressed by number is so that if an object is translated, rotated, or scaled, the changes need only be made to the master list of vertices, and all facets of the patch will automatically be correctly positioned. This is much faster than stepping through each facet and individually repositioning each vertex in that way, because each facet shares at least two vertices with other facets in the same object.

The ambience, diffusion, and reflection coefficients all control how light reflecting off the object is treated. The reflection coefficients consist of three numbers in the range 0 to 65535. Each controls what percentage of the red, green and blue light is reflected from the object. A coefficient of 0 indicates 0%, 32767 is 50%, and 65535 is 100% reflection. When using the zbuffer rendering, then the ambience and diffusion coefficients come into play also. If there is ambient light, then the ambience coefficient determines what percentage of that light is reflected from the object, while the diffusion coefficient determines what percentage of the light is reflected uniformly in all directions.

The specular index, the specularity and transparency coefficients all determine the quality of the illumination of the object. The transparency coefficient determines the percentage of the background color which is added to the final color of the object. If it is 0, then the object is opaque, and none of the background color is added, whereas if it is 1, then the object is invisible, and its color is 100% determined by the background color. The specular index and the specular coefficient are related and determine how shiny the object is and how that shininess is distributed across the surface of the object.

In addition to all of these rendering options for the patch, there are also several miscellaneous attributes. There are three attributes that are specifically concerned with lighting effects. If a patch is declared as a light source, then it emanates light of the color determined by the reflection coefficients. If the ambient effect and distance effect booleans are set, then the ambient light is added directly to the light reaching the viewer’s eye, causing more distant objects to become grayed out. The farther away an object is, the lower the intensity of the light reaching the viewer’s eye, causing more distant objects to become darker. There are also three attributes that are used to determine how the object is rendered. If the framed boolean is set, then all facets are drawn with the edges in a different color than the facet itself. The color to draw the edges in is given in the frameColor field. If the pattern boolean is set, then the facet is drawn with a QuickDraw color pattern inside. Related to the pattern boolean is the grayscale boolean, which fills the facet with one of 65 gray levels ranging from white to black.

Advanced Options

In order to give the objects displayed a more photo-realistic look, 3D Graphic Tools also has several advanced rendering options. These options, although they increase the time required to display the scene, do not require nearly as much time as full-blown ray traces, yet they provide a level of realism approaching that of ray tracing. These advanced functions include texture mapping, anti-aliasing, and shadows.

Texture mapping is one of the most impressive features of the package. It allows the programmer to add any one of six “textures” to an object. Each texturemap may be rotated, scaled, or translated to produce interesting effects when projected onto the object. The first of the six texture types is not really a texture at all, it is a PICT file of the programmer’s choosing that will be placed onto the object in much the same way as if the PICT were projected onto the object by a movie projector or slide projector. However, it is also possible for the PICT to be repeated in every facet of the object, causing it to appear again and again. In addition, the PICT can be enlarged or reduced to any desired extent. Three more “naturalistic” textures include wood, rock, and bumps. These have other attributes such as grain and roughness to make them even more versatile.

Anti-aliasing is a technique that is used to soften and smooth the appearance of the object. There are several algorithms used in computer graphics for anti-aliasing. The one used in 3D Graphic Tools is to create a 3 X 3 convolution matrix of the selected pixel and the eight pixels surrounding it, and then use that matrix to get a weighted average of the color of the pixels. This color is then used to determine the displayed color in the pixel. The main use for this technique is to soften the edges of facets in the object. Once an object is rendered, if edge anti-aliasing is enabled, then each visible facet in an object is processed a second time, but only the edge pixels are redrawn. In addition, it is possible to apply anti-aliasing to a rectangular portion of an image, allowing anti-aliasing to work either on any portion or the entirety of a rendered image.

Shadows are the result of a reduction in illumination intensity caused by the presence of an object between a light source and another object. The object between the light source and the second object will cast a shadow on the far object. The degree to which the illumination is reduced is a function of the transparency of the interposing object. The more opaque the interposing object is, the less light reaches the far object. This is the model that 3D Graphic Tools uses to generate shadows. This model does have one limitation. If there are multiple objects between a light source and the far object, only the first object encountered will be used to cast a shadow.

Rendering

There are three ways of rendering a scene using 3D Graphic Tools. The one the programmer uses depends on how fast the programmer wishes the scene rendered, how detailed the scene needs to be, and much memory the programmer is willing to devote to holding the image.

The fastest and least realistic looking rendering of a scene is when it is rendered in just wire-frame. In this case, the facets are all drawn and every edge of every facet is visible. There is no effort to block edges that are behind other edges. This can be done very rapidly because there is a minimal amount of calculation involved. The only calculations required are the transforms needed to place the vertices into the proper perspective in the scene, and then another set of mathematical transforms to place the points in their proper place on the screen so that the two dimensional representation is correct.

The second algorithm used is known as the painter’s algorithm. When the painter’s algorithm is used, first, the package figures the surface normal to each facet to determine if that facet is visible to the viewer. Then the package takes the center of mass of each visible facet and checks to see whether it is inside or outside of the clipping planes formed by the edges of the screen. Next, it determines the distance from the viewer to the center of mass of each visible facet. The facets are then rendered with the most distant facets rendered before the closer facets. In the same way as a painter paints in the background before the foreground, as the near facets are drawn, they obscure those parts of the far facets that are behind them. The painter’s algorithm is not as fast as plain wire-frame drawings; however, it is still relatively quick. However, it has a problem with facets that are of unusual shapes and also with intersecting objects. Because the center of mass of the facet is used to determine the distance of the facet from the viewer, the painter’s algorithm doesn’t handle long, thin facets, facets that intersect with each other or facets that are aligned generally along an axis parallel to the axis of viewing properly. This is not a particular defect of 3D Graphic Tools, rather, it is a known defect with the painter’s algorithm.

The final algorithm that is used for rendering in the package is called zbuffer rendering. In zbuffer rendering, each facet is processed, and each pixel is stored as a three dimensional value giving the x, y, and z coordinates of that pixel. The x and y coordinates are just the screen coordinates of that pixel, while the z coordinate is the distance from that pixel to the viewer. In addition, a global matrix of z values is maintained for each pixel on the screen, and the z value of the pixel closest to the viewer is kept in this global array. As each facet is drawn, each pixel’s z value is checked against the global value for that pixel, and if the value is greater than that in the global array, then that pixel of the facet is not visible to the viewer, so it is not drawn. Obviously, this checking of each rendered pixel against the global values is a rather time-consuming process, however, the zbuffer algorithm is capable of properly displaying even very complicated, intersecting facets in their proper perspective.

Several of the more advanced rendering techniques are available only when using zbuffer rendering. These include ambience, diffusion, specularity, transparency, texture mapping, shadows and anti-aliasing.

Using 3D Graphic Tools

To demonstrate the way in which the programmer would use 3D Graphic Tools, we will briefly examine one of the tutorials that is given in the manual. In this tutorial, the programmer uses the package to render a lamp on a table that is created from scratch, using only the tools provided in the package. See Figure 1.

To install the package, it is only necessary to drag the source and header files to your hard disk. Then you just ensure that the proper source files and header files are included in your project, if you are using THINK C, or are included in your makefile, if you are using MPW C.

First, the programmer has to allocate a place to store the information from which the scene is rendered. This is called a collection. A collection consists of an arbitrary number of groups, which in turn consist of an arbitrary number of patches, with each patch roughly corresponding to an object. So the pro-grammer creates a collection that will hold two groups, one group to contain the information for the lamp, the other to contain the information for the table.

The group containing the information for the lamp will be made up of four objects, the shade, the base, a support tube for bulb, and the bulb itself. In creating the lamp, first we create the body. This is done by passing an array of control points for the lamp body to HermiteCurve3D() which interpolates the control points to make a smooth curve. Then that two dimensional curve is rotated through 360š to create a smooth surface. This set of points is then installed into a patch and that patch added to the first group. Next, the support tube for the bulb is created by a call to SolidCylinder(). This is stored in another patch and then added to the first group. Then, the bulb is created using SolidSphere(), but then the programmer needs to call the function SetPatchRenderingAttribs() to set the lightSource boolean so that the program knows that the bulb is giving off light. This is then stored in a patch and the patch added to the group. Finally, the shade is created by calling the function SolidCylinder() with different diameters for the top and bottom circles. A similar procedure is followed in creating the table, the top is defined as a octagonal solid, each piece is installed into a patch, and then each patch is added to the second group.

Now that the objects are properly created, and all of the rendering attributes properly set, then the point of view must be selected. This is the point in space from which the scene is viewed. To choose this point, the programmer calls AimCamera3D(). Then, the lighting environment needs to be specified. 3D Graphic Tools allows the programmer to provide an unlimited number of light sources of arbitrary color and brightness located at any point within the internal three dimensional space of the package.

After the programmer has determined the position and the lighting, then it is possible to set up an off-screen GrafPort to do all the drawing in and then copybits the finished image into a window on-screen.

This is done through calls to NewOffScreenCPort(), UseOffScreenCPort(), ShowOffScreenCPort(), and DisposOffScreenCPort(). It is very convenient and easy to use these off-screen ports to give animations a smooth and professional look. The programmer renders the scene using xfRenderCollection(), and then shows the off-screen port, causing it to be copybitsed onto the on-screen window.

Conclusion

3D Graphic Tools is a comprehensive set of routines for doing three dimensional rendering on the Macintosh. The only limitations of the package are that it does not support parametric representation of surfaces, there is no provided way to import data sets from other three dimensional modeling programs into the package, and it stops just short of providing the facilities to do full ray tracing. However, since the entire package is provided with source code and there are no licensing fees, this makes it excellent for engineering or scientific programming where the programmer wishes to do three dimensional plots or as a starting place for those writing a three dimensional graphics application who do not wish to have to reinvent the wheel.

A Sample Listing of Lamp.c

/*Program:Lamp.c
 Purpose: Tutorial demonstration - Lamp on Table
 ©1991 Mark M. Owen - All Rights Reserved. */

/* Compiler specific headers */
#pragma segment  Main

#ifndef THINK_C

#include <OSEvents.h>
#include <Fonts.h>
#include <Desk.h>
#include <Dialogs.h>
#include <Menus.h>
#include <Memory.h>
#include <Packages.h>
#include <Quickdraw.h>
#include <Resources.h>
#include <Traps.h>
#include <Windows.h>

extern _DataInit();

#endif  THINK_C

/* 3d Graphic Tools headers (for things we’ll use only) */
#include <3dExterns.h>
#include <3dGrid.h>
#include <3dHermiteCurves.h>
#include <3dHierarchy.h>
#include <3dResources.h>
#include <3dMatrix2Patch.h>
#include <3dQuadratics.h>
#include <3dSolidsPgn.h>
#include <3dSpline2Patch.h>
#include <3dText.h>
#include <Camera.h>
#include <OffScreenPorts.h>
#include <SysEnvirons.h>

/* define this to observe the offscreen drawing effects */
#undef  _OFFSCREEN_

/* Define resource related items */
#define RESOURCEFILE “\pLamp.Π.rsrc”
#define WINDOWID 1001

/* Define a few, miscellaneous, fixed point constants */
#define f_0p1  6554L
#define f_0p4  26214L
#define f_0p6  39322L
#define f_3p6  235930L
#define f_6 393216L

/* Prototypes for our functions... very important */
void    main(void);
void    ProduceScene (void);
void    DrawGrid (void);
hCollection MakeLamp (void);
void    GenRotatedSurfaceBody (hGroup hG,short ixP);
void    GenRotatedSurfaceTable(hGroup hG,short ixP);
void    SetRenderingAttributes(pRendAttr pRA,colorFactor r,colorFactor 
g,colorFactor b);
pLighting SetupLighting   (void);

void main()
{
 short  masters = 4;
 EventRecordevt; /* for event polling*/
 WindowPtrwp;
 
#ifndef THINK_C
 UnloadSeg(_DataInit);  /* for MPW C only, get rid of Data Initializer 
after use */
#endif

 MaxApplZone();
 while( masters- )
 MoreMasters();
 FlushEvents(everyEvent, 0);
#ifndef THINK_C
 InitGraf(& QDGLOBALS thePort);
#else
 InitGraf(&thePort);
#endif  THINK_C
 InitFonts();
 InitWindows();
 InitMenus();
 TEInit();
 InitDialogs(0L);

 OpenResFile( RESOURCEFILE );
 SelectWindow( (wp = GetNewCWindow( WINDOWID, (Ptr)0L, 
(WindowPtr)-1L )) );
 SetPort( wp );
 
 Init3d();
 ProduceScene();
 while( !GetNextEvent( mDownMask|keyDownMask, &evt ) );
 
 FlushEvents(everyEvent, 0);
 DisposeWindow(FrontWindow());/* don’t need  */
 ExitToShell();  /* we are out of here NOW!  */
}

void  ProduceScene()
{
 hCollection hC; /* collection storage ref   */
 Point3d Camera = {-f_100,f_45,-f_180}; /* loc */
 Point3d Focus = {f_0,f_0,f_0};  /* focus pt */
 Fixed Lens = Lens80mm; /*angle of view/magnification */
 pLightingpL;  /* lighting information */
 WindowPtrtheWindow = FrontWindow();
 GrafPtrosGP;

 /*Generate the scene objects */
 hC = MakeLamp();
 
 AimCamera3d( Camera.x,Camera.y,Camera.z, Focus.x,Focus.y,Focus.z, Lens 
);
 
 /*Setup ambient & point light sources */
 pL = SetupLighting();

#ifdef  _OFFSCREEN_
 /*Create offscreen drawing port */
 if( ColorPresent )
 {
 osGP = (GrafPtr)NewOffScreenCPort ( &theWindow->portRect );
 UseOffScreenCPort( (CGrafPtr)osGP );
 }
 else
 {
 osGP = NewOffScreenPort(&theWindow->portRect);
 UseOffScreenPort( osGP );
 }
#endif  _OFFSCREEN_
 
 /* Clear the screen */
 EraseRect( &theWindow->portRect );
 
 DrawGrid();
 
 /*How to render it based on graphics device bit depth */
 if( GDevicePixelBits() > 8 )
 { /* We have a VERY good screen so use ZBuffered rendering method */
 SetAntiAliasing(true);
 xfRenderCollectionPgn( hC, &xFormViewer, pL );
 }
 else
 /*We have only a basic mono, grayscale or 8 bit color screen, so use 
the Paint rendering method */
 xfRenderCollection( hC, &xFormViewer, pL, false );
 
 /*release some of the memory we allocated */
 DisposeCollection( hC );
 DisposPtr( (Ptr)pL );

#ifdef  _OFFSCREEN_
 /*Display offscreen buffer & dispose of it */
 if( ColorPresent )
 {
 ShowOffScreenCPort((CGrafPtr)osGP, theWindow);
 DisposeOffScreenCPort( (CGrafPtr)osGP );
 }
 else
 {
 ShowOffScreenPort( osGP, theWindow );
 DisposeOffScreenPort( osGP );
 }
#endif  _OFFSCREEN_
}

void  DrawGrid(void)
{
 Point3dmin = { -f_16,-f_16,-f_16 };
 Point3dmax = {  f_16, f_16, f_16 };
 Point3dsteps  = { f_8,f_8,f_8 };
 GridOptionsoptions;
 
 options.left  = false;
 options.right = true;
 options.top= false;
 options.bottom  = true;
 options.front = false;
 options.back  = true;
 options.gridPat = GP_BLACK;
 options.connectX= false;
 options.connectY= false;
 options.connectZ= false;
 ForeColor( blueColor );
 xfGrid(min, max, steps, options, &xFormViewer);
 ForeColor( blackColor );
 xFormCombined = xFormViewer;
 TextFace( bold );
 TextFont( geneva );
 TextSize( 12 );
 DrawString3d(min.x,f_0,max.z,”\pX”,centerAlign);
 DrawString3d(f_0,max.y,max.z,”\pY”,centerAlign);
 DrawString3d(f_0,min.y,min.z,”\pZ”,centerAlign);
}

hCollection MakeLamp()
{
 hCollection hC; /*collection storage ref */
 hGroup hG; /* group storage ref */
 RendAttr RA;    /* working copy of rendering attributes*/

 hC = NewCollection( 2 );/* allocate storage for collection*/
 hG = NewGroup( 4 ); /* ditto for the group and patches*/
 
 (**hC).hG[0] = hG;/* put group handle in collection*/
 
 /*Make the lamp body */
 GenRotatedSurfaceBody( hG, 0 );

 /*Now a cylinder for the bulb support */
 SetRenderingAttributes( &RA, 32767,32767,32767 );
 SetInstanceReferenceFrame(f_0, f_0, f_0, f_1, f_1, f_1, f_0, Int2Fix(12), 
f_0);
 SolidCylinder( 8,f_0p25,f_0p25,Int2Fix(12),f_8,false,hG,1,RA,&xFormInstance);

 /*The light bulb itself */
 SetRenderingAttributes(&RA, 65535, 65535, 65535);
 SetInstanceReferenceFrame(f_0, f_0, f_0, f_2, f_2 + f_0p5, f_2, f_0, 
Int2Fix(14), f_0);
 SolidSphere(9,9,f_1,Int2Fix(9),false,hG,2,RA,&xFormInstance);

 /*And the lamp’s shade */
 SetRenderingAttributes(&RA, 42000,42000,42000);
 RA.transparency = f_0p25;
 RA.framed= true;
 SetInstanceReferenceFrame(f_0, f_0, f_0, f_1, f_1, f_1, f_0, Int2Fix(12), 
f_0);
 SolidCylinder( 8,f_3,f_10,Int2Fix(12),f_8,false,hG,3,RA,&xFormInstance);

 /*A table to set it on  */
 hG = NewGroup( 1 ); /* alloc group & patches */
 (**hC).hG[1] = hG; /* put group handle in collection */ 
 GenRotatedSurfaceTable(hG,0);

 return hC;
}

void  GenRotatedSurfaceBody(hGroup hG,short ixP)
{
 int    nDataPts = 8;
 Point3dDataPt[] =
 {
 {f_1,f_0,f_0}
 , {f_2,f_1,f_0}
 , {f_3,f_3,f_0}
 , {f_2,f_4,f_0}
 , {f_2,f_5,f_0}
 , {f_1,f_6,f_0}
 , {f_0,f_4,f_0}
 , {f_0,f_2,f_0}
 };
 Point3daxis = {f_0,f_1,f_0}; /* rotation axis */
 RendAttr RA;    /* rendering attributes */
 
 int    nPts;
 Point3d*pPts;
 
HermiteCurve3d(HERMITE_CLOSEDCURVE, 3, nDataPts, DataPt, &nPts, &pPts);
 SetInstanceReferenceFrame( f_0, f_0, f_0, f_2, f_3, f_2,
 f_0,-Int2Fix(9),f_0);
 SetRenderingAttributes(&RA, 32767, 32767, 42000);
 RotateToSurface
 ( f_0, f_360, axis, 12,
 nPts, pPts,
 hG,ixP,RA, &xFormInstance
 );
 DisposPtr( (Ptr)pPts );
}

void  GenRotatedSurfaceTable(hGroup hG,short ixP)
{
 int    nDataPts = 5;
 Point3dDataPt[] =
 {
 {f_0  ,-f_0p6,f_0}
 , {f_3p6,-f_0p6,f_0}
 , {f_3p6,-f_0p4,f_0}
 , {f_3  , f_0  ,f_0}
 , {f_0  , f_0  ,f_0}
 };
 Point3daxis = {f_0,f_1,f_0}; /* rotation axis */
 RendAttr RA;    /* rendering attributes */
 
 SetInstanceReferenceFrame(f_0, f_0, f_0, f_6, f_2, f_6, f_0, -Int2Fix(9),f_0);
#undef  _WOOD_
#ifdef  _WOOD_
 SetRenderingAttributes(&RA, 58000,36000,18000);
 RA.framed= true;
 RA.frameColor.red = 65000;
 RA.frameColor.green =  57000;
 RA.frameColor.blue= 18000;
 RA.normalVisibility =  true;
 RA.texture = TX_WOOD;
 SetPt3d( &RA.tx[TXI_WOOD].txRotations, Int2Fix(85), Int2Fix(30), f_0 
);
 SetPt3d( &RA.tx[TXI_WOOD].txScalars, f_2  f_0p5, f_2 + f_0p5, f_2 + 
f_0p5 );
 SetPt3d( &RA.tx[TXI_WOOD].txTranslations, f_0, f_0, f_0 );
 RA.tx[TXI_WOOD].txArgument[0] = 0;
 /* do not add noise values */
 RA.tx[TXI_WOOD].txArgument[1] = f_0p6;
 /* lightest grain */
 RA.tx[TXI_WOOD].txArgument[2] = f_0p5;
 /* darkest grain*/
 RA.tx[TXI_WOOD].txArgument[3] = 0;
 /* not used for wood texture */
#else // _ROCK_
 SetRenderingAttributes(&RA, 65000,65000,65000);
 RA.framed= true;
 RA.frameColor.red = 65000;
 RA.frameColor.green =  47000;
 RA.frameColor.blue=  3000;
 RA.normalVisibility =  true;
 RA.texture = TX_ROCK;
 SetPt3d( &RA.tx[TXI_ROCK].txRotations, Int2Fix(30),Int2Fix(0),Int2Fix(20) 
);
 SetPt3d( &RA.tx[TXI_ROCK].txScalars, f_1,f_1,f_1 );
 SetPt3d( &RA.tx[TXI_ROCK].txTranslations, f_45,f_0,f_0 );
 RA.tx[TXI_ROCK].txArgument[0] = fixratio(16,1);
 RA.tx[TXI_ROCK].txArgument[1] = fixratio(4,10);   
 RA.tx[TXI_ROCK].txArgument[2] = fixratio(8,10);   
 RA.tx[TXI_ROCK].txArgument[3] = fixratio(7,10);
 RA.diffusion    = fixratio(15,100);
 RA.specIndex    = 30;
 RA.specularity  = fixratio(85,100);
 RA.ambience=  fixratio(1,100);
#endif  _WOOD_
 RotateToSurface
 ( f_0, f_360, axis, 8,
 nDataPts, DataPt,
 hG,ixP,RA, &xFormInstance
 );
}

void  SetRenderingAttributes(pRendAttr pRA, colorFactor r, colorFactor 
g,colorFactor b)
{
 pRA->R = r;
 pRA->G = g;
 pRA->B = b;
 pRA->frameColor.red =  32767;
 pRA->frameColor.green  = 32767;
 pRA->frameColor.blue=  32767;
 pRA->lightSource= false;
 pRA->distanceEffect =  true;
 pRA->ambientEffect= true;
 pRA->normalVisibility  = false;
 pRA->framed=  false;
 pRA->patterned  = true;
 pRA->grayScaled = false;
 pRA->texture    = TX_NONE;
 pRA->diffusion  = f_0p5;
 pRA->specIndex  = 20;
 pRA->specularity= f_0p25;
 pRA->ambience   = f_0p1;
 pRA->absorption = 0;
 pRA->translucence = 0;
 pRA->refraction = 0;
 pRA->transparency = 0;
}
pLighting SetupLighting()
{
 pLightingpL;
 LtSource LS[3];

 /*create light sources */
 Set3dLtSource
 ( &LS[0],65535,65535,65535,f_0p1,
 Int2Fix(  0 ), Int2Fix( 14 ), Int2Fix( 0 )    
 );
 Set3dLtSource
 ( &LS[1],32767, 32767, 32767,f_1+f_0p5,
 Int2Fix( 180 ), Int2Fix( 180 ), Int2Fix( -80 )
 );
 Set3dLtSource
 ( &LS[2],32767, 65535, 65535,fixratio(29,10),
 Int2Fix( -200 ), Int2Fix(  180 ), Int2Fix(  200 )
 );

 /*set ambient light and store point sources */
 pL = NewLighting(32767, 32767, 32767,fixratio(5,100), 3, LS );
 
 /*transform its coordinates into the viewer’s (camera’s) reference frame 
*/
 TransformLighting(pL,&xFormViewer);

 /*apply the ambient light color to the background (if we have color) 
*/
 if( ColorPresent )
 RGBBackColor( &pL->color );
 return pL;
}


 
AAPL
$97.03
Apple Inc.
-0.16
MSFT
$44.40
Microsoft Corpora
-0.47
GOOG
$593.35
Google Inc.
-2.63

MacTech Search:
Community Search:

Software Updates via MacUpdate

Audio Hijack Pro 2.11.0 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Intermission 1.1.1 - Pause and rewind li...
Intermission allows you to pause and rewind live audio from any application on your Mac. Intermission will buffer up to 3 hours of audio, allowing users to skip through any assortment of audio... Read more
Airfoil 4.8.7 - Send audio from any app...
Airfoil allows you to send any audio to AirPort Express units, Apple TVs, and even other Macs and PCs, all in sync! It's your audio - everywhere. With Airfoil you can take audio from any... Read more
Microsoft Remote Desktop 8.0.8 - Connect...
With Microsoft Remote Desktop, you can connect to a remote PC and your work resources from almost anywhere. Experience the power of Windows with RemoteFX in a Remote Desktop client designed to help... Read more
xACT 2.30 - Audio compression toolkit. (...
xACT stands for X Aaudio Compression Toolkit, an application that encodes and decodes FLAC, SHN, Monkey’s Audio, TTA, Wavpack, and Apple Lossless files. It also can encode these formats to MP3, AAC... Read more
Firefox 31.0 - Fast, safe Web browser. (...
Firefox for Mac offers a fast, safe Web browsing experience. Browse quickly, securely, and effortlessly. With its industry-leading features, Firefox is the choice of Web development professionals... Read more
Little Snitch 3.3.3 - Alerts you to outg...
Little Snitch gives you control over your private outgoing data. Track background activityAs soon as your computer connects to the Internet, applications often have permission to send any... Read more
Thunderbird 31.0 - Email client from Moz...
As of July 2012, Thunderbird has transitioned to a new governance model, with new features being developed by the broader free software and open source community, and security fixes and improvements... Read more
Together 3.2 - Store and organize all of...
Together helps you organize your Mac, giving you the ability to store, edit and preview your files in a single clean, uncluttered interface. Smart storage. With simple drag-and-drop functionality,... Read more
Cyberduck 4.5 - FTP and SFTP browser. (F...
Cyberduck is a robust FTP/FTP-TLS/SFTP browser for the Mac whose lack of visual clutter and cleverly intuitive features make it easy to use. Support for external editors and system technologies such... Read more

Latest Forum Discussions

See All

LEX Goes Free For One Day In Honor of Ne...
LEX Goes Free For One Day In Honor of New Update Posted by Jennifer Allen on July 24th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Thomas Was Alone Goes Universal, Slashes...
Thomas Was Alone Goes Universal, Slashes Price to $3.99 Posted by Ellis Spice on July 24th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Meerkatz Challenge Review
Meerkatz Challenge Review By Jennifer Allen on July 24th, 2014 Our Rating: :: FONDLY PUZZLINGUniversal App - Designed for iPhone and iPad Cute and challenging, Meerkatz Challenge is a fun puzzle game, particularly for fans of... | Read more »
Book Your Appointment with F.E.A.R. this...
Book Your Appointment with F.E.A.R. | Read more »
It Came From Canada: Epic Skater
For all the hate that it gets for being a pastime for slackers, skateboarding really does require a lot of skill. All those flips and spins take real athleticism, and there’s all the jargon to memorize. Fortunately for us less extreme individuals,... | Read more »
Cultures Review
Cultures Review By Jennifer Allen on July 24th, 2014 Our Rating: :: SLOW-PACED EMPIRE BUILDINGiPad Only App - Designed for the iPad Cute it might seem, but Cultures is a bit too slow paced when it comes to those pesky timers to... | Read more »
More Paintings Have Been Added to Paint...
More Paintings Have Been Added to Paint it Back! Posted by Jessica Fisher on July 24th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
The Order of Souls Review
The Order of Souls Review By Campbell Bird on July 24th, 2014 Our Rating: :: STORY GRINDUniversal App - Designed for iPhone and iPad The Order of Souls is a free-to-play, turn-based RPG with a genre-mixing art style, interesting... | Read more »
Revolution 60 Review
Revolution 60 Review By Jordan Minor on July 24th, 2014 Our Rating: :: LASS EFFECTUniversal App - Designed for iPhone and iPad Revolution 60 is a bold, cinematic action game with ambition to spare.   | Read more »
Matter (Photography)
Matter 1.0.1 Device: iOS Universal Category: Photography Price: $1.99, Version: 1.0.1 (iTunes) Description: Add stunning 3D effects to your photos with real-time shadows and reflections. Export your creations as photos or video loops... | Read more »

Price Scanner via MacPrices.net

Global Tablet Market Grows 11% in Q2/14 Notwi...
Worldwide tablet sales grew 11.0 percent year over year in the second quarter of 2014, with shipments reaching 49.3 million units according to preliminary data from the International Data Corporation... Read more
Save on 5th generation refurbished iPod touch...
The Apple Store has Apple Certified Refurbished 5th generation iPod touches available starting at $149. Apple’s one-year warranty is included with each model, and shipping is free. Many, but not all... Read more
What Should Apple’s Next MacBook Priority Be;...
Stabley Times’ Phil Moore says that after expanding its iMac lineup with a new low end model, Apple’s next Mac hardware decision will be how it wants to approach expanding its MacBook lineup as well... Read more
ArtRage For iPhone Painting App Free During C...
ArtRage for iPhone is currently being offered for free (regularly $1.99) during Comic-Con San Diego #SDCC, July 24-27, in celebration of the upcoming ArtRage 4.5 and other 64-bit versions of the... Read more
With The Apple/IBM Alliance, Is The iPad Now...
Almost since the iPad was rolled out in 2010, and especially after Apple made a 128 GB storage configuration available in 2012, there’s been debate over whether the iPad is a serious tool for... Read more
MacBook Airs on sale starting at $799, free s...
B&H Photo has the new 2014 MacBook Airs on sale for up to $100 off MSRP for a limited time. Shipping is free, and B&H charges NY sales tax only. They also include free copies of Parallels... Read more
Apple 27″ Thunderbolt Display (refurbished) a...
The Apple Store has Apple Certified Refurbished 27″ Thunderbolt Displays available for $799 including free shipping. That’s $200 off the cost of new models. Read more
WaterField Designs Unveils Cycling Ride Pouch...
High end computer case and bag maker WaterField Designs of San Francisco now enters the cycling market with the introduction of the Cycling Ride Pouch – an upscale toolkit with a scratch-free iPhone... Read more
Kingston Digital Ships Large Capacity Near 1T...
Kingston Digital, Inc., the Flash memory affiliate of Kingston Technology Company, Inc.,has announced its latest addition to the SSDNow V300 series, the V310. The Kingston SSDNow V310 solid-state... Read more
Apple’s Fiscal Third Quarter Results; Record...
Apple has announced financial results for its fiscal 2014 third quarter ended June 28, 2014, racking up quarterly revenue of $37.4 billion and quarterly net profit of $7.7 billion, or $1.28 per... Read more

Jobs Board

Sr. Project Manager for *Apple* Campus 2 -...
…the design and construction of one building or building components of the New Apple Campus located in Cupertino, CA. They will provide project management oversight for Read more
WW Sales Program Manager, *Apple* Online St...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Project Manager / Business Analyst, WW *Appl...
…a senior project manager / business analyst to work within our Worldwide Apple Fulfillment Operations and the Business Process Re-engineering team. This role will work Read more
Sr. Manager, *Apple* Deployment Programs fo...
**Job Summary** Apple is seeking candidates for a new position on the Education Content and Technology team. iPad and Mac is in the hands of millions of teachers and Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.