/*****************************************************************************
*
*                                   texture.c
*
*   from DKBTrace (c) 1990  David Buck
*
*  This module implements solid texturing functions such as wood, marble, and
*  bozo.  The noise function used here is the one described by Ken Perlin in
*  "Hypertexture", SIGGRAPH '89 Conference Proceedings page 253.
*
* This software is freely distributable. The source and/or object code may be
* copied or uploaded to communications services so long as this notice remains
* at the top of each file.  If any changes are made to the program, you must
* clearly indicate in the documentation and in the programs startup message
* who it was who made the changes. The documentation should also describe what
* those changes were. This software may not be included in whole or in
* part into any commercial package without the express written consent of the
* author.  It may, however, be included in other public domain or freely
* distributed software so long as the proper credit for the software is given.
*
* This software is provided as is without any guarantees or warranty. Although
* the author has attempted to find and correct any bugs in the software, he
* is not responsible for any damage caused by the use of the software.  The
* author is under no obligation to provide service, corrections, or upgrades
* to this package.
*
* Despite all the legal stuff above, if you do find bugs, I would like to hear
* about them.  Also, if you have any comments or questions, you may contact me
* at the following address:
*
*     David Buck
*     22C Sonnet Cres.
*     Nepean Ontario
*     Canada, K2H 8W7
*
*  I can also be reached on the following bulleton boards:
*
*     ATX              (613) 526-4141
*     OMX              (613) 731-3419
*     Mystic           (613) 731-0088 or (613) 731-6698
*
*  Fidonet:   1:163/109.9
*  Internet:  David_Buck@Carleton.CA
*
*  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
*
*     Lattice BBS                      (708) 916-1200
*     The Information Exchange BBS     (708) 945-5575
*     Stillwaters BBS                  (708) 403-2826
*
*
*
*
*  The Noise and DNoise functions (and associated functions) were written by
*  Robert Skinner (robert@sgi.com) and are used here with his permission.
*  They are a lot better than the noise functions I had before!
*
*****************************************************************************/


#include "frame.h"
#include "vector.h"
#include "dkbproto.h"

extern long Calls_To_Noise, Calls_To_DNoise;

#define MINX	-10000		/* Ridiculously large scaling values */
#define MINY	MINX
#define MINZ	MINX

#define MAXSIZE 267
#define RNDMASK 0x7FFF
#define RNDDIVISOR (float) RNDMASK
#define NUMBER_OF_WAVES 10
#define SINTABSIZE 1000
#define EPSILON	(DBL) 0.00001

#define FLOOR(x) ((x) >= 0.0 ? floor(x) : (0.0 - floor(0.0 - (x)) - 1.0))
#define FABS(x) ((x) < 0.0 ? (0.0 - x) : (x))
#define SCURVE(a) ((a)*(a)*(3.0-2.0*(a)))
#define REALSCALE ( 2.0 / 65535.0 )
#define Hash3d(a,b,c) hashTable[(int)(hashTable[(int)(hashTable[(int)((a) & 0xfffL)] ^ ((b) & 0xfffL))] ^ ((c) & 0xfffL))]
#define INCRSUM(m,s,x,y,z)	((s)*(RTable[m]*0.5		\
					+ RTable[m+1]*(x)	\
					+ RTable[m+2]*(y)	\
					+ RTable[m+3]*(z)))

DBL sintab [SINTABSIZE];
DBL frequency[NUMBER_OF_WAVES];
VECTOR Wave_Sources[NUMBER_OF_WAVES];
DBL	RTable[MAXSIZE];
short *hashTable;
unsigned short crctab[256] =
{
   0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
   0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
   0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
   0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
   0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
   0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
   0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
   0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
   0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
   0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
   0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
   0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
   0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
   0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
   0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
   0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
   0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
   0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
   0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
   0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
   0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
   0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
   0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
   0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
   0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
   0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
   0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
   0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
   0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
   0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
   0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
   0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040
};


