| /*************************************************************************/ |
| /* */ |
| /* Copyright (c) 1994 Stanford University */ |
| /* */ |
| /* All rights reserved. */ |
| /* */ |
| /* Permission is given to use, copy, and modify this software for any */ |
| /* non-commercial purpose as long as this copyright notice is not */ |
| /* removed. All other uses, including redistribution in whole or in */ |
| /* part, are forbidden without prior written permission. */ |
| /* */ |
| /* This software is provided with absolutely no warranty and no */ |
| /* support. */ |
| /* */ |
| /*************************************************************************/ |
| |
| |
| /* |
| * NAME |
| * shade.c |
| * |
| * DESCRIPTION |
| * This file contains routines that shade a ray, both nonshadowed and |
| * shadowed. |
| * |
| * Generated secondary reflection and refractions rays are pushed onto |
| * the raytree stack. |
| */ |
| |
| |
| #include <stdio.h> |
| #include <math.h> |
| #include "rt.h" |
| |
| |
| |
| /* |
| * NAME |
| * SpecularDirection - compute reflected ray |
| * |
| * SYNOPSIS |
| * VOID SpecularDirection(R, N, I) |
| * POINT R; // Reflected ray. |
| * POINT N; // Normal. |
| * POINT I; // Incident ray. |
| * |
| * RETURNS |
| * Nothing. |
| */ |
| |
| VOID SpecularDirection(R, N, I) |
| POINT R; |
| POINT N; |
| POINT I; |
| { |
| REAL I_dot_N; /* I*N */ |
| POINT N2; /* 2N */ |
| POINT vprime; /* Scale of I */ |
| |
| /* Turner's calculation from first paper. */ |
| |
| I_dot_N = VecDot(I,N); |
| I_dot_N = ABS(I_dot_N); |
| I_dot_N = 1.0/I_dot_N; |
| |
| VecScale(vprime, I_dot_N, I); |
| VecScale(N2, 2.0, N); |
| |
| VecAdd(R, vprime, N2); |
| VecNorm(R); |
| } |
| |
| |
| |
| /* |
| * NAME |
| * TransmissionDirection - calculate refracted ray |
| * |
| * SYNOPSIS |
| * BOOL TransmissionDirection(T, N, I, kn) |
| * POINT T; // Transmitted ray. |
| * POINT N; // Normal. |
| * POINT I; // Incident ray. |
| * REAL kn; // Index of refraction. |
| * |
| * RETURNS |
| * TRUE if the ray was transmitted, FALSE if the ray was blocked. |
| */ |
| |
| BOOL TransmissionDirection(T, N, I, kn) |
| POINT T; |
| POINT N; |
| POINT I; |
| REAL kn; |
| { |
| POINT vprime; /* Parameters in calculation. */ |
| POINT vplusn; |
| REAL I_dot_N; |
| REAL kf; |
| REAL vprime_sq; |
| REAL vplusn_sq; |
| |
| /* Turner's calculation from first paper. */ |
| |
| I_dot_N = VecDot(I,N); |
| I_dot_N = ABS(I_dot_N); |
| I_dot_N = 1.0/I_dot_N; |
| |
| VecScale(vprime, I_dot_N, I); |
| VecAdd(vplusn, vprime, N); |
| |
| vprime_sq = VecDot(vprime, vprime); |
| vplusn_sq = VecDot(vplusn, vplusn); |
| |
| kf = kn*kn*vprime_sq - vplusn_sq; |
| |
| if (kf > RAYEPS) |
| { |
| kf = 1.0/sqrt(kf); |
| |
| VecScale(vplusn, kf, vplusn); |
| VecSub(T, vplusn, N); |
| VecNorm(T); |
| } |
| else |
| return (FALSE); |
| |
| return (TRUE); |
| } |
| |
| |
| |
| /* |
| * NAME |
| * Shade - shade a ray |
| * |
| * SYNOPSIS |
| * VOID Shade(iP, N, ray, hit, pid) |
| * VEC3 iP; // Intersection point. |
| * VEC3 N; // Normal at intersection. |
| * RAY *ray; // Incident ray. |
| * IRECORD *hit; // Intersect info. |
| * INT pid; // Process id number. |
| * |
| * RETURNS |
| * Nothing. |
| */ |
| |
| VOID Shade(iP, N, ray, hit, pid) |
| VEC3 iP; |
| VEC3 N; |
| RAY *ray; |
| IRECORD *hit; |
| INT pid; |
| { |
| VEC3 Lvec; /* Light vector. */ |
| VEC3 Hvec; /* Highlight vector. */ |
| VEC3 Evec; /* Eye vector. */ |
| RAY shad_ray; /* Shadow ray. */ |
| RAY secondary_ray; /* Secondary ray. */ |
| COLOR surfcol; /* Primitive surface color. */ |
| COLOR col; /* Ray color contribution. */ |
| REAL NdotL; /* Diffuse conritbution. */ |
| REAL Diff; /* Diffuse variable. */ |
| REAL NdotH; /* Highlight contribution. */ |
| REAL spec; /* Highlight variable. */ |
| OBJECT *po; /* Ptr to object. */ |
| SURF *s; /* Surface pointer. */ |
| INT i, j; /* Index variables. */ |
| REAL lightlen; /* Length of light vector. */ |
| REAL shadtrans; /* Shadow transmission. */ |
| LIGHT *lptr; /* Light pointer. */ |
| |
| /* Initialize primitive info and ray color. */ |
| |
| po = hit->pelem->parent; |
| s = po->surf; |
| VecCopy(surfcol, s->fcolor); |
| |
| /* Initialize color to ambient. */ |
| |
| col[0] = View.ambient[0] * surfcol[0]; |
| col[1] = View.ambient[1] * surfcol[1]; |
| col[2] = View.ambient[2] * surfcol[2]; |
| |
| /* Set shadow ray origin. */ |
| |
| VecCopy(shad_ray.P, iP); |
| VecNegate(Evec, ray->D); |
| |
| /* Account for all lights. */ |
| |
| lptr = lights; |
| for (i = 0; i < nlights; i++) |
| { |
| VecSub(Lvec, lptr->pos, iP); |
| lightlen = VecLen(Lvec); |
| VecNorm(Lvec); |
| VecCopy(shad_ray.D, Lvec); |
| |
| LOCK(gm->ridlock); |
| shad_ray.id = gm->rid++; |
| UNLOCK(gm->ridlock); |
| |
| NdotL = VecDot(N, Lvec); |
| |
| if (NdotL > 0.0) |
| { |
| /* Test to see if point shadowed. */ |
| |
| if (View.shad && !lptr->shadow) |
| { |
| switch (TraversalType) |
| { |
| case TT_LIST: |
| shadtrans = ShadowIntersect(&shad_ray, lightlen, hit->pelem); |
| break; |
| |
| case TT_HUG: |
| shadtrans = HuniformShadowIntersect(&shad_ray, lightlen, hit->pelem, pid); |
| break; |
| } |
| } |
| else |
| shadtrans = 1.0; |
| |
| /* Compute non-shadowed shades. */ |
| |
| if (shadtrans > 0.0) |
| { |
| Diff = po->surf->kdiff * NdotL * shadtrans; |
| |
| col[0] += surfcol[0] * lptr->col[0] * Diff; |
| col[1] += surfcol[1] * lptr->col[1] * Diff; |
| col[2] += surfcol[2] * lptr->col[2] * Diff; |
| |
| /* Add specular. */ |
| |
| if (s->kspec > 0.0) |
| { |
| VecAdd(Hvec,Lvec,Evec); |
| VecNorm(Hvec); |
| NdotH = VecDot(N,Hvec); |
| |
| if (NdotH > 0.0) |
| { |
| spec = pow(NdotH, s->kspecn); |
| spec *= s->kspec; |
| |
| col[0] += lptr->col[0]*spec; |
| col[1] += lptr->col[1]*spec; |
| col[2] += lptr->col[2]*spec; |
| } |
| } |
| } |
| } |
| |
| lptr = lptr->next; |
| } |
| |
| /* Add color to pixel frame buffer. */ |
| |
| VecScale(col, ray->weight, col); |
| AddPixelColor(col, ray->x, ray->y); |
| |
| /* Recurse if not at maximum level. */ |
| |
| if ((ray->level) + 1 < Display.maxlevel) |
| { |
| VecCopy(secondary_ray.P, iP); |
| |
| /* Specular. */ |
| secondary_ray.weight = po->surf->kspec * ray->weight; |
| |
| if (secondary_ray.weight > Display.minweight) |
| { |
| SpecularDirection(secondary_ray.D, N, ray->D); |
| secondary_ray.level = ray->level + 1; |
| |
| LOCK(gm->ridlock); |
| secondary_ray.id = gm->rid++; |
| UNLOCK(gm->ridlock); |
| |
| secondary_ray.x = ray->x; |
| secondary_ray.y = ray->y; |
| |
| PushRayTreeStack(&secondary_ray, pid); |
| |
| } |
| |
| /* Transmission. */ |
| secondary_ray.weight = po->surf->ktran * ray->weight; |
| |
| if (secondary_ray.weight > Display.minweight) |
| { |
| if (TransmissionDirection(secondary_ray.D, N, ray->D, po->surf->refrindex)) |
| { |
| secondary_ray.level = ray->level + 1; |
| |
| LOCK(gm->ridlock); |
| secondary_ray.id = gm->rid++; |
| UNLOCK(gm->ridlock); |
| |
| secondary_ray.x = ray->x; |
| secondary_ray.y = ray->y; |
| |
| PushRayTreeStack(&secondary_ray, pid); |
| |
| } |
| } |
| } |
| } |
| |
