dsp.cpp

Go to the documentation of this file.

/*
** ---------------------------------------------------------------
** dsp.cpp -  Display class.
**
** ---------------------------------------------------------------
*/

/*
** ---------------------------------------------------------------
** Global variables and symbols:
*/
#include <stdlib.h>
#include <math.h>

#include "cd.h"

#include "dsp.h"
#include "t3d.h"
#include "zbf.h"

/*
** ---------------------------------------------------------------
** Initialization of class variables:
*/
double Dsp::MIN_COLOR_INTENS = 0.50;

int Dsp::FRAMES = 720;

double Dsp::M_PI = 3.141592654;

double Dsp::alpha = 0.0;

double Dsp::delta = 2.0*Dsp::M_PI/Dsp::FRAMES;

Dsp::Vec Dsp::view_vector = { 0.0, 0.0, 0.0 };

Dsp::Vec Dsp::box[8] =
         { { 0.0, 0.0, 0.0 },
           { 1.0, 0.0, 0.0 },
           { 1.0, 2.0, 0.0 },
           { 0.0, 2.0, 0.0 },
           { 0.0, 0.0, 3.0 },
           { 1.0, 0.0, 3.0 },
           { 1.0, 2.0, 3.0 },
           { 0.0, 2.0, 3.0 } };

double Dsp::xmin = 0.0;
double Dsp::xmax = 1.0;
double Dsp::ymin = 0.0;
double Dsp::ymax = 2.0;
double Dsp::zmin = 0.0;
double Dsp::zmax = 3.0;

double Dsp::eyex = 0.0;
double Dsp::eyey = 0.0;
double Dsp::eyez = 0.0;

double Dsp::refx = 0.0;
double Dsp::refy = 0.0;
double Dsp::refz = 0.0;

double Dsp::vupx = 0.0;
double Dsp::vupy = 0.0;
double Dsp::vupz = 0.0;

double Dsp::left = 0.0;
double Dsp::right = 0.0;
double Dsp::bottom = 0.0;
double Dsp::top = 0.0;
double Dsp::front = 0.0;
double Dsp::back = 0.0;

/*
** ---------------------------------------------------------------
** Private class functions:
*/
/*=======================  Dsp::ShadeColor  ========================*/

long int Dsp::ShadeColor( Vec* normal, Vec* view, long int color )
{
 unsigned char red;
 unsigned char green;
 unsigned char blue;
 double        fac;    /* intensity factor */

 DecodeColor( color, &red, &green, &blue );

 fac = VecDot( normal, view );
 fac = fabs( fac );

 fac = MIN_COLOR_INTENS + (1.0 - MIN_COLOR_INTENS) * fac;

 if( fac < 0.0 )
  fac = 0.0;
 else if( fac > 1.0 )
  fac = 1.0;

 red   = (unsigned char)(fac * (double)red);
 green = (unsigned char)(fac * (double)green);
 blue  = (unsigned char)(fac * (double)blue);

 return( EncodeColor( red, green, blue ) );
}

/*======================  Dsp::DisplaySolid  =======================*/

void Dsp::DisplaySolid( void )
{
 /* Face -x */
 ZbfBeginPoly( CD_GREEN, -1.0, 0.0, 0.0 );
 ZbfVertex( box[0].x, box[0].y, box[0].z );
 ZbfVertex( box[4].x, box[4].y, box[4].z );
 ZbfVertex( box[7].x, box[7].y, box[7].z );
 ZbfVertex( box[3].x, box[3].y, box[3].z );
 ZbfEndPoly( );

 /* Face -y */
 ZbfBeginPoly( CD_CYAN, 0.0, -1.0, 0.0 );
 ZbfVertex( box[0].x, box[0].y, box[0].z );
 ZbfVertex( box[1].x, box[1].y, box[1].z );
 ZbfVertex( box[5].x, box[5].y, box[5].z );
 ZbfVertex( box[4].x, box[4].y, box[4].z );
 ZbfEndPoly( );

 /* Face -z */
 ZbfBeginPoly( CD_YELLOW, 0.0, 0.0, -1.0 );
 ZbfVertex( box[3].x, box[3].y, box[3].z );
 ZbfVertex( box[2].x, box[2].y, box[2].z );
 ZbfVertex( box[1].x, box[1].y, box[1].z );
 ZbfVertex( box[0].x, box[0].y, box[0].z );
 ZbfEndPoly( );

 /* Face +x */
 ZbfBeginPoly( CD_GREEN, 1.0, 0.0, 0.0 );
 ZbfVertex( box[1].x, box[1].y, box[1].z );
 ZbfVertex( box[2].x, box[2].y, box[2].z );
 ZbfVertex( box[6].x, box[6].y, box[6].z );
 ZbfVertex( box[5].x, box[5].y, box[5].z );
 ZbfEndPoly( );

 /* Face +y */
 ZbfBeginPoly( CD_CYAN, 0.0, 1.0, 0.0 );
 ZbfVertex( box[2].x, box[2].y, box[2].z );
 ZbfVertex( box[3].x, box[3].y, box[3].z );
 ZbfVertex( box[7].x, box[7].y, box[7].z );
 ZbfVertex( box[6].x, box[6].y, box[6].z );
 ZbfEndPoly( );

 /* Face +z */
 ZbfBeginPoly( CD_YELLOW, 0.0, 0.0, 1.0 );
 ZbfVertex( box[4].x, box[4].y, box[4].z );
 ZbfVertex( box[5].x, box[5].y, box[5].z );
 ZbfVertex( box[6].x, box[6].y, box[6].z );
 ZbfVertex( box[7].x, box[7].y, box[7].z );
 ZbfEndPoly( );
}