void Compute_Colour (Colour, Colour_Map, value)
   COLOUR *Colour;
   COLOUR_MAP *Colour_Map;
   DBL value;
   {
   register int i;
   COLOUR_MAP_ENTRY *Entry;
   register DBL fraction;

   for (i = 0, Entry = &(Colour_Map->Colour_Map_Entries[0]) ; i < Colour_Map -> Number_Of_Entries ; i++, Entry++)
      if ((value >= Entry->start) && (value <= Entry->end))
      {
      fraction = (value - Entry->start) / (Entry->end - Entry->start);
      Colour -> Red = Entry->Start_Colour.Red + fraction * (Entry->End_Colour.Red - Entry->Start_Colour.Red);
      Colour -> Green = Entry->Start_Colour.Green + fraction * (Entry->End_Colour.Green - Entry->Start_Colour.Green);
      Colour -> Blue = Entry->Start_Colour.Blue + fraction * (Entry->End_Colour.Blue - Entry->Start_Colour.Blue);
      Colour -> Alpha = Entry->Start_Colour.Alpha + fraction * (Entry->End_Colour.Alpha - Entry->Start_Colour.Alpha);
      return;
      }

   Colour -> Red = 0.0;
   Colour -> Green = 0.0;
   Colour -> Blue = 0.0;
   Colour -> Alpha = 0.0;
   printf ("No colour for value: %f\n", value);
   return;
   }

void Initialize_Noise ()
   {
   register int i = 0;
   VECTOR point;

   InitRTable();

   for (i = 0 ; i < SINTABSIZE ; i++)
      sintab[i] = sin(i/(DBL)SINTABSIZE * (3.14159265359 * 2.0));

   for (i = 0 ; i < NUMBER_OF_WAVES ; i++)
      {
      DNoise (&point, (DBL) i, 0.0, 0.0);
      VNormalize (Wave_Sources[i], point);
      frequency[i] = (rand() & RNDMASK) / RNDDIVISOR + 0.01;
      }
   }

void InitTextureTable()
   {
   int i, j, temp;

   srand(0);

   hashTable = (short int *) malloc(4096*sizeof(short int));
   for (i = 0; i < 4096; i++)
      hashTable[i] = i;
   for (i = 4095; i >= 0; i--)
      {
      j = rand() % 4096;
      temp = hashTable[i];
      hashTable[i] = hashTable[j];
      hashTable[j] = temp;
      }
   }


/* modified by AAC to work properly with little bitty integers (16 bits) */

void InitRTable()
   {
   int i;
   VECTOR rp;

   InitTextureTable();

   for (i = 0; i < MAXSIZE; i++)
      {
      rp.x = rp.y = rp.z = (DBL)i;
      RTable[i] = (unsigned int) R(&rp) * REALSCALE - 1.0;
      }
   }


int R(v)
   VECTOR *v;
   {
   v->x *= .12345;
   v->y *= .12345;
   v->z *= .12345;

   return (Crc16((char *) v, sizeof(VECTOR)));
   }

/*
 * Note that passing a VECTOR array to Crc16 and interpreting it as
 * an array of chars means that machines with different floating-point
 * representation schemes will evaluate Noise(point) differently.
 */

int Crc16(buf, count)
   register char *buf;
   register int  count;
   {
   register unsigned short crc = 0;

   while (count--)
      crc = (crc >> 8) ^ crctab[ (unsigned char) (crc ^ *buf++) ];

   return ((int) crc);
   }


/*
	Robert's Skinner's Perlin-style "Noise" function - modified by AAC
	to ensure uniformly distributed clamped values between 0 and 1.0...
*/

