Home | History | Annotate | Line # | Download | only in internals 
      1 /*
      2 ** License Applicability. Except to the extent portions of this file are
      3 ** made subject to an alternative license as permitted in the SGI Free
      4 ** Software License B, Version 1.1 (the "License"), the contents of this
      5 ** file are subject only to the provisions of the License. You may not use
      6 ** this file except in compliance with the License. You may obtain a copy
      7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
      8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
      9 **
     10 ** http://oss.sgi.com/projects/FreeB
     11 **
     12 ** Note that, as provided in the License, the Software is distributed on an
     13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
     14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
     15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
     16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
     17 **
     18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
     19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
     20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
     21 ** Copyright in any portions created by third parties is as indicated
     22 ** elsewhere herein. All Rights Reserved.
     23 **
     24 ** Additional Notice Provisions: The application programming interfaces
     25 ** established by SGI in conjunction with the Original Code are The
     26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
     27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
     28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
     29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
     30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
     31 ** published by SGI, but has not been independently verified as being
     32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
     33 */
     34 
     35 /*
     36  * quilt.c++
     37  *
     38  */
     39 
     40 #include "glimports.h"
     41 #include "mystdio.h"
     42 #include "myassert.h"
     43 #include "quilt.h"
     44 #include "backend.h"
     45 #include "mapdesc.h"
     46 #include "flist.h"
     47 #include "patchlist.h"
     48 #include "simplemath.h" //min()
     49 
     50 /* local preprocessor definitions */
     51 #define DEF_PATCH_STEPSIZE	.4
     52 #define fsizeof(x)		(sizeof(x)/sizeof(REAL))
     53 
     54 
     55 Quilt::Quilt( Mapdesc *_mapdesc )
     56 {
     57     mapdesc = _mapdesc;
     58 }
     59 
     60 void
     61 Quilt::deleteMe( Pool& p )
     62 {
     63     for( Quiltspec *q=qspec; q != eqspec; q++ ) {
     64 #if 1
     65 	if( q->breakpoints) delete[] q->breakpoints;  q->breakpoints = 0;
     66 #else
     67 	if( q->breakpoints) {
     68 	   delete[] q->breakpoints;
     69 	   q->breakpoints = 0;
     70 printf("in here\n");
     71         }
     72 #endif
     73     }
     74     if( cpts ) delete[] cpts;
     75     cpts = 0;
     76     PooledObj::deleteMe( p );
     77 }
     78 
     79 void
     80 Quilt::show( void )
     81 {
     82 #ifndef NDEBUG
     83     int nc = mapdesc->getNcoords();
     84     REAL *ps  = cpts;
     85     ps += qspec[0].offset;
     86     ps += qspec[1].offset;
     87     for( int i=0; i!= qspec[0].order * qspec[0].width; i++ ) {
     88 	for( int j = 0; j!= qspec[1].order * qspec[1].width; j++ ) {
     89 	    for( int k=0; k < nc; k++ )
     90 		_glu_dprintf(  "%g ", ps[i*qspec[0].stride + j*qspec[1].stride + k] );
     91 	    _glu_dprintf(  "\n" );
     92 	}
     93 	_glu_dprintf(  "\n" );
     94     }
     95     _glu_dprintf( "\n" );
     96 #endif
     97 }
     98 
     99 /*--------------------------------------------------------------------------
    100  * Quilt::select - find which map in each quilt contains the points
    101  *			pta and ptb with pta[i] < ptb[i]
    102  *--------------------------------------------------------------------------
    103  */
    104 
    105 void
    106 Quilt::select( REAL *pta, REAL *ptb )
    107 {
    108     int dim = eqspec - qspec;
    109     int i, j;
    110     for( i=0; i<dim; i++) {
    111 	for( j=qspec[i].width-1; j>=0; j-- )
    112 	    if( (qspec[i].breakpoints[j] <= pta[i]   ) &&
    113 	    	(ptb[i] <= qspec[i].breakpoints[j+1] ) )
    114 		 break;
    115 	assert( j != -1 );
    116 	qspec[i].index = j;
    117     }
    118 }
    119 
    120 void
    121 Quilt::download( Backend &backend )
    122 {
    123     if( getDimension() == 2 ) {
    124 	REAL *ps  = cpts;
    125 	ps += qspec[0].offset;
    126 	ps += qspec[1].offset;
    127 	ps += qspec[0].index * qspec[0].order * qspec[0].stride;
    128 	ps += qspec[1].index * qspec[1].order * qspec[1].stride;
    129 	backend.surfpts( mapdesc->getType(), ps,
    130 		  qspec[0].stride,
    131 		  qspec[1].stride,
    132 		  qspec[0].order,
    133 		  qspec[1].order,
    134 		  qspec[0].breakpoints[qspec[0].index],
    135 		  qspec[0].breakpoints[qspec[0].index+1],
    136 		  qspec[1].breakpoints[qspec[1].index],
    137 		  qspec[1].breakpoints[qspec[1].index+1] );
    138     } else {
    139 	REAL *ps  = cpts;
    140 	ps += qspec[0].offset;
    141 	ps += qspec[0].index * qspec[0].order * qspec[0].stride;
    142 	backend.curvpts( mapdesc->getType(), ps,
    143 		      qspec[0].stride,
    144 		      qspec[0].order,
    145 		      qspec[0].breakpoints[qspec[0].index],
    146 		      qspec[0].breakpoints[qspec[0].index+1] );
    147     }
    148 }
    149 
    150 /*--------------------------------------------------------------------------
    151  * Quilt::downloadAll - download each map that contains the current patch
    152  *--------------------------------------------------------------------------
    153  */
    154 
    155 void
    156 Quilt::downloadAll( REAL *pta, REAL *ptb, Backend &backend )
    157 {
    158     for( Quilt *m = this; m; m=m->next ) {
    159 	m->select( pta, ptb );
    160 	m->download( backend );
    161     }
    162 }
    163 
    164 /*--------------------------------------------------------------------------
    165   * Quilt::isCulled - determine if an entire quilt is trivially rejected.
    166  *--------------------------------------------------------------------------
    167  */
    168 
    169 int
    170 Quilt::isCulled( void )
    171 {
    172     if( mapdesc->isCulling() )
    173 	return mapdesc->xformAndCullCheck( cpts + qspec[0].offset + qspec[1].offset,
    174 			qspec[0].order * qspec[0].width, qspec[0].stride,
    175 			qspec[1].order * qspec[1].width, qspec[1].stride );
    176     else
    177 	return CULL_ACCEPT;
    178 }
    179 
    180 /*---------------------------------------------------------------------------
    181  * Quilt::getRange - retrieve the valid paramater range of a set of quilts
    182  *---------------------------------------------------------------------------
    183  */
    184 void
    185 Quilt::getRange( REAL *from, REAL *to, Flist& slist, Flist &tlist )
    186 {
    187     getRange( from, to, 0, slist );
    188     getRange( from, to, 1, tlist );
    189 }
    190 
    191 /*---------------------------------------------------------------------------
    192  * Quilt::getRange - retrieve the valid paramater range of a set of quilts
    193  *---------------------------------------------------------------------------
    194  */
    195 void
    196 Quilt::getRange( REAL *from, REAL *to, int i, Flist &list )
    197 {
    198     Quilt *maps = this;
    199     from[i] = maps->qspec[i].breakpoints[0];
    200     to[i]   = maps->qspec[i].breakpoints[maps->qspec[i].width];
    201     int maxpts = 0;
    202     Quilt_ptr m;
    203     for( m=maps; m; m=m->next ) {
    204 	if( m->qspec[i].breakpoints[0] > from[i] )
    205 	    from[i] = m->qspec[i].breakpoints[0];
    206 	if( m->qspec[i].breakpoints[m->qspec[i].width] < to[i] )
    207 	    to[i] = m->qspec[i].breakpoints[m->qspec[i].width];
    208 	maxpts += m->qspec[i].width + 1;
    209     }
    210 
    211     list.grow( maxpts );
    212 
    213     for( m=maps; m; m=m->next )
    214 	for( int j=0; j<=m->qspec[i].width; j++ ) {
    215 	    list.add( m->qspec[i].breakpoints[j] );
    216 	}
    217 
    218     list.filter( );
    219     list.taper( from[i], to[i] );
    220 }
    221 
    222 void
    223 Quilt::getRange( REAL *from, REAL *to, Flist& slist )
    224 {
    225     getRange( from, to, 0, slist );
    226 }
    227 
    228 void
    229 Quilt::findRates( Flist& slist, Flist& tlist, REAL rate[2] )
    230 {
    231     findSampleRates( slist, tlist );
    232     rate[0] = qspec[0].step_size;
    233     rate[1] = qspec[1].step_size;
    234 
    235     for( Quilt *q = next; q; q = q->next ) {
    236 	q->findSampleRates( slist, tlist );
    237 	if( q->qspec[0].step_size < rate[0] )
    238 	    rate[0] = q->qspec[0].step_size;
    239 	if( q->qspec[1].step_size < rate[1] )
    240 	    rate[1] = q->qspec[1].step_size;
    241     }
    242 }
    243 
    244 void
    245 Quilt::findSampleRates( Flist& slist, Flist& tlist )
    246 {
    247     qspec[0].step_size = DEF_PATCH_STEPSIZE *
    248 	    (qspec[0].breakpoints[qspec[0].width] - qspec[0].breakpoints[0]);
    249     qspec[1].step_size = DEF_PATCH_STEPSIZE *
    250 	    (qspec[1].breakpoints[qspec[1].width] - qspec[1].breakpoints[0]);
    251 
    252     for( int i = slist.start; i < slist.end-1; i++ ) {
    253 	for( int j = tlist.start; j < tlist.end-1; j++ ) {
    254 
    255 	    REAL pta[2], ptb[2];
    256 	    pta[0] = slist.pts[i];
    257 	    ptb[0] = slist.pts[i+1];
    258 	    pta[1] = tlist.pts[j];
    259 	    ptb[1] = tlist.pts[j+1];
    260 	    Patchlist patchlist( this, pta, ptb );
    261 	    patchlist.getstepsize();
    262 
    263 	    {
    264 	    float edge_len_s = min(glu_abs(ptb[0]-pta[0]),1.0);
    265 	    float edge_len_t = min(glu_abs(ptb[1]-pta[1]),1.0);
    266 
    267 	    if( patchlist.getStepsize(0)/edge_len_s < qspec[0].step_size )
    268 	       qspec[0].step_size = patchlist.getStepsize(0)/edge_len_s;
    269 	    if( patchlist.getStepsize(1)/edge_len_t < qspec[1].step_size )
    270 	      qspec[1].step_size = patchlist.getStepsize(1)/edge_len_t;
    271 	    }
    272 	}
    273     }
    274 }
    275