home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Chestnut's Multimedia Mania
/
MM_MANIA.ISO
/
graphics
/
povsrc20
/
lighting.c
< prev
next >
Wrap
C/C++ Source or Header
|
1993-10-03
|
38KB
|
1,249 lines
/****************************************************************************
* lighting.c
*
* This module calculates lighting properties like ambient, diffuse, specular,
* reflection, refraction, etc.
*
* from Persistence of Vision Raytracer
* Copyright 1993 Persistence of Vision Team
*---------------------------------------------------------------------------
* NOTICE: This source code file is provided so that users may experiment
* with enhancements to POV-Ray and to port the software to platforms other
* than those supported by the POV-Ray Team. There are strict rules under
* which you are permitted to use this file. The rules are in the file
* named POVLEGAL.DOC which should be distributed with this file. If
* POVLEGAL.DOC is not available or for more info please contact the POV-Ray
* Team Coordinator by leaving a message in CompuServe's Graphics Developer's
* Forum. The latest version of POV-Ray may be found there as well.
*
* This program is based on the popular DKB raytracer version 2.12.
* DKBTrace was originally written by David K. Buck.
* DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
*
*****************************************************************************/
#include "frame.h"
#include "vector.h"
#include "povproto.h"
extern int Trace_Level;
extern FRAME Frame;
extern OBJECT *Root_Object;
extern unsigned int Options;
extern int Use_Slabs;
extern unsigned long Quality_Flags;
extern int Shadow_Test_Flag;
extern long Shadow_Ray_Tests, Shadow_Rays_Succeeded, Shadow_Cache_Hits;
extern long Reflected_Rays_Traced, Refracted_Rays_Traced;
extern long Transmitted_Rays_Traced;
extern short *hashTable;
extern unsigned short crctab[256];
#define rand3d(a,b) crctab[(int)(hashTable[(int)(hashTable[(int)((a)&0xfff)]^(b))&0xfff])&0xff]
#define COORDINATE_LIMIT 1.0e17
#define BLACK_LEVEL 0.003
/* "Small_Tolerance" is just too tight for higher order polynomial equations.
this value should probably be a variable of some sort, but for now just
use a reasonably small value. If people render real small objects real
close to each other then there may be some shading problems. Otherwise
having SHADOW_TOLERANCE as large as this won't affect images. */
#define SHADOW_TOLERANCE 1.0e-3
static void do_light PARAMS((LIGHT_SOURCE *Light_Source,
DBL *Light_Source_Depth, RAY *Light_Source_Ray, VECTOR *IPoint,
COLOUR *Light_Colour));
static int do_blocking PARAMS((INTERSECTION *Local_Intersection,
COLOUR *Light_Colour, ISTACK *Local_Stack));
static void do_phong PARAMS((FINISH *Finish, RAY *Light_Source_Ray,
VECTOR *Eye, VECTOR *Layer_Normal, COLOUR *Colour, COLOUR *Light_Colour,
COLOUR *Layer_Pigment_Colour));
static void do_specular PARAMS((FINISH *Finish, RAY *Light_Source_Ray,
VECTOR *REye, VECTOR *Layer_Normal, COLOUR *Colour, COLOUR *Light_Colour,
COLOUR *Layer_Pigment_Colour));
static void do_diffuse PARAMS((FINISH *Finish, RAY *Light_Source_Ray,
VECTOR *Layer_Normal, COLOUR *Colour, COLOUR *Light_Colour,
COLOUR *Layer_Pigment_Colour, DBL Attenuation));
static void Block_Area_Light PARAMS((LIGHT_SOURCE *Light_Source,
DBL Light_Source_Depth, RAY *Light_Source_Ray_Ptr, VECTOR *IPoint,
COLOUR *Light_Colour, int u1, int v1, int u2, int v2, int Level));
static void Block_Point_Light PARAMS((LIGHT_SOURCE *Light_Source,
DBL Light_Source_Depth, RAY *Light_Source_Ray_Ptr, COLOUR *Light_Colour));
static void Block_Point_Light (Light_Source, Light_Source_Depth, Light_Source_Ray_Ptr, Light_Colour)
LIGHT_SOURCE *Light_Source;
DBL Light_Source_Depth;
RAY *Light_Source_Ray_Ptr;
COLOUR *Light_Colour;
{
OBJECT *Blocking_Object;
int Quit_Looking, Not_Found_Shadow, Cache_Me;
INTERSECTION *Local_Intersection, Bounded_Intersection;
ISTACK *Local_Stack;
RAY Local_Ray;
RAY Light_Source_Ray;
Light_Source_Ray = *Light_Source_Ray_Ptr;
Local_Stack = open_istack ();
Quit_Looking = FALSE;
/* Test the cached object first */
/* Made changes so that semi-transparent objects never get cached */
if (Light_Source->Shadow_Cached_Object != NULL)
{
Shadow_Ray_Tests++;
if (Ray_In_Bounds (&Light_Source_Ray, Light_Source->Shadow_Cached_Object->Bound))
{
if (All_Intersections (Light_Source->Shadow_Cached_Object, &Light_Source_Ray, Local_Stack))
while ((Local_Intersection=pop_entry(Local_Stack)) != NULL)
{
if ((!Local_Intersection->Object->No_Shadow_Flag) &&
(Local_Intersection->Depth < Light_Source_Depth-Small_Tolerance) &&
(Local_Intersection->Depth > SHADOW_TOLERANCE))
if (do_blocking(Local_Intersection, Light_Colour, Local_Stack))
{
Quit_Looking = TRUE;
Shadow_Cache_Hits++;
break;
}
}
}
}
if (Quit_Looking)
{
close_istack (Local_Stack);
return;
}
Not_Found_Shadow = TRUE;
Cache_Me = FALSE;
if (!Use_Slabs)
{
for (Blocking_Object = Frame.Objects;
Blocking_Object != NULL;
Blocking_Object = Blocking_Object->Sibling)
{
if (Blocking_Object == Light_Source->Shadow_Cached_Object)
continue;
Shadow_Ray_Tests++;
if (!Ray_In_Bounds (&Light_Source_Ray, Blocking_Object->Bound))
continue;
if (!All_Intersections (Blocking_Object, &Light_Source_Ray, Local_Stack))
continue;
while ((Local_Intersection = pop_entry(Local_Stack)) != NULL)
if ((!Local_Intersection->Object->No_Shadow_Flag) &&
(Local_Intersection->Depth < Light_Source_Depth-Small_Tolerance) &&
(Local_Intersection->Depth > SHADOW_TOLERANCE))
{
if (do_blocking(Local_Intersection, Light_Colour, Local_Stack))
{
Cache_Me = Not_Found_Shadow;
Quit_Looking = TRUE;
break; /* from while */
}
Not_Found_Shadow = FALSE;
}
if (Quit_Looking)
break; /* from for */
}
}
else /* Use bounding slabs to look for shadows */
{
Local_Ray = Light_Source_Ray;
while (!Quit_Looking)
{
Shadow_Ray_Tests++;
Local_Ray.Quadric_Constants_Cached = 0;
Bounded_Intersection.Depth = Light_Source_Depth;
if (Bounds_Intersect(Root_Object, &Local_Ray, &Bounded_Intersection,
&Blocking_Object))
{
if (Bounded_Intersection.Depth > Light_Source_Depth)
break; /* Intersection was beyond the light */
if (!(Bounded_Intersection.Object->No_Shadow_Flag))
if (Blocking_Object != Light_Source->Shadow_Cached_Object)
{
Shadow_Rays_Succeeded++;
Filter_Shadow_Ray(&Bounded_Intersection, Light_Colour);
if ((fabs(Light_Colour->Red) < BLACK_LEVEL) &&
(fabs(Light_Colour->Green) < BLACK_LEVEL) &&
(fabs(Light_Colour->Blue) < BLACK_LEVEL))
{
Cache_Me = Not_Found_Shadow;
Quit_Looking = TRUE;
break; /* from while */
}
}
/* Move the ray to the point of intersection, plus some */
Light_Source_Depth -= Bounded_Intersection.Depth;
Local_Ray.Initial = Bounded_Intersection.IPoint;
Not_Found_Shadow = FALSE;
}
else /* No intersections in the direction of the ray */
{
break;
}
} /*endwhile*/
} /*endelse*/
if (Cache_Me)
Light_Source->Shadow_Cached_Object = Blocking_Object;
close_istack (Local_Stack);
}
static void Block_Area_Light (Light_Source, Light_Source_Depth,
Light_Source_Ray_Ptr,IPoint, Light_Colour, u1, v1, u2, v2, Level)
LIGHT_SOURCE *Light_Source;
DBL Light_Source_Depth;
RAY *Light_Source_Ray_Ptr;
VECTOR *IPoint;
COLOUR *Light_Colour;
int u1, v1, u2, v2, Level;
{
COLOUR Sample_Colour[4], Dummy_Colour;
VECTOR Center_Save, NewAxis1, NewAxis2;
int i, j, u, v, New_u1, New_v1, New_u2, New_v2;
DBL Jitter_u, Jitter_v, ScaleFactor;
RAY Light_Source_Ray;
Light_Source_Ray = *Light_Source_Ray_Ptr;
/* First call, initialize */
if (u1 == 0 && v1 == 0 && u2 == 0 && v2 == 0)
{
/* Flag uncalculated points with a negative value for Red */
for (i = 0; i < Light_Source->Area_Size1; i++)
{
for (j = 0; j < Light_Source->Area_Size2; j++)
Light_Source->Light_Grid[i][j].Red = -1.0;
}
u1 = 0;
v1 = 0;
u2 = Light_Source->Area_Size1 - 1;
v2 = Light_Source->Area_Size2 - 1;
}
/* Save the light source center since we'll be fiddling with it */
Center_Save=Light_Source->Center;
/* Sample the four corners of the region */
for (i = 0; i < 4; i++)
{
switch (i)
{
case 0:
u = u1; v = v1; break;
case 1:
u = u2; v = v1; break;
case 2:
u = u1; v = v2; break;
case 3:
u = u2; v = v2; break;
}
if (Light_Source -> Light_Grid[u][v].Red >= 0.0)
/* We've already calculated this point, reuse it */
Sample_Colour[i]=Light_Source->Light_Grid[u][v];
else
{
Jitter_u = (DBL)u;
Jitter_v = (DBL)v;
if (Light_Source -> Jitter)
{
Jitter_u += (rand() % 4096)/4096.0 - 0.5;
Jitter_v += (rand() % 4096)/4096.0 - 0.5;
/*
Not sure if jx = IPoint->x + 100*u;
this works jy = IPoint->y + 100*v;
yet
Jitter_u += ((rand3d(jx, jy) & 0x7FFF)/32768.0) - 0.5;
Jitter_v += ((rand3d(jx+10, jy+10) & 0x7FFF)/32768.0) - 0.5;
*/
}
if (Light_Source -> Area_Size1 > 1)
{
ScaleFactor = Jitter_u/(DBL)(Light_Source->Area_Size1 - 1) - 0.5;
VScale (NewAxis1, Light_Source->Axis1, ScaleFactor)
}
else
Make_Vector (&NewAxis1, 0.0, 0.0, 0.0);
if (Light_Source -> Area_Size2 > 1)
{
ScaleFactor = Jitter_v/(DBL)(Light_Source->Area_Size2 - 1) - 0.5;
VScale (NewAxis2, Light_Source->Axis2, ScaleFactor)
}
else
Make_Vector (&NewAxis2, 0.0, 0.0, 0.0);
Light_Source->Center=Center_Save;
VAdd (Light_Source->Center, Light_Source->Center, NewAxis1);
VAdd (Light_Source->Center, Light_Source->Center, NewAxis2);
/* Recalculate the light source ray but not the colour */
do_light (Light_Source, &Light_Source_Depth, &Light_Source_Ray,
IPoint, &Dummy_Colour);
Sample_Colour[i]=*Light_Colour;
Block_Point_Light (Light_Source, Light_Source_Depth,
&Light_Source_Ray, &Sample_Colour[i]);
Light_Source->Light_Grid[u][v]=Sample_Colour[i];
}
}
Light_Source->Center=Center_Save;
if ( (u2 - u1 > 1 || v2 - v1 > 1) && (Level < Light_Source -> Adaptive_Level ||
Colour_Distance (&Sample_Colour[0], &Sample_Colour[1]) > 0.1 ||
Colour_Distance (&Sample_Colour[1], &Sample_Colour[3]) > 0.1 ||
Colour_Distance (&Sample_Colour[3], &Sample_Colour[2]) > 0.1 ||
Colour_Distance (&Sample_Colour[2], &Sample_Colour[0]) > 0.1) )
{
for (i = 0; i < 4; i++)
{
switch (i)
{
case 0:
New_u1 = u1;
New_v1 = v1;
New_u2 = (int)floor ((u1 + u2)/2.0);
New_v2 = (int)floor ((v1 + v2)/2.0);
break;
case 1:
New_u1 = (int)ceil ((u1 + u2)/2.0);
New_v1 = v1;
New_u2 = u2;
New_v2 = (int)floor ((v1 + v2)/2.0);
break;
case 2:
New_u1 = u1;
New_v1 = (int)ceil ((v1 + v2)/2.0);
New_u2 = (int)floor ((u1 + u2)/2.0);
New_v2 = v2;
break;
case 3:
New_u1 = (int)ceil ((u1 + u2)/2.0);
New_v1 = (int)ceil ((v1 + v2)/2.0);
New_u2 = u2;
New_v2 = v2;
break;
}
/* Recalculate the light source ray but not the colour */
do_light (Light_Source, &Light_Source_Depth, &Light_Source_Ray,
IPoint, &Dummy_Colour);
Sample_Colour[i]=*Light_Colour;
Block_Area_Light (Light_Source, Light_Source_Depth,
&Light_Source_Ray, IPoint,
&Sample_Colour[i],
New_u1, New_v1, New_u2, New_v2, Level+1);
}
}
/* Add up the light contributions */
Make_Colour (Light_Colour, 0.0, 0.0, 0.0);
for (i = 0; i < 4; i++)
{
Scale_Colour (&Sample_Colour[i], &Sample_Colour[i], 0.25);
Add_Colour (Light_Colour, Light_Colour, &Sample_Colour[i]);
}
}
static void do_light(Light_Source, Light_Source_Depth, Light_Source_Ray, IPoint, Light_Colour)
LIGHT_SOURCE *Light_Source;
DBL *Light_Source_Depth;
RAY *Light_Source_Ray;
VECTOR *IPoint;
COLOUR *Light_Colour;
{
DBL Attenuation = 1.0;
/* Get the light source colour. */
*Light_Colour = Light_Source->Colour;
Light_Source_Ray->Initial = *IPoint;
Light_Source_Ray->Quadric_Constants_Cached = FALSE;
VSub (Light_Source_Ray->Direction,
Light_Source->Center,
*IPoint);
VLength (*Light_Source_Depth, Light_Source_Ray->Direction);
VScale (Light_Source_Ray->Direction, Light_Source_Ray->Direction,
1.0/(*Light_Source_Depth));
Attenuation = Attenuate_Light(Light_Source, Light_Source_Ray);
/* Now scale the color by the attenuation */
Light_Colour->Red *= Attenuation;
Light_Colour->Green *= Attenuation;
Light_Colour->Blue *= Attenuation;
return;
}
static int do_blocking(Local_Intersection, Light_Colour, Local_Stack)
INTERSECTION *Local_Intersection;
COLOUR *Light_Colour;
ISTACK *Local_Stack;
{
Shadow_Rays_Succeeded++;
Filter_Shadow_Ray (Local_Intersection, Light_Colour);
if ((fabs(Light_Colour->Red) < BLACK_LEVEL) &&
(fabs(Light_Colour->Green) < BLACK_LEVEL) &&
(fabs(Light_Colour->Blue) < BLACK_LEVEL))
{
while ((Local_Intersection = pop_entry(Local_Stack)) != NULL)
{
}
return(TRUE);
}
return(FALSE);
}
static void do_phong(Finish, Light_Source_Ray, Eye, Layer_Normal, Colour, Light_Colour, Layer_Pigment_Colour)
FINISH *Finish;
RAY *Light_Source_Ray;
VECTOR *Layer_Normal, *Eye;
COLOUR *Colour, *Light_Colour, *Layer_Pigment_Colour;
{
DBL Cos_Angle_Of_Incidence, Normal_Length, Intensity;
VECTOR Local_Normal, Normal_Projection, Reflect_Direction;
VDot(Cos_Angle_Of_Incidence, *Eye, *Layer_Normal);
if (Cos_Angle_Of_Incidence < 0.0)
{
Local_Normal = *Layer_Normal;
Cos_Angle_Of_Incidence = -Cos_Angle_Of_Incidence;
}
else
{
VScale (Local_Normal, *Layer_Normal, -1.0);
}
VScale (Normal_Projection, Local_Normal, Cos_Angle_Of_Incidence);
VScale (Normal_Projection, Normal_Projection, 2.0);
VAdd (Reflect_Direction, *Eye, Normal_Projection);
VDot (Cos_Angle_Of_Incidence, Reflect_Direction, Light_Source_Ray->Direction);
VLength (Normal_Length, Light_Source_Ray->Direction);
if (Normal_Length == 0.0)
Cos_Angle_Of_Incidence = 0.0;
else
Cos_Angle_Of_Incidence /= Normal_Length;
if (Cos_Angle_Of_Incidence < 0.0)
Cos_Angle_Of_Incidence = 0;
if (Finish->Phong_Size != 1.0)
Intensity = pow(Cos_Angle_Of_Incidence, Finish->Phong_Size);
else
Intensity = Cos_Angle_Of_Incidence;
Intensity *= Finish->Phong;
if (Finish->Metallic_Flag)
{
Colour->Red+=Intensity*(Layer_Pigment_Colour->Red)*(Light_Colour->Red);
Colour->Green+=Intensity*(Layer_Pigment_Colour->Green)*(Light_Colour->Green);
Colour->Blue+=Intensity*(Layer_Pigment_Colour->Blue)*(Light_Colour->Blue);
}
else
{
Colour->Red+=Intensity*(Light_Colour->Red);
Colour->Green+=Intensity*(Light_Colour->Green);
Colour->Blue+=Intensity*(Light_Colour->Blue);
}
}
static void do_specular(Finish, Light_Source_Ray, REye, Layer_Normal, Colour, Light_Colour, Layer_Pigment_Colour)
FINISH *Finish;
RAY *Light_Source_Ray;
VECTOR *Layer_Normal, *REye;
COLOUR *Colour, *Light_Colour, *Layer_Pigment_Colour;
{
DBL Cos_Angle_Of_Incidence, Normal_Length, Intensity, Halfway_Length;
VECTOR Halfway;
VHalf (Halfway, *REye, Light_Source_Ray->Direction);
VLength (Normal_Length, *Layer_Normal);
VLength (Halfway_Length, Halfway);
VDot (Cos_Angle_Of_Incidence, Halfway, *Layer_Normal);
if (Normal_Length == 0.0 || Halfway_Length == 0.0)
Cos_Angle_Of_Incidence = 0.0;
else
Cos_Angle_Of_Incidence /= (Normal_Length * Halfway_Length);
if (Cos_Angle_Of_Incidence < 0.0)
Cos_Angle_Of_Incidence = 0.0;
if (Finish->Roughness != 1.0)
Intensity = pow(Cos_Angle_Of_Incidence, Finish->Roughness);
else
Intensity = Cos_Angle_Of_Incidence;
Intensity *= Finish->Specular;
if (Finish->Metallic_Flag)
{
Colour->Red+=Intensity*(Layer_Pigment_Colour->Red)*(Light_Colour->Red);
Colour->Green+=Intensity*(Layer_Pigment_Colour->Green)*(Light_Colour->Green);
Colour->Blue+=Intensity*(Layer_Pigment_Colour->Blue)*(Light_Colour->Blue);
}
else
{
Colour->Red+=Intensity*(Light_Colour->Red);
Colour->Green+=Intensity*(Light_Colour->Green);
Colour->Blue+=Intensity*(Light_Colour->Blue);
}
}
static void do_diffuse(Finish, Light_Source_Ray, Layer_Normal, Colour, Light_Colour, Layer_Pigment_Colour, Attenuation)
FINISH *Finish;
RAY *Light_Source_Ray;
VECTOR *Layer_Normal;
COLOUR *Colour, *Light_Colour, *Layer_Pigment_Colour;
DBL Attenuation;
{
DBL Cos_Angle_Of_Incidence, Intensity;
VDot (Cos_Angle_Of_Incidence, *Layer_Normal, Light_Source_Ray->Direction);
if (Cos_Angle_Of_Incidence < 0.0)
Cos_Angle_Of_Incidence = -Cos_Angle_Of_Incidence;
if (Finish->Brilliance != 1.0)
Intensity = pow(Cos_Angle_Of_Incidence, Finish->Brilliance);
else
Intensity = Cos_Angle_Of_Incidence;
Intensity *= Finish->Diffuse * Attenuation;
if (Finish->Crand > 0.0)
Intensity -= ((rand()&0x7FFF)/(DBL) 0x7FFF) * Finish->Crand;
Colour->Red += Intensity * (Layer_Pigment_Colour->Red) * (Light_Colour->Red);
Colour->Green += Intensity * (Layer_Pigment_Colour->Green) * (Light_Colour->Green);
Colour->Blue += Intensity * (Layer_Pigment_Colour->Blue) * (Light_Colour->Blue);
return;
}
/* Given a 3d point and a pigment, accumulate colour from that layer */
/* Formerly called "Colour_At" */
void Add_Pigment (Colour, Pigment, IPoint)
COLOUR *Colour;
PIGMENT *Pigment;
VECTOR *IPoint;
{
register DBL x, y, z;
VECTOR TPoint,PTurbulence;
if (Pigment->Trans != NULL)
MInvTransPoint (&TPoint, IPoint, Pigment->Trans);
else
TPoint = *IPoint;
x = TPoint.x;
y = TPoint.y;
z = TPoint.z;
if(Pigment->Type != WOOD_PIGMENT &&
Pigment->Type != MARBLE_PIGMENT &&
Pigment->Type != NO_PIGMENT &&
Pigment->Type != COLOUR_PIGMENT &&
/* Pigment->Type != SPOTTED_PIGMENT && */ /*maybe?*/
Pigment->Flags & HAS_TURB)
{
DTurbulence (&PTurbulence, x, y, z,
Pigment->omega,Pigment->lambda,Pigment->Octaves);
x += PTurbulence.x * Pigment->Turbulence.x;
y += PTurbulence.y * Pigment->Turbulence.y;
z += PTurbulence.z * Pigment->Turbulence.z;
}
if (x > COORDINATE_LIMIT)
x = COORDINATE_LIMIT;
else
if (x < -COORDINATE_LIMIT)
x = -COORDINATE_LIMIT;
if (y > COORDINATE_LIMIT)
y = COORDINATE_LIMIT;
else
if (y < -COORDINATE_LIMIT)
y = -COORDINATE_LIMIT;
if (z > COORDINATE_LIMIT)
z = COORDINATE_LIMIT;
else
if (z < -COORDINATE_LIMIT)
z = -COORDINATE_LIMIT;
switch (Pigment->Type)
{
case NO_PIGMENT:
/* No colouring pigment has been specified - make it black. */
Make_Colour (Colour, 0.0, 0.0, 0.0);
Colour -> Filter = 0.0;
break;
case COLOUR_PIGMENT:
Colour -> Red += Pigment->Colour1->Red;
Colour -> Green += Pigment->Colour1->Green;
Colour -> Blue += Pigment->Colour1->Blue;
Colour -> Filter += Pigment->Colour1->Filter;
break;
case BOZO_PIGMENT:
bozo (x, y, z, Pigment, Colour);
break;
case MARBLE_PIGMENT:
marble (x, y, z, Pigment, Colour);
break;
case WOOD_PIGMENT:
wood (x, y, z, Pigment, Colour);
break;
case CHECKER_PIGMENT:
checker (x, y, z, Pigment, Colour);
break;
case SPOTTED_PIGMENT:
spotted (x, y, z, Pigment, Colour);
break;
case AGATE_PIGMENT:
agate (x, y, z, Pigment, Colour);
break;
case GRANITE_PIGMENT:
granite (x, y, z, Pigment, Colour);
break;
case GRADIENT_PIGMENT:
gradient (x, y, z, Pigment, Colour);
break;
case HEXAGON_PIGMENT:
hexagon (x, y, z, Pigment, Colour);
break;
case RADIAL_PIGMENT:
radial (x, y, z, Pigment, Colour);
break;
case MANDEL_PIGMENT:
mandel (x, y, z, Pigment, Colour);
break;
case IMAGE_MAP_PIGMENT:
image_map (x, y, z, Pigment, Colour);
break;
case ONION_PIGMENT:
onion (x, y, z, Pigment, Colour);
break;
case LEOPARD_PIGMENT:
leopard (x, y, z, Pigment, Colour);
break;
case PAINTED1_PIGMENT:
painted1 (x, y, z, Pigment, Colour);
break;
case PAINTED2_PIGMENT:
painted2 (x, y, z, Pigment, Colour);
break;
case PAINTED3_PIGMENT:
painted3 (x, y, z, Pigment, Colour);
break;
}
}
void Perturb_Normal(Layer_Normal, Tnormal, IPoint)
VECTOR *Layer_Normal, *IPoint;
TNORMAL *Tnormal;
{
register DBL x, y, z;
VECTOR TPoint,NTurbulence;
if (Tnormal->Trans != NULL)
MInvTransPoint (&TPoint, IPoint, Tnormal->Trans);
else
TPoint = *IPoint;
x = TPoint.x;
y = TPoint.y;
z = TPoint.z;
if(Tnormal->Flags && HAS_TURB)
{
DTurbulence (&NTurbulence, x, y, z,
Tnormal->omega,Tnormal->lambda,Tnormal->Octaves);
x += NTurbulence.x * Tnormal->Turbulence.x;
y += NTurbulence.y * Tnormal->Turbulence.y;
z += NTurbulence.z * Tnormal->Turbulence.z;
}
switch (Tnormal->Type)
{
case WAVES:
waves (x, y, z, Tnormal, Layer_Normal);
break;
case RIPPLES:
ripples (x, y, z, Tnormal, Layer_Normal);
break;
case WRINKLES:
wrinkles (x, y, z, Tnormal, Layer_Normal);
break;
case BUMPS:
bumps (x, y, z, Tnormal, Layer_Normal);
break;
case DENTS:
dents (x, y, z, Tnormal, Layer_Normal);
break;
case BUMPY1:
bumpy1 (x, y, z, Tnormal, Layer_Normal);
break;
case BUMPY2:
bumpy2 (x, y, z, Tnormal, Layer_Normal);
break;
case BUMPY3:
bumpy3 (x, y, z, Tnormal, Layer_Normal);
break;
case BUMP_MAP:
bump_map (x, y, z, Tnormal, Layer_Normal);
break;
}
return;
}
void Diffuse (Finish, IPoint, Eye, Layer_Normal, Layer_Pigment_Colour, Colour, Attenuation)
FINISH *Finish;
VECTOR *IPoint, *Layer_Normal;
COLOUR *Layer_Pigment_Colour;
COLOUR *Colour;
RAY *Eye;
DBL Attenuation;
{
DBL Light_Source_Depth, Cos_Shadow_Angle;
RAY Light_Source_Ray;
LIGHT_SOURCE *Light_Source;
VECTOR REye;
COLOUR Light_Colour;
if ((Finish->Diffuse == 0.0) && (Finish->Specular == 0.0) && (Finish->Phong == 0.0))
return;
if (Finish->Specular != 0.0)
{
REye.x = -Eye->Direction.x;
REye.y = -Eye->Direction.y;
REye.z = -Eye->Direction.z;
}
for (Light_Source = Frame.Light_Sources ;
Light_Source != NULL;
Light_Source = Light_Source->Next_Light_Source)
{
/* Get a colour and a ray */
do_light(Light_Source, &Light_Source_Depth,
&Light_Source_Ray, IPoint,
&Light_Colour);
/* Don't calculate spotlights when outside of the light's cone */
if (fabs(Light_Colour.Red) < BLACK_LEVEL &&
fabs(Light_Colour.Green) < BLACK_LEVEL &&
fabs(Light_Colour.Blue) < BLACK_LEVEL)
continue;
/* See if light on far side of surface from camera. */
VDot(Cos_Shadow_Angle,*Layer_Normal,Light_Source_Ray.Direction);
if (Cos_Shadow_Angle < 0.0)
continue;
/* If light source was not blocked by any intervening object, then
calculate it's contribution to the object's overall illumination */
Shadow_Test_Flag = TRUE;
if (Quality_Flags & Q_SHADOW)
{
if ((Light_Source->Area_Light) && (Quality_Flags & Q_AREA_LIGHT))
Block_Area_Light (Light_Source, Light_Source_Depth,
&Light_Source_Ray, IPoint,
&Light_Colour, 0, 0, 0, 0, 0);
else
Block_Point_Light (Light_Source, Light_Source_Depth,
&Light_Source_Ray, &Light_Colour);
}
Shadow_Test_Flag = FALSE;
if (fabs(Light_Colour.Red) > BLACK_LEVEL ||
fabs(Light_Colour.Green) > BLACK_LEVEL ||
fabs(Light_Colour.Blue) > BLACK_LEVEL)
{
if (Finish->Phong > 0.0)
do_phong(Finish,&Light_Source_Ray,&Eye->Direction,Layer_Normal,Colour,&Light_Colour, Layer_Pigment_Colour);
if (Finish->Specular > 0.0)
do_specular(Finish,&Light_Source_Ray,&REye,Layer_Normal,Colour,&Light_Colour, Layer_Pigment_Colour);
if (Finish->Diffuse > 0.0)
do_diffuse(Finish,&Light_Source_Ray,Layer_Normal,Colour,&Light_Colour,Layer_Pigment_Colour, Attenuation);
}
}
return;
}
void Reflect (Reflection, IPoint, Ray, Layer_Normal, Colour)
DBL Reflection;
VECTOR *IPoint;
RAY *Ray;
VECTOR *Layer_Normal;
COLOUR *Colour;
{
RAY New_Ray;
COLOUR Temp_Colour;
VECTOR Local_Normal;
VECTOR Normal_Projection;
VECTOR Surface_Offset;
register DBL Normal_Component;
if (Reflection != 0.0)
{
Reflected_Rays_Traced++;
VDot (Normal_Component, Ray -> Direction, *Layer_Normal);
if (Normal_Component < 0.0)
{
Local_Normal = *Layer_Normal;
Normal_Component *= -1.0;
}
else
VScale (Local_Normal, *Layer_Normal, -1.0);
VScale (Normal_Projection, Local_Normal, Normal_Component);
VScale (Normal_Projection, Normal_Projection, 2.0);
VAdd (New_Ray.Direction, Ray -> Direction, Normal_Projection);
New_Ray.Initial = *IPoint;
/* ARE 08/25/91 */
VScale(Surface_Offset, New_Ray.Direction, 2.0 * Small_Tolerance);
VAdd(New_Ray.Initial, New_Ray.Initial, Surface_Offset);
Copy_Ray_Containers (&New_Ray, Ray);
Trace_Level++;
Make_Colour (&Temp_Colour, 0.0, 0.0, 0.0);
New_Ray.Quadric_Constants_Cached = FALSE;
Trace (&New_Ray, &Temp_Colour);
Trace_Level--;
Colour -> Red += Temp_Colour.Red * Reflection;
Colour -> Green += Temp_Colour.Green * Reflection;
Colour -> Blue += Temp_Colour.Blue * Reflection;
}
}
void Refract (Texture, IPoint, Ray, Top_Normal, Colour)
TEXTURE *Texture;
VECTOR *IPoint;
RAY *Ray;
VECTOR *Top_Normal;
COLOUR *Colour;
{
RAY New_Ray;
COLOUR Temp_Colour;
VECTOR Local_Normal;
VECTOR Ray_Direction;
register DBL Normal_Component, Temp_IOR;
DBL temp, ior;
/* int inside; */
if (Top_Normal == NULL)
{
New_Ray.Initial = *IPoint;
New_Ray.Direction = Ray->Direction;
Copy_Ray_Containers (&New_Ray, Ray);
Trace_Level++;
Transmitted_Rays_Traced++;
Make_Colour (&Temp_Colour, 0.0, 0.0, 0.0);
New_Ray.Quadric_Constants_Cached = FALSE;
Trace (&New_Ray, &Temp_Colour);
Trace_Level--;
(Colour -> Red) += Temp_Colour.Red;
(Colour -> Green) += Temp_Colour.Green;
(Colour -> Blue) += Temp_Colour.Blue;
}
else
{
Refracted_Rays_Traced++;
VDot (Normal_Component, Ray -> Direction, *Top_Normal);
if (Normal_Component <= 0.0)
{
Local_Normal.x = Top_Normal -> x;
Local_Normal.y = Top_Normal -> y;
Local_Normal.z = Top_Normal -> z;
Normal_Component *= -1.0;
/* inside = FALSE;*/
}
else
{
VScale (Local_Normal, *Top_Normal, -1.0);
/* inside = TRUE;*/
}
Copy_Ray_Containers (&New_Ray, Ray);
if (Ray -> Containing_Index == -1)
{
/* The ray is entering from the atmosphere */
Ray_Enter (&New_Ray, Texture);
ior = (Frame.Atmosphere_IOR)/(Texture->Finish->Index_Of_Refraction);
}
else
{
/* The ray is currently inside an object */
if (New_Ray.Containing_Textures [New_Ray.Containing_Index] == Texture)
/* if (inside) */
{
/* The ray is leaving the current object */
Ray_Exit (&New_Ray);
if (New_Ray.Containing_Index == -1)
/* The ray is leaving into the atmosphere */
Temp_IOR = Frame.Atmosphere_IOR;
else
/* The ray is leaving into another object */
Temp_IOR = New_Ray.Containing_IORs [New_Ray.Containing_Index];
ior = (Texture->Finish->Index_Of_Refraction)/Temp_IOR;
}
else
{
/* The ray is entering a new object */
Temp_IOR = New_Ray.Containing_IORs [New_Ray.Containing_Index];
Ray_Enter (&New_Ray, Texture);
ior = Temp_IOR / (Texture->Finish->Index_Of_Refraction);
}
}
temp = 1.0 + ior * ior * (Normal_Component * Normal_Component - 1.0);
if (temp < 0.0)
{
Reflect ((1.0 - Texture->Finish->Reflection), IPoint,
Ray, Top_Normal, Colour);
return;
}
temp = ior*Normal_Component - sqrt(temp);
VScale (Local_Normal, Local_Normal, temp);
VScale (Ray_Direction, Ray->Direction, ior);
VAdd (New_Ray.Direction, Local_Normal, Ray_Direction);
VNormalize (New_Ray.Direction, New_Ray.Direction);
New_Ray.Initial = *IPoint;
Trace_Level++;
Make_Colour (&Temp_Colour, 0.0, 0.0, 0.0);
New_Ray.Quadric_Constants_Cached = FALSE;
Trace (&New_Ray, &Temp_Colour);
Trace_Level--;
(Colour -> Red) += (Temp_Colour.Red)
* (Texture -> Finish->Refraction);
(Colour -> Green) += (Temp_Colour.Green)
* (Texture -> Finish->Refraction);
(Colour -> Blue) += (Temp_Colour.Blue)
* (Texture -> Finish->Refraction);
}
}
void Fog (Distance, Fog_Colour, Fog_Distance, Colour)
DBL Distance, Fog_Distance;
COLOUR *Fog_Colour, *Colour;
{
DBL Fog_Factor, Fog_Factor_Inverse;
Fog_Factor = exp(-1.0 * Distance/Fog_Distance);
Fog_Factor_Inverse = 1.0 - Fog_Factor;
Colour->Red = Colour->Red*Fog_Factor + Fog_Colour->Red*Fog_Factor_Inverse;
Colour->Green = Colour->Green*Fog_Factor + Fog_Colour->Green*Fog_Factor_Inverse;
Colour->Blue = Colour->Blue*Fog_Factor + Fog_Colour->Blue*Fog_Factor_Inverse;
}
void Compute_Reflected_Colour (Ray, Finish, Ray_Intersection, Layer_Pigment_Colour, Filter_Colour, Colour, Layer_Normal)
RAY *Ray;
FINISH *Finish;
INTERSECTION *Ray_Intersection;
COLOUR *Layer_Pigment_Colour;
COLOUR *Filter_Colour;
COLOUR *Colour;
VECTOR *Layer_Normal;
{
DBL Attenuation, Ambient;
COLOUR Emitted_Colour;
/* This variable keeps track of how much colour comes from the surface
of the object and how much is transmited through. */
Make_Colour (&Emitted_Colour, 0.0, 0.0, 0.0);
if (Quality_Flags & Q_FULL_AMBIENT)
{
Layer_Pigment_Colour->Filter = 0.0;
Colour->Red += Layer_Pigment_Colour->Red * Filter_Colour->Filter;
Colour->Green += Layer_Pigment_Colour->Green * Filter_Colour->Filter;
Colour->Blue += Layer_Pigment_Colour->Blue * Filter_Colour->Filter;
return;
}
Attenuation = Filter_Colour->Filter * (1.0 - Layer_Pigment_Colour->Filter);
if ((Ambient = Finish->Ambient*Attenuation) != 0.0)
{
Emitted_Colour.Red += Layer_Pigment_Colour->Red * Ambient;
Emitted_Colour.Green += Layer_Pigment_Colour->Green * Ambient;
Emitted_Colour.Blue += Layer_Pigment_Colour->Blue * Ambient;
}
Diffuse (Finish, &Ray_Intersection ->IPoint, Ray,
Layer_Normal, Layer_Pigment_Colour, &Emitted_Colour, Attenuation);
Colour->Red += Emitted_Colour.Red;
Colour->Green += Emitted_Colour.Green;
Colour->Blue += Emitted_Colour.Blue;
if (Quality_Flags & Q_REFLECT)
Reflect (Finish->Reflection, &Ray_Intersection -> IPoint, Ray,
Layer_Normal, Colour);
}
/* Given an intersection point, a ray, & a shadow flag, add that point's
color to the given colour and return it. */
void Determine_Apparent_Colour (Ray_Intersection, Colour, Ray)
INTERSECTION *Ray_Intersection;
COLOUR *Colour;
RAY *Ray;
{
COLOUR Layer_Pigment_Colour, Refracted_Colour, Filter_Colour;
TEXTURE *Layer, *Texture;
FINISH *Finish;
VECTOR Layer_Normal, Raw_Normal, Top_Normal;
DBL Normal_Direction;
int layer_number;
#define QColour Texture->Pigment->Quick_Colour
Normal (&Raw_Normal, Ray_Intersection->Object, &Ray_Intersection->IPoint);
/* Now, we perform the lighting calculations. */
/* We assume here that Post_Process has propagated all parent
textures to the object itself and that everything has some texture.
Redirrect to the proper texture if its a material or checker texture */
for (Texture = Ray_Intersection->Object->Texture;
Texture->Type != PNF_TEXTURE;)
switch (Texture->Type)
{
case TILE_TEXTURE:
Texture = tiles_texture(&Ray_Intersection->IPoint,((TILES *)Texture));
break;
case MAT_TEXTURE:
Texture = material_map(&Ray_Intersection->IPoint,((MATERIAL *)Texture));
break;
default:
fprintf(stderr, "Bad texture type: %d\n", Texture->Type);
close_all();
exit(1);
};
Make_ColourA (&Filter_Colour, 1.0, 1.0, 1.0, 1.0);
for (layer_number=1 , Layer = Texture;
(Layer != NULL) && (fabs(Filter_Colour.Filter) > BLACK_LEVEL);
layer_number++, Layer = Layer->Next_Layer)
{
Make_Colour (&Layer_Pigment_Colour, 0.0, 0.0, 0.0);
if (Quality_Flags & Q_QUICKC)
Layer_Pigment_Colour = QColour;
else
Add_Pigment (&Layer_Pigment_Colour, Layer->Pigment, &Ray_Intersection->IPoint);
Layer_Normal = Raw_Normal;
if ((Quality_Flags & Q_NORMAL) && (Texture->Tnormal != NULL))
Perturb_Normal (&Layer_Normal, Texture->Tnormal,
&Ray_Intersection->IPoint);
/* If the surface normal points away, flip its direction. */
VDot (Normal_Direction, Layer_Normal, Ray->Direction);
if (Normal_Direction > 0.0)
{
VScaleEq (Layer_Normal, -1.0);
}
if (layer_number == 1)
Top_Normal = Layer_Normal;
Compute_Reflected_Colour (Ray,
Layer->Finish,
Ray_Intersection,
&Layer_Pigment_Colour,
&Filter_Colour,
Colour, &Layer_Normal);
Filter_Colour.Red *= Layer_Pigment_Colour.Red;
Filter_Colour.Green *= Layer_Pigment_Colour.Green;
Filter_Colour.Blue *= Layer_Pigment_Colour.Blue;
Filter_Colour.Filter *= Layer_Pigment_Colour.Filter;
}
Finish = Texture->Finish;
if ((fabs(Filter_Colour.Filter) > BLACK_LEVEL) && (Quality_Flags & Q_REFRACT))
{
Make_Colour (&Refracted_Colour, 0.0, 0.0, 0.0);
if (Finish->Refraction > 0.0)
Refract (Texture, &Ray_Intersection -> IPoint, Ray,
&Top_Normal, &Refracted_Colour);
else
Refract (Texture, &Ray_Intersection->IPoint, Ray,
NULL, &Refracted_Colour);
Colour->Red += Filter_Colour.Red * Refracted_Colour.Red * Filter_Colour.Filter;
Colour->Green += Filter_Colour.Green * Refracted_Colour.Green * Filter_Colour.Filter;
Colour->Blue += Filter_Colour.Blue * Refracted_Colour.Blue * Filter_Colour.Filter;
}
if (Frame.Fog_Distance != 0.0)
Fog (Ray_Intersection->Depth, &Frame.Fog_Colour, Frame.Fog_Distance,
Colour);
}
void Filter_Shadow_Ray (Ray_Intersection, Colour)
INTERSECTION *Ray_Intersection;
COLOUR *Colour;
{
COLOUR Layer_Pigment_Colour, Filter_Colour;
TEXTURE *Layer, *Texture;
FINISH *Finish;
int layer_number;
#define QColour Texture->Pigment->Quick_Colour
if (!(Quality_Flags & Q_SHADOW))
return;
/* Now, we perform the lighting calculations. */
/* We assume here that Post_Process has propagated all parent
textures to the object itself and that everything has some texture.
Redirrect to the proper texture if its a material or checker texture */
for (Texture = Ray_Intersection->Object->Texture;
Texture->Type != PNF_TEXTURE;)
switch (Texture->Type)
{
case TILE_TEXTURE:
Texture = tiles_texture(&Ray_Intersection->IPoint,((TILES *)Texture));
break;
case MAT_TEXTURE:
Texture = material_map(&Ray_Intersection->IPoint,((MATERIAL *)Texture));
break;
default:
fprintf(stderr, "Bad texture type: %d\n", Texture->Type);
close_all();
exit(1);
};
Make_ColourA (&Filter_Colour, 1.0, 1.0, 1.0, 1.0);
for (layer_number=1 , Layer = Texture;
(Layer != NULL) && (fabs(Filter_Colour.Filter) > BLACK_LEVEL);
layer_number++, Layer = Layer->Next_Layer)
{
if (Quality_Flags & Q_QUICKC)
Layer_Pigment_Colour = QColour;
else
{
Make_Colour (&Layer_Pigment_Colour, 0.0, 0.0, 0.0);
Add_Pigment (&Layer_Pigment_Colour, Layer->Pigment, &Ray_Intersection->IPoint);
}
Filter_Colour.Red *= Layer_Pigment_Colour.Red;
Filter_Colour.Green *= Layer_Pigment_Colour.Green;
Filter_Colour.Blue *= Layer_Pigment_Colour.Blue;
Filter_Colour.Filter *= Layer_Pigment_Colour.Filter;
}
Finish = Texture->Finish;
/* For shadow rays, we have the filter colour now - time to return */
if (fabs(Filter_Colour.Filter) < BLACK_LEVEL)
{
Make_Colour (Colour, 0.0, 0.0, 0.0);
return;
}
if (Finish->Refraction > 0.0)
{
Colour->Red *= Filter_Colour.Red * Finish->Refraction * Filter_Colour.Filter;
Colour->Green *= Filter_Colour.Green * Finish->Refraction * Filter_Colour.Filter;
Colour->Blue *= Filter_Colour.Blue * Finish->Refraction * Filter_Colour.Filter;
}
else
{
Colour->Red *= Filter_Colour.Red * Filter_Colour.Filter;
Colour->Green *= Filter_Colour.Green * Filter_Colour.Filter;
Colour->Blue *= Filter_Colour.Blue * Filter_Colour.Filter;
}
return;
}