/*************************************************************************/
/*                                                                       */
/*  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
 *	trace.c
 *
 * DESCRIPTION
 *	This file contains the routines to process ray jobs from the work pool
 *	containing primary ray jobs.
 */


#include <stdio.h>
#include <math.h>
#include "rt.h"

/*
 * NAME
 *	frand - generate random floating point number
 *
 * SYNOPSIS
 *	REAL	frand()
 *  Used instead of standard srand for portability to other systems than Unix.
 *
 * RETURNS
 *	A random floating point number in the range 0 <= x < 1.
 */

REAL	frand()
	{
	REAL	r;
	static	LONG	lLastRand = 0;

	lLastRand = lLastRand*214013L + 2531011L;
	r  = (REAL)((lLastRand >> 16) & 0x7FFF)/32768.0;
	return (r);
	}


/*
 * NAME
 *	GetRayJobFromBundle -
 *
 * SYNOPSIS
 *	BOOL	GetRayJobFromBundle(job, x, y)
 *	RAYJOB	*job;			// Ray job from work pool.
 *	INT	*x, *y; 		// Pixel address.
 *
 * DESCRIPTION
 *	This routine determines if there are any more primary rays left to
 *	process in the ray bundle job.
 *
 *	The routine returns FALSE if the bundle processing is complete.  If
 *	there are more jobs, the current x and y pixel position are returned
 *	through procedure parameters.  Then, x and y are bundle is updated for
 *	the next inquiry and TRUE is returned.
 *
 * RETURNS
 *	See above.
 */

BOOL	GetRayJobFromBundle(job, x, y)
RAYJOB	*job;
INT	*x, *y;
	{
	*x = job->xcurr;			/* Set pixel address first.  */
	*y = job->ycurr;

	if ((job->y + job->ylen) == job->ycurr) /* All done?		     */
		return (FALSE);

	job->xcurr++;				/* Update to next pixel.     */
	if ((job->x +job->xlen) == job->xcurr )
		{
		job->xcurr = job->x;		/* Go to new scanline.	     */
		job->ycurr++;
		}

	return (TRUE);
	}


/*
 * NAME
 *	ConvertPrimRayJobToRayMsg - convert primary ray job to the ray message format
 *
 * SYNOPSIS
 *	VOID	ConvertPrimRayJobToRayMsg(ray, x, y)
 *	RAY	*ray;			// Ray message.
 *	REAL	x, y;			// Pixel.
 *
 * DESCRIPTION
 *	This routine converts the primary ray job to the ray message format.
 *	The ray origin and direction are computed and the other ray message
 *	variables are initialized.
 *
 *		Perspective Projection:
 *
 *		Calculate ray direction thru pixel and transform it back to
 *		the world coordinate system.  Origin of ray is eye position.
 *
 *		Orthographic Projection:
 *
 *		Calculate ray direction thru pixel and transform it back to
 *		the world coordinate system.  Origin of ray must also be
 *		calculated.
 * RETURNS
 *	Nothing.
 */

VOID	ConvertPrimRayJobToRayMsg(ray, x, y)
RAY	*ray;
REAL	x, y;
	{
	VEC4	dir;
	VEC4	origin;

	if (View.projection == PT_PERSP)
		{
		dir[0] = -Display.scrHalfWidth	+ (x*Display.vWscale);
		dir[1] =  Display.scrHalfHeight - (y*Display.vHscale);
		dir[2] =  Display.scrDist;
		dir[3] =  0.0;

		/* Transform ray back to world. */
		TransformViewRay(dir);

		VecNorm(dir);
		VecCopy(ray->D, dir);
		VecCopy(ray->P, View.eye);
		}
	else
		{
		/* Orthographic projection. */

		dir[0] = 0.0;
		dir[1] = 0.0;
		dir[2] = 1.0;
		dir[3] = 0.0;

		/* Transform ray back to world. */
		TransformViewRay(dir);
		VecNorm(dir);

		VecCopy(ray->D, dir);

		/* Calculate origin. */

		origin[0] = -Display.scrHalfWidth  + (x*Display.vWscale);
		origin[1] =  Display.scrHalfHeight - (y*Display.vHscale);
		origin[2] =  0.0;
		origin[3] =  1.0;

		/* Transform origin back to world. */

		TransformViewRay(origin);
		VecCopy(ray->P, origin);
		}


	/* Initialize other fields of ray message. */

	ray->level  = 0;
	ray->weight = 1.0/(REAL)NumSubRays;

	LOCK(gm->ridlock);
	ray->id = gm->rid++;
	UNLOCK(gm->ridlock);

	ray->x = (INT)x;
	ray->y = (INT)y;

	}


