---

quad.c

Go to the documentation of this file.

/*
** ----------------------------------------------------------------
** quad.c  -  Quadrilateral primitive module.
**
** ----------------------------------------------------------------
*/

/*
** ---------------------------------------------------------------
** Global variables and symbols:
*/
#ifdef _WIN32
#include <windows.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include "prm.h"
#include "quad.h"
#include "cd.h"
#include "wd.h"
#include "dsp.h"

/*
** ---------------------------------------------------------------
** Local variables and symbols:
*/

struct _quad {
  Coord         p[4];
 };


/*
** ---------------------------------------------------------------
** Private functions:
*/
static void quadPickCode( double x, double y, double xmin, double xmax,
                          double ymin, double ymax, int cod[4] );
static int quadPickLine( double x, double y, double pick_tol,
                         double x0, double y0, double x1, double y1 );
static void quadFaceNormal( Pnt3d *p0, Pnt3d *p1, Pnt3d *p2, Pnt3d *p3,
                            Vec3d *normal );
static void quadBuildSolidPrm( Quad *quad, double height, Pnt3d *solid_prm );

/*=========================  quadPickCode  =======================*/

static void quadPickCode( double x, double y, double xmin, double xmax,
                          double ymin, double ymax, int cod[4] )
{
 cod[0] = x < xmin;
 cod[1] = x > xmax;
 cod[2] = y < ymin;
 cod[3] = y > ymax;
}

/*=========================  quadPickLine  =======================*/
  
static int quadPickLine( double x, double y, double pick_tol,
                         double x0, double y0, double x1, double y1 )
{
 int    cod0[4], cod1[4];       /* pick code vectors of line points */
 double xmin, xmax, ymin, ymax; /* tolerance window for checking proximity  */
 int    j;

 xmin = x - pick_tol;
 xmax = x + pick_tol;
 ymin = y - pick_tol;
 ymax = y + pick_tol;

 quadPickCode( x1, y1, xmin, xmax, ymin, ymax, cod1 );
 do
 {
  quadPickCode( x0, y0, xmin, xmax, ymin, ymax, cod0 );
  for( j = 0; j < 4; j++ )
  {
   if( cod0[j] && cod1[j] )     /* test no-trivial pick */
    break;
  }
  if( j != 4 )
   break;

/* move line point 0 to window limit 
 */
  if( cod0[0] )
  {
   y0 += (xmin - x0) * (y1 - y0) / (x1 - x0);
   x0 = xmin;
  }
  else if( cod0[1] )
  {
   y0 += (xmax - x0) * (y1 - y0) / (x1 - x0);
   x0 = xmax;
  }
  else if( cod0[2] )
  {
   x0 += (ymin - y0 ) * (x1 - x0) / (y1 - y0);
   y0 = ymin;
  }
  else if( cod0[3] )
  {
   x0 += (ymax - y0) * (x1 - x0) / (y1 - y0);
   y0 = ymax;
  }
  else
  {
   return( 1 );
  }
 } while( 1 );

 return( 0 );
}

/*=======================  quadFaceNormal  =======================*/

static void quadFaceNormal( Pnt3d *p0, Pnt3d *p1, Pnt3d *p2, Pnt3d *p3,
                            Vec3d *normal )
{
 double len;

 normal->x = 0.0;
 normal->y = 0.0;
 normal->z = 0.0;

 normal->x +=  (p1->y - p0->y) * (p2->z - p0->z) -
               (p1->z - p0->z) * (p2->y - p0->y);
 normal->y += -(p1->x - p0->x) * (p2->z - p0->z) +
               (p1->z - p0->z) * (p2->x - p0->x);
 normal->z +=  (p1->x - p0->x) * (p2->y - p0->y) -
               (p1->y - p0->y) * (p2->x - p0->x);

 normal->x +=  (p2->y - p0->y) * (p3->z - p0->z) -
               (p2->z - p0->z) * (p3->y - p0->y);
 normal->y += -(p2->x - p0->x) * (p3->z - p0->z) +
               (p2->z - p0->z) * (p3->x - p0->x);
 normal->z +=  (p2->x - p0->x) * (p3->y - p0->y) -
               (p2->y - p0->y) * (p3->x - p0->x);

 len = sqrt( normal->x*normal->x + normal->y*normal->y + normal->z*normal->z );

 if( len != 0.0 )
 {
  normal->x /= len;
  normal->y /= len;
  normal->z /= len;
 }
}

/*======================  quadBuildSolidPrm  ======================*/

