← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/extras/ogl-sample/main/gfx/lib/glu/libnurbs/internals/quilt.cc

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/extras/ogl-sample/main/gfx/lib/glu/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
 * $Date$ $Revision$
 
39
 * $Header: //depot/main/gfx/lib/glu/libnurbs/internals/quilt.cc#5 $
 
40
 */
 
41
 
 
42
#include "glimports.h"
 
43
#include "mystdio.h"
 
44
#include "myassert.h"
 
45
#include "quilt.h"
 
46
#include "backend.h"
 
47
#include "mapdesc.h"
 
48
#include "flist.h"
 
49
#include "knotvector.h"
 
50
#include "patchlist.h"
 
51
#include "math.h"     //fabs()
 
52
#include "simplemath.h" //min()
 
53
 
 
54
/* local preprocessor definitions */
 
55
#define DEF_PATCH_STEPSIZE      .4
 
56
#define fsizeof(x)              (sizeof(x)/sizeof(REAL))
 
57
 
 
58
 
 
59
Quilt::Quilt( Mapdesc *_mapdesc )
 
60
{
 
61
    mapdesc = _mapdesc;
 
62
}
 
63
 
 
64
void
 
65
Quilt::deleteMe( Pool& p )
 
66
{
 
67
    for( Quiltspec *q=qspec; q != eqspec; q++ ) {
 
68
#if 1
 
69
        if( q->breakpoints) delete[] q->breakpoints;  q->breakpoints = 0;
 
70
#else
 
71
        if( q->breakpoints) {
 
72
           delete[] q->breakpoints;  
 
73
           q->breakpoints = 0;
 
74
printf("in here\n");
 
75
        }
 
76
#endif
 
77
    }
 
78
    if( cpts ) delete[] cpts;  
 
79
    cpts = 0;
 
80
    PooledObj::deleteMe( p );
 
81
}
 
82
 
 
83
void
 
84
Quilt::show( void )
 
85
{
 
86
#ifndef NDEBUG
 
87
    int nc = mapdesc->getNcoords();
 
88
    REAL *ps  = cpts; 
 
89
    ps += qspec[0].offset;
 
90
    ps += qspec[1].offset;
 
91
    for( int i=0; i!= qspec[0].order * qspec[0].width; i++ ) {
 
92
        for( int j = 0; j!= qspec[1].order * qspec[1].width; j++ ) {
 
93
            for( int k=0; k < nc; k++ )
 
94
                dprintf(  "%g ", ps[i*qspec[0].stride + j*qspec[1].stride + k] );
 
95
            dprintf(  "\n" );
 
96
        }
 
97
        dprintf(  "\n" );
 
98
    }
 
99
    dprintf( "\n" );
 
100
#endif
 
101
}
 
102
 
 
103
/*--------------------------------------------------------------------------
 
104
 * Quilt::select - find which map in each quilt contains the points
 
105
 *                      pta and ptb with pta[i] < ptb[i]
 
106
 *--------------------------------------------------------------------------
 
107
 */
 
108
 
 
109
void
 
110
Quilt::select( REAL *pta, REAL *ptb )
 
111
{
 
112
    int dim = eqspec - qspec; 
 
113
    int i, j;
 
114
    for( i=0; i<dim; i++) {
 
115
        for( j=qspec[i].width-1; j>=0; j-- )
 
116
            if( (qspec[i].breakpoints[j] <= pta[i]   ) &&
 
117
                (ptb[i] <= qspec[i].breakpoints[j+1] ) ) 
 
118
                 break;
 
119
        assert( j != -1 ); 
 
120
        qspec[i].index = j;
 
121
    }
 
122
}
 
123
 
 
124
void 
 
125
Quilt::download( Backend &backend )
 
126
{
 
127
    if( getDimension() == 2 ) {
 
128
        REAL *ps  = cpts; 
 
129
        ps += qspec[0].offset;
 
130
        ps += qspec[1].offset;
 
131
        ps += qspec[0].index * qspec[0].order * qspec[0].stride;
 
132
        ps += qspec[1].index * qspec[1].order * qspec[1].stride;
 
133
        backend.surfpts( mapdesc->getType(), ps, 
 
134
                  qspec[0].stride,
 
135
                  qspec[1].stride,
 
136
                  qspec[0].order,
 
137
                  qspec[1].order,
 
138
                  qspec[0].breakpoints[qspec[0].index],
 
139
                  qspec[0].breakpoints[qspec[0].index+1],
 
140
                  qspec[1].breakpoints[qspec[1].index],
 
141
                  qspec[1].breakpoints[qspec[1].index+1] );
 
142
    } else {
 
143
        REAL *ps  = cpts; 
 
144
        ps += qspec[0].offset;
 
145
        ps += qspec[0].index * qspec[0].order * qspec[0].stride;
 
146
        backend.curvpts( mapdesc->getType(), ps, 
 
147
                      qspec[0].stride,
 
148
                      qspec[0].order,
 
149
                      qspec[0].breakpoints[qspec[0].index],
 
150
                      qspec[0].breakpoints[qspec[0].index+1] );
 
151
    }
 
152
}
 
153
 
 
154
/*--------------------------------------------------------------------------
 
155
 * Quilt::downloadAll - download each map that contains the current patch
 
156
 *--------------------------------------------------------------------------
 
157
 */
 
158
 
 
159
void
 
160
Quilt::downloadAll( REAL *pta, REAL *ptb, Backend &backend )
 