DBL Noise(x, y, z)
   DBL x, y, z;
   {
   register long ix, iy, iz, jx, jy, jz;
   DBL sx, sy, sz, tx, ty, tz;
   DBL sum;
   short m;


   Calls_To_Noise++;
   /* ensures the values are positive. */
   x -= MINX;
   y -= MINY;
   z -= MINZ;

   /* its equivalent integer lattice point. */
   ix = (long)x; iy = (long)y; iz = (long)z;
   jx = ix + 1; jy = iy + 1; jz = iz + 1;

   sx = SCURVE(x - ix); sy = SCURVE(y - iy); sz = SCURVE(z - iz);

   /* the complement values of sx,sy,sz */
   tx = 1.0 - sx; ty = 1.0 - sy; tz = 1.0 - sz;

   /*
    *  interpolate!
    */
   m = Hash3d( ix, iy, iz ) & 0xFF;
   sum = INCRSUM(m,(tx*ty*tz),(x-ix),(y-iy),(z-iz));

   m = Hash3d( jx, iy, iz ) & 0xFF;
   sum += INCRSUM(m,(sx*ty*tz),(x-jx),(y-iy),(z-iz));

   m = Hash3d( ix, jy, iz ) & 0xFF;
   sum += INCRSUM(m,(tx*sy*tz),(x-ix),(y-jy),(z-iz));

   m = Hash3d( jx, jy, iz ) & 0xFF;
   sum += INCRSUM(m,(sx*sy*tz),(x-jx),(y-jy),(z-iz));

   m = Hash3d( ix, iy, jz ) & 0xFF;
   sum += INCRSUM(m,(tx*ty*sz),(x-ix),(y-iy),(z-jz));

   m = Hash3d( jx, iy, jz ) & 0xFF;
   sum += INCRSUM(m,(sx*ty*sz),(x-jx),(y-iy),(z-jz));

   m = Hash3d( ix, jy, jz ) & 0xFF;
   sum += INCRSUM(m,(tx*sy*sz),(x-ix),(y-jy),(z-jz));

   m = Hash3d( jx, jy, jz ) & 0xFF;
   sum += INCRSUM(m,(sx*sy*sz),(x-jx),(y-jy),(z-jz));

   sum = sum + 0.5;          /* range at this point -0.5 - 0.5... */
	
   if (sum < 0.0)
      sum = 0.0;
   if (sum > 1.0)
      sum = 1.0;

   return (sum);
   }


/*
       Vector-valued version of "Noise"
*/

void DNoise(result, x, y, z)
   VECTOR *result;
   DBL x, y, z;
   {
   register long ix, iy, iz, jx, jy, jz;
   DBL px, py, pz, s;
   DBL sx, sy, sz, tx, ty, tz;
   short m;

   Calls_To_DNoise++;
   /* ensures the values are positive. */
   x -= MINX;
   y -= MINY;
   z -= MINZ;

   /* its equivalent integer lattice point. */
   ix = (long)x; iy = (long)y; iz = (long)z;
   jx = ix+1; jy = iy + 1; jz = iz + 1;

   sx = SCURVE(x - ix); sy = SCURVE(y - iy); sz = SCURVE(z - iz);

   /* the complement values of sx,sy,sz */
   tx = 1.0 - sx; ty = 1.0 - sy; tz = 1.0 - sz;

   /*
    *  interpolate!
    */
   m = Hash3d( ix, iy, iz ) & 0xFF;
   px = x-ix;  py = y-iy;  pz = z-iz;
   s = tx*ty*tz;
   result->x = INCRSUM(m,s,px,py,pz);
   result->y = INCRSUM(m+4,s,px,py,pz);
   result->z = INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( jx, iy, iz ) & 0xFF;
   px = x-jx;
   s = sx*ty*tz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( jx, jy, iz ) & 0xFF;
   py = y-jy;
   s = sx*sy*tz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( ix, jy, iz ) & 0xFF;
   px = x-ix;
   s = tx*sy*tz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( ix, jy, jz ) & 0xFF;
   pz = z-jz;
   s = tx*sy*sz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( jx, jy, jz ) & 0xFF;
   px = x-jx;
   s = sx*sy*sz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( jx, iy, jz ) & 0xFF;
   py = y-iy;
   s = sx*ty*sz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);

   m = Hash3d( ix, iy, jz ) & 0xFF;
   px = x-ix;
   s = tx*ty*sz;
   result->x += INCRSUM(m,s,px,py,pz);
   result->y += INCRSUM(m+4,s,px,py,pz);
   result->z += INCRSUM(m+8,s,px,py,pz);
   }

