Sanchayan Maity
0f4b39775c
During the last commit of splash2 benchmark it seems before committing when we ran "make clean", it effectively undid what the patch at below link did http://www.capsl.udel.edu/splash/Download.html Fix this since without this it is not possible to build the arcane splash2 benchmark.
301 lines
6.8 KiB
C
301 lines
6.8 KiB
C
/*************************************************************************/
|
|
/* */
|
|
/* 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(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(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(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; /* 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);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|