static void quadBuildSolidPrm( Quad *quad, double height, Pnt3d *solid_prm )
{
 Pnt3d face[4];
 Vec3d prm_norm;

/* Build a temporary face with the primitive points.
 */
 face[0].x = quad->p[0].x;
 face[0].y = quad->p[0].y;
 face[0].z = 0.0;
 face[1].x = quad->p[1].x;
 face[1].y = quad->p[1].y;
 face[1].z = 0.0;
 face[2].x = quad->p[2].x;
 face[2].y = quad->p[2].y;
 face[2].z = 0.0;
 face[3].x = quad->p[3].x;
 face[3].y = quad->p[3].y;
 face[3].z = 0.0;

/* Compute the normal vector of the 2D primitive to find out whether
 * it has a clockwise or counter-clockwise orientation.
 * A negative z component of the normal vector indicates a 
 * clockwise orientation.
 */
 quadFaceNormal( &face[0], &face[1], &face[2], &face[3], &prm_norm );

/* Build solid version of primitive with the base faces with normal
 * vectors pointing outward when traversing the vertices in 
 * counter-clockwise orientation. 
 */
 if( prm_norm.z < 0.0 )
 {
  solid_prm[0] = face[0];
  solid_prm[1] = face[1];
  solid_prm[2] = face[2];
  solid_prm[3] = face[3];
  
  solid_prm[4] = face[0];
  solid_prm[5] = face[3];
  solid_prm[6] = face[2];
  solid_prm[7] = face[1];
 }
 else
 {
  solid_prm[0] = face[0];
  solid_prm[1] = face[3];
  solid_prm[2] = face[2];
  solid_prm[3] = face[1];

  solid_prm[4] = face[0];
  solid_prm[5] = face[1];
  solid_prm[6] = face[2];
  solid_prm[7] = face[3];
 }
 solid_prm[4].z += height;
 solid_prm[5].z += height;
 solid_prm[6].z += height;
 solid_prm[7].z += height;
}


/*
** ---------------------------------------------------------------
** Public functions:
*/

/*=========================  quadCreate  ========================*/

Quad *quadCreate( void )
{
 Quad *quad;

/* Allocate memory for a new primitive.
 */
 quad = malloc( sizeof( Quad ) );
 if( quad == NULL )
  return( NULL );

/* Set default values for new primitive.
 */
 quad->p[0].x = 0.0;
 quad->p[0].y = 0.0;
 quad->p[1].x = 1.0;
 quad->p[1].y = 1.0;
 quad->p[2].x = 1.0;
 quad->p[2].y = 0.0;
 quad->p[3].x = 0.0;
 quad->p[3].y = 1.0;

 return( quad );
}

/*=========================  quadDelete  ========================*/

void quadDelete( Quad *quad )
{
 free( quad );
}

/*==========================  quadRead  =========================*/

void quadRead( Quad *quad, FILE *fd )
{
/*** COMPLETE HERE: 16 ***/
}

/*=========================  quadWrite  =========================*/

void quadWrite( Quad *quad, FILE *fd )
{
/*** COMPLETE HERE: 17 ***/
}

/*========================  quadGetNPts  ========================*/

int quadGetNPts( Quad *quad )
{
 return( 4 );
}

/*=======================  quadSetCoords  =======================*/

void quadSetCoords( Quad *quad, int id, double x, double y )
{
/*** COMPLETE HERE: 18 ***/
}

/*=======================  quadGetCoords  =======================*/

void quadGetCoords( Quad *quad, int id, double *x, double *y )
{
/*** COMPLETE HERE: 19 ***/
}

/*=======================  quadSet1stPt  ========================*/

void quadSet1stPt( Quad *quad, double x, double y )
{
/*** COMPLETE HERE: 20 ***/
}

/*=======================  quadSet2ndPt  ========================*/

void quadSet2ndPt( Quad *quad, double x, double y )
{
/*** COMPLETE HERE: 21 ***/
}

/*=======================  quadPickArea  ========================*/

