src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/mesa/src/src/glu/sgi/libnurbs/internals/nurbsinterfac.cc - public/gem5-resources - Git at Google

 /*
 ** 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.
 */

 /*
  * nurbsinterfac.c++
  *
  */

 #include "glimports.h"
 #include "mystdio.h"
 #include "nurbsconsts.h"
 #include "nurbstess.h"
 #include "bufpool.h"
 #include "quilt.h"
 #include "displaylist.h"
 #include "knotvector.h"
 #include "mapdesc.h"

 #define THREAD( work, arg, cleanup ) \
 	if( dl ) {\
 	    arg->save = 1;\
 	    dl->append( (PFVS)&NurbsTessellator::work, (void *) arg, (PFVS)&NurbsTessellator::cleanup );\
  	} else {\
 	    arg->save = 0;\
 	    work( arg );\
 	}

 #define THREAD2( work ) \
 	if( dl ) {\
 	    dl->append( (PFVS)&NurbsTessellator::work, 0, 0 );\
  	} else {\
 	    work( );\
 	}

 NurbsTessellator::NurbsTessellator( BasicCurveEvaluator &c, BasicSurfaceEvaluator& e)
 	: maplist( backend ),
 	  backend( c, e ),
           subdivider( renderhints, backend ),
 	  o_pwlcurvePool( sizeof( O_pwlcurve ), 32, "o_pwlcurvePool" ),
 	  o_nurbscurvePool( sizeof( O_nurbscurve ), 32, "o_nurbscurvePool"),
 	  o_curvePool( sizeof( O_curve ), 32,  "o_curvePool" ),
 	  o_trimPool( sizeof( O_trim ), 32,  "o_trimPool" ),
 	  o_surfacePool( sizeof( O_surface ), 1, "o_surfacePool" ),
 	  o_nurbssurfacePool( sizeof( O_nurbssurface ), 4, "o_nurbssurfacePool" ),
 	  propertyPool( sizeof( Property ), 32, "propertyPool" ),
           quiltPool( sizeof( Quilt  ), 32, "quiltPool" )
 {
     dl		= 0;
     inSurface	= 0;
     inCurve	= 0;
     inTrim	= 0;
     playBack	= 0;
     jumpbuffer  = newJumpbuffer();
     subdivider.setJumpbuffer( jumpbuffer );
 }

 NurbsTessellator::~NurbsTessellator( void )
 {
     if( inTrim ) {
 	do_nurbserror( 12 );
 	endtrim();
     }

     if( inSurface ) {
         *nextNurbssurface = 0;
         do_freeall();
     }

     if (jumpbuffer) {
         deleteJumpbuffer(jumpbuffer);
 	jumpbuffer= 0;
     }
 }

 /*-----------------------------------------------------------------------------
  * bgnsurface - allocate and initialize an o_surface structure
  *
  * Client: GL user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::bgnsurface( long nuid )
 {
     O_surface *o_surface = new(o_surfacePool) O_surface;
     o_surface->nuid = nuid;
     THREAD( do_bgnsurface, o_surface, do_freebgnsurface );
 }

 /*-----------------------------------------------------------------------------
  * bgncurve - allocate an initialize an o_curve structure
  *
  * Client: GL user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::bgncurve( long nuid )
 {
     O_curve *o_curve = new(o_curvePool) O_curve;
     o_curve->nuid = nuid;
     THREAD( do_bgncurve, o_curve, do_freebgncurve );
 }
 /*-----------------------------------------------------------------------------
  * endcurve -
  *
  * Client:
  *-----------------------------------------------------------------------------
  */

 void
 NurbsTessellator::endcurve( void )
 {
     THREAD2( do_endcurve );
 }

 /*-----------------------------------------------------------------------------
  * endsurface - user level end of surface call
  *
  * Client: GL user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::endsurface( void )
 {
     THREAD2( do_endsurface );
 }


 /*-----------------------------------------------------------------------------
  * bgntrim - allocate and initialize a new trim loop structure (o_trim )
  *
  * Client: GL user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::bgntrim( void )
 {
     O_trim *o_trim = new(o_trimPool) O_trim;
     THREAD( do_bgntrim, o_trim, do_freebgntrim );
 }

 /*-----------------------------------------------------------------------------
  * endtrim -
  *
  * Client: GL user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::endtrim( void )
 {
     THREAD2( do_endtrim );
 }


 /*-----------------------------------------------------------------------------
  * pwlcurve -
  *
  *      count        - number of points on curve
  *      array        - array of points on curve
  *      byte_stride  - distance between points in bytes
  *      type         - valid data flag
  *
  * Client: Gl user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::pwlcurve( long count, INREAL array[], long byte_stride, long type )
 {
     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 ) {
 	do_nurbserror( 35 );
 	isDataValid = 0;
 	return;
     }

     if ( (type != N_P2D) && (type != N_P2DR) ) {
 	do_nurbserror( 22 );
 	isDataValid = 0;
 	return;
     }
     if( count < 0 ) {
 	do_nurbserror( 33 );
 	isDataValid = 0;
 	return;
     }
     if( byte_stride < 0 ) {
 	do_nurbserror( 34 );
 	isDataValid = 0;
 	return;
     }

 #ifdef NOTDEF
     if( mapdesc->isRational() ) {
 	INREAL *p = array;
 	INREAL x = p[0]; INREAL y = p[1]; INREAL w = p[2];
 	p = (INREAL *) (((char *) p) + byte_stride);
 	for( long i = 1; i != count; i++ ) {
 	    if( p[0] == x && p[1] == y && p[2] == w ) break;
 	    x = p[0]; y = p[1]; w = p[2];
 	    p = (INREAL *) (((char *) p) + byte_stride);
 	}
 	if( i != count ) {
 	    do_nurbserror( 37 );
 	    _glu_dprintf( "point %d (%f,%f)\n", i, x, y );
 	    isDataValid = 0;
 	    return;
 	}
     } else {
 	INREAL *p = array;
 	INREAL x = p[0]; INREAL y = p[1];
 	p = (INREAL *) (((char *) p) + byte_stride);
 	for( long i = 1; i != count; i++ ) {
 	    if( p[0] == x && p[1] == y ) break;
 	    x = p[0]; y = p[1];
 	    p = (INREAL *) (((char *) p) + byte_stride);
 	}
 	if( i != count ) {
 	    do_nurbserror( 37 );
 	    _glu_dprintf( "point %d (%f,%f)\n", i, x, y );
 	    isDataValid = 0;
 	    return;
 	}
     }
 #endif

     O_pwlcurve	*o_pwlcurve = new(o_pwlcurvePool) O_pwlcurve( type, count, array, byte_stride, extTrimVertexPool.get((int)count) );
     THREAD( do_pwlcurve, o_pwlcurve, do_freepwlcurve );
 }


 /*-----------------------------------------------------------------------------
  * nurbscurve -
  *
  * Client: GL user
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::nurbscurve(
     long nknots, 		/* number of p knots */
     INREAL knot[], 		/* nondecreasing knot values in p */
     long byte_stride,		/* distance in bytes between control points */
     INREAL ctlarray[], 		/* pointer to first control point */
     long order,			/* order of spline */
     long type )			/* description of range space */
 {

     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 ) {
 	do_nurbserror( 35 );
 	isDataValid = 0;
 	return;
     }

     if( ctlarray == 0 ) {
 	do_nurbserror( 36 );
 	isDataValid = 0;
 	return;
     }

     if( byte_stride < 0 ) {
 	do_nurbserror( 34 );
 	isDataValid = 0;
 	return;
     }

     Knotvector knots;

     knots.init( nknots, byte_stride, order, knot );
     if( do_check_knots( &knots, "curve" ) ) return;

     O_nurbscurve *o_nurbscurve = new(o_nurbscurvePool) O_nurbscurve(type);
     o_nurbscurve->bezier_curves = new(quiltPool) Quilt(mapdesc);
     o_nurbscurve->bezier_curves->toBezier( knots,ctlarray, mapdesc->getNcoords() );

     THREAD( do_nurbscurve, o_nurbscurve, do_freenurbscurve );
 }


 /*-----------------------------------------------------------------------------
  * nurbssurface -
  *
  * Client: User routine
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::nurbssurface(
     long sknot_count,		/* number of s knots */
     INREAL sknot[],		/* nondecreasing knot values in s */
     long tknot_count, 		/* number of t knots */
     INREAL tknot[],		/* nondecreasing knot values in t */
     long s_byte_stride,		/* s step size in memory bytes */
     long t_byte_stride,		/* t step size in memory bytes */
     INREAL ctlarray[],		/* pointer to first control point */
     long sorder,		/* order of the spline in s parameter */
     long torder,		/* order of the spline in t parameter */
     long type)			/* description of range space */
 {
     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 ) {
 	do_nurbserror( 35 );
 	isDataValid = 0;
 	return;
     }

     if( s_byte_stride < 0 ) {
 	do_nurbserror( 34 );
 	isDataValid = 0;
 	return;
     }

     if( t_byte_stride < 0 ) {
 	do_nurbserror( 34 );
 	isDataValid = 0;
 	return;
     }

     Knotvector sknotvector, tknotvector;

     sknotvector.init( sknot_count, s_byte_stride, sorder, sknot );
     if( do_check_knots( &sknotvector, "surface" ) ) return;

     tknotvector.init( tknot_count, t_byte_stride, torder, tknot );
     if( do_check_knots( &tknotvector, "surface" ) ) return;

     O_nurbssurface *o_nurbssurface = new(o_nurbssurfacePool) O_nurbssurface(type);
     o_nurbssurface->bezier_patches = new(quiltPool) Quilt(mapdesc);

     o_nurbssurface->bezier_patches->toBezier( sknotvector, tknotvector,
 	ctlarray, mapdesc->getNcoords() );
     THREAD( do_nurbssurface, o_nurbssurface, do_freenurbssurface );
 }


 /*-----------------------------------------------------------------------------
  * setnurbsproperty -
  *
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::setnurbsproperty( long tag, INREAL value )
 {
     if( ! renderhints.isProperty( tag ) ) {
 	do_nurbserror( 26 );
     } else {
 	Property *prop = new(propertyPool) Property( tag, value );
 	THREAD( do_setnurbsproperty, prop, do_freenurbsproperty );
     }
 }

 /*-----------------------------------------------------------------------------
  * setnurbsproperty -
  *
  *-----------------------------------------------------------------------------
  */
 void
 NurbsTessellator::setnurbsproperty( long type, long tag, INREAL value )
 {
     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 ) {
 	do_nurbserror( 35 );
 	return;
     }

     if( ! mapdesc->isProperty( tag ) ) {
 	do_nurbserror( 26 );
 	return;
     }

     Property *prop = new(propertyPool) Property( type, tag, value );
     THREAD( do_setnurbsproperty2, prop, do_freenurbsproperty );
 }


 /*-----------------------------------------------------------------------------
  * getnurbsproperty -
  *
  *-----------------------------------------------------------------------------
  */

 void
 NurbsTessellator::getnurbsproperty( long tag, INREAL *value )
 {
     if( renderhints.isProperty( tag ) ) {
 	*value = renderhints.getProperty( tag );
     } else {
 	do_nurbserror( 26 );
     }
 }

 /*-----------------------------------------------------------------------------
  * getnurbsproperty -
  *
  *-----------------------------------------------------------------------------
  */

 void
 NurbsTessellator::getnurbsproperty( long type, long tag, INREAL *value )
 {
     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 )
 	do_nurbserror( 35 );

     if( mapdesc->isProperty( tag  ) ) {
 	*value = mapdesc->getProperty( tag );
     } else {
 	do_nurbserror( 26 );
     }
 }

 /*--------------------------------------------------------------------------
  * setnurbsproperty - accept a user supplied matrix as culling or sampling mat
  *--------------------------------------------------------------------------
  */

 void
 NurbsTessellator::setnurbsproperty( long type, long purpose, INREAL *mat )
 {
     // XXX - cannot be put in display list
     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 ) {
 	do_nurbserror( 35 );
 	isDataValid = 0;
     } else if( purpose == N_BBOXSIZE ) {
 	mapdesc->setBboxsize( mat );
     } else {
 #ifndef NDEBUG
         _glu_dprintf( "ERRORRORRORR!!!\n");
 #endif
     }
 }

 /*--------------------------------------------------------------------------
  * setnurbsproperty - accept a user supplied matrix as culling or sampling mat
  *--------------------------------------------------------------------------
  */

 void
 NurbsTessellator::setnurbsproperty( long type, long purpose, INREAL *mat,
     long rstride, long cstride )
 {
     // XXX - cannot be put in display list
     Mapdesc *mapdesc = maplist.locate( type );

     if( mapdesc == 0 ) {
 	do_nurbserror( 35 );
 	isDataValid = 0;
     } else if( purpose == N_CULLINGMATRIX ) {
 	mapdesc->setCmat( mat, rstride, cstride );
     } else if( purpose == N_SAMPLINGMATRIX ) {
 	mapdesc->setSmat( mat, rstride, cstride );
     } else if( purpose == N_BBOXMATRIX ) {
 	mapdesc->setBmat( mat, rstride, cstride );
     } else {
 #ifndef NDEBUG
         _glu_dprintf( "ERRORRORRORR!!!\n");
 #endif
     }
 }

 void
 NurbsTessellator::redefineMaps( void )
 {
     maplist.initialize();
 }

 void
 NurbsTessellator::defineMap( long type, long rational, long ncoords )
 {
     maplist.define( type, (int) rational, (int) ncoords );
 }

 void
 NurbsTessellator::discardRecording( void *_dl )
 {
     delete (DisplayList *) _dl;
 }

 void *
 NurbsTessellator::beginRecording( void )
 {
     dl = new DisplayList( this );
     return (void *) dl;
 }

 void
 NurbsTessellator::endRecording( void )
 {
     dl->endList();
     dl = 0;
 }

 void
 NurbsTessellator::playRecording( void *_dl )
 {
     playBack = 1;
     bgnrender();
     ((DisplayList *)_dl)->play();
     endrender();
     playBack = 0;
 }
	/*
	** 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.
	*/

	/*
	* nurbsinterfac.c++
	*
	*/

	#include "glimports.h"
	#include "mystdio.h"
	#include "nurbsconsts.h"
	#include "nurbstess.h"
	#include "bufpool.h"
	#include "quilt.h"
	#include "displaylist.h"
	#include "knotvector.h"
	#include "mapdesc.h"

	#define THREAD( work, arg, cleanup ) \
	if( dl ) {\
	arg->save = 1;\
	dl->append( (PFVS)&NurbsTessellator::work, (void *) arg, (PFVS)&NurbsTessellator::cleanup );\
	} else {\
	arg->save = 0;\
	work( arg );\
	}

	#define THREAD2( work ) \
	if( dl ) {\
	dl->append( (PFVS)&NurbsTessellator::work, 0, 0 );\
	} else {\
	work( );\
	}

	NurbsTessellator::NurbsTessellator( BasicCurveEvaluator &c, BasicSurfaceEvaluator& e)
	: maplist( backend ),
	backend( c, e ),
	subdivider( renderhints, backend ),
	o_pwlcurvePool( sizeof( O_pwlcurve ), 32, "o_pwlcurvePool" ),
	o_nurbscurvePool( sizeof( O_nurbscurve ), 32, "o_nurbscurvePool"),
	o_curvePool( sizeof( O_curve ), 32, "o_curvePool" ),
	o_trimPool( sizeof( O_trim ), 32, "o_trimPool" ),
	o_surfacePool( sizeof( O_surface ), 1, "o_surfacePool" ),
	o_nurbssurfacePool( sizeof( O_nurbssurface ), 4, "o_nurbssurfacePool" ),
	propertyPool( sizeof( Property ), 32, "propertyPool" ),
	quiltPool( sizeof( Quilt ), 32, "quiltPool" )
	{
	dl = 0;
	inSurface = 0;
	inCurve = 0;
	inTrim = 0;
	playBack = 0;
	jumpbuffer = newJumpbuffer();
	subdivider.setJumpbuffer( jumpbuffer );
	}

	NurbsTessellator::~NurbsTessellator( void )
	{
	if( inTrim ) {
	do_nurbserror( 12 );
	endtrim();
	}

	if( inSurface ) {
	*nextNurbssurface = 0;
	do_freeall();
	}

	if (jumpbuffer) {
	deleteJumpbuffer(jumpbuffer);
	jumpbuffer= 0;
	}
	}

	/*-----------------------------------------------------------------------------
	* bgnsurface - allocate and initialize an o_surface structure
	*
	* Client: GL user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::bgnsurface( long nuid )
	{
	O_surface *o_surface = new(o_surfacePool) O_surface;
	o_surface->nuid = nuid;
	THREAD( do_bgnsurface, o_surface, do_freebgnsurface );
	}

	/*-----------------------------------------------------------------------------
	* bgncurve - allocate an initialize an o_curve structure
	*
	* Client: GL user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::bgncurve( long nuid )
	{
	O_curve *o_curve = new(o_curvePool) O_curve;
	o_curve->nuid = nuid;
	THREAD( do_bgncurve, o_curve, do_freebgncurve );
	}
	/*-----------------------------------------------------------------------------
	* endcurve -
	*
	* Client:
	*-----------------------------------------------------------------------------
	*/

	void
	NurbsTessellator::endcurve( void )
	{
	THREAD2( do_endcurve );
	}

	/*-----------------------------------------------------------------------------
	* endsurface - user level end of surface call
	*
	* Client: GL user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::endsurface( void )
	{
	THREAD2( do_endsurface );
	}


	/*-----------------------------------------------------------------------------
	* bgntrim - allocate and initialize a new trim loop structure (o_trim )
	*
	* Client: GL user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::bgntrim( void )
	{
	O_trim *o_trim = new(o_trimPool) O_trim;
	THREAD( do_bgntrim, o_trim, do_freebgntrim );
	}

	/*-----------------------------------------------------------------------------
	* endtrim -
	*
	* Client: GL user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::endtrim( void )
	{
	THREAD2( do_endtrim );
	}


	/*-----------------------------------------------------------------------------
	* pwlcurve -
	*
	* count - number of points on curve
	* array - array of points on curve
	* byte_stride - distance between points in bytes
	* type - valid data flag
	*
	* Client: Gl user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::pwlcurve( long count, INREAL array[], long byte_stride, long type )
	{
	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 ) {
	do_nurbserror( 35 );
	isDataValid = 0;
	return;
	}

	if ( (type != N_P2D) && (type != N_P2DR) ) {
	do_nurbserror( 22 );
	isDataValid = 0;
	return;
	}
	if( count < 0 ) {
	do_nurbserror( 33 );
	isDataValid = 0;
	return;
	}
	if( byte_stride < 0 ) {
	do_nurbserror( 34 );
	isDataValid = 0;
	return;
	}

	#ifdef NOTDEF
	if( mapdesc->isRational() ) {
	INREAL *p = array;
	INREAL x = p[0]; INREAL y = p[1]; INREAL w = p[2];
	p = (INREAL ) (((char ) p) + byte_stride);
	for( long i = 1; i != count; i++ ) {
	if( p[0] == x && p[1] == y && p[2] == w ) break;
	x = p[0]; y = p[1]; w = p[2];
	p = (INREAL ) (((char ) p) + byte_stride);
	}
	if( i != count ) {
	do_nurbserror( 37 );
	_glu_dprintf( "point %d (%f,%f)\n", i, x, y );
	isDataValid = 0;
	return;
	}
	} else {
	INREAL *p = array;
	INREAL x = p[0]; INREAL y = p[1];
	p = (INREAL ) (((char ) p) + byte_stride);
	for( long i = 1; i != count; i++ ) {
	if( p[0] == x && p[1] == y ) break;
	x = p[0]; y = p[1];
	p = (INREAL ) (((char ) p) + byte_stride);
	}
	if( i != count ) {
	do_nurbserror( 37 );
	_glu_dprintf( "point %d (%f,%f)\n", i, x, y );
	isDataValid = 0;
	return;
	}
	}
	#endif

	O_pwlcurve *o_pwlcurve = new(o_pwlcurvePool) O_pwlcurve( type, count, array, byte_stride, extTrimVertexPool.get((int)count) );
	THREAD( do_pwlcurve, o_pwlcurve, do_freepwlcurve );
	}


	/*-----------------------------------------------------------------------------
	* nurbscurve -
	*
	* Client: GL user
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::nurbscurve(
	long nknots, /* number of p knots */
	INREAL knot[], /* nondecreasing knot values in p */
	long byte_stride, /* distance in bytes between control points */
	INREAL ctlarray[], /* pointer to first control point */
	long order, /* order of spline */
	long type ) /* description of range space */
	{

	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 ) {
	do_nurbserror( 35 );
	isDataValid = 0;
	return;
	}

	if( ctlarray == 0 ) {
	do_nurbserror( 36 );
	isDataValid = 0;
	return;
	}

	if( byte_stride < 0 ) {
	do_nurbserror( 34 );
	isDataValid = 0;
	return;
	}

	Knotvector knots;

	knots.init( nknots, byte_stride, order, knot );
	if( do_check_knots( &knots, "curve" ) ) return;

	O_nurbscurve *o_nurbscurve = new(o_nurbscurvePool) O_nurbscurve(type);
	o_nurbscurve->bezier_curves = new(quiltPool) Quilt(mapdesc);
	o_nurbscurve->bezier_curves->toBezier( knots,ctlarray, mapdesc->getNcoords() );

	THREAD( do_nurbscurve, o_nurbscurve, do_freenurbscurve );
	}


	/*-----------------------------------------------------------------------------
	* nurbssurface -
	*
	* Client: User routine
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::nurbssurface(
	long sknot_count, /* number of s knots */
	INREAL sknot[], /* nondecreasing knot values in s */
	long tknot_count, /* number of t knots */
	INREAL tknot[], /* nondecreasing knot values in t */
	long s_byte_stride, /* s step size in memory bytes */
	long t_byte_stride, /* t step size in memory bytes */
	INREAL ctlarray[], /* pointer to first control point */
	long sorder, /* order of the spline in s parameter */
	long torder, /* order of the spline in t parameter */
	long type) /* description of range space */
	{
	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 ) {
	do_nurbserror( 35 );
	isDataValid = 0;
	return;
	}

	if( s_byte_stride < 0 ) {
	do_nurbserror( 34 );
	isDataValid = 0;
	return;
	}

	if( t_byte_stride < 0 ) {
	do_nurbserror( 34 );
	isDataValid = 0;
	return;
	}

	Knotvector sknotvector, tknotvector;

	sknotvector.init( sknot_count, s_byte_stride, sorder, sknot );
	if( do_check_knots( &sknotvector, "surface" ) ) return;

	tknotvector.init( tknot_count, t_byte_stride, torder, tknot );
	if( do_check_knots( &tknotvector, "surface" ) ) return;

	O_nurbssurface *o_nurbssurface = new(o_nurbssurfacePool) O_nurbssurface(type);
	o_nurbssurface->bezier_patches = new(quiltPool) Quilt(mapdesc);

	o_nurbssurface->bezier_patches->toBezier( sknotvector, tknotvector,
	ctlarray, mapdesc->getNcoords() );
	THREAD( do_nurbssurface, o_nurbssurface, do_freenurbssurface );
	}


	/*-----------------------------------------------------------------------------
	* setnurbsproperty -
	*
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::setnurbsproperty( long tag, INREAL value )
	{
	if( ! renderhints.isProperty( tag ) ) {
	do_nurbserror( 26 );
	} else {
	Property *prop = new(propertyPool) Property( tag, value );
	THREAD( do_setnurbsproperty, prop, do_freenurbsproperty );
	}
	}

	/*-----------------------------------------------------------------------------
	* setnurbsproperty -
	*
	*-----------------------------------------------------------------------------
	*/
	void
	NurbsTessellator::setnurbsproperty( long type, long tag, INREAL value )
	{
	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 ) {
	do_nurbserror( 35 );
	return;
	}

	if( ! mapdesc->isProperty( tag ) ) {
	do_nurbserror( 26 );
	return;
	}

	Property *prop = new(propertyPool) Property( type, tag, value );
	THREAD( do_setnurbsproperty2, prop, do_freenurbsproperty );
	}


	/*-----------------------------------------------------------------------------
	* getnurbsproperty -
	*
	*-----------------------------------------------------------------------------
	*/

	void
	NurbsTessellator::getnurbsproperty( long tag, INREAL *value )
	{
	if( renderhints.isProperty( tag ) ) {
	*value = renderhints.getProperty( tag );
	} else {
	do_nurbserror( 26 );
	}
	}

	/*-----------------------------------------------------------------------------
	* getnurbsproperty -
	*
	*-----------------------------------------------------------------------------
	*/

	void
	NurbsTessellator::getnurbsproperty( long type, long tag, INREAL *value )
	{
	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 )
	do_nurbserror( 35 );

	if( mapdesc->isProperty( tag ) ) {
	*value = mapdesc->getProperty( tag );
	} else {
	do_nurbserror( 26 );
	}
	}

	/*--------------------------------------------------------------------------
	* setnurbsproperty - accept a user supplied matrix as culling or sampling mat
	*--------------------------------------------------------------------------
	*/

	void
	NurbsTessellator::setnurbsproperty( long type, long purpose, INREAL *mat )
	{
	// XXX - cannot be put in display list
	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 ) {
	do_nurbserror( 35 );
	isDataValid = 0;
	} else if( purpose == N_BBOXSIZE ) {
	mapdesc->setBboxsize( mat );
	} else {
	#ifndef NDEBUG
	_glu_dprintf( "ERRORRORRORR!!!\n");
	#endif
	}
	}

	/*--------------------------------------------------------------------------
	* setnurbsproperty - accept a user supplied matrix as culling or sampling mat
	*--------------------------------------------------------------------------
	*/

	void
	NurbsTessellator::setnurbsproperty( long type, long purpose, INREAL *mat,
	long rstride, long cstride )
	{
	// XXX - cannot be put in display list
	Mapdesc *mapdesc = maplist.locate( type );

	if( mapdesc == 0 ) {
	do_nurbserror( 35 );
	isDataValid = 0;
	} else if( purpose == N_CULLINGMATRIX ) {
	mapdesc->setCmat( mat, rstride, cstride );
	} else if( purpose == N_SAMPLINGMATRIX ) {
	mapdesc->setSmat( mat, rstride, cstride );
	} else if( purpose == N_BBOXMATRIX ) {
	mapdesc->setBmat( mat, rstride, cstride );
	} else {
	#ifndef NDEBUG
	_glu_dprintf( "ERRORRORRORR!!!\n");
	#endif
	}
	}

	void
	NurbsTessellator::redefineMaps( void )
	{
	maplist.initialize();
	}

	void
	NurbsTessellator::defineMap( long type, long rational, long ncoords )
	{
	maplist.define( type, (int) rational, (int) ncoords );
	}

	void
	NurbsTessellator::discardRecording( void *_dl )
	{
	delete (DisplayList *) _dl;
	}

	void *
	NurbsTessellator::beginRecording( void )
	{
	dl = new DisplayList( this );
	return (void *) dl;
	}

	void
	NurbsTessellator::endRecording( void )
	{
	dl->endList();
	dl = 0;
	}

	void
	NurbsTessellator::playRecording( void *_dl )
	{
	playBack = 1;
	bgnrender();
	((DisplayList *)_dl)->play();
	endrender();
	playBack = 0;
	}