DBL Turbulence (x, y, z)
   DBL x, y, z;
   {
   register DBL pixelSize = 0.1;
   register DBL t = 0.0;
   register DBL scale, value;

   for (scale = 1.0 ; scale > pixelSize ; scale *= 0.5) {
      value = Noise (x/scale, y/scale, z/scale);
      t += FABS (value) * scale;
      }
   return (t);
   }

void DTurbulence (result, x, y, z)
   VECTOR *result;
   DBL x, y, z;
   {
   register DBL pixelSize = 0.01;
   register DBL scale;
   VECTOR value;

   result -> x = 0.0;
   result -> y = 0.0;
   result -> z = 0.0;

   value.x = value.y = value.z = 0.0;

   for (scale = 1.0 ; scale > pixelSize ; scale *= 0.5) {
      DNoise(&value, x/scale, y/scale, z/scale);
      result -> x += value.x * scale;
      result -> y += value.y * scale;
      result -> z += value.z * scale;
      }
   }

DBL cycloidal (value)
   DBL value;
   {

   if (value >= 0.0)
      return (sintab [(int)((value - floor (value)) * SINTABSIZE)]);
   else
      return (0.0 - sintab [(int)((0.0 - (value + floor (0.0 - value)))
                                    * SINTABSIZE)]);
   }


DBL Triangle_Wave (value)
   DBL value;
   {
   register DBL offset;

   if (value >= 0.0) offset = value - floor(value);
   else offset = value - (-1.0 - floor(FABS(value)));

   if (offset >= 0.5) return (2.0 * (1.0 - offset));
   else return (2.0 * offset);
   }


int Bozo (x, y, z, Object, Colour)
DBL x, y, z;
OBJECT *Object;
COLOUR *Colour;
   {
   register DBL noise, turb;
   COLOUR New_Colour;
   VECTOR BozoTurbulence;


   if ((turb = Object->Object_Texture->Turbulence) != 0.0)
      {
      DTurbulence (&BozoTurbulence, x, y, z);
      x += BozoTurbulence.x * turb;
      y += BozoTurbulence.y * turb;
      z += BozoTurbulence.z * turb;
      }

   noise = Noise (x, y, z);

   if (Object -> Object_Texture->Colour_Map != NULL) {
      Compute_Colour (&New_Colour, Object->Object_Texture->Colour_Map, noise);
      Colour -> Red += New_Colour.Red;
      Colour -> Green += New_Colour.Green;
      Colour -> Blue += New_Colour.Blue;
      Colour -> Alpha += New_Colour.Alpha;
      return (0);
      }

   if (noise < 0.4) {
      Colour -> Red += 1.0;
      Colour -> Green += 1.0;
      Colour -> Blue += 1.0;
      return (0);
      }

   if (noise < 0.6) {
      Colour -> Green += 1.0;
      return (0);
      }

   if (noise < 0.8) {
      Colour -> Blue += 1.0;
      return (0);
      }

   Colour -> Red += 1.0;
   return (0);
   }

