static void Invert_Quadric(OBJECT *Object)
{
QUADRIC *Quadric = (QUADRIC *) Object;
VScaleEq(Quadric->Square_Terms, -1.0);
VScaleEq(Quadric->Mixed_Terms, -1.0);
VScaleEq(Quadric->Terms, -1.0);
Quadric->Constant *= -1.0;
Invert_Flag(Object, INVERTED_FLAG);
}
static void Scale_Smooth_Triangle(OBJECT *Object, VECTOR Vector, TRANSFORM * /*Trans*/)
{
DBL Length;
SMOOTH_TRIANGLE *Triangle = (SMOOTH_TRIANGLE *)Object;
if (!Test_Flag(Object, DEGENERATE_FLAG))
{
/* BEG ROSE
this is useless, because Compute_Triange recalculates this anyway:
Triangle->Normal_Vector[X] = Triangle->Normal_Vector[X] / Vector[X];
Triangle->Normal_Vector[Y] = Triangle->Normal_Vector[Y] / Vector[Y];
Triangle->Normal_Vector[Z] = Triangle->Normal_Vector[Z] / Vector[Z];
VLength(Length, Triangle->Normal_Vector);
VScaleEq(Triangle->Normal_Vector, 1.0 / Length);
Triangle->Distance /= Length;
END ROSE */
VEvaluateEq(Triangle->P1, Vector);
VEvaluateEq(Triangle->P2, Vector);
VEvaluateEq(Triangle->P3, Vector);
/* BEG ROSE
The normal vectors also have to be transformed (BUG fix): */
Triangle->N1[X] /= Vector[X];
Triangle->N1[Y] /= Vector[Y];
Triangle->N1[Z] /= Vector[Z];
VLength(Length,Triangle->N1);
VScaleEq(Triangle->N1,1.0/Length);
Triangle->N2[X] /= Vector[X];
Triangle->N2[Y] /= Vector[Y];
Triangle->N2[Z] /= Vector[Z];
VLength(Length,Triangle->N2);
VScaleEq(Triangle->N2,1.0/Length);
Triangle->N3[X] /= Vector[X];
Triangle->N3[Y] /= Vector[Y];
Triangle->N3[Z] /= Vector[Z];
VLength(Length,Triangle->N3);
VScaleEq(Triangle->N3,1.0/Length);
/* END ROSE */
Compute_Triangle((TRIANGLE *)Triangle,true);
}
}
/*****************************************************************************
*
* FUNCTION
*
* MInvers3
*
* INPUT
*
* OUTPUT
*
* RETURNS
*
* AUTHOR
*
* Alexander Enzmann
*
* DESCRIPTION
*
* - Invert a 3x3 Matrix
*
* CHANGES
*
* -
*
******************************************************************************/
int MInvers3(const VECTOR inM[3], VECTOR outM[3])
{
DBL det;
outM[0][X] = (inM[1][Y] * inM[2][Z] - inM[1][Z] * inM[2][Y]);
outM[1][X] = - (inM[0][Y] * inM[2][Z] - inM[0][Z] * inM[2][Y]);
outM[2][X] = (inM[0][Y] * inM[1][Z] - inM[0][Z] * inM[1][Y]);
outM[0][Y] = - (inM[1][X] * inM[2][Z] - inM[1][Z] * inM[2][X]);
outM[1][Y] = (inM[0][X] * inM[2][Z] - inM[0][Z] * inM[2][X]);
outM[2][Y] = - (inM[0][X] * inM[1][Z] - inM[0][Z] * inM[1][X]);
outM[0][Z] = (inM[1][X] * inM[2][Y] - inM[1][Y] * inM[2][X]);
outM[1][Z] = - (inM[0][X] * inM[2][Y] - inM[0][Y] * inM[2][X]);
outM[2][Z] = (inM[0][X] * inM[1][Y] - inM[0][Y] * inM[1][X]);
det = inM[0][X] * inM[1][Y] * inM[2][Z] +
inM[0][Y] * inM[1][Z] * inM[2][X] +
inM[0][Z] * inM[1][X] * inM[2][Y] -
inM[0][Z] * inM[1][Y] * inM[2][X] -
inM[0][X] * inM[1][Z] * inM[2][Y] -
inM[0][Y] * inM[1][X] * inM[2][Z];
if (fabs(det) < 1.0e-10)
{
return (0);
}
det = 1.0 / det;
VScaleEq(outM[0], det);
VScaleEq(outM[1], det);
VScaleEq(outM[2], det);
return (1);
}
static int compute_smooth_triangle(SMOOTH_TRIANGLE *Triangle)
{
VECTOR P3MinusP2, VTemp1, VTemp2;
DBL x, y, z, uDenominator, Proj;
VSub(P3MinusP2, Triangle->P3, Triangle->P2);
x = fabs(P3MinusP2[X]);
y = fabs(P3MinusP2[Y]);
z = fabs(P3MinusP2[Z]);
Triangle->vAxis = max3_coordinate(x, y, z);
VSub(VTemp1, Triangle->P2, Triangle->P3);
VNormalize(VTemp1, VTemp1);
VSub(VTemp2, Triangle->P1, Triangle->P3);
VDot(Proj, VTemp2, VTemp1);
VScaleEq(VTemp1, Proj);
VSub(Triangle->Perp, VTemp1, VTemp2);
VNormalize(Triangle->Perp, Triangle->Perp);
VDot(uDenominator, VTemp2, Triangle->Perp);
VInverseScaleEq(Triangle->Perp, -uDenominator);
/* Degenerate if smooth normals are more than 90 from actual normal
or its inverse. */
VDot(x,Triangle->Normal_Vector,Triangle->N1);
VDot(y,Triangle->Normal_Vector,Triangle->N2);
VDot(z,Triangle->Normal_Vector,Triangle->N3);
if ( ((x<0.0) && (y<0.0) && (z<0.0)) ||
((x>0.0) && (y>0.0) && (z>0.0)) )
{
return(true);
}
Set_Flag(Triangle, DEGENERATE_FLAG);
return(false);
}
void Warp_EPoint (VECTOR TPoint, VECTOR EPoint, TPATTERN *TPat)
{
VECTOR PTurbulence,RP;
int Axis,i,temp_rand;
int blockX = 0, blockY = 0, blockZ = 0 ;
SNGL BlkNum;
DBL Length;
DBL Strength;
WARP *Warp=TPat->Warps;
TURB *Turb;
TRANS *Tr;
REPEAT *Repeat;
BLACK_HOLE *Black_Hole;
VECTOR Delta, Center;
Assign_Vector(TPoint, EPoint);
while (Warp != NULL)
{
switch(Warp->Warp_Type)
{
case CLASSIC_TURB_WARP:
if ((TPat->Type == MARBLE_PATTERN) ||
(TPat->Type == NO_PATTERN) ||
(TPat->Type == WOOD_PATTERN))
{
break;
}
/* If not a special type, fall through to next case */
case EXTRA_TURB_WARP:
Turb=(TURB *)Warp;
DTurbulence (PTurbulence, TPoint, Turb);
TPoint[X] += PTurbulence[X] * Turb->Turbulence[X];
TPoint[Y] += PTurbulence[Y] * Turb->Turbulence[Y];
TPoint[Z] += PTurbulence[Z] * Turb->Turbulence[Z];
break;
case NO_WARP:
break;
case TRANSFORM_WARP:
Tr=(TRANS *)Warp;
MInvTransPoint(TPoint, TPoint, &(Tr->Trans));
break;
case REPEAT_WARP:
Repeat=(REPEAT *)Warp;
Assign_Vector(RP,TPoint);
Axis=Repeat->Axis;
BlkNum=(SNGL)floor(TPoint[Axis]/Repeat->Width);
RP[Axis]=TPoint[Axis]-BlkNum*Repeat->Width;
if (((int)BlkNum) & 1)
{
VEvaluateEq(RP,Repeat->Flip);
if ( Repeat->Flip[Axis] < 0 )
{
RP[Axis] = Repeat->Width+RP[Axis];
}
}
VAddScaledEq(RP,BlkNum,Repeat->Offset);
Assign_Vector(TPoint,RP);
break;
case BLACK_HOLE_WARP:
Black_Hole = (BLACK_HOLE *) Warp ;
Assign_Vector (Center, Black_Hole->Center) ;
if (Black_Hole->Repeat)
{
/* first, get the block number we're in for each dimension */
/* block numbers are (currently) calculated relative to 0 */
/* we use floor () since it correctly returns -1 for the
first block below 0 in each axis */
/* one final point - we could run into overflow problems if
the repeat vector was small and the scene very large. */
if (Black_Hole->Repeat_Vector [X] >= Small_Tolerance)
blockX = (int) floor (TPoint [X] / Black_Hole->Repeat_Vector [X]) ;
if (Black_Hole->Repeat_Vector [Y] >= Small_Tolerance)
blockY = (int) floor (TPoint [Y] / Black_Hole->Repeat_Vector [Y]) ;
if (Black_Hole->Repeat_Vector [Z] >= Small_Tolerance)
blockZ = (int) floor (TPoint [Z] / Black_Hole->Repeat_Vector [Z]) ;
if (Black_Hole->Uncertain)
{
/* if the position is uncertain calculate the new one first */
/* this will allow the same numbers to be returned by frand */
temp_rand = POV_GET_OLD_RAND(); /*protect seed*/
POV_SRAND (Hash3d (blockX, blockY, blockZ)) ;
Center [X] += FRAND () * Black_Hole->Uncertainty_Vector [X] ;
Center [Y] += FRAND () * Black_Hole->Uncertainty_Vector [Y] ;
Center [Z] += FRAND () * Black_Hole->Uncertainty_Vector [Z] ;
POV_SRAND (temp_rand) ; /*restore*/
}
Center [X] += Black_Hole->Repeat_Vector [X] * blockX ;
Center [Y] += Black_Hole->Repeat_Vector [Y] * blockY ;
Center [Z] += Black_Hole->Repeat_Vector [Z] * blockZ ;
}
VSub (Delta, TPoint, Center) ;
VLength (Length, Delta) ;
/* Length is the distance from the centre of the black hole */
if (Length >= Black_Hole->Radius) break ;
if (Black_Hole->Type == 0)
{
/* now convert the length to a proportion (0 to 1) that the point
is from the edge of the black hole. a point on the perimeter
of the black hole will be 0.0 ; a point at the centre will be
1.0 ; a point exactly halfway will be 0.5, and so forth. */
Length = (Black_Hole->Radius - Length) / Black_Hole->Radius ;
/* Strength is the magnitude of the transformation effect. firstly,
apply the Power variable to Length. this is meant to provide a
means of controlling how fast the power of the Black Hole falls
off from its centre. if Power is 2.0, then the effect is inverse
square. increasing power will cause the Black Hole to be a lot
weaker in its effect towards its perimeter.
finally we multiply Strength with the Black Hole's Strength
variable. if the resultant value exceeds 1.0 we clip it to 1.0.
this means a point will never be transformed by more than its
original distance from the centre. the result of this clipping
is that you will have an 'exclusion' area near the centre of
the black hole where all points whose final value exceeded or
equalled 1.0 were moved by a fixed amount. this only happens
if the Strength value of the Black Hole was greater than one. */
Strength = pow (Length, Black_Hole->Power) * Black_Hole->Strength ;
if (Strength > 1.0) Strength = 1.0 ;
/* if the Black Hole is inverted, it gives the impression of 'push-
ing' the pattern away from its centre. otherwise it sucks. */
VScaleEq (Delta, Black_Hole->Inverted ? -Strength : Strength) ;
/* add the scaled Delta to the input point to end up with TPoint. */
VAddEq (TPoint, Delta) ;
}
break;
/* 10/23/1998 Talious added SPherical Cylindrical and toroidal
warps */
case CYLINDRICAL_WARP:
warp_cylindrical(TPoint, (CYLW *)Warp);
break;
case PLANAR_WARP:
warp_planar(TPoint, (PLANARW *)Warp);
break;
case SPHERICAL_WARP:
warp_spherical(TPoint, (SPHEREW *)Warp);
break;
case TOROIDAL_WARP:
warp_toroidal(TPoint, (TOROIDAL *) Warp);
break;
default:
Error("Warp type %d not yet implemented",Warp->Warp_Type);
}
Warp=Warp->Next_Warp;
}
for (i=X; i<=Z; i++)
if (TPoint[i] > COORDINATE_LIMIT)
TPoint[i]= COORDINATE_LIMIT;
else
if (TPoint[i] < -COORDINATE_LIMIT)
TPoint[i] = -COORDINATE_LIMIT;
}
static void facets (const VECTOR EPoint, const TNORMAL *Tnormal, VECTOR normal, TraceThreadData *Thread)
{
int i;
int thisseed;
DBL sum, minsum;
VECTOR sv, tv, dv, t1, add, newnormal, pert;
DBL scale;
int UseSquare;
int UseUnity;
DBL Metric;
VECTOR *cv = Thread->Facets_Cube;
Metric = Tnormal->Vals.Facets.Metric;
UseSquare = (Metric == 2 );
UseUnity = (Metric == 1 );
VNormalize( normal, normal );
if ( Tnormal->Vals.Facets.UseCoords )
{
Assign_Vector(tv,EPoint);
}
else
{
Assign_Vector(tv,normal);
}
if ( Tnormal->Vals.Facets.Size < 1e-6 )
{
scale = 1e6;
}
else
{
scale = 1. / Tnormal->Vals.Facets.Size;
}
VScaleEq( tv, scale );
/*
* Check to see if the input point is in the same unit cube as the last
* call to this function, to use cache of cubelets for speed.
*/
thisseed = PickInCube(tv, t1);
if (thisseed != Thread->Facets_Last_Seed)
{
/*
* No, not same unit cube. Calculate the random points for this new
* cube and its 80 neighbours which differ in any axis by 1 or 2.
* Why distance of 2? If there is 1 point in each cube, located
* randomly, it is possible for the closest random point to be in the
* cube 2 over, or the one two over and one up. It is NOT possible
* for it to be two over and two up. Picture a 3x3x3 cube with 9 more
* cubes glued onto each face.
*/
/* Now store a points for this cube and each of the 80 neighbour cubes. */
int cvc = 0;
for (add[X] = -2.0; add[X] < 2.5; add[X] +=1.0)
{
for (add[Y] = -2.0; add[Y] < 2.5; add[Y] += 1.0)
{
for (add[Z] = -2.0; add[Z] < 2.5; add[Z] += 1.0)
{
/* For each cubelet in a 5x5 cube. */
if ((fabs(add[X])>1.5)+(fabs(add[Y])>1.5)+(fabs(add[Z])>1.5) <= 1.0)
{
/* Yes, it's within a 3d knight move away. */
VAdd(sv, tv, add);
PickInCube(sv, t1);
cv[cvc][X] = t1[X];
cv[cvc][Y] = t1[Y];
cv[cvc][Z] = t1[Z];
cvc++;
}
}
}
}
Thread->Facets_Last_Seed = thisseed;
Thread->Facets_CVC = cvc;
}
/*
* Find the point with the shortest distance from the input point.
*/
VSub(dv, cv[0], tv);
if ( UseSquare )
{
minsum = VSumSqr(dv);
}
else if ( UseUnity )
{
minsum = dv[X]+dv[Y]+dv[Z];
}
else
{
minsum = pow(fabs(dv[X]), Metric)+
pow(fabs(dv[Y]), Metric)+
pow(fabs(dv[Z]), Metric);
}
Assign_Vector( newnormal, cv[0] );
/* Loop for the 81 cubelets to find closest. */
for (i = 1; i < Thread->Facets_CVC; i++)
{
VSub(dv, cv[i], tv);
if ( UseSquare )
{
sum = VSumSqr(dv);
}
else
{
if ( UseUnity )
{
sum = dv[X]+dv[Y]+dv[Z];
}
else
{
sum = pow(fabs(dv[X]), Metric)+
pow(fabs(dv[Y]), Metric)+
pow(fabs(dv[Z]), Metric);
}
}
if (sum < minsum)
{
minsum = sum;
Assign_Vector( newnormal, cv[i] );
}
}
if ( Tnormal->Vals.Facets.UseCoords )
{
DNoise( pert, newnormal );
VDot( sum, pert, normal );
VScale( newnormal, normal, sum );
VSubEq( pert, newnormal );
VAddScaledEq( normal, Tnormal->Vals.Facets.UseCoords, pert );
}
else
{
Assign_Vector( normal, newnormal );
}
}
void bump_map(VECTOR EPoint, TNORMAL *Tnormal, VECTOR normal)
{
DBL xcoor = 0.0, ycoor = 0.0;
int index, index2, index3;
COLOUR colour1, colour2, colour3;
VECTOR p1, p2, p3;
VECTOR bump_normal;
VECTOR xprime, yprime, zprime, Temp;
DBL Length;
DBL Amount = Tnormal->Amount;
IMAGE *Image = Tnormal->Vals.Image;
Make_ColourA(colour1, 0.0, 0.0, 0.0, 0.0, 0.0);
Make_ColourA(colour2, 0.0, 0.0, 0.0, 0.0, 0.0);
Make_ColourA(colour3, 0.0, 0.0, 0.0, 0.0, 0.0);
/* going to have to change this */
/* need to know if bump point is off of image for all 3 points */
if (map(EPoint, (TPATTERN *) Tnormal, &xcoor, &ycoor))
{
return;
}
else
{
image_colour_at(Image, xcoor, ycoor, colour1, &index);
}
xcoor--;
ycoor++;
if (xcoor < 0.0)
{
xcoor += (DBL)Image->iwidth;
}
else
{
if (xcoor >= Image->iwidth)
{
xcoor -= (DBL)Image->iwidth;
}
}
if (ycoor < 0.0)
{
ycoor += (DBL)Image->iheight;
}
else
{
if (ycoor >= (DBL)Image->iheight)
{
ycoor -= (DBL)Image->iheight;
}
}
image_colour_at(Image, xcoor, ycoor, colour2, &index2);
xcoor += 2.0;
if (xcoor < 0.0)
{
xcoor += (DBL)Image->iwidth;
}
else
{
if (xcoor >= Image->iwidth)
{
xcoor -= (DBL)Image->iwidth;
}
}
image_colour_at(Image, xcoor, ycoor, colour3, &index3);
if (Image->Colour_Map == NULL || Image->Use_Colour_Flag)
{
p1[X] = 0;
p1[Y] = Amount * (GREY_SCALE( colour1 ));
p1[Z] = 0;
p2[X] = -1;
p2[Y] = Amount * (GREY_SCALE( colour2 ));
p2[Z] = 1;
p3[X] = 1;
p3[Y] = Amount * (GREY_SCALE( colour3 ));
p3[Z] = 1;
}
else
{
p1[X] = 0;
p1[Y] = Amount * index;
p1[Z] = 0;
p2[X] = -1;
p2[Y] = Amount * index2;
p2[Z] = 1;
p3[X] = 1;
p3[Y] = Amount * index3;
p3[Z] = 1;
}
/* we have points 1,2,3 for a triangle now we need the surface normal for it */
VSub(xprime, p1, p2);
VSub(yprime, p3, p2);
VCross(bump_normal, yprime, xprime);
VNormalize(bump_normal, bump_normal);
Assign_Vector(yprime, normal);
Make_Vector(Temp, 0.0, 1.0, 0.0);
VCross(xprime, yprime, Temp);
VLength(Length, xprime);
if (Length < EPSILON)
{
if (fabs(normal[Y] - 1.0) < Small_Tolerance)
{
Make_Vector(yprime, 0.0, 1.0, 0.0);
Make_Vector(xprime, 1.0, 0.0, 0.0);
Length = 1.0;
}
else
{
Make_Vector(yprime, 0.0, -1.0, 0.0);
Make_Vector(xprime, 1.0, 0.0, 0.0);
Length = 1.0;
}
}
VScaleEq(xprime, 1.0 / Length);
VCross(zprime, xprime, yprime);
VNormalizeEq(zprime);
VScaleEq(xprime, bump_normal[X]);
VScaleEq(yprime, bump_normal[Y]);
VScaleEq(zprime, bump_normal[Z]);
VAdd(Temp, xprime, yprime);
VScaleEq(zprime, -1);
VAdd(normal, Temp, zprime);
}
static void Invert_Plane (OBJECT *Object)
{
VScaleEq(((PLANE *)Object)->Normal_Vector, -1.0);
((PLANE *)Object)->Distance *= -1.0;
}
void Plane::Invert()
{
VScaleEq(Normal_Vector, -1.0);
Distance *= -1.0;
}
static int intersect_subpatch(BICUBIC_PATCH *Shape, RAY *ray, VECTOR V1[3], DBL uu[3], DBL vv[3], DBL *Depth, VECTOR P, VECTOR N, DBL *u, DBL *v)
{
DBL squared_b0, squared_b1;
DBL d, n, a, b, r;
VECTOR Q, T1;
VECTOR B[3], IB[3], NN[3];
VSub(B[0], V1[1], V1[0]);
VSub(B[1], V1[2], V1[0]);
VCross(B[2], B[0], B[1]);
VDot(d, B[2], B[2]);
squared_b0 = VSumSqr(B[0]);
squared_b1 = VSumSqr(B[1]);
if (d <= (BEZIER_EPSILON * squared_b1 * squared_b0))
{
return (0);
}
d = 1.0 / sqrt(d);
VScaleEq(B[2], d);
/* Degenerate triangle. */
if (!MInvers3(B, IB))
{
return (0);
}
VDot(d, ray->Direction, IB[2]);
if (fabs(d) < BEZIER_EPSILON)
{
return (0);
}
VSub(Q, V1[0], ray->Initial);
VDot(n, Q, IB[2]);
*Depth = n / d;
if (*Depth < BEZIER_TOLERANCE)
{
return (0);
}
VScale(T1, ray->Direction, *Depth);
VAdd(P, ray->Initial, T1);
VSub(Q, P, V1[0]);
VDot(a, Q, IB[0]);
VDot(b, Q, IB[1]);
if ((a < 0.0) || (b < 0.0) || (a + b > 1.0))
{
return (0);
}
r = 1.0 - a - b;
Make_Vector(N, 0.0, 0.0, 0.0);
bezier_value((VECTOR(*)[4][4])&Shape->Control_Points, uu[0], vv[0], T1, NN[0]);
bezier_value((VECTOR(*)[4][4])&Shape->Control_Points, uu[1], vv[1], T1, NN[1]);
bezier_value((VECTOR(*)[4][4])&Shape->Control_Points, uu[2], vv[2], T1, NN[2]);
VScale(T1, NN[0], r); VAddEq(N, T1);
VScale(T1, NN[1], a); VAddEq(N, T1);
VScale(T1, NN[2], b); VAddEq(N, T1);
*u = r * uu[0] + a * uu[1] + b * uu[2];
*v = r * vv[0] + a * vv[1] + b * vv[2];
VDot(d, N, N);
if (d > BEZIER_EPSILON)
{
d = 1.0 / sqrt(d);
VScaleEq(N, d);
}
else
{
Make_Vector(N, 1, 0, 0);
}
return (1);
}
static void bezier_value(VECTOR (*Control_Points)[4][4], DBL u0, DBL v0, VECTOR P, VECTOR N)
{
const DBL C[] = { 1.0, 3.0, 3.0, 1.0 };
int i, j;
DBL c, t, ut, vt;
DBL u[4], uu[4], v[4], vv[4];
DBL du[4], duu[4], dv[4], dvv[4];
DBL squared_u1, squared_v1;
VECTOR U1, V1;
/* Calculate binomial coefficients times coordinate positions. */
u[0] = 1.0; uu[0] = 1.0; du[0] = 0.0; duu[0] = 0.0;
v[0] = 1.0; vv[0] = 1.0; dv[0] = 0.0; dvv[0] = 0.0;
for (i = 1; i < 4; i++)
{
u[i] = u[i - 1] * u0; uu[i] = uu[i - 1] * (1.0 - u0);
v[i] = v[i - 1] * v0; vv[i] = vv[i - 1] * (1.0 - v0);
du[i] = i * u[i - 1]; duu[i] = -i * uu[i - 1];
dv[i] = i * v[i - 1]; dvv[i] = -i * vv[i - 1];
}
/* Now evaluate position and tangents based on control points. */
Make_Vector(P, 0, 0, 0);
Make_Vector(U1, 0, 0, 0);
Make_Vector(V1, 0, 0, 0);
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
c = C[i] * C[j];
ut = u[i] * uu[3 - i];
vt = v[j] * vv[3 - j];
t = c * ut * vt;
VAddScaledEq(P, t, (*Control_Points)[i][j]);
t = c * vt * (du[i] * uu[3 - i] + u[i] * duu[3 - i]);
VAddScaledEq(U1, t, (*Control_Points)[i][j]);
t = c * ut * (dv[j] * vv[3 - j] + v[j] * dvv[3 - j]);
VAddScaledEq(V1, t, (*Control_Points)[i][j]);
}
}
/* Make the normal from the cross product of the tangents. */
VCross(N, U1, V1);
VDot(t, N, N);
squared_u1 = VSumSqr(U1);
squared_v1 = VSumSqr(V1);
if (t > (BEZIER_EPSILON * squared_u1 * squared_v1))
{
t = 1.0 / sqrt(t);
VScaleEq(N, t);
}
else
{
Make_Vector(N, 1, 0, 0);
}
}
