ReactOS  0.4.15-dev-499-g1f31905
curve.cc
Go to the documentation of this file.
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  * curve.c++
37  *
38  */
39 
40 //#include "glimports.h"
41 //#include "myassert.h"
42 //#include "mystdio.h"
43 #include "mymath.h"
44 #include "curve.h"
45 #include "mapdesc.h"
46 //#include "types.h"
47 #include "quilt.h"
48 //#include "nurbsconsts.h"
49 
50 /*--------------------------------------------------------------------------
51  * Curve::Curve - copy curve from quilt and transform control points
52  *--------------------------------------------------------------------------
53  */
54 
55 Curve::Curve( Quilt_ptr geo, REAL pta, REAL ptb, Curve *c )
56 {
57  mapdesc = geo->mapdesc;
58  next = c;
61  order = geo->qspec[0].order;
62  stride = MAXCOORDS;
63  for( int i = 0; i < MAXORDER * MAXCOORDS; i++ ) {
64  cpts[i] = 0;
65  spts[i] = 0;
66  }
67  stepsize = 0;
68  minstepsize = 0;
69 
70  REAL *ps = geo->cpts;
71  Quiltspec_ptr qs = geo->qspec;
72  ps += qs->offset;
73  ps += qs->index * qs->order * qs->stride;
74 
75  if( needsSampling )
76  mapdesc->xformSampling( ps, qs->order, qs->stride, spts, stride );
77 
78  if( cullval == CULL_ACCEPT )
79  mapdesc->xformCulling( ps, qs->order, qs->stride, cpts, stride );
80 
81  /* set untrimmed curve range */
82  range[0] = qs->breakpoints[qs->index];
83  range[1] = qs->breakpoints[qs->index+1];
84  range[2] = range[1] - range[0];
85 
86  if( range[0] != pta ) {
87  Curve lower( *this, pta, 0 );
88  lower.next = next;
89  *this = lower;
90  }
91  if( range[1] != ptb ) {
92  Curve lower( *this, ptb, 0 );
93  }
94 }
95 
96 /*--------------------------------------------------------------------------
97  * Curve::Curve - subdivide a curve along an isoparametric line
98  *--------------------------------------------------------------------------
99  */
100 
102 {
103  Curve &lower = *this;
104 
105  lower.next = c;
106  lower.mapdesc = upper.mapdesc;
107  lower.needsSampling = upper.needsSampling;
108  lower.order = upper.order;
109  lower.stride = upper.stride;
110  lower.cullval = upper.cullval;
111 
112  REAL d = (value - upper.range[0]) / upper.range[2];
113 
114  if( needsSampling )
115  mapdesc->subdivide( upper.spts, lower.spts, d, upper.stride, upper.order );
116 
117  if( cullval == CULL_ACCEPT )
118  mapdesc->subdivide( upper.cpts, lower.cpts, d, upper.stride, upper.order );
119 
120  lower.range[0] = upper.range[0];
121  lower.range[1] = value;
122  lower.range[2] = value - upper.range[0];
123  upper.range[0] = value;
124  upper.range[2] = upper.range[1] - value;
125 }
126 
127 
128 /*--------------------------------------------------------------------------
129  * Curve::clamp - clamp the sampling rate to a given maximum
130  *--------------------------------------------------------------------------
131  */
132 
133 void
135 {
136  if( stepsize < minstepsize )
138 }
139 
140 void
142 {
143  stepsize = ( max >= 1.0 ) ? (range[2] / max) : range[2];
145 }
146 
147 void
149 {
150  minstepsize= 0;
151 
152  if( mapdesc->isConstantSampling() ) {
153  // fixed number of samples per patch in each direction
154  // maxrate is number of s samples per patch
156  } else if( mapdesc->isDomainSampling() ) {
157  // maxrate is number of s samples per unit s length of domain
158  setstepsize( mapdesc->maxrate * range[2] );
159  } else {
160  // upper bound on path length between sample points
161 
162  assert( order <= MAXORDER );
163 
164  /* points have been transformed, therefore they are homogeneous */
165  REAL tmp[MAXORDER][MAXCOORDS];
166  const int tstride = sizeof(tmp[0]) / sizeof(REAL);
167  int val = mapdesc->project( spts, stride, &tmp[0][0], tstride, order );
168 
169  if( val == 0 ) {
170  // control points cross infinity, therefore derivatives are undefined
172  } else {
175  REAL d = mapdesc->calcPartialVelocity( &tmp[0][0], tstride, order, 2, range[2] );
176  stepsize = (d > 0.0) ? sqrtf( 8.0 * t / d ) : range[2];
177  minstepsize = ( mapdesc->maxrate > 0.0 ) ? (range[2] / mapdesc->maxrate) : 0.0;
178  } else if( mapdesc->isPathLengthSampling() ) {
179  // t is upper bound on path (arc) length
180  REAL d = mapdesc->calcPartialVelocity( &tmp[0][0], tstride, order, 1, range[2] );
181  stepsize = ( d > 0.0 ) ? (t / d) : range[2];
182  minstepsize = ( mapdesc->maxrate > 0.0 ) ? (range[2] / mapdesc->maxrate) : 0.0;
183  } else {
184  // control points cross infinity, therefore partials are undefined
186  }
187  }
188  }
189 }
190 
191 int
193 {
194  return ( stepsize < minstepsize ) ? 1 : 0;
195 }
196 
197 int
199 {
200  if( cullval == CULL_ACCEPT )
202  return cullval;
203 }
204 
int needsSamplingSubdivision(void)
Definition: curve.cc:192
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
#define max(a, b)
Definition: svc.c:63
REAL cpts[MAXORDER *MAXCOORDS]
Definition: curve.h:58
void setstepsize(REAL)
Definition: curve.cc:141
void xformCulling(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:472
REAL calcPartialVelocity(REAL *, int, int, int, REAL)
Definition: mapdescv.cc:54
GLdouble GLdouble t
Definition: gl.h:2047
#define assert(x)
Definition: debug.h:53
int isDomainSampling(void)
Definition: mapdesc.h:210
int project(REAL *, int, REAL *, int, int)
Definition: mapdesc.cc:647
REAL getProperty(long)
Definition: mapdesc.cc:769
int cullCheck(REAL *, int, int)
Definition: mapdesc.cc:425
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
int stride
Definition: quilt.h:52
int isParametricDistanceSampling(void)
Definition: mapdesc.h:216
int offset
Definition: quilt.h:54
#define N_PIXEL_TOLERANCE
Definition: nurbsconsts.h:89
#define CULL_ACCEPT
Definition: defines.h:42
Curve(Quilt *, REAL, REAL, Curve *)
REAL maxrate
Definition: mapdesc.h:109
class Quilt * Quilt_ptr
Definition: quilt.h:90
#define MAXORDER
Definition: defines.h:45
GLuint GLfloat * val
Definition: glext.h:7180
GLsizei stride
Definition: glext.h:5848
#define d
Definition: ke_i.h:81
int cullval
Definition: curve.h:56
const GLubyte * c
Definition: glext.h:8905
REAL stepsize
Definition: curve.h:60
Mapdesc * mapdesc
Definition: curve.h:53
void subdivide(REAL *, REAL *, REAL, int, int)
Definition: mapdesc.cc:577
void xformSampling(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:454
int needsSampling
Definition: curve.h:57
int cullCheck(void)
Definition: curve.cc:198
Definition: curve.h:46
GLsizei const GLfloat * value
Definition: glext.h:6069
int stride
Definition: curve.h:54
int index
Definition: quilt.h:56
GLenum GLint * range
Definition: glext.h:7539
#define CULL_TRIVIAL_ACCEPT
Definition: defines.h:41
REAL minstepsize
Definition: curve.h:61
int order
Definition: quilt.h:55
int isRangeSampling(void)
Definition: mapdesc.h:246
REAL spts[MAXORDER *MAXCOORDS]
Definition: curve.h:59
Knot * breakpoints
Definition: quilt.h:59
int isPathLengthSampling(void)
Definition: mapdesc.h:240
#define sqrtf(x)
Definition: mymath.h:59
#define c
Definition: ke_i.h:80
REAL clampfactor
Definition: mapdesc.h:107
void clamp(void)
Definition: curve.cc:134
void getstepsize(void)
Definition: curve.cc:148
#define MAXCOORDS
Definition: defines.h:48
REAL range[3]
Definition: curve.h:62
float REAL
Definition: types.h:41
int isConstantSampling(void)
Definition: mapdesc.h:204
int order
Definition: curve.h:55
Curve * next
Definition: curve.h:51
int isCulling(void)
Definition: mapdesc.h:261