CoveAndTiler Class Reference

#include <coveandtiler.h>

Inheritance diagram for CoveAndTiler:

Collaboration diagram for CoveAndTiler:

Public Member Functions
	CoveAndTiler (Backend &)
	~CoveAndTiler (void)
void	coveAndTile (void)
Public Member Functions inherited from TrimRegion
	TrimRegion ()
void	init (REAL)
void	advance (REAL, REAL, REAL)
void	setDu (REAL)
void	init (long, Arc_ptr)
void	getPts (Arc_ptr)
void	getPts (Backend &)
void	getGridExtent (TrimVertex *, TrimVertex *)
void	getGridExtent (void)
int	canTile (void)

Private Member Functions
void	tile (long, long, long)
void	coveLowerLeft (void)
void	coveLowerRight (void)
void	coveUpperLeft (void)
void	coveUpperRight (void)
void	coveUpperLeftNoGrid (TrimVertex *)
void	coveUpperRightNoGrid (TrimVertex *)
void	coveLowerLeftNoGrid (TrimVertex *)
void	coveLowerRightNoGrid (TrimVertex *)
void	coveLL (void)
void	coveLR (void)
void	coveUL (void)
void	coveUR (void)
void	output (GridTrimVertex &)
void	output (GridVertex &)
void	output (TrimVertex *)

Private Attributes
Backend &	backend

Static Private Attributes
static const int	MAXSTRIPSIZE = 1000

Additional Inherited Members
Public Attributes inherited from TrimRegion
Trimline	left
Trimline	right
Gridline	top
Gridline	bot
Uarray	uarray

Detailed Description

Definition at line 46 of file coveandtiler.h.

Constructor & Destructor Documentation

CoveAndTiler()

CoveAndTiler::CoveAndTiler

(

Backend &

b

)

Definition at line 52 of file coveandtiler.cc.

        : backend( b )
{ }

~CoveAndTiler()

CoveAndTiler::~CoveAndTiler

(

void

)

Definition at line 56 of file coveandtiler.cc.

{ }

Member Function Documentation

coveAndTile()

void CoveAndTiler::coveAndTile

(

void

)

Definition at line 78 of file coveandtiler.cc.

{
    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();
    }
}

Referenced by Slicer::slice_old().

coveLL()

void CoveAndTiler::coveLL ( void  )

private

Definition at line 348 of file coveandtiler.cc.

{
    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;
        }
    }
    }
}

Referenced by coveLowerLeft(), and coveLowerLeftNoGrid().

coveLowerLeft()

void CoveAndTiler::coveLowerLeft ( void  )

private

Definition at line 320 of file coveandtiler.cc.

{
    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();
}

Referenced by coveAndTile().

coveLowerLeftNoGrid()

void CoveAndTiler::coveLowerLeftNoGrid ( TrimVertex *  tl )

private

Definition at line 336 of file coveandtiler.cc.

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

Referenced by coveAndTile().

coveLowerRight()

void CoveAndTiler::coveLowerRight ( void  )

private

Definition at line 381 of file coveandtiler.cc.

{
    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( );
}

Referenced by coveAndTile().

coveLowerRightNoGrid()

void CoveAndTiler::coveLowerRightNoGrid ( TrimVertex *  tr )

private

Definition at line 397 of file coveandtiler.cc.

{
    backend.bgntmesh( "coveLowerRIght" );
    output( right.last() );
    output( right.prev() );
    output( tr );
    backend.swaptmesh();
    coveLR();
    backend.endtmesh();
}

Referenced by coveAndTile().

coveLR()

void CoveAndTiler::coveLR ( void  )

private

Definition at line 409 of file coveandtiler.cc.

{
    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;
        }
    }
    }
}

Referenced by coveLowerRight(), and coveLowerRightNoGrid().

coveUL()

void CoveAndTiler::coveUL ( void  )

private

Definition at line 287 of file coveandtiler.cc.

{
    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;
        }
    }
    }
}

Referenced by coveUpperLeft(), and coveUpperLeftNoGrid().

coveUpperLeft()

void CoveAndTiler::coveUpperLeft ( void  )

private

Definition at line 259 of file coveandtiler.cc.

{
    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();
}

Referenced by coveAndTile().

coveUpperLeftNoGrid()

void CoveAndTiler::coveUpperLeftNoGrid ( TrimVertex *  bl )

private

Definition at line 275 of file coveandtiler.cc.

{
    backend.bgntmesh( "coveUpperLeftNoGrid" );
    output( left.first() );
    output( left.next() );
    output( bl );
    backend.swaptmesh();
    coveUL();
    backend.endtmesh();
}

Referenced by coveAndTile().

coveUpperRight()

void CoveAndTiler::coveUpperRight ( void  )

private

Definition at line 197 of file coveandtiler.cc.

{
    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();
}

Referenced by coveAndTile().

coveUpperRightNoGrid()

void CoveAndTiler::coveUpperRightNoGrid ( TrimVertex *  br )

private

Definition at line 213 of file coveandtiler.cc.

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

Referenced by coveAndTile().

coveUR()

void CoveAndTiler::coveUR ( void  )

private

Definition at line 225 of file coveandtiler.cc.

{
    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;
        }
    }
    }
}

Referenced by coveUpperRight(), and coveUpperRightNoGrid().

output() [1/3]

void CoveAndTiler::output ( GridTrimVertex &  g )

inlineprivate

Definition at line 72 of file coveandtiler.cc.

{
    backend.tmeshvert( &g );
}

Referenced by coveAndTile(), coveLL(), coveLowerLeft(), coveLowerLeftNoGrid(), coveLowerRight(), coveLowerRightNoGrid(), coveLR(), coveUL(), coveUpperLeft(), coveUpperLeftNoGrid(), coveUpperRight(), coveUpperRightNoGrid(), and coveUR().

output() [2/3]

void CoveAndTiler::output ( GridVertex &  gv )

inlineprivate

Definition at line 60 of file coveandtiler.cc.

{
    backend.tmeshvert( &gv );
}

output() [3/3]

void CoveAndTiler::output ( TrimVertex *  tv )

inlineprivate

Definition at line 66 of file coveandtiler.cc.

{
    backend.tmeshvert( tv );
}

tile()

void CoveAndTiler::tile ( long  vindex, long  ustart, long  uend  )

private

Definition at line 181 of file coveandtiler.cc.

{
    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 );
    }
}

Referenced by coveAndTile(), and tile().

Member Data Documentation

backend

Backend& CoveAndTiler::backend

private

Definition at line 52 of file coveandtiler.h.

Referenced by coveAndTile(), coveLL(), coveLowerLeft(), coveLowerLeftNoGrid(), coveLowerRight(), coveLowerRightNoGrid(), coveLR(), coveUL(), coveUpperLeft(), coveUpperLeftNoGrid(), coveUpperRight(), coveUpperRightNoGrid(), coveUR(), output(), and tile().

MAXSTRIPSIZE

const int CoveAndTiler::MAXSTRIPSIZE = 1000

staticprivate

Definition at line 53 of file coveandtiler.h.

Referenced by tile().

---

The documentation for this class was generated from the following files:

• dll/opengl/glu32/src/libnurbs/internals/coveandtiler.h
• dll/opengl/glu32/src/libnurbs/internals/coveandtiler.cc