void Compute_Triangle_BBox(TRIANGLE *Triangle)
{
VECTOR Min, Max, Epsilon;
Make_Vector(Epsilon, EPSILON, EPSILON, EPSILON);
Min[X] = min3(Triangle->P1[X], Triangle->P2[X], Triangle->P3[X]);
Min[Y] = min3(Triangle->P1[Y], Triangle->P2[Y], Triangle->P3[Y]);
Min[Z] = min3(Triangle->P1[Z], Triangle->P2[Z], Triangle->P3[Z]);
Max[X] = max3(Triangle->P1[X], Triangle->P2[X], Triangle->P3[X]);
Max[Y] = max3(Triangle->P1[Y], Triangle->P2[Y], Triangle->P3[Y]);
Max[Z] = max3(Triangle->P1[Z], Triangle->P2[Z], Triangle->P3[Z]);
VSubEq(Min, Epsilon);
VAddEq(Max, Epsilon);
Make_BBox_from_min_max(Triangle->BBox, Min, Max);
}
void Compute_Quadric_BBox(QUADRIC *Quadric, VECTOR ClipMin, VECTOR ClipMax)
{
DBL A, B, C, D, E, F, G, H, I, J;
DBL a, b, c, d;
DBL rx, ry, rz, rx1, rx2, ry1, ry2, rz1, rz2, x, y, z;
DBL New_Volume, Old_Volume;
VECTOR Min, Max, TmpMin, TmpMax, NewMin, NewMax, T1;
BBOX Old;
OBJECT *Sib;
/*
* Check for 'normal' form. If the quadric isn't in it's normal form
* we can't do anything (we could, but that would be to tedious!
* Diagonalising the quadric's 4x4 matrix, i.e. finding its eigenvalues
* and eigenvectors -> solving a 4th order polynom).
*/
/* Get quadrics coefficients. */
A = Quadric->Square_Terms[X];
E = Quadric->Square_Terms[Y];
H = Quadric->Square_Terms[Z];
B = Quadric->Mixed_Terms[X] / 2.0;
C = Quadric->Mixed_Terms[Y] / 2.0;
F = Quadric->Mixed_Terms[Z] / 2.0;
D = Quadric->Terms[X] / 2.0;
G = Quadric->Terms[Y] / 2.0;
I = Quadric->Terms[Z] / 2.0;
J = Quadric->Constant;
/* Set small values to 0. */
if (fabs(A) < EPSILON) A = 0.0;
if (fabs(B) < EPSILON) B = 0.0;
if (fabs(C) < EPSILON) C = 0.0;
if (fabs(D) < EPSILON) D = 0.0;
if (fabs(E) < EPSILON) E = 0.0;
if (fabs(F) < EPSILON) F = 0.0;
if (fabs(G) < EPSILON) G = 0.0;
if (fabs(H) < EPSILON) H = 0.0;
if (fabs(I) < EPSILON) I = 0.0;
if (fabs(J) < EPSILON) J = 0.0;
/* Non-zero mixed terms --> return */
if ((B != 0.0) || (C != 0.0) || (F != 0.0))
{
return;
}
/* Non-zero linear terms --> get translation vector */
if ((D != 0.0) || (G != 0.0) || (I != 0.0))
{
if (A != 0.0)
{
T1[X] = -D / A;
}
else
{
if (D != 0.0)
{
T1[X] = J / (2.0 * D);
}
else
{
T1[X] = 0.0;
}
}
if (E != 0.0)
{
T1[Y] = -G / E;
}
else
{
if (G != 0.0)
{
T1[Y] = J / (2.0 * G);
}
else
{
T1[Y] = 0.0;
}
}
if (H != 0.0)
{
T1[Z] = -I / H;
}
else
{
if (I != 0.0)
{
T1[Z] = J / (2.0 * I);
}
else
{
T1[Z] = 0.0;
}
}
/* Recalculate coefficients. */
D += A * T1[X];
G += E * T1[Y];
I += H * T1[Z];
J -= T1[X]*(A*T1[X] + 2.0*D) + T1[Y]*(E*T1[Y] + 2.0*G) + T1[Z]*(H*T1[Z] + 2.0*I);
}
else
{
Make_Vector(T1, 0.0, 0.0, 0.0);
}
/* Get old bounding box. */
Old = Quadric->BBox;
/* Init new bounding box. */
NewMin[X] = NewMin[Y] = NewMin[Z] = -BOUND_HUGE/2;
NewMax[X] = NewMax[Y] = NewMax[Z] = BOUND_HUGE/2;
/* Get the bounding box of the clipping object. */
if (Quadric->Clip != NULL)
{
Min[X] = Min[Y] = Min[Z] = -BOUND_HUGE;
Max[X] = Max[Y] = Max[Z] = BOUND_HUGE;
/* Intersect the members bounding boxes. */
for (Sib = Quadric->Clip; Sib != NULL; Sib = Sib->Sibling)
{
if (!Test_Flag(Sib, INVERTED_FLAG))
{
if (Sib->Methods == &Plane_Methods)
{
Compute_Plane_Min_Max((PLANE *)Sib, TmpMin, TmpMax);
}
else
{
Make_min_max_from_BBox(TmpMin, TmpMax, Sib->BBox);
}
Min[X] = max(Min[X], TmpMin[X]);
Min[Y] = max(Min[Y], TmpMin[Y]);
Min[Z] = max(Min[Z], TmpMin[Z]);
Max[X] = min(Max[X], TmpMax[X]);
Max[Y] = min(Max[Y], TmpMax[Y]);
Max[Z] = min(Max[Z], TmpMax[Z]);
}
}
Assign_Vector(ClipMin, Min);
Assign_Vector(ClipMax, Max);
}
/* Translate clipping box. */
VSubEq(ClipMin, T1);
VSubEq(ClipMax, T1);
/* We want A to be non-negative. */
if (A < 0.0)
{
A = -A;
D = -D;
E = -E;
G = -G;
H = -H;
I = -I;
J = -J;
}
/*
*
* Check for ellipsoid.
*
* x*x y*y z*z
* ----- + ----- + ----- - 1 = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E > 0.0) && (H > 0.0) && (J < 0.0))
{
a = sqrt(-J/A);
b = sqrt(-J/E);
c = sqrt(-J/H);
NewMin[X] = -a;
NewMin[Y] = -b;
NewMin[Z] = -c;
NewMax[X] = a;
NewMax[Y] = b;
NewMax[Z] = c;
}
/*
*
* Check for cylinder (x-axis).
*
* y*y z*z
* ----- + ----- - 1 = 0
* b*b c*c
*
*/
if ((A == 0.0) && (E > 0.0) && (H > 0.0) && (J < 0.0))
{
b = sqrt(-J/E);
c = sqrt(-J/H);
NewMin[Y] = -b;
NewMin[Z] = -c;
NewMax[Y] = b;
NewMax[Z] = c;
}
/*
*
* Check for cylinder (y-axis).
*
* x*x z*z
* ----- + ----- - 1 = 0
* a*a c*c
*
*/
if ((A > 0.0) && (E == 0.0) && (H > 0.0) && (J < 0.0))
{
a = sqrt(-J/A);
c = sqrt(-J/H);
NewMin[X] = -a;
NewMin[Z] = -c;
NewMax[X] = a;
NewMax[Z] = c;
}
/*
*
* Check for cylinder (z-axis).
*
* x*x y*y
* ----- + ----- - 1 = 0
* a*a b*b
*
*/
if ((A > 0.0) && (E > 0.0) && (H == 0.0) && (J < 0.0))
{
a = sqrt(-J/A);
b = sqrt(-J/E);
NewMin[X] = -a;
NewMin[Y] = -b;
NewMax[X] = a;
NewMax[Y] = b;
}
/*
*
* Check for cone (x-axis).
*
* x*x y*y z*z
* ----- - ----- - ----- = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E < 0.0) && (H < 0.0) && (J == 0.0))
{
a = sqrt(1.0/A);
b = sqrt(-1.0/E);
c = sqrt(-1.0/H);
/* Get radii for lower x value. */
x = ClipMin[X];
ry1 = fabs(x * b / a);
rz1 = fabs(x * c / a);
/* Get radii for upper x value. */
x = ClipMax[X];
ry2 = fabs(x * b / a);
rz2 = fabs(x * c / a);
ry = max(ry1, ry2);
rz = max(rz1, rz2);
NewMin[Y] = -ry;
NewMin[Z] = -rz;
NewMax[Y] = ry;
NewMax[Z] = rz;
}
/*
*
* Check for cone (y-axis).
*
* x*x y*y z*z
* ----- - ----- + ----- = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E < 0.0) && (H > 0.0) && (J == 0.0))
{
a = sqrt(1.0/A);
b = sqrt(-1.0/E);
c = sqrt(1.0/H);
/* Get radii for lower y value. */
y = ClipMin[Y];
rx1 = fabs(y * a / b);
rz1 = fabs(y * c / b);
/* Get radii for upper y value. */
y = ClipMax[Y];
rx2 = fabs(y * a / b);
rz2 = fabs(y * c / b);
rx = max(rx1, rx2);
rz = max(rz1, rz2);
NewMin[X] = -rx;
NewMin[Z] = -rz;
NewMax[X] = rx;
NewMax[Z] = rz;
}
/*
*
* Check for cone (z-axis).
*
* x*x y*y z*z
* ----- + ----- - ----- = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E > 0.0) && (H < 0.0) && (J == 0.0))
{
a = sqrt(1.0/A);
b = sqrt(1.0/E);
c = sqrt(-1.0/H);
/* Get radii for lower z value. */
z = ClipMin[Z];
rx1 = fabs(z * a / c);
ry1 = fabs(z * b / c);
/* Get radii for upper z value. */
z = ClipMax[Z];
rx2 = fabs(z * a / c);
ry2 = fabs(z * b / c);
rx = max(rx1, rx2);
ry = max(ry1, ry2);
NewMin[X] = -rx;
NewMin[Y] = -ry;
NewMax[X] = rx;
NewMax[Y] = ry;
}
/*
*
* Check for hyperboloid (x-axis).
*
* x*x y*y z*z
* ----- - ----- - ----- + 1 = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E < 0.0) && (H < 0.0) && (J > 0.0))
{
/* Get radii for lower x value. */
x = ClipMin[X];
d = 1.0 + A * Sqr(x);
ry1 = sqrt(-d / E);
rz1 = sqrt(-d / H);
/* Get radii for upper x value. */
x = ClipMax[X];
d = 1.0 + A * Sqr(x);
ry2 = sqrt(-d / E);
rz2 = sqrt(-d / H);
ry = max(ry1, ry2);
rz = max(rz1, rz2);
NewMin[Y] = -ry;
NewMin[Z] = -rz;
NewMax[Y] = ry;
NewMax[Z] = rz;
}
/*
*
* Check for hyperboloid (y-axis).
*
* x*x y*y z*z
* ----- - ----- + ----- - 1 = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E < 0.0) && (H > 0.0) && (J < 0.0))
{
/* Get radii for lower y value. */
y = ClipMin[Y];
d = 1.0 - E * Sqr(y);
rx1 = sqrt(d / A);
rz1 = sqrt(d / H);
/* Get radii for upper y value. */
y = ClipMax[Y];
d = 1.0 - E * Sqr(y);
rx2 = sqrt(d / A);
rz2 = sqrt(d / H);
rx = max(rx1, rx2);
rz = max(rz1, rz2);
NewMin[X] = -rx;
NewMin[Z] = -rz;
NewMax[X] = rx;
NewMax[Z] = rz;
}
/*
*
* Check for hyperboloid (z-axis).
*
* x*x y*y z*z
* ----- + ----- - ----- - 1 = 0
* a*a b*b c*c
*
*/
if ((A > 0.0) && (E > 0.0) && (H < 0.0) && (J < 0.0))
{
/* Get radii for lower z value. */
z = ClipMin[Z];
d = 1.0 - H * Sqr(z);
rx1 = sqrt(d / A);
ry1 = sqrt(d / E);
/* Get radii for upper z value. */
z = ClipMax[Z];
d = 1.0 - H * Sqr(z);
rx2 = sqrt(d / A);
ry2 = sqrt(d / E);
rx = max(rx1, rx2);
ry = max(ry1, ry2);
NewMin[X] = -rx;
NewMin[Y] = -ry;
NewMax[X] = rx;
NewMax[Y] = ry;
}
/*
*
* Check for paraboloid (x-axis).
*
* y*y z*z
* x - ----- - ----- = 0
* b*b c*c
*
*/
if ((A == 0.0) && (D != 0.0) && (E != 0.0) && (H != 0.0) && (J == 0.0))
{
/* Get radii for lower x value. */
x = ClipMin[X];
ry1 = sqrt(fabs(2.0 * D * x / E));
rz1 = sqrt(fabs(2.0 * D * x / H));
/* Get radii for upper x value. */
x = ClipMax[X];
ry2 = sqrt(fabs(2.0 * D * x / E));
rz2 = sqrt(fabs(2.0 * D * x / H));
ry = max(ry1, ry2);
rz = max(rz1, rz2);
NewMin[Y] = -ry;
NewMin[Z] = -rz;
NewMax[Y] = ry;
NewMax[Z] = rz;
}
/*
*
* Check for paraboloid (y-axis).
*
* x*x z*z
* y - ----- - ----- = 0
* a*a c*c
*
*/
if ((E == 0.0) && (G != 0.0) && (A != 0.0) && (H != 0.0) && (J == 0.0))
{
/* Get radii for lower y-value. */
y = ClipMin[Y];
rx1 = sqrt(fabs(2.0 * G * y / A));
rz1 = sqrt(fabs(2.0 * G * y / H));
/* Get radii for upper y value. */
y = ClipMax[Y];
rx2 = sqrt(fabs(2.0 * G * y / A));
rz2 = sqrt(fabs(2.0 * G * y / H));
rx = max(rx1, rx2);
rz = max(rz1, rz2);
NewMin[X] = -rx;
NewMin[Z] = -rz;
NewMax[X] = rx;
NewMax[Z] = rz;
}
/*
*
* Check for paraboloid (z-axis).
*
* x*x y*y
* z - ----- - ----- = 0
* a*a b*b
*
*/
if ((H == 0.0) && (I != 0.0) && (A != 0.0) && (E != 0.0) && (J == 0.0))
{
/* Get radii for lower z-value. */
z = ClipMin[Z];
rx1 = sqrt(fabs(2.0 * I * z / A));
ry1 = sqrt(fabs(2.0 * I * z / E));
/* Get radii for upper z value. */
z = ClipMax[Z];
rx2 = sqrt(fabs(2.0 * I * z / A));
ry2 = sqrt(fabs(2.0 * I * z / E));
rx = max(rx1, rx2);
ry = max(ry1, ry2);
NewMin[X] = -rx;
NewMin[Y] = -ry;
NewMax[X] = rx;
NewMax[Y] = ry;
}
/* Intersect clipping object's and quadric's bounding boxes */
NewMin[X] = max(NewMin[X], ClipMin[X]);
NewMin[Y] = max(NewMin[Y], ClipMin[Y]);
NewMin[Z] = max(NewMin[Z], ClipMin[Z]);
NewMax[X] = min(NewMax[X], ClipMax[X]);
NewMax[Y] = min(NewMax[Y], ClipMax[Y]);
NewMax[Z] = min(NewMax[Z], ClipMax[Z]);
/* Use old or new bounding box? */
New_Volume = (NewMax[X] - NewMin[X]) * (NewMax[Y] - NewMin[Y]) * (NewMax[Z] - NewMin[Z]);
BOUNDS_VOLUME(Old_Volume, Old);
if (New_Volume < Old_Volume)
{
/* Add translation. */
Quadric->Automatic_Bounds = true;
VAddEq(NewMin, T1);
VAddEq(NewMax, T1);
Make_BBox_from_min_max(Quadric->BBox, NewMin, NewMax);
/* Beware of bounding boxes to large. */
if ((Quadric->BBox.Lengths[X] > CRITICAL_LENGTH) ||
(Quadric->BBox.Lengths[Y] > CRITICAL_LENGTH) ||
(Quadric->BBox.Lengths[Z] > CRITICAL_LENGTH))
{
Make_BBox(Quadric->BBox, -BOUND_HUGE/2, -BOUND_HUGE/2, -BOUND_HUGE/2,
BOUND_HUGE, BOUND_HUGE, BOUND_HUGE);
}
}
}
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 );
}
}
static void Box_UVCoord(UV_VECT Result, OBJECT *Object, INTERSECTION *Inter)
{
VECTOR P, Box_Diff;
BOX *Box = (BOX *)Object;
/* Transform the point into the cube's space */
if (Box->Trans != NULL)
MInvTransPoint(P, Inter->IPoint, Box->Trans);
else
Assign_Vector(P, Inter->IPoint);
VSub(Box_Diff,Box->bounds[1],Box->bounds[0]);
/* this line moves the bottom,left,front corner of the box to <0,0,0> */
VSubEq(P, Box->bounds[0]);
/* this line normalizes the face offsets */
VDivEq(P, Box_Diff);
/* if no normalize above, then we should use Box->UV_Trans and also
inverse-transform the bounds */
/* The following code does a variation of cube environment mapping. All the
textures are not mirrored when the cube is viewed from outside. */
switch (Inter->i1)
{
case SIDE_X_0:
Result[U] = (P[Z] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
case SIDE_X_1:
Result[U] = (3.0 / 4.0) - (P[Z] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
case SIDE_Y_0:
Result[U] = (1.0 / 4.0) + (P[X] / 4.0);
Result[V] = (P[Z] / 3.0);
break;
case SIDE_Y_1:
Result[U] = (1.0 / 4.0) + (P[X] / 4.0);
Result[V] = (3.0 / 3.0) - (P[Z] / 3.0);
break;
case SIDE_Z_0:
Result[U] = 1.0 - (P[X] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
case SIDE_Z_1:
Result[U] = (1.0 / 4.0) + (P[X] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
default: Error("Unknown box side in Box_Normal().");
}
/*
This is the original cube environment mapping. The texture is correct
when viewed from inside the cube.
switch (Inter->i1)
{
case SIDE_X_0:
Result[U] = (1.0 / 4.0) - (P[Z] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
case SIDE_X_1:
Result[U] = (2.0 / 4.0) + (P[Z] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
case SIDE_Y_0:
Result[U] = (1.0 / 4.0) + (P[X] / 4.0);
Result[V] = (1.0 / 3.0) - (P[Z] / 3.0);
break;
case SIDE_Y_1:
Result[U] = (1.0 / 4.0) + (P[X] / 4.0);
Result[V] = (2.0 / 3.0) + (P[Z] / 3.0);
break;
case SIDE_Z_0:
Result[U] = (1.0 / 4.0) + (P[X] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
case SIDE_Z_1:
Result[U] = 1.0 - (P[X] / 4.0);
Result[V] = (1.0 / 3.0) + (P[Y] / 3.0);
break;
default: Error("Unknown box side in Box_Normal().");
}
*/
}
int IsoSurface_Function_Find_Root(ISOSURFACE* ISOSRF, VECTOR P, VECTOR D, DBL* Depth1, DBL* Depth2, bool in_shadow_test)
{
DBL dt, t21, l_b, l_e, oldmg;
ISO_Pair EP1, EP2;
VECTOR VTmp;
Increase_Counter(stats[Ray_IsoSurface_Find_Root]);
VLength(ISOSRF->Vlength, D);
if(ISOSRF->cache)
{
Increase_Counter(stats[Ray_IsoSurface_Cache]);
VEvaluateRay(VTmp, P, *Depth1, D);
VSubEq(VTmp, ISOSRF->P);
VLength(l_b, VTmp);
VEvaluateRay(VTmp, P, *Depth2, D);
VSubEq(VTmp, ISOSRF->D);
VLength(l_e, VTmp);
if((ISOSRF->fmax - ISOSRF->max_gradient * max(l_b, l_e)) > 0.0)
{
Increase_Counter(stats[Ray_IsoSurface_Cache_Succeeded]);
return false;
}
}
Assign_Vector(ISOSRF->P, P);
Assign_Vector(ISOSRF->D, D);
ISOSRF->cache = false;
EP1.t = *Depth1;
EP1.f = Float_IsoSurface_Function(ISOSRF, Depth1);
ISOSRF->fmax = EP1.f;
if((ISOSRF->closed == false) && (EP1.f < 0.0))
{
ISOSRF->Inv3 *= -1;
EP1.f *= -1;
}
EP2.t = *Depth2;
EP2.f = Float_IsoSurface_Function(ISOSRF, Depth2);
ISOSRF->fmax = min(EP2.f, ISOSRF->fmax);
oldmg = ISOSRF->max_gradient;
t21 = (*Depth2 - *Depth1);
if((ISOSRF->eval == true) && (ISOSRF->max_gradient > ISOSRF->eval_param[0]))
ISOSRF->max_gradient *= ISOSRF->eval_param[2];
dt = ISOSRF->max_gradient * ISOSRF->Vlength * t21;
if(IsoSurface_Function_Find_Root_R(ISOSRF, &EP1, &EP2, dt, t21, 1.0 / (ISOSRF->Vlength * t21), in_shadow_test))
{
if(ISOSRF->eval == true)
{
DBL curvar = fabs(ISOSRF->max_gradient - oldmg);
if(curvar > ISOSRF->mginfo->eval_var)
ISOSRF->mginfo->eval_var = curvar;
ISOSRF->mginfo->eval_cnt++;
ISOSRF->mginfo->eval_gradient_sum += ISOSRF->max_gradient;
if(ISOSRF->max_gradient > ISOSRF->mginfo->eval_max)
ISOSRF->mginfo->eval_max = ISOSRF->max_gradient;
}
*Depth1 = ISOSRF->tl;
return true;
}
else if(!in_shadow_test)
{
ISOSRF->cache = true;
VEvaluateRay(ISOSRF->P, P, EP1.t, D);
VEvaluateRay(ISOSRF->D, P, EP2.t, D);
return false;
}
return false;
}
