backend.cc

/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
*/

/*
 * backend.c++
 *
 */

/* Bezier surface backend
        - interprets display mode (wireframe,shaded,...)
*/
#include <stdio.h>
#include "glimports.h"
#include "mystdio.h"
#include "backend.h"
#include "basiccrveval.h"
#include "basicsurfeval.h"
#include "nurbsconsts.h"

#define NOWIREFRAME


/*-------------------------------------------------------------------------
 * bgnsurf - preamble to surface definition and evaluations
 *-------------------------------------------------------------------------
 */
void
Backend::bgnsurf( int wiretris, int wirequads, long nuid )
{
/*#ifndef NOWIREFRAME*/ //need this for old version
    wireframetris = wiretris;
    wireframequads = wirequads;
/*#endif*/

    /*in the spec, GLU_DISPLAY_MODE is either
     * GLU_FILL
     * GLU_OUTLINE_POLY
     * GLU_OUTLINE_PATCH.
     *In fact, GLU_FLL is has the same effect as
     * set GL_FRONT_AND_BACK to be GL_FILL
     * and GLU_OUTLINE_POLY is the same as set 
     *     GL_FRONT_AND_BACK to be GL_LINE
     *It is more efficient to do this once at the beginning of
     *each surface than to do it for each primitive.
     *   The internal has more options: outline_triangle and outline_quad
     *can be seperated. But since this is not in spec, and more importantly,
     *this is not so useful, so we don't need to keep this option.
     */

    surfaceEvaluator.bgnmap2f( nuid );

    if(wiretris)
      surfaceEvaluator.polymode(N_MESHLINE);
    else
      surfaceEvaluator.polymode(N_MESHFILL);
}

void
Backend::patch( REAL ulo, REAL uhi, REAL vlo, REAL vhi )
{
    surfaceEvaluator.domain2f( ulo, uhi, vlo, vhi );
}

void
Backend::surfbbox( long type, REAL *from, REAL *to )
{
    surfaceEvaluator.range2f( type, from, to );
}

/*-------------------------------------------------------------------------
 * surfpts - pass a desription of a surface map
 *-------------------------------------------------------------------------
 */
void 
Backend::surfpts(
    long type,          /* geometry, color, texture, normal     */
    REAL *pts,          /* control points                       */
    long ustride,       /* distance to next point in u direction */
    long vstride,       /* distance to next point in v direction */
    int uorder, /* u parametric order                   */
    int vorder, /* v parametric order                   */
    REAL ulo,           /* u lower bound                        */
    REAL uhi,           /* u upper bound                        */
    REAL vlo,           /* v lower bound                        */
    REAL vhi )          /* v upper bound                        */
{
    surfaceEvaluator.map2f( type,ulo,uhi,ustride,uorder,vlo,vhi,vstride,vorder,pts );
    surfaceEvaluator.enable( type );
}

/*-------------------------------------------------------------------------
 * surfgrid - define a lattice of points with origin and offset
 *-------------------------------------------------------------------------
 */
void
Backend::surfgrid( REAL u0, REAL u1, long nu, REAL v0, REAL v1, long nv )
{
    surfaceEvaluator.mapgrid2f( nu, u0, u1, nv, v0, v1 );
}

/*-------------------------------------------------------------------------
 * surfmesh - evaluate a mesh of points on lattice
 *-------------------------------------------------------------------------
 */
void
Backend::surfmesh( long u, long v, long n, long m )
{
#ifndef NOWIREFRAME
    if( wireframequads ) {
        long v0,  v1;
        long u0f = u, u1f = u+n;
        long v0f = v, v1f = v+m;
        long parity = (u & 1);

        for( v0 = v0f, v1 = v0f++ ; v0<v1f; v0 = v1, v1++ ) {
            surfaceEvaluator.bgnline();
            for( long u = u0f; u<=u1f; u++ ) {
                if( parity ) {
                    surfaceEvaluator.evalpoint2i( u, v0 );
                    surfaceEvaluator.evalpoint2i( u, v1 );
                } else {
                    surfaceEvaluator.evalpoint2i( u, v1 );
                    surfaceEvaluator.evalpoint2i( u, v0 );
                }
                parity = 1 - parity;
            }
            surfaceEvaluator.endline();
        }
    } else {
        surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m );
    }
