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:
10 ** http://oss.sgi.com/projects/FreeB
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.
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.
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.
40 #include "glimports.h"
47 #include "patchlist.h"
48 #include "simplemath.h" //min()
50 /* local preprocessor definitions */
51 #define DEF_PATCH_STEPSIZE .4
52 #define fsizeof(x) (sizeof(x)/sizeof(REAL))
55 Quilt::Quilt( Mapdesc
*_mapdesc
)
61 Quilt::deleteMe( Pool
& p
)
63 for( Quiltspec
*q
=qspec
; q
!= eqspec
; q
++ ) {
65 if( q
->breakpoints
) delete[] q
->breakpoints
; q
->breakpoints
= 0;
68 delete[] q
->breakpoints
;
74 if( cpts
) delete[] cpts
;
76 PooledObj::deleteMe( p
);
83 int nc
= mapdesc
->getNcoords();
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
] );
99 /*--------------------------------------------------------------------------
100 * Quilt::select - find which map in each quilt contains the points
101 * pta and ptb with pta[i] < ptb[i]
102 *--------------------------------------------------------------------------
106 Quilt::select( REAL
*pta
, REAL
*ptb
)
108 int dim
= eqspec
- qspec
;
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] ) )
121 Quilt::download( Backend
&backend
)
123 if( getDimension() == 2 ) {
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
,
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] );
140 ps
+= qspec
[0].offset
;
141 ps
+= qspec
[0].index
* qspec
[0].order
* qspec
[0].stride
;
142 backend
.curvpts( mapdesc
->getType(), ps
,
145 qspec
[0].breakpoints
[qspec
[0].index
],
146 qspec
[0].breakpoints
[qspec
[0].index
+1] );
150 /*--------------------------------------------------------------------------
151 * Quilt::downloadAll - download each map that contains the current patch
152 *--------------------------------------------------------------------------
156 Quilt::downloadAll( REAL
*pta
, REAL
*ptb
, Backend
&backend
)
158 for( Quilt
*m
= this; m
; m
=m
->next
) {
159 m
->select( pta
, ptb
);
160 m
->download( backend
);
164 /*--------------------------------------------------------------------------
165 * Quilt::isCulled - determine if an entire quilt is trivially rejected.
166 *--------------------------------------------------------------------------
170 Quilt::isCulled( void )
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
);
180 /*---------------------------------------------------------------------------
181 * Quilt::getRange - retrieve the valid paramater range of a set of quilts
182 *---------------------------------------------------------------------------
185 Quilt::getRange( REAL
*from
, REAL
*to
, Flist
& slist
, Flist
&tlist
)
187 getRange( from
, to
, 0, slist
);
188 getRange( from
, to
, 1, tlist
);
191 /*---------------------------------------------------------------------------
192 * Quilt::getRange - retrieve the valid paramater range of a set of quilts
193 *---------------------------------------------------------------------------
196 Quilt::getRange( REAL
*from
, REAL
*to
, int i
, Flist
&list
)
199 from
[i
] = maps
->qspec
[i
].breakpoints
[0];
200 to
[i
] = maps
->qspec
[i
].breakpoints
[maps
->qspec
[i
].width
];
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;
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
] );
219 list
.taper( from
[i
], to
[i
] );
223 Quilt::getRange( REAL
*from
, REAL
*to
, Flist
& slist
)
225 getRange( from
, to
, 0, slist
);
229 Quilt::findRates( Flist
& slist
, Flist
& tlist
, REAL rate
[2] )
231 findSampleRates( slist
, tlist
);
232 rate
[0] = qspec
[0].step_size
;
233 rate
[1] = qspec
[1].step_size
;
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
;
245 Quilt::findSampleRates( Flist
& slist
, Flist
& tlist
)
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]);
252 for( int i
= slist
.start
; i
< slist
.end
-1; i
++ ) {
253 for( int j
= tlist
.start
; j
< tlist
.end
-1; j
++ ) {
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();
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);
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
;