161
{
 
162
    for( Quilt *m = this; m; m=m->next ) {
 
163
        m->select( pta, ptb );
 
164
        m->download( backend );
 
165
    }
 
166
}
 
167
 
 
168
/*--------------------------------------------------------------------------
 
169
  * Quilt::isCulled - determine if an entire quilt is trivially rejected.
 
170
 *--------------------------------------------------------------------------
 
171
 */
 
172
 
 
173
int
 
174
Quilt::isCulled( void )
 
175
{
 
176
    if( mapdesc->isCulling() )
 
177
        return mapdesc->xformAndCullCheck( cpts + qspec[0].offset + qspec[1].offset,
 
178
                        qspec[0].order * qspec[0].width, qspec[0].stride, 
 
179
                        qspec[1].order * qspec[1].width, qspec[1].stride );
 
180
    else
 
181
        return CULL_ACCEPT;
 
182
}
 
183
 
 
184
/*---------------------------------------------------------------------------
 
185
 * Quilt::getRange - retrieve the valid paramater range of a set of quilts
 
186
 *---------------------------------------------------------------------------
 
187
 */
 
188
void
 
189
Quilt::getRange( REAL *from, REAL *to, Flist& slist, Flist &tlist )
 
190
{
 
191
    getRange( from, to, 0, slist );
 
192
    getRange( from, to, 1, tlist );
 
193
}
 
194
 
 
195
/*---------------------------------------------------------------------------
 
196
 * Quilt::getRange - retrieve the valid paramater range of a set of quilts
 
197
 *---------------------------------------------------------------------------
 
198
 */
 
199
void
 
200
Quilt::getRange( REAL *from, REAL *to, int i, Flist &list )
 
201
{
 
202
    Quilt *maps = this;
 
203
    from[i] = maps->qspec[i].breakpoints[0];
 
204
    to[i]   = maps->qspec[i].breakpoints[maps->qspec[i].width];
 
205
    int maxpts = 0;
 
206
    Quilt_ptr m;    
 
207
    for( m=maps; m; m=m->next ) {
 
208
        if( m->qspec[i].breakpoints[0] > from[i] ) 
 
209
            from[i] = m->qspec[i].breakpoints[0]; 
 
210
        if( m->qspec[i].breakpoints[m->qspec[i].width] < to[i] ) 
 
211
            to[i] = m->qspec[i].breakpoints[m->qspec[i].width]; 
 
212
        maxpts += m->qspec[i].width + 1;
 
213
    }
 
214
 
 
215
    list.grow( maxpts );
 
216
 
 
217
    for( m=maps; m; m=m->next )
 
218
        for( int j=0; j<=m->qspec[i].width; j++ ) {
 
219
            list.add( m->qspec[i].breakpoints[j] );
 
220
        }
 
221
 
 
222
    list.filter( );
 
223
    list.taper( from[i], to[i] );
 
224
}
 
225
 
 
226
void
 
227
Quilt::getRange( REAL *from, REAL *to, Flist& slist )
 
228
{
 
229
    getRange( from, to, 0, slist );
 
230
}
 
231
 
 
232
void
 
233
Quilt::findRates( Flist& slist, Flist& tlist, REAL rate[2] )
 
234
{
 
235
    findSampleRates( slist, tlist );
 
236
    rate[0] = qspec[0].step_size;
 
237
    rate[1] = qspec[1].step_size;
 
238
 
 
239
    for( Quilt *q = next; q; q = q->next ) {
 
240
        q->findSampleRates( slist, tlist );
 
241
        if( q->qspec[0].step_size < rate[0] ) 
 
242
            rate[0] = q->qspec[0].step_size;
 
243
        if( q->qspec[1].step_size < rate[1] ) 
 
244
            rate[1] = q->qspec[1].step_size;
 
245
    }
 
246
}
 
247
 
 
248
void
 
249
Quilt::findSampleRates( Flist& slist, Flist& tlist )
 
250
{
 
251
    qspec[0].step_size = DEF_PATCH_STEPSIZE * 
 
252
            (qspec[0].breakpoints[qspec[0].width] - qspec[0].breakpoints[0]); 
 
253
    qspec[1].step_size = DEF_PATCH_STEPSIZE * 
 
254
            (qspec[1].breakpoints[qspec[1].width] - qspec[1].breakpoints[0]); 
 
255
 
 
256
    for( int i = slist.start; i < slist.end-1; i++ ) {
 
257
        for( int j = tlist.start; j < tlist.end-1; j++ ) {
 
258
 
 
259
            REAL pta[2], ptb[2];
 
260
            pta[0] = slist.pts[i];
 
261
            ptb[0] = slist.pts[i+1];
 
262
            pta[1] = tlist.pts[j];
 
263
            ptb[1] = tlist.pts[j+1];
 
264
            Patchlist patchlist( this, pta, ptb );
 
265
            patchlist.getstepsize();
 
266
            
 
267
            {
 
268
            float edge_len_s = min(fabs(ptb[0]-pta[0]),1.0);
 
269
            float edge_len_t = min(fabs(ptb[1]-pta[1]),1.0);
 
270
 
 
271
            if( patchlist.getStepsize(0)/edge_len_s < qspec[0].step_size ) 
 
272
               qspec[0].step_size = patchlist.getStepsize(0)/edge_len_s;
 
273
            if( patchlist.getStepsize(1)/edge_len_t < qspec[1].step_size ) 
 
274
              qspec[1].step_size = patchlist.getStepsize(1)/edge_len_t;
 
275
            }
 
276
        }
 
277
    }
 
278
}