src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/mesa/src/src/glu/sgi/libnurbs/internals/coveandtiler.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.
 */

 /*
  * coveandtiler.c++
  *
  */

 #include "glimports.h"
 #include "myassert.h"
 #include "mystdio.h"
 #include "coveandtiler.h"
 #include "gridvertex.h"
 #include "gridtrimvertex.h"
 #include "uarray.h"
 #include "backend.h"


 const int CoveAndTiler::MAXSTRIPSIZE = 1000;

 CoveAndTiler::CoveAndTiler( Backend& b )
 	    : backend( b )
 { }

 CoveAndTiler::~CoveAndTiler( void )
 { }

 inline void
 CoveAndTiler::output( GridVertex &gv )
 {
     backend.tmeshvert( &gv );
 }

 inline void
 CoveAndTiler::output( TrimVertex *tv )
 {
     backend.tmeshvert( tv );
 }

 inline void
 CoveAndTiler::output( GridTrimVertex& g )
 {
     backend.tmeshvert( &g );
 }

 void
 CoveAndTiler::coveAndTile( void )
 {
     long ustart = (top.ustart >= bot.ustart) ? top.ustart : bot.ustart;
     long uend	= (top.uend <= bot.uend)     ? top.uend   : bot.uend;
     if( ustart <= uend ) {
 	tile( bot.vindex, ustart, uend );
 	if( top.ustart >= bot.ustart )
 	    coveUpperLeft();
 	else
 	    coveLowerLeft();

 	if( top.uend <= bot.uend )
 	    coveUpperRight();
 	else
 	    coveLowerRight();
     } else {
 	TrimVertex blv, tlv, *bl, *tl;
 	GridTrimVertex bllv, tllv;
 	TrimVertex *lf = left.first();
 	TrimVertex *ll = left.last();
 	if( lf->param[0] >= ll->param[0] ) {
 	    blv.param[0] = lf->param[0];
 	    blv.param[1] = ll->param[1];
 	    blv.nuid = 0; // XXX
 	    assert( blv.param[1] == bot.vval );
 	    bl = &blv;
 	    tl = lf;
 	    tllv.set( lf );
 	    if( ll->param[0] > uarray.uarray[top.ustart-1] ) {
 		bllv.set( ll );
 		assert( ll->param[0] <= uarray.uarray[bot.ustart] );
 	    } else {
 		bllv.set( top.ustart-1, bot.vindex );
 	    }
 	    coveUpperLeftNoGrid( bl );
 	} else {
 	    tlv.param[0] = ll->param[0];
 	    tlv.param[1] = lf->param[1];
 	    tlv.nuid = 0; // XXX
 	    assert( tlv.param[1] == top.vval );
 	    tl = &tlv;
 	    bl = ll;
 	    bllv.set( ll );
 	    if( lf->param[0] > uarray.uarray[bot.ustart-1] ) {
 		assert( lf->param[0] <= uarray.uarray[bot.ustart] );
 		tllv.set( lf );
 	    } else {
 		tllv.set( bot.ustart-1, top.vindex );
 	    }
 	    coveLowerLeftNoGrid( tl );
 	}

 	TrimVertex brv, trv, *br, *tr;
 	GridTrimVertex brrv, trrv;
 	TrimVertex *rf = right.first();
 	TrimVertex *rl = right.last();

 	if( rf->param[0] <= rl->param[0] ) {
 	    brv.param[0] = rf->param[0];
 	    brv.param[1] = rl->param[1];
 	    brv.nuid = 0; // XXX
 	    assert( brv.param[1] == bot.vval );
 	    br = &brv;
 	    tr = rf;
 	    trrv.set( rf );
 	    if( rl->param[0] < uarray.uarray[top.uend+1] ) {
 		assert( rl->param[0] >= uarray.uarray[top.uend] );
 		brrv.set( rl );
 	    } else {
 		brrv.set( top.uend+1, bot.vindex );
 	    }
 	    coveUpperRightNoGrid( br );
 	} else {
 	    trv.param[0] = rl->param[0];
 	    trv.param[1] = rf->param[1];
 	    trv.nuid = 0; // XXX
 	    assert( trv.param[1] == top.vval );
 	    tr = &trv;
 	    br = rl;
 	    brrv.set( rl );
 	    if( rf->param[0] < uarray.uarray[bot.uend+1] ) {
 		assert( rf->param[0] >= uarray.uarray[bot.uend] );
 		trrv.set( rf );
 	    } else {
 		trrv.set( bot.uend+1, top.vindex );
 	    }
 	    coveLowerRightNoGrid( tr );
 	}

 	backend.bgntmesh( "doit" );
 	output(trrv);
 	output(tllv);
 	output( tr );
 	output( tl );
 	output( br );
 	output( bl );
 	output(brrv);
 	output(bllv);
 	backend.endtmesh();
     }
 }

 void
 CoveAndTiler::tile( long vindex, long ustart, long uend )
 {
     long numsteps = uend - ustart;

     if( numsteps == 0 ) return;

     if( numsteps > MAXSTRIPSIZE ) {
 	long umid = ustart + (uend - ustart) / 2;
 	tile( vindex, ustart, umid );
 	tile( vindex, umid, uend );
     } else {
 	backend.surfmesh( ustart, vindex-1, numsteps, 1 );
     }
 }

 void
 CoveAndTiler::coveUpperRight( void )
 {
     GridVertex tgv( top.uend, top.vindex );
     GridVertex gv( top.uend, bot.vindex );

     right.first();
     backend.bgntmesh( "coveUpperRight" );
     output( right.next() );
     output( tgv );
     backend.swaptmesh();
     output( gv );
 	coveUR();
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveUpperRightNoGrid( TrimVertex* br )
 {
     backend.bgntmesh( "coveUpperRight" );
     output( right.first() );
     output( right.next() );
     backend.swaptmesh();
     output( br );
 	coveUR();
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveUR( )
 {
     GridVertex gv( top.uend, bot.vindex );
     TrimVertex *vert = right.next();
     if( vert == NULL ) return;

     assert( vert->param[0] >= uarray.uarray[gv.gparam[0]]  );

     if( gv.nextu() >= bot.uend ) {
 	for( ; vert; vert = right.next() ) {
 	    output( vert );
 	    backend.swaptmesh();
 	}
     } else while( 1 ) {
 	if( vert->param[0] < uarray.uarray[gv.gparam[0]]  ) {
 	    output( vert );
 	    backend.swaptmesh();
 	    vert = right.next();
 	    if( vert == NULL ) break;
 	} else {
 	    backend.swaptmesh();
 	    output( gv );
 	    if( gv.nextu() == bot.uend ) {
 		for( ; vert; vert = right.next() ) {
 		    output( vert );
 		    backend.swaptmesh();
 		}
 		break;
 	    }
 	}
     }
 }

 void
 CoveAndTiler::coveUpperLeft( void )
 {
     GridVertex tgv( top.ustart, top.vindex );
     GridVertex gv( top.ustart, bot.vindex );

     left.first();
     backend.bgntmesh( "coveUpperLeft" );
     output( tgv );
     output( left.next() );
     output( gv );
     backend.swaptmesh();
 	coveUL();
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveUpperLeftNoGrid( TrimVertex* bl )
 {
     backend.bgntmesh( "coveUpperLeftNoGrid" );
     output( left.first() );
     output( left.next() );
     output( bl );
     backend.swaptmesh();
 	coveUL();
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveUL()
 {
     GridVertex gv( top.ustart, bot.vindex );
     TrimVertex *vert = left.next();
     if( vert == NULL ) return;
     assert( vert->param[0] <= uarray.uarray[gv.gparam[0]]  );

     if( gv.prevu() <= bot.ustart ) {
 	for( ; vert; vert = left.next() ) {
 	    backend.swaptmesh();
 	    output( vert );
 	}
     } else while( 1 ) {
 	if( vert->param[0] > uarray.uarray[gv.gparam[0]]  ) {
 	    backend.swaptmesh();
 	    output( vert );
 	    vert = left.next();
 	    if( vert == NULL ) break;
 	} else {
 	    output( gv );
 	    backend.swaptmesh();
 	    if( gv.prevu() == bot.ustart ) {
 		for( ; vert; vert = left.next() ) {
 		    backend.swaptmesh();
 		    output( vert );
 		}
 		break;
 	    }
 	}
     }
 }

 void
 CoveAndTiler::coveLowerLeft( void )
 {
     GridVertex bgv( bot.ustart, bot.vindex );
     GridVertex gv( bot.ustart, top.vindex );

     left.last();
     backend.bgntmesh( "coveLowerLeft" );
     output( left.prev() );
     output( bgv );
     backend.swaptmesh();
     output( gv );
 	coveLL();
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveLowerLeftNoGrid( TrimVertex* tl )
 {
     backend.bgntmesh( "coveLowerLeft" );
     output( left.last() );
     output( left.prev() );
     backend.swaptmesh();
     output( tl );
 	coveLL( );
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveLL()
 {
     GridVertex gv( bot.ustart, top.vindex );
     TrimVertex *vert = left.prev();
     if( vert == NULL ) return;
     assert( vert->param[0] <= uarray.uarray[gv.gparam[0]]  );

     if( gv.prevu() <= top.ustart ) {
 	for( ; vert; vert = left.prev() ) {
 	    output( vert );
 	    backend.swaptmesh();
 	}
     } else while( 1 ) {
 	if( vert->param[0] > uarray.uarray[gv.gparam[0]] ){
 	    output( vert );
 	    backend.swaptmesh();
 	    vert = left.prev();
 	    if( vert == NULL ) break;
 	} else {
 	    backend.swaptmesh();
 	    output( gv );
 	    if( gv.prevu() == top.ustart ) {
 		for( ; vert; vert = left.prev() ) {
 		    output( vert );
 		    backend.swaptmesh();
 		}
 		break;
 	    }
 	}
     }
 }

 void
 CoveAndTiler::coveLowerRight( void )
 {
     GridVertex bgv( bot.uend, bot.vindex );
     GridVertex gv( bot.uend, top.vindex );

     right.last();
     backend.bgntmesh( "coveLowerRight" );
     output( bgv );
     output( right.prev() );
     output( gv );
     backend.swaptmesh();
 	coveLR();
     backend.endtmesh( );
 }

 void
 CoveAndTiler::coveLowerRightNoGrid( TrimVertex* tr )
 {
     backend.bgntmesh( "coveLowerRIght" );
     output( right.last() );
     output( right.prev() );
     output( tr );
     backend.swaptmesh();
 	coveLR();
     backend.endtmesh();
 }

 void
 CoveAndTiler::coveLR( )
 {
     GridVertex gv( bot.uend, top.vindex );
     TrimVertex *vert = right.prev();
     if( vert == NULL ) return;
     assert( vert->param[0] >= uarray.uarray[gv.gparam[0]]  );

     if( gv.nextu() >= top.uend ) {
 	for( ; vert; vert = right.prev() ) {
 	    backend.swaptmesh();
 	    output( vert );
 	}
     } else while( 1 ) {
 	if( vert->param[0] < uarray.uarray[gv.gparam[0]]  ) {
 	    backend.swaptmesh();
 	    output( vert );
 	    vert = right.prev();
 	    if( vert == NULL ) break;
 	} else {
 	    output( gv );
 	    backend.swaptmesh();
 	    if( gv.nextu() == top.uend ) {
 		for( ; vert; vert = right.prev() ) {
 		    backend.swaptmesh();
 		    output( vert );
 		}
 		break;
 	    }
 	}
     }
 }
	/*
	** 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.
	*/

	/*
	* coveandtiler.c++
	*
	*/

	#include "glimports.h"
	#include "myassert.h"
	#include "mystdio.h"
	#include "coveandtiler.h"
	#include "gridvertex.h"
	#include "gridtrimvertex.h"
	#include "uarray.h"
	#include "backend.h"


	const int CoveAndTiler::MAXSTRIPSIZE = 1000;

	CoveAndTiler::CoveAndTiler( Backend& b )
	: backend( b )
	{ }

	CoveAndTiler::~CoveAndTiler( void )
	{ }

	inline void
	CoveAndTiler::output( GridVertex &gv )
	{
	backend.tmeshvert( &gv );
	}

	inline void
	CoveAndTiler::output( TrimVertex *tv )
	{
	backend.tmeshvert( tv );
	}

	inline void
	CoveAndTiler::output( GridTrimVertex& g )
	{
	backend.tmeshvert( &g );
	}

	void
	CoveAndTiler::coveAndTile( void )
	{
	long ustart = (top.ustart >= bot.ustart) ? top.ustart : bot.ustart;
	long uend = (top.uend <= bot.uend) ? top.uend : bot.uend;
	if( ustart <= uend ) {
	tile( bot.vindex, ustart, uend );
	if( top.ustart >= bot.ustart )
	coveUpperLeft();
	else
	coveLowerLeft();

	if( top.uend <= bot.uend )
	coveUpperRight();
	else
	coveLowerRight();
	} else {
	TrimVertex blv, tlv, bl, tl;
	GridTrimVertex bllv, tllv;
	TrimVertex *lf = left.first();
	TrimVertex *ll = left.last();
	if( lf->param[0] >= ll->param[0] ) {
	blv.param[0] = lf->param[0];
	blv.param[1] = ll->param[1];
	blv.nuid = 0; // XXX
	assert( blv.param[1] == bot.vval );
	bl = &blv;
	tl = lf;
	tllv.set( lf );
	if( ll->param[0] > uarray.uarray[top.ustart-1] ) {
	bllv.set( ll );
	assert( ll->param[0] <= uarray.uarray[bot.ustart] );
	} else {
	bllv.set( top.ustart-1, bot.vindex );
	}
	coveUpperLeftNoGrid( bl );
	} else {
	tlv.param[0] = ll->param[0];
	tlv.param[1] = lf->param[1];
	tlv.nuid = 0; // XXX
	assert( tlv.param[1] == top.vval );
	tl = &tlv;
	bl = ll;
	bllv.set( ll );
	if( lf->param[0] > uarray.uarray[bot.ustart-1] ) {
	assert( lf->param[0] <= uarray.uarray[bot.ustart] );
	tllv.set( lf );
	} else {
	tllv.set( bot.ustart-1, top.vindex );
	}
	coveLowerLeftNoGrid( tl );
	}

	TrimVertex brv, trv, br, tr;
	GridTrimVertex brrv, trrv;
	TrimVertex *rf = right.first();
	TrimVertex *rl = right.last();

	if( rf->param[0] <= rl->param[0] ) {
	brv.param[0] = rf->param[0];
	brv.param[1] = rl->param[1];
	brv.nuid = 0; // XXX
	assert( brv.param[1] == bot.vval );
	br = &brv;
	tr = rf;
	trrv.set( rf );
	if( rl->param[0] < uarray.uarray[top.uend+1] ) {
	assert( rl->param[0] >= uarray.uarray[top.uend] );
	brrv.set( rl );
	} else {
	brrv.set( top.uend+1, bot.vindex );
	}
	coveUpperRightNoGrid( br );
	} else {
	trv.param[0] = rl->param[0];
	trv.param[1] = rf->param[1];
	trv.nuid = 0; // XXX
	assert( trv.param[1] == top.vval );
	tr = &trv;
	br = rl;
	brrv.set( rl );
	if( rf->param[0] < uarray.uarray[bot.uend+1] ) {
	assert( rf->param[0] >= uarray.uarray[bot.uend] );
	trrv.set( rf );
	} else {
	trrv.set( bot.uend+1, top.vindex );
	}
	coveLowerRightNoGrid( tr );
	}

	backend.bgntmesh( "doit" );
	output(trrv);
	output(tllv);
	output( tr );
	output( tl );
	output( br );
	output( bl );
	output(brrv);
	output(bllv);
	backend.endtmesh();
	}
	}

	void
	CoveAndTiler::tile( long vindex, long ustart, long uend )
	{
	long numsteps = uend - ustart;

	if( numsteps == 0 ) return;

	if( numsteps > MAXSTRIPSIZE ) {
	long umid = ustart + (uend - ustart) / 2;
	tile( vindex, ustart, umid );
	tile( vindex, umid, uend );
	} else {
	backend.surfmesh( ustart, vindex-1, numsteps, 1 );
	}
	}

	void
	CoveAndTiler::coveUpperRight( void )
	{
	GridVertex tgv( top.uend, top.vindex );
	GridVertex gv( top.uend, bot.vindex );

	right.first();
	backend.bgntmesh( "coveUpperRight" );
	output( right.next() );
	output( tgv );
	backend.swaptmesh();
	output( gv );
	coveUR();
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveUpperRightNoGrid( TrimVertex* br )
	{
	backend.bgntmesh( "coveUpperRight" );
	output( right.first() );
	output( right.next() );
	backend.swaptmesh();
	output( br );
	coveUR();
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveUR( )
	{
	GridVertex gv( top.uend, bot.vindex );
	TrimVertex *vert = right.next();
	if( vert == NULL ) return;

	assert( vert->param[0] >= uarray.uarray[gv.gparam[0]] );

	if( gv.nextu() >= bot.uend ) {
	for( ; vert; vert = right.next() ) {
	output( vert );
	backend.swaptmesh();
	}
	} else while( 1 ) {
	if( vert->param[0] < uarray.uarray[gv.gparam[0]] ) {
	output( vert );
	backend.swaptmesh();
	vert = right.next();
	if( vert == NULL ) break;
	} else {
	backend.swaptmesh();
	output( gv );
	if( gv.nextu() == bot.uend ) {
	for( ; vert; vert = right.next() ) {
	output( vert );
	backend.swaptmesh();
	}
	break;
	}
	}
	}
	}

	void
	CoveAndTiler::coveUpperLeft( void )
	{
	GridVertex tgv( top.ustart, top.vindex );
	GridVertex gv( top.ustart, bot.vindex );

	left.first();
	backend.bgntmesh( "coveUpperLeft" );
	output( tgv );
	output( left.next() );
	output( gv );
	backend.swaptmesh();
	coveUL();
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveUpperLeftNoGrid( TrimVertex* bl )
	{
	backend.bgntmesh( "coveUpperLeftNoGrid" );
	output( left.first() );
	output( left.next() );
	output( bl );
	backend.swaptmesh();
	coveUL();
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveUL()
	{
	GridVertex gv( top.ustart, bot.vindex );
	TrimVertex *vert = left.next();
	if( vert == NULL ) return;
	assert( vert->param[0] <= uarray.uarray[gv.gparam[0]] );

	if( gv.prevu() <= bot.ustart ) {
	for( ; vert; vert = left.next() ) {
	backend.swaptmesh();
	output( vert );
	}
	} else while( 1 ) {
	if( vert->param[0] > uarray.uarray[gv.gparam[0]] ) {
	backend.swaptmesh();
	output( vert );
	vert = left.next();
	if( vert == NULL ) break;
	} else {
	output( gv );
	backend.swaptmesh();
	if( gv.prevu() == bot.ustart ) {
	for( ; vert; vert = left.next() ) {
	backend.swaptmesh();
	output( vert );
	}
	break;
	}
	}
	}
	}

	void
	CoveAndTiler::coveLowerLeft( void )
	{
	GridVertex bgv( bot.ustart, bot.vindex );
	GridVertex gv( bot.ustart, top.vindex );

	left.last();
	backend.bgntmesh( "coveLowerLeft" );
	output( left.prev() );
	output( bgv );
	backend.swaptmesh();
	output( gv );
	coveLL();
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveLowerLeftNoGrid( TrimVertex* tl )
	{
	backend.bgntmesh( "coveLowerLeft" );
	output( left.last() );
	output( left.prev() );
	backend.swaptmesh();
	output( tl );
	coveLL( );
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveLL()
	{
	GridVertex gv( bot.ustart, top.vindex );
	TrimVertex *vert = left.prev();
	if( vert == NULL ) return;
	assert( vert->param[0] <= uarray.uarray[gv.gparam[0]] );

	if( gv.prevu() <= top.ustart ) {
	for( ; vert; vert = left.prev() ) {
	output( vert );
	backend.swaptmesh();
	}
	} else while( 1 ) {
	if( vert->param[0] > uarray.uarray[gv.gparam[0]] ){
	output( vert );
	backend.swaptmesh();
	vert = left.prev();
	if( vert == NULL ) break;
	} else {
	backend.swaptmesh();
	output( gv );
	if( gv.prevu() == top.ustart ) {
	for( ; vert; vert = left.prev() ) {
	output( vert );
	backend.swaptmesh();
	}
	break;
	}
	}
	}
	}

	void
	CoveAndTiler::coveLowerRight( void )
	{
	GridVertex bgv( bot.uend, bot.vindex );
	GridVertex gv( bot.uend, top.vindex );

	right.last();
	backend.bgntmesh( "coveLowerRight" );
	output( bgv );
	output( right.prev() );
	output( gv );
	backend.swaptmesh();
	coveLR();
	backend.endtmesh( );
	}

	void
	CoveAndTiler::coveLowerRightNoGrid( TrimVertex* tr )
	{
	backend.bgntmesh( "coveLowerRIght" );
	output( right.last() );
	output( right.prev() );
	output( tr );
	backend.swaptmesh();
	coveLR();
	backend.endtmesh();
	}

	void
	CoveAndTiler::coveLR( )
	{
	GridVertex gv( bot.uend, top.vindex );
	TrimVertex *vert = right.prev();
	if( vert == NULL ) return;
	assert( vert->param[0] >= uarray.uarray[gv.gparam[0]] );

	if( gv.nextu() >= top.uend ) {
	for( ; vert; vert = right.prev() ) {
	backend.swaptmesh();
	output( vert );
	}
	} else while( 1 ) {
	if( vert->param[0] < uarray.uarray[gv.gparam[0]] ) {
	backend.swaptmesh();
	output( vert );
	vert = right.prev();
	if( vert == NULL ) break;
	} else {
	output( gv );
	backend.swaptmesh();
	if( gv.nextu() == top.uend ) {
	for( ; vert; vert = right.prev() ) {
	backend.swaptmesh();
	output( vert );
	}
	break;
	}
	}
	}
	}