#else
    if( wireframequads ) {

        surfaceEvaluator.mapmesh2f( N_MESHLINE, u, u+n, v, v+m );
    } else {

        surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m );
    }
#endif
}

/*-------------------------------------------------------------------------
 * endsurf - postamble to surface
 *-------------------------------------------------------------------------
 */
void
Backend::endsurf( void )
{
    surfaceEvaluator.endmap2f();
}

/***************************************/
void
Backend::bgntfan( void )
{
  surfaceEvaluator.bgntfan();
/*
  if(wireframetris)     
    surfaceEvaluator.polymode( N_MESHLINE );
  else
    surfaceEvaluator.polymode( N_MESHFILL );
*/
}

void
Backend::endtfan( void )
{
   surfaceEvaluator.endtfan();
}

void
Backend::bgnqstrip( void )
{
   surfaceEvaluator.bgnqstrip();
/*
  if(wireframequads)
    surfaceEvaluator.polymode( N_MESHLINE );
  else
    surfaceEvaluator.polymode( N_MESHFILL );    
*/
}

void
Backend::endqstrip( void )
{
   surfaceEvaluator.endqstrip();
}

void
Backend::evalUStrip(int n_upper, REAL v_upper, REAL* upper_val,
                       int n_lower, REAL v_lower, REAL* lower_val
                       )
{
        surfaceEvaluator.evalUStrip(n_upper, v_upper, upper_val, 
                                      n_lower, v_lower, lower_val);
}

void 
Backend::evalVStrip(int n_left, REAL u_left, REAL* left_val, 
                    int n_right, REAL u_right, REAL* right_val
                    )
{
  surfaceEvaluator.evalVStrip(n_left, u_left, left_val,
                                n_right, u_right, right_val);
}

/***************************************/
   

/*-------------------------------------------------------------------------
 * bgntmesh - preamble to a triangle mesh
 *-------------------------------------------------------------------------
 */
void
Backend::bgntmesh( const char * )               
{
#ifndef NOWIREFRAME

    meshindex = 0;      /* I think these need to be initialized to zero */
    npts = 0;

    if( !wireframetris ) {
        surfaceEvaluator.bgntmesh();
    }
#else

    if( wireframetris ) {
        surfaceEvaluator.bgntmesh();
        surfaceEvaluator.polymode( N_MESHLINE );
    } else {
        surfaceEvaluator.bgntmesh();
        surfaceEvaluator.polymode( N_MESHFILL );
    }
#endif
}

void
Backend::tmeshvert( GridTrimVertex *v )
{
    if( v->isGridVert() ) {
        tmeshvert( v->g );
    } else {
        tmeshvert( v->t );
    }
}

void
Backend::tmeshvertNOGE(TrimVertex *t)
{
//      surfaceEvaluator.inDoEvalCoord2NOGE( t->param[0], t->param[1], temp, ttt);
#ifdef USE_OPTTT
        surfaceEvaluator.inDoEvalCoord2NOGE( t->param[0], t->param[1], t->cache_point, t->cache_normal);    
#endif
}

//opt for a line with the same u.
void
Backend::tmeshvertNOGE_BU(TrimVertex *t)
{
#ifdef USE_OPTTT
        surfaceEvaluator.inDoEvalCoord2NOGE_BU( t->param[0], t->param[1], t->cache_point, t->cache_normal);    
#endif
}