int marble (x, y, z, Object, colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *colour;
   {
   register DBL noise, hue;
   COLOUR New_Colour;

   noise = Triangle_Wave(x + Turbulence(x, y, z) * Object -> Object_Texture->Turbulence);

   if (Object -> Object_Texture->Colour_Map != NULL)
      {
      Compute_Colour (&New_Colour, Object->Object_Texture->Colour_Map, noise);
      colour -> Red += New_Colour.Red;
      colour -> Green += New_Colour.Green;
      colour -> Blue += New_Colour.Blue;
      colour -> Alpha += New_Colour.Alpha;
      return (0);
      }

   if (noise < 0.0)
      {
      colour -> Red += 0.9;
      colour -> Green += 0.8;
      colour -> Blue += 0.8;
      }
   else if (noise < 0.9)
      {
      colour -> Red += 0.9;
      hue = 0.8 - noise * 0.8;
      colour -> Green += hue;
      colour -> Blue += hue;
      }
   return (0);
   }


void ripples (x, y, z, Object, Vector)
   DBL x, y, z;
   OBJECT *Object;
   VECTOR *Vector;
   {
   register int i;
   VECTOR point;
   register DBL length, scalar, index;

   for (i = 0 ; i < NUMBER_OF_WAVES ; i++) {
      point.x = x;
      point.y = y;
      point.z = z;
      VSub (point, point, Wave_Sources[i]);
      VDot (length, point, point);
      if (length == 0.0)
         length = 1.0;

      length = sqrt(length);
      index = length*Object->Object_Texture->Frequency
                    + Object -> Object_Texture->Phase;
      scalar = cycloidal (index) * Object -> Object_Texture->Bump_Amount;
      VScale (point, point, scalar/length/(DBL)NUMBER_OF_WAVES);
      VAdd (*Vector, *Vector, point);
      }
   VNormalize (*Vector, *Vector);
   }

void waves (x, y, z, Object, Vector)
   DBL x, y, z;
   OBJECT *Object;
   VECTOR *Vector;
   {
   register int i;
   VECTOR point;
   register DBL length, scalar, index, sinValue ;

   for (i = 0 ; i < NUMBER_OF_WAVES ; i++) {
      point.x = x;
      point.y = y;
      point.z = z;
      VSub (point, point, Wave_Sources[i]);
      VDot (length, point, point);
      if (length == 0.0)
         length = 1.0;

      length = sqrt(length);
      index = (length * Object -> Object_Texture->Frequency * frequency[i])
                   + Object -> Object_Texture->Phase;
      sinValue = cycloidal (index);

      scalar =  sinValue * Object -> Object_Texture->Bump_Amount /
                  frequency[i];
      VScale (point, point, scalar/length/(DBL)NUMBER_OF_WAVES);
      VAdd (*Vector, *Vector, point);
      }
   VNormalize (*Vector, *Vector);
   }

int wood (x, y, z, Object, colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *colour;
   {
   register DBL noise, length;
   VECTOR WoodTurbulence;
   VECTOR point;
   COLOUR New_Colour;

   DTurbulence (&WoodTurbulence, x, y, z);

   point.x = cycloidal((x + WoodTurbulence.x)
               * Object -> Object_Texture->Turbulence);
   point.y = cycloidal((y + WoodTurbulence.y)
               * Object -> Object_Texture->Turbulence);
   point.z = 0.0;

   point.x += x;
   point.y += y;
   point.z += z;

   VLength (length, point);

   noise = Triangle_Wave(length);

   if (Object -> Object_Texture->Colour_Map != NULL) {
      Compute_Colour (&New_Colour, Object->Object_Texture->Colour_Map, noise);
      colour -> Red += New_Colour.Red;
      colour -> Green += New_Colour.Green;
      colour -> Blue += New_Colour.Blue;
      colour -> Alpha += New_Colour.Alpha;
      return (0);
      }

   if (noise > 0.6) {
      colour -> Red += 0.4;
      colour -> Green += 0.133;
      colour -> Blue += 0.066;
      }
  else {
      colour -> Red += 0.666;
      colour -> Green += 0.312;
      colour -> Blue += 0.2;
      }
      return (0);
   }


void checker (x, y, z, Object, colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *colour;
   {
   int brkindx;

   brkindx = (int) FLOOR(x) + (int) FLOOR(z);

   if (brkindx & 1)
      *colour = Object -> Object_Texture->Colour1;
   else
      *colour = Object -> Object_Texture->Colour2;
   return;
   }

/*
   Ideas garnered from SIGGRAPH '85 Volume 19 Number 3, "An Image Synthesizer"
   By Ken Perlin.
*/


/*	
	With a little reflectivity and brilliance, can look like organ pipe
	metal.   With tiny scaling values can look like masonry or concrete.
	Works with color maps, supposedly. (?)
*/

void spotted (x, y, z, Object, Colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *Colour;
   {
   register DBL noise;
   COLOUR New_Colour;

   noise = Noise (x, y, z);

   if (Object -> Object_Texture->Colour_Map != NULL)
      {
      Compute_Colour (&New_Colour, Object->Object_Texture->Colour_Map, noise);
      Colour -> Red += New_Colour.Red;
      Colour -> Green += New_Colour.Green;
      Colour -> Blue += New_Colour.Blue;
      Colour -> Alpha += New_Colour.Alpha;
      return;
      }

   Colour -> Red += noise;             /* "white (1.0) * noise" */
   Colour -> Green += noise;
   Colour -> Blue += noise;

   return;
   }

void bumps (x, y, z, Object, normal)
   DBL x, y, z;
   OBJECT *Object;
   VECTOR *normal;
   {
   VECTOR bump_turb;

   if (Object -> Object_Texture->Bump_Amount == 0.0)
      return;                            /* why are we here?? */

   DNoise (&bump_turb, x, y, z);         /* Get Normal Displacement Val. */
   VScale(bump_turb, bump_turb, Object->Object_Texture->Bump_Amount);
   VAdd (*normal, *normal, bump_turb);   /* displace "normal" */
   VNormalize (*normal, *normal);        /* normalize normal! */
   return;
   }

/*
   dents is similar to bumps, but uses noise() to control the amount of
   dnoise() perturbation of the object normal...
*/

void dents (x, y, z, Object, normal)
   DBL x, y, z;
   OBJECT *Object;
   VECTOR *normal;
   {
   VECTOR stucco_turb;
   DBL noise;

   if (Object -> Object_Texture->Bump_Amount == 0.0)
      return;                           /* why are we here?? */

   noise = Noise (x, y, z);

   noise =  noise * noise * noise * Object->Object_Texture->Bump_Amount;

   DNoise (&stucco_turb, x, y, z);       /* Get Normal Displacement Val. */
	
   VScale (stucco_turb, stucco_turb, noise);
   VAdd (*normal, *normal, stucco_turb); /* displace "normal" */
   VNormalize (*normal, *normal);        /* normalize normal! */
   return;
   }


void agate (x, y, z, Object, colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *colour;
   {
   register DBL noise, hue;
   COLOUR New_Colour;

   noise = cycloidal(1.3 * Turbulence(x, y, z) + 1.1 * z) + 1;
   noise *= 0.5;
   noise = pow(noise, 0.77);

   if (Object -> Object_Texture->Colour_Map != NULL)
      {
      Compute_Colour (&New_Colour, Object->Object_Texture->Colour_Map, noise);
      colour -> Red += New_Colour.Red;
      colour -> Green += New_Colour.Green;
      colour -> Blue += New_Colour.Blue;
      colour -> Alpha += New_Colour.Alpha;
      return;
      }

   hue = 1.0 - noise;

   if (noise < 0.5)
      {
      colour -> Red += (1.0 - (noise / 10));
      colour -> Green += (1.0 - (noise / 5));
      colour -> Blue += hue;
      }
   else if (noise < 0.6)
      {
      colour -> Red += 0.9;
      colour -> Green += 0.7;
      colour -> Blue += hue;
      }
   else
      {
      colour -> Red += (0.6 + hue);
      colour -> Green += (0.3 + hue);
      colour -> Blue += hue;
      }
   return;
   }


/*
   Ideas garnered from the April 89 Byte Graphics Supplement on RenderMan,
   refined from "The RenderMan Companion, by Steve Upstill of Pixar, (C) 1990
   Addison-Wesley.
*/


/*
   wrinkles - This is my implementation of the dented() routine, using
   a surface iterative fractal derived from DTurbulence.  This is a 3-D vers.
   (thanks to DNoise()...) of the usual version using the singular Noise()...
   Seems to look a lot like wrinkles, however... (hmmm)
*/

void wrinkles (x, y, z, Object, normal)
   DBL x, y, z;
   OBJECT *Object;
   VECTOR *normal;
   {
   register int i;
   register DBL scale = 1.0;
   VECTOR result, value;

   if (Object -> Object_Texture->Bump_Amount == 0.0)
      return;                                /* why are we here?? */

   result.x = 0.0;
   result.y = 0.0;
   result.z = 0.0;

   for (i = 0; i < 10 ; scale *= 2.0, i++)
      {
      DNoise(&value, x * scale, y * scale, z * scale);   /* * scale,*/
      result.x += FABS (value.x / scale);
      result.y += FABS (value.y / scale);
      result.z += FABS (value.z / scale);
      }

   VScale(result, result, Object->Object_Texture->Bump_Amount);
   VAdd (*normal, *normal, result);             /* displace "normal" */
   VNormalize (*normal, *normal);               /* normalize normal! */
   return;
   }


/*
   Granite - kind of a union of the "spotted" and the "dented" textures,
   using a 1/f fractal noise function for color values.  Typically used
   w/ small scaling values.  Should work with colour maps for pink granite...
*/


void granite (x, y, z, Object, Colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *Colour;
   {
   register int i;
   register DBL temp, noise = 0.0, freq = 1.0;
   COLOUR New_Colour;

   for (i = 0; i < 6 ; freq *= 2.0, i++)
      {
      temp = 0.5 - Noise (x * 4 * freq, y * 4 * freq, z * 4 * freq);
      temp = FABS(temp);
      noise += temp / freq;
      }

   if (Object -> Object_Texture->Colour_Map != NULL)
      {
      Compute_Colour (&New_Colour, Object->Object_Texture->Colour_Map, noise);
      Colour -> Red += New_Colour.Red;
      Colour -> Green += New_Colour.Green;
      Colour -> Blue += New_Colour.Blue;
      Colour -> Alpha += New_Colour.Alpha;
      return;
      }

   Colour -> Red += noise;                  /* "white (1.0) * noise" */
   Colour -> Green += noise;
   Colour -> Blue += noise;

   return;
   }

/*
   Further Ideas Garnered from "The RenderMan Companion" (Addison Wesley)
*/


/*
   Color Gradient Texture - gradient based on the fractional values of x, y or
   z, based on whether or not the given directional vector is a 1.0 or a 0.0.
   Note - ONLY works with colour maps, preferably one that is circular - i.e.
   the last defined colour (value 1.001) is the same as the first colour (with
   a value of 0.0) in the map.  The basic concept of this is from DBW Render,
   but Dave Wecker's only supports simple Y axis gradients.
*/

void gradient (x, y, z, Object, Colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *Colour;
   {
   COLOUR New_Colour;
   DBL value = 0.0, turb;
   VECTOR GradTurbulence;

   if ((turb = Object->Object_Texture->Turbulence) != 0.0)
      {
      DTurbulence (&GradTurbulence, x, y, z);
      x += GradTurbulence.x * turb;
      y += GradTurbulence.y * turb;
      z += GradTurbulence.z * turb;
      }

   if (Object -> Object_Texture->Colour_Map == NULL)
      return;
   if (Object -> Object_Texture->Texture_Gradient.x != 0.0)
      {
      x = FABS(x);
      value += x - FLOOR(x);	/* obtain fractional X component */
      }
   if (Object -> Object_Texture->Texture_Gradient.y != 0.0)
      {
      y = FABS(y);
      value += y - FLOOR(y);	/* obtain fractional Y component */
   }
   if (Object -> Object_Texture->Texture_Gradient.z != 0.0)
      {
      z = FABS(z);
      value += z - FLOOR(z);	/* obtain fractional Z component */
      }
   value = ((value > 1.0) ? fmod(value, 1.0) : value); /* clamp to 1.0 */
   Compute_Colour(&New_Colour, Object->Object_Texture->Colour_Map, value);
   Colour -> Red += New_Colour.Red;
   Colour -> Green += New_Colour.Green;
   Colour -> Blue += New_Colour.Blue;
   Colour -> Alpha += New_Colour.Alpha;
   return;
   }

/*
   2-D to 3-D Procedural Texture Mapping of a Bitmapped Image onto an Object:
	   
   Simplistic method of object image projection devised by DKB and AAC.

   1. Transform texture in 3-D space if requested.
   2. Determine local object 2-d coords from 3-d coords by <X Y Z> triple.
   3. Return pixel color value at that position on the 2-d plane of "Image".
   3. Map colour value in Image [0..255] to a more normal colour range [0..1].
*/

void texture_map (x, y, z, Object, colour)
   DBL x, y, z;
   OBJECT *Object;
   COLOUR *colour;
   {
   /* determine local object 2-d coords from 3-d coords */
   /* "unwrap" object 2-d coord onto flat 2-d plane */
   /* return pixel color value at that posn on 2-d plane */

   int xcoor, ycoor, index;
   TEXTURE *local_texture;
   DBL width, height, turb;
   VECTOR TextureTurbulence;

   local_texture = Object->Object_Texture;

   if ((turb = local_texture->Turbulence) != 0.0)
      {
      DTurbulence (&TextureTurbulence, x, y, z);
      x += TextureTurbulence.x * turb;
      y += TextureTurbulence.y * turb;
      z += TextureTurbulence.z * turb;
      }

   width = local_texture->Image->width;
   height = local_texture->Image->height;

   if (local_texture -> Texture_Gradient.x != 0.0) {
      if ((local_texture->Once_Flag) &&
           ((x < 0.0) || (x > 1.0))) {
         *colour = Object -> Object_Colour;
         return;
         }

      if (local_texture -> Texture_Gradient.x > 0)
         xcoor = (int) fmod (x * width, width);
      else ycoor = (int) fmod (x * height, height);
      }

   if (local_texture -> Texture_Gradient.y != 0.0) {
      if ((local_texture->Once_Flag) &&
           ((y < 0.0) || (y > 1.0))) {
         *colour = Object -> Object_Colour;
         return;
         }

      if (local_texture -> Texture_Gradient.y > 0)
         xcoor = (int) fmod (y * width, width);
      else ycoor = (int) fmod (y * height, height);
      }

   if (local_texture -> Texture_Gradient.z != 0.0) {
      if ((local_texture->Once_Flag) &&
           ((z < 0.0) || (z > 1.0))) {
         *colour = Object -> Object_Colour;
         return;
         }

      if (local_texture -> Texture_Gradient.z > 0)
         xcoor = (int) fmod (z * width, width);
      else ycoor = (int) fmod (z * height, height);
      }

   if (xcoor < 0)
      xcoor += local_texture->Image->iwidth;
   if (ycoor < 0)
      ycoor += local_texture->Image->iheight;

   if ((xcoor >= local_texture->Image->iwidth) ||
       (ycoor >= local_texture->Image->iheight) ||
       (xcoor < 0) || (ycoor < 0))
     printf ("Out of range\n");

   index = (unsigned)ycoor* (unsigned)local_texture->Image->iwidth +
           (unsigned)xcoor;

   Make_Colour (colour, (DBL) local_texture->Image->red[index]/255.0,
                        (DBL) local_texture->Image->green[index]/255.0,
                        (DBL) local_texture->Image->blue[index]/255.0);
   }