/*=======================  Dsp::ZbfBeginPoly  ======================*/

void Dsp::ZbfBeginPoly( long int color, double nx, double ny, double nz )
{
 Vec normal;            /* face normal vector */
 long int shaded_color; /* face color with modified intensity */

 normal.x = nx;
 normal.y = ny;
 normal.z = nz;
 shaded_color = ShadeColor( &normal, &view_vector, color );
 Zbf::BeginPoly( shaded_color );
}

/*=========================  Dsp::ZbfVertex  =======================*/

void Dsp::ZbfVertex( double x, double y, double z )
{
 T3d::Transform( &x, &y, &z );
 Zbf::Vertex( x, y, z );
}

/*========================  Dsp::ZbfEndPoly  =======================*/

void Dsp::ZbfEndPoly( void )
{
 Zbf::EndPoly( );
}

/*
** ---------------------------------------------------------------
** Public class functions:
**
*/
/*========================  Dsp::SetupView  ========================*/

void Dsp::SetupView( cdCanvas* zbuffer_canvas )
{
 int width, height;
 double sizex, sizey, sizez;
 double max_size;
 double size_w, size_h;
 double ratio;

 cdCanvasGetSize( zbuffer_canvas, &width, &height, 0L, 0L );

 sizex = xmax - xmin;
 sizey = ymax - ymin;
 sizez = zmax - zmin;
 max_size = MAX( sizex, sizey );
 max_size = MAX( max_size, sizez );

/* Place reference point at center of bounding box.
 */
 refx = (xmin + xmax) * 0.5;
 refy = (ymin + ymax) * 0.5;
 refz = (zmin + zmax) * 0.5;

/* Place camera with same x coordinate of reference point, distant
 * 4 "max_sizes" to reference point in y direction, and distant
 * 2 "max_size" to reference point in z direction.
 */
 eyex = refx;
 eyey = refy + 4.0*max_size;
 eyez = refz + 2.0*max_size;

/* Define camera vertical plane perpendicular to xy plane.
 */
 vupx = 0.0;
 vupy = 0.0;
 vupz = 1.0;

/* Define view window with aspect ration equal to canvas 
 * and display entire object.
 */
 size_w = size_h = max_size;
 ratio = (double)height / (double)width;
 if( ratio < 1.0 )
  size_w = size_h / ratio;
 else
  size_h = size_w * ratio;

/* Define view volume parameters such that:
 * (1) view window center coincides with canvas center;
 * (2) front clip plane is located at 3 "max_sizes" from camera;
 * (3) back  clip plane is located at 5 "max_sizes" from camera;
 */
 left = -size_w * 0.5;
 right = size_w * 0.5;
 bottom = -size_h * 0.5;
 top = size_h * 0.5;
 front = 3.0 * max_size;
 back = 5.0 * max_size;
}

/*========================  Dsp::RotateView  =======================*/

void Dsp::RotateView( void )
{
/* Increment rotation angle.
 */
 alpha += delta;

/* Define rotation radius equal to distance between camera and
 * reference point projected on xy plane.
 */
 double radius = sqrt( (eyex-refx)*(eyex-refx) +
                       (eyey-refy)*(eyey-refy) );

/* Update camera position, rotation it about reference point around
 * z axis.
 */
 eyex = refx + radius*sin( alpha );
 eyey = refy + radius*cos( alpha );
}

/*=========================  Dsp::ZbfModel  ========================*/

void Dsp::ZbfModel( cdCanvas* zbuffer_canvas )
{
 cdCanvasActivate( zbuffer_canvas );

/* Set gray background color and clear canvas.
 */
 unsigned char gray_intensity = (unsigned char)(0.75 * 255.0);
 cdCanvasBackground( zbuffer_canvas, 
               EncodeColor(gray_intensity, gray_intensity, gray_intensity) );
 cdCanvasClear( zbuffer_canvas );

/* Compute normalized view vector.
 */
 view_vector.x = refx - eyex;
 view_vector.y = refy - eyey;
 view_vector.z = refz - eyez;
 VecUnit( &view_vector, &view_vector );

/* Build a 3D transformation that transforms from world (object)
 * coordinates to normalized screen coordinates (the view frustum
 * is transformed into a cube of size 2 and center at origin).
 * Use perspective projection, placing the projection plane at
 * the front view volume plane (OpenGL does this way).
 */
 T3d::Identity( );
/*** COMPLETE AQUI: DSP-01 ***/



/*** COMPLETE AQUI: DSP-01 ***/

/* Display the model in the zbuffer canvas.
 */
 DisplaySolid( );
}

---