//opt for a line with the same v.
void
Backend::tmeshvertNOGE_BV(TrimVertex *t)
{
#ifdef USE_OPTTT
        surfaceEvaluator.inDoEvalCoord2NOGE_BV( t->param[0], t->param[1], t->cache_point, t->cache_normal);    
#endif
}

void
Backend::preEvaluateBU(REAL u)
{
        surfaceEvaluator.inPreEvaluateBU_intfac(u);
}

void 
Backend::preEvaluateBV(REAL v)
{
        surfaceEvaluator.inPreEvaluateBV_intfac(v);
}


/*-------------------------------------------------------------------------
 * tmeshvert - evaluate a point on a triangle mesh
 *-------------------------------------------------------------------------
 */
void
Backend::tmeshvert( TrimVertex *t )
{

#ifndef NOWIREFRAME
    const long nuid = t->nuid;
#endif
    const REAL u = t->param[0];
    const REAL v = t->param[1];

#ifndef NOWIREFRAME
    npts++;
    if( wireframetris ) {
        if( npts >= 3 ) {
            surfaceEvaluator.bgnclosedline();
            if( mesh[0][2] == 0 )
                surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] );
            else
                surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] );
            if( mesh[1][2] == 0 )
                surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] );
            else
                surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] );
            surfaceEvaluator.evalcoord2f( nuid, u, v );
            surfaceEvaluator.endclosedline();
        }
        mesh[meshindex][0] = u;
        mesh[meshindex][1] = v;
        mesh[meshindex][2] = 0;
        mesh[meshindex][3] = nuid;
        meshindex = (meshindex+1) % 2;
    } else {
        surfaceEvaluator.evalcoord2f( nuid, u, v );
    }
#else
          
          surfaceEvaluator.evalcoord2f( 0, u, v );
//for uninitial memory read          surfaceEvaluator.evalcoord2f( nuid, u, v );
#endif
}

//the same as tmeshvert(trimvertex), for efficiency purpose
void
Backend::tmeshvert( REAL u, REAL v )
{
#ifndef NOWIREFRAME
    const long nuid = 0;
    
    npts++;
    if( wireframetris ) {
        if( npts >= 3 ) {
            surfaceEvaluator.bgnclosedline();
            if( mesh[0][2] == 0 )
                surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] );
            else
                surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] );
            if( mesh[1][2] == 0 )
                surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] );
            else
                surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] );
            surfaceEvaluator.evalcoord2f( nuid, u, v );
            surfaceEvaluator.endclosedline();
        }
        mesh[meshindex][0] = u;
        mesh[meshindex][1] = v;
        mesh[meshindex][2] = 0;
        mesh[meshindex][3] = nuid;
        meshindex = (meshindex+1) % 2;
    } else {
        surfaceEvaluator.evalcoord2f( nuid, u, v );
    }
#else
          
          surfaceEvaluator.evalcoord2f( 0, u, v );
#endif
}

/*-------------------------------------------------------------------------
 * tmeshvert - evaluate a grid point of a triangle mesh
 *-------------------------------------------------------------------------
 */
void
Backend::tmeshvert( GridVertex *g )
{
    const long u = g->gparam[0];
    const long v = g->gparam[1];

#ifndef NOWIREFRAME
    npts++;
    if( wireframetris ) {
        if( npts >= 3 ) {
            surfaceEvaluator.bgnclosedline();
            if( mesh[0][2] == 0 )
                surfaceEvaluator.evalcoord2f( (long) mesh[0][3], mesh[0][0], mesh[0][1] );
            else
                surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] );
            if( mesh[1][2] == 0 )
                surfaceEvaluator.evalcoord2f( (long) mesh[1][3], mesh[1][0], mesh[1][1] );
            else
                surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] );
            surfaceEvaluator.evalpoint2i( u, v );
            surfaceEvaluator.endclosedline();
        }
        mesh[meshindex][0] = u;
        mesh[meshindex][1] = v;
        mesh[meshindex][2] = 1;
        meshindex = (meshindex+1) % 2;
    } else {
        surfaceEvaluator.evalpoint2i( u, v );
    }