int quadPickArea( Quad *quad, double x, double y )
{
 int     ni = 0;            /* no. of intersections of ray with polygon */
 double  px0, py0;          /* coordinates of current edge first point */
 double  px1, py1;          /* coordinates of current edge second point */
 double  xc;                /* x coordinate of intersection point */
 int     i;

 for( i = 0; i < 4; i++ )
 {
  quadGetCoords( quad,       i, &px0, &py0 );
  quadGetCoords( quad, (i+1)%4, &px1, &py1 );
  if( !(py0 == py1) &&                /* disregard horizontal edges */
      !((py0 > y) && (py1 > y)) &&    /* disregard edges above point */
      !((py0 < y) && (py1 < y)) &&    /* disregard edges below point */
      !((px0 < x) && (px1 < x)) )     /* disregard edges to the left */
  {
   if( py0 == y )   /* first edge point at same level of given point */
   {
    if( (px0 > x) && (py1 > y) )
     ni++;           /* edge above and to the right of given point */
   }
   else
   {
    if( py1 == y )   /* second edge point at same level of given point */
    {
     if( (px1 > x) && (py0 > y) )
      ni++;          /* edge above and to the right of given point */
    }
    else     /* given point level is within edge end levels */
    {
     if( (px0 > x) && (px1 > x) )
      ni++;  /* edge is completely to the right of given point */
     else
     {       /* check to see whether intersection point is to the right */
      double dx = px0 - px1;
      xc = px0;
      if( dx != 0.0 )
        xc += ( y - py0 ) * dx / ( py0 - py1 );
      if( xc > x )
        ni++;
     }
    }
   }
  }
 }

 return( ni % 2 );
}

/*======================  quadPickVertex  =======================*/

int quadPickVertex( Quad *quad, double x, double y, double tol,
                    int *id )
{
/*** COMPLETE HERE: 22 ***/
 
 return( 0 );
}

/*=======================  quadPickSide  ========================*/

int quadPickSide( Quad *quad, double x, double y, double tol,
                  int *id )
{
/*** COMPLETE HERE: 23 ***/

 return( 0 );
}

/*=======================  quadTranslate  =======================*/

void quadTranslate( Quad *quad, double dx, double dy )
{
/*** COMPLETE HERE: 24 ***/
}

/*====================  quadTranslateVertex  ====================*/

void quadTranslateVertex( Quad *quad, int id, double dx, double dy )
{
/*** COMPLETE HERE: 25 ***/
}

/*=====================  quadTranslateSide  =====================*/

void quadTranslateSide( Quad *quad, int id, double dx, double dy )
{
/*** COMPLETE HERE: 26 ***/
}

/*=========================  quadGetBox  ========================*/

void quadGetBox( Quad *quad, double *xmin, double *xmax, 
                             double *ymin, double *ymax )
{
/*** COMPLETE HERE: 27 ***/
}

/*====================  quadDisplayBoundary  ====================*/

void quadDisplayBoundary( Quad *quad )
{
/*** COMPLETE HERE: 28 ***/
}

/*====================  quadDisplayInterior  ====================*/

void quadDisplayInterior( Quad *quad )
{
/*** COMPLETE HERE: 29 ***/
}

/*=====================  quadDisplaySolid  ======================*/

void quadDisplaySolid( Quad *quad, double height )
{
/*** COMPLETE HERE: 29-A ***/
/*** Study function quadDisplayZbuffer below ***/
/*** Use OpenGL functions ***/
}

/*======================  quadHighltSolid  ======================*/

void quadHighltSolid( Quad *quad, double height )
{
/*** COMPLETE HERE: 29-B ***/
/*** Use OpenGL functions ***/
}

/*====================  quadDisplayZbuffer  =====================*/