/*
 * NAME
 *	RayTrace - process primary ray bundle jobs from the workpool
 *
 * SYNOPSIS
 *	VOID	RayTrace(pid)
 *	INT	pid;			// Process id.
 *
 * DESCRIPTION
 *	Process primary ray bundle jobs from the workpool.  Each ray job from
 *	the ray bundle list performs the following tasks.
 *
 *		A ray bundle job is converted to a ray message and pushed
 *		on the raytree stack.  A ray job consists of a pixel address
 *		while the ray message also contains the ray origin, direction,
 *		level in tree, ray weight, ray id, and grid parameters.
 *		Processing begins with the primary ray and secondary rays being
 *		pushed onto the stack as the raytree is built and processed.
 *		The raytree stack is used to avoid recursion.
 *
 *		Processes all jobs on raytree stack.
 *
 *		Calls routines for intersecting a ray with the environment and
 *		for shading the ray.
 *
 * RETURNS
 *	Nothing.
 */

VOID	RayTrace(pid)
INT	pid;
	{
	INT	i, j;
	INT	x, y;			/* Pixel address.		     */
	REAL	xx, yy;
	VEC3	N;			/* Normal at intersection.	     */
	VEC3	Ipoint; 		/* Intersection point.		     */
	COLOR	c;			/* Color for storing background.     */
	RAY	*ray;			/* Ray pointer. 		     */
	RAY	rmsg;			/* Ray message. 		     */
	RAYJOB	job;			/* Ray job from work pool.	     */
	OBJECT	*po;			/* Ptr to object.		     */
	BOOL	hit;			/* An object hit?		     */
	IRECORD hitrecord;		/* Intersection record. 	     */

	ray = &rmsg;

	while (GetJobs(&job, pid) != WPS_EMPTY)
		{
		while (GetRayJobFromBundle(&job, &x, &y))
			{
			/* Convert the ray job to the ray message format. */

			xx = (REAL)x;
			yy = (REAL)y;

			if (AntiAlias)
				for (j = 0; j < NumSubRays; j++)
					{
					ConvertPrimRayJobToRayMsg(ray, xx + frand(), yy + frand());
					PushRayTreeStack(ray, pid);
					}
			else
				{
				ConvertPrimRayJobToRayMsg(ray, xx, yy);
				PushRayTreeStack(ray, pid);
				}

			while (PopRayTreeStack(ray, pid) != RTS_EMPTY)
				{
				/* Find which object is closest along the ray. */

				switch (TraversalType)
					{
					case TT_LIST:
						hit = Intersect(ray, &hitrecord);
						break;

					case TT_HUG:
						hit = TraverseHierarchyUniform(ray, &hitrecord, pid);
						break;
					}

				/* Process the object ray hit. */

				if (hit)
					{
					/*
					 *  Get parent object to be able to access
					 *  object operations.
					 */

					po = hitrecord.pelem->parent;

					/* Calculate intersection point. */
					RayPoint(Ipoint, ray, hitrecord.t);

					/* Calculate normal at this point. */
					(*po->procs->normal)(&hitrecord, Ipoint, N);

					/* Make sure normal is pointing toward ray origin. */
					if ((VecDot(ray->D, N)) >  0.0)
						VecNegate(N, N);

					/*
					 *  Compute shade at this point - will process
					 *  shadow rays and add secondary reflection
					 *  and refraction rays to ray tree stack
					 */

					Shade(Ipoint, N, ray, &hitrecord, pid);
					}
				else
					{
					/* Add background as pixel contribution. */

					VecCopy(c, View.bkg);
					VecScale(c, ray->weight, c);
					AddPixelColor(c, ray->x, ray->y);
					}
				}
			}
		}
	}