#else
    surfaceEvaluator.evalpoint2i( u, v );
#endif
}

/*-------------------------------------------------------------------------
 * swaptmesh - perform a swap of the triangle mesh pointers
 *-------------------------------------------------------------------------
 */
void
Backend::swaptmesh( void )
{
#ifndef NOWIREFRAME
    if( wireframetris ) {
        meshindex = 1 - meshindex;
    } else {
        surfaceEvaluator.swaptmesh();
    }
#else
    surfaceEvaluator.swaptmesh();
#endif
}

/*-------------------------------------------------------------------------
 * endtmesh - postamble to triangle mesh
 *-------------------------------------------------------------------------
 */
void
Backend::endtmesh( void )
{
#ifndef NOWIREFRAME
    if( ! wireframetris )
        surfaceEvaluator.endtmesh();
#else
    surfaceEvaluator.endtmesh();
/*    surfaceEvaluator.polymode( N_MESHFILL );*/
#endif
}


/*-------------------------------------------------------------------------
 * bgnoutline - preamble to outlined rendering
 *-------------------------------------------------------------------------
 */
void
Backend::bgnoutline( void )
{
    surfaceEvaluator.bgnline();
}

/*-------------------------------------------------------------------------
 * linevert - evaluate a point on an outlined contour
 *-------------------------------------------------------------------------
 */
void
Backend::linevert( TrimVertex *t )
{
    surfaceEvaluator.evalcoord2f( t->nuid, t->param[0], t->param[1] );
}

/*-------------------------------------------------------------------------
 * linevert - evaluate a grid point of an outlined contour
 *-------------------------------------------------------------------------
 */
void
Backend::linevert( GridVertex *g )
{
    surfaceEvaluator.evalpoint2i( g->gparam[0], g->gparam[1] );
}

/*-------------------------------------------------------------------------
 * endoutline - postamble to outlined rendering
 *-------------------------------------------------------------------------
 */
void
Backend::endoutline( void )
{
    surfaceEvaluator.endline();
}

/*-------------------------------------------------------------------------
 * triangle - output a triangle 
 *-------------------------------------------------------------------------
 */
void
Backend::triangle( TrimVertex *a, TrimVertex *b, TrimVertex *c )
{
/*    bgntmesh( "spittriangle" );*/
    bgntfan();
    tmeshvert( a );
    tmeshvert( b );
    tmeshvert( c );
    endtfan();
/*    endtmesh();*/
}

void 
Backend::bgncurv( void )
{
    curveEvaluator.bgnmap1f( 0 );
}

void
Backend::segment( REAL ulo, REAL uhi )
{
    curveEvaluator.domain1f( ulo, uhi );
} 

void 
Backend::curvpts( 
    long type,                  /* geometry, color, texture, normal */
    REAL *pts,                  /* control points */
    long stride,                /* distance to next point */
    int order,                  /* parametric order */
    REAL ulo,                   /* lower parametric bound */
    REAL uhi )                  /* upper parametric bound */

{
    curveEvaluator.map1f( type, ulo, uhi, stride, order, pts );
    curveEvaluator.enable( type );
}

void 
Backend::curvgrid( REAL u0, REAL u1, long nu )
{
    curveEvaluator.mapgrid1f( nu, u0, u1 );
}

void 
Backend::curvmesh( long from, long n )
{
    curveEvaluator.mapmesh1f( N_MESHFILL, from, from+n );
}

void 
Backend::curvpt(REAL u)
{
    curveEvaluator.evalcoord1f( 0, u );
}

void 
Backend::bgnline( void )                
{
    curveEvaluator.bgnline();
}

void 
Backend::endline( void )
{
    curveEvaluator.endline();
}

void 
Backend::endcurv( void )
{
    curveEvaluator.endmap1f();
}