void quadDisplayZbuffer( Quad *quad, double height, long int color )
{
 Pnt3d solid_prm[8];    /* solid version of primitive */
 Vec3d normal;          /* face normal vector */
 
/* If the height of the primitive is null,
 * just display one face: the primitive.
 * To display means to project the face and send it to the zbuffer module.
 */
 if( height == 0.0 )
 {
  dspZbfBeginPoly( color, 0.0, 0.0, 1.0 );
  dspZbfVertex( quad->p[0].x, quad->p[0].y, 0.0 );
  dspZbfVertex( quad->p[1].x, quad->p[1].y, 0.0 );
  dspZbfVertex( quad->p[2].x, quad->p[2].y, 0.0 );
  dspZbfVertex( quad->p[3].x, quad->p[3].y, 0.0 );
  dspZbfEndPoly( );
  return;
 }
 
/* Build solid version.
 */
 quadBuildSolidPrm( quad, height, solid_prm );
 
/* Display base faces (send to zbuffer module).
 */
 dspZbfBeginPoly( color, 0.0, 0.0, -1.0 );
 dspZbfVertex( solid_prm[0].x, solid_prm[0].y, solid_prm[0].z );
 dspZbfVertex( solid_prm[1].x, solid_prm[1].y, solid_prm[1].z );
 dspZbfVertex( solid_prm[2].x, solid_prm[2].y, solid_prm[2].z );
 dspZbfVertex( solid_prm[3].x, solid_prm[3].y, solid_prm[3].z );
 dspZbfEndPoly( );

 dspZbfBeginPoly( color, 0.0, 0.0, 1.0 );
 dspZbfVertex( solid_prm[4].x, solid_prm[4].y, solid_prm[4].z );
 dspZbfVertex( solid_prm[5].x, solid_prm[5].y, solid_prm[5].z );
 dspZbfVertex( solid_prm[6].x, solid_prm[6].y, solid_prm[6].z );
 dspZbfVertex( solid_prm[7].x, solid_prm[7].y, solid_prm[7].z );
 dspZbfEndPoly( );

/* Display lateral faces (send to zbuffer module).
 */
 quadFaceNormal( &solid_prm[0], &solid_prm[4], &solid_prm[7], &solid_prm[1],
                 &normal );
 dspZbfBeginPoly( color, normal.x, normal.y, normal.z );
 dspZbfVertex( solid_prm[0].x, solid_prm[0].y, solid_prm[0].z );
 dspZbfVertex( solid_prm[4].x, solid_prm[4].y, solid_prm[4].z );
 dspZbfVertex( solid_prm[7].x, solid_prm[7].y, solid_prm[7].z );
 dspZbfVertex( solid_prm[1].x, solid_prm[1].y, solid_prm[1].z );
 dspZbfEndPoly( );

 quadFaceNormal( &solid_prm[1], &solid_prm[7], &solid_prm[6], &solid_prm[2],
                 &normal );
 dspZbfBeginPoly( color, normal.x, normal.y, normal.z );
 dspZbfVertex( solid_prm[1].x, solid_prm[1].y, solid_prm[1].z );
 dspZbfVertex( solid_prm[7].x, solid_prm[7].y, solid_prm[7].z );
 dspZbfVertex( solid_prm[6].x, solid_prm[6].y, solid_prm[6].z );
 dspZbfVertex( solid_prm[2].x, solid_prm[2].y, solid_prm[2].z );
 dspZbfEndPoly( );

 quadFaceNormal( &solid_prm[2], &solid_prm[6], &solid_prm[5], &solid_prm[3],
                 &normal );
 dspZbfBeginPoly( color, normal.x, normal.y, normal.z );
 dspZbfVertex( solid_prm[2].x, solid_prm[2].y, solid_prm[2].z );
 dspZbfVertex( solid_prm[6].x, solid_prm[6].y, solid_prm[6].z );
 dspZbfVertex( solid_prm[5].x, solid_prm[5].y, solid_prm[5].z );
 dspZbfVertex( solid_prm[3].x, solid_prm[3].y, solid_prm[3].z );
 dspZbfEndPoly( );

 quadFaceNormal( &solid_prm[3], &solid_prm[5], &solid_prm[4], &solid_prm[0],
                 &normal );
 dspZbfBeginPoly( color, normal.x, normal.y, normal.z );
 dspZbfVertex( solid_prm[3].x, solid_prm[3].y, solid_prm[3].z );
 dspZbfVertex( solid_prm[5].x, solid_prm[5].y, solid_prm[5].z );
 dspZbfVertex( solid_prm[4].x, solid_prm[4].y, solid_prm[4].z );
 dspZbfVertex( solid_prm[0].x, solid_prm[0].y, solid_prm[0].z );
 dspZbfEndPoly( );
}

 solid_prm[5].x, solid_prm[5].y, solid_prm[5].z );
 dspZbfVertex( solid_prm[3].x, solid_prm[3].y, solid_prm[3].z );
 dspZbfEndPoly( );

 quadFaceNormal( &solid_prm[3], &solid_prm[5], &solid_prm[4], &solid_prm[0],
                 &normal );
 dspZbfBeginPoly( color, normal.x, normal.y, normal.z );
 dspZbfVertex( solid_prm[3].x, solid_prm[3].y, solid_prm[3].z );
 dspZbfVertex( solid_prm[5].x, solid_prm[5].y, solid_prm[5].z );
 dspZbfVertex( solid_prm[4].x, solid_prm[4].y, solid_prm[4].z );
 dspZbfVertex( solid_prm[0].x, solid_prm[0].y, solid_prm[0].z );
 dspZbfEndPoly( );
}

---