src/glu/sgi/libnurbs/internals/quilt.cc

   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 }