void Do_Infinite_Atmosphere(RAY *Ray, COLOUR Colour)
{
if (opts.Options & OUTPUT_ALPHA &&
!(In_Reflection_Ray || (Radiosity_Trace_Level>1)))
{
/*
If we are using the alpha channel, then the background
must be black - this is necessary for proper antialiasing
of the alpha channel, and assures overall correctness and
consistency.
However, we do want to use the background and sky sphere for radiosity
and for reflections.
*/
Colour[pRED] = Colour[pGREEN] = Colour[pBLUE] = Colour[pFILTER] = 0.0;
Colour[pTRANSM] = 1.0;
}
else
{
/* Set background color. */
Assign_Colour(Colour, Frame.Background_Colour);
Colour[pFILTER] = 0.0;
Colour[pTRANSM] = 1.0;
/* Determine atmospheric effects for infinite ray. */
do_skysphere(Ray, Colour);
}
}
COLOUR *Copy_Colour (COLOUR Old)
{
COLOUR *New;
if (Old != NULL)
{
New = Create_Colour ();
Assign_Colour(*New,Old);
}
else
{
New = NULL;
}
return (New);
}
PIGMENT *Copy_Pigment (PIGMENT *Old)
{
PIGMENT *New;
if (Old != NULL)
{
New = Create_Pigment ();
Copy_TPat_Fields ((TPATTERN *)New, (TPATTERN *)Old);
if (Old->Type == PLAIN_PATTERN)
{
Assign_Colour(New->Colour,Old->Colour);
}
New->Next = (TPATTERN *)Copy_Pigment((PIGMENT *)Old->Next);
}
else
{
New = NULL;
}
return (New);
}
static DBL constant_fog(RAY *Ray, DBL Depth, DBL Width, FOG *Fog, COLOUR Colour)
{
DBL k;
VECTOR P;
if (Fog->Turb != NULL)
{
Depth += Width / 2.0;
VEvaluateRay(P, Ray->Initial, Depth, Ray->Direction);
VEvaluateEq(P, Fog->Turb->Turbulence);
/* The further away the less influence turbulence has. */
k = exp(-Width / Fog->Distance);
Width *= 1.0 - k * min(1.0, Turbulence(P, Fog->Turb, NULL)*Fog->Turb_Depth);
}
Assign_Colour(Colour, Fog->Colour);
return (exp(-Width / Fog->Distance));
}
bool Compute_Pigment (Colour& colour, const PIGMENT *Pigment, const VECTOR EPoint, const Intersection *Intersect, const Ray *ray, TraceThreadData *Thread)
{
int Colour_Found;
VECTOR TPoint;
DBL value;
register DBL fraction;
const BLEND_MAP_ENTRY *Cur, *Prev;
Colour Temp_Colour;
const BLEND_MAP *Blend_Map = Pigment->Blend_Map;
UV_VECT UV_Coords;
if ((Thread->qualityFlags & Q_QUICKC) != 0 && Pigment->Quick_Colour[pRED] != -1.0 && Pigment->Quick_Colour[pGREEN] != -1.0 && Pigment->Quick_Colour[pBLUE] != -1.0)
{
colour = Pigment->Quick_Colour;
return (true);
}
if (Pigment->Type <= LAST_SPECIAL_PATTERN)
{
Colour_Found = true;
switch (Pigment->Type)
{
case NO_PATTERN:
colour.clear();
break;
case PLAIN_PATTERN:
colour = Pigment->colour;
break;
case AVERAGE_PATTERN:
Warp_EPoint (TPoint, EPoint, reinterpret_cast<const TPATTERN *>(Pigment));
Do_Average_Pigments(colour, Pigment, TPoint, Intersect, ray, Thread);
break;
case UV_MAP_PATTERN:
if(Intersect == NULL)
throw POV_EXCEPTION_STRING("The 'uv_mapping' pattern cannot be used as part of a pigment function!");
Cur = &(Pigment->Blend_Map->Blend_Map_Entries[0]);
if (Blend_Map->Type == COLOUR_TYPE)
{
Colour_Found = true;
Assign_Colour(*colour, Cur->Vals.colour);
}
else
{
/* Don't bother warping, simply get the UV vect of the intersection */
Intersect->Object->UVCoord(UV_Coords, Intersect, Thread);
TPoint[X] = UV_Coords[U];
TPoint[Y] = UV_Coords[V];
TPoint[Z] = 0;
if (Compute_Pigment(colour, Cur->Vals.Pigment,TPoint,Intersect, ray, Thread))
Colour_Found = true;
}
break;
case BITMAP_PATTERN:
Warp_EPoint (TPoint, EPoint, reinterpret_cast<const TPATTERN *>(Pigment));
colour.clear();
Colour_Found = image_map (TPoint, Pigment, colour);
break;
default:
throw POV_EXCEPTION_STRING("Pigment type not yet implemented.");
}
return(Colour_Found);
}
Colour_Found = false;
/* NK 19 Nov 1999 added Warp_EPoint */
Warp_EPoint (TPoint, EPoint, reinterpret_cast<const TPATTERN *>(Pigment));
value = Evaluate_TPat (reinterpret_cast<const TPATTERN *>(Pigment),TPoint,Intersect, ray, Thread);
Search_Blend_Map (value, Blend_Map, &Prev, &Cur);
if (Blend_Map->Type == COLOUR_TYPE)
{
Colour_Found = true;
Assign_Colour(*colour, Cur->Vals.colour);
}
else
{
Warp_EPoint (TPoint, EPoint, reinterpret_cast<const TPATTERN *>(Pigment));
if (Compute_Pigment(colour, Cur->Vals.Pigment,TPoint,Intersect, ray, Thread))
Colour_Found = true;
}
if (Prev != Cur)
{
if (Blend_Map->Type == COLOUR_TYPE)
{
Colour_Found = true;
Assign_Colour(*Temp_Colour, Prev->Vals.colour);
}
else
{
if (Compute_Pigment(Temp_Colour, Prev->Vals.Pigment, TPoint, Intersect, ray, Thread))
Colour_Found = true;
}
fraction = (value - Prev->value) / (Cur->value - Prev->value);
colour = Temp_Colour + fraction * (colour - Temp_Colour);
}
return(Colour_Found);
}
int Compute_Pigment (COLOUR Colour, PIGMENT *Pigment, VECTOR EPoint, INTERSECTION *Intersect)
{
int Colour_Found;
VECTOR TPoint;
DBL value;
register DBL fraction;
BLEND_MAP_ENTRY *Cur, *Prev;
COLOUR Temp_Colour;
BLEND_MAP *Blend_Map = Pigment->Blend_Map;
UV_VECT UV_Coords;
if (Pigment->Type <= LAST_SPECIAL_PATTERN)
{
Colour_Found = true;
switch (Pigment->Type)
{
case NO_PATTERN:
Make_Colour(Colour, 0.0, 0.0, 0.0);
break;
case PLAIN_PATTERN:
Assign_Colour(Colour,Pigment->Colour);
break;
case AVERAGE_PATTERN:
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Pigment);
Do_Average_Pigments(Colour,Pigment,TPoint,Intersect);
break;
case UV_MAP_PATTERN:
if(Intersect == NULL)
Error("The 'uv_mapping' pattern cannot be used as part of a pigment function!");
Cur = &(Pigment->Blend_Map->Blend_Map_Entries[0]);
if (Blend_Map->Type == COLOUR_TYPE)
{
Colour_Found = true;
Assign_Colour(Colour, Cur->Vals.Colour);
}
else
{
/* Don't bother warping, simply get the UV vect of the intersection */
UVCoord(UV_Coords, Intersect->Object, Intersect);
TPoint[X] = UV_Coords[U];
TPoint[Y] = UV_Coords[V];
TPoint[Z] = 0;
if (Compute_Pigment(Colour, Cur->Vals.Pigment,TPoint,Intersect))
{
Colour_Found = true;
}
}
break;
case BITMAP_PATTERN:
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Pigment);
Make_Colour(Colour, 0.0, 0.0, 0.0);
Colour_Found = image_map (TPoint, Pigment, Colour);
break;
default:
Error("Pigment type %d not yet implemented",Pigment->Type);
}
return(Colour_Found);
}
Colour_Found = false;
/* NK 19 Nov 1999 added Warp_EPoint */
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Pigment);
value = Evaluate_TPat ((TPATTERN *)Pigment,TPoint,Intersect);
Search_Blend_Map (value, Blend_Map, &Prev, &Cur);
if (Blend_Map->Type == COLOUR_TYPE)
{
Colour_Found = true;
Assign_Colour(Colour, Cur->Vals.Colour);
}
else
{
Warp_EPoint (TPoint, EPoint, (TPATTERN *)Pigment);
if (Compute_Pigment(Colour, Cur->Vals.Pigment,TPoint,Intersect))
{
Colour_Found = true;
}
}
if (Prev != Cur)
{
if (Blend_Map->Type == COLOUR_TYPE)
{
Colour_Found = true;
Assign_Colour(Temp_Colour, Prev->Vals.Colour);
}
else
{
if (Compute_Pigment(Temp_Colour, Prev->Vals.Pigment, TPoint,Intersect))
{
Colour_Found = true;
}
}
fraction = (value - Prev->value) / (Cur->value - Prev->value);
Colour[pRED] = Temp_Colour[pRED] + fraction * (Colour[pRED] - Temp_Colour[pRED]);
Colour[pGREEN] = Temp_Colour[pGREEN] + fraction * (Colour[pGREEN] - Temp_Colour[pGREEN]);
Colour[pBLUE] = Temp_Colour[pBLUE] + fraction * (Colour[pBLUE] - Temp_Colour[pBLUE]);
Colour[pFILTER] = Temp_Colour[pFILTER] + fraction * (Colour[pFILTER] - Temp_Colour[pFILTER]);
Colour[pTRANSM] = Temp_Colour[pTRANSM] + fraction * (Colour[pTRANSM] - Temp_Colour[pTRANSM]);
}
return(Colour_Found);
}
static DBL ground_fog(RAY *Ray, DBL Depth, DBL Width, FOG *Fog, COLOUR Colour)
{
DBL fog_density, delta;
DBL start, end;
DBL y1, y2, k;
VECTOR P, P1, P2;
/* Get start point. */
VEvaluateRay(P1, Ray->Initial, Depth, Ray->Direction);
/* Get end point. */
VLinComb2(P2, 1.0, P1, Width, Ray->Direction);
/*
* Could preform transfomation here to translate Start and End
* points into ground fog space.
*/
VDot(y1, P1, Fog->Up);
VDot(y2, P2, Fog->Up);
start = (y1 - Fog->Offset) / Fog->Alt;
end = (y2 - Fog->Offset) / Fog->Alt;
/* Get integral along y-axis from start to end. */
if (start <= 0.0)
{
if (end <= 0.0)
{
fog_density = 1.0;
}
else
{
fog_density = (atan(end) - start) / (end - start);
}
}
else
{
if (end <= 0.0)
{
fog_density = (atan(start) - end) / (start - end);
}
else
{
delta = start - end;
if (fabs(delta) > EPSILON)
{
fog_density = (atan(start) - atan(end)) / delta;
}
else
{
fog_density = 1.0 / (Sqr(start) + 1.0);
}
}
}
/* Apply turbulence. */
if (Fog->Turb != NULL)
{
VHalf(P, P1, P2);
VEvaluateEq(P, Fog->Turb->Turbulence);
/* The further away the less influence turbulence has. */
k = exp(-Width / Fog->Distance);
Width *= 1.0 - k * min(1.0, Turbulence(P, Fog->Turb, NULL)*Fog->Turb_Depth);
}
Assign_Colour(Colour, Fog->Colour);
return (exp(-Width * fog_density / Fog->Distance));
}
