home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Mega Top 1
/
os2_top1.zip
/
os2_top1
/
APPS
/
RAYTRACE
/
POVRAY2
/
SRC
/
TEXTURE.C
< prev
next >
Wrap
C/C++ Source or Header
|
1993-10-03
|
21KB
|
812 lines
/****************************************************************************
* texture.c
*
* This module implements texturing functions such as noise, turbulence and
* texture transformation functions. The actual texture routines are in the
* files pigment.c & normal.c.
* The noise function used here is the one described by Ken Perlin in
* "Hypertexture", SIGGRAPH '89 Conference Proceedings page 253.
*
* 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.
*
*****************************************************************************/
/*
Some texture ideas garnered from SIGGRAPH '85 Volume 19 Number 3,
"An Image Synthesizer" By Ken Perlin.
Further Ideas Garnered from "The RenderMan Companion" (Addison Wesley)
*/
#include "frame.h"
#include "vector.h"
#include "povproto.h"
#include "texture.h"
DBL *sintab;
DBL frequency[NUMBER_OF_WAVES];
VECTOR Wave_Sources[NUMBER_OF_WAVES];
DBL *RTable;
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, Pigment, value)
COLOUR *Colour;
PIGMENT *Pigment;
DBL value;
{
COLOUR_MAP *Colour_Map = Pigment->Colour_Map;
int max_colors = Colour_Map->Number_Of_Entries-1;
COLOUR_MAP_ENTRY *Cur, *Prev;
register DBL fraction;
value = fmod(value * Pigment->Frequency + Pigment->Phase,1.00001);
if (value < 0.0) /* allow negative Frequency */
value -=floor(value);
/* if greater than last, use last. */
if (value >= Colour_Map->Colour_Map_Entries[max_colors].value)
{
*Colour = Colour_Map->Colour_Map_Entries[max_colors].Colour;
return;
}
Prev = Cur = &(Colour_Map->Colour_Map_Entries[0]);
while (value >= Cur->value)
Prev = Cur++;
/* if stopped on first entry, use first. */
if (Prev == Cur)
{
*Colour = Cur->Colour;
return;
}
fraction = (value - Prev->value) / (Cur->value - Prev->value);
Colour->Red = Prev->Colour.Red + fraction * (Cur->Colour.Red - Prev->Colour.Red);
Colour->Green = Prev->Colour.Green + fraction * (Cur->Colour.Green - Prev->Colour.Green);
Colour->Blue = Prev->Colour.Blue + fraction * (Cur->Colour.Blue - Prev->Colour.Blue);
Colour->Filter = Prev->Colour.Filter + fraction * (Cur->Colour.Filter - Prev->Colour.Filter);
return;
}
void Initialize_Noise ()
{
register int i = 0;
VECTOR point;
InitRTable();
if ((sintab = (DBL *)malloc(SINTABSIZE * sizeof(DBL))) == NULL)
MAError ("sine table");
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);
if ((hashTable = (short int *) malloc(4096*sizeof(short int))) == NULL)
MAError ("hash table");
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();
if ((RTable = (DBL *)malloc(MAXSIZE * sizeof(DBL))) == NULL)
MAError ("RTable");
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;
{
DBL *mp;
long ix, iy, iz, jx, jy, jz;
int ixiy_hash, ixjy_hash, jxiy_hash, jxjy_hash;
DBL sx, sy, sz, tx, ty, tz;
DBL sum;
DBL x_ix, x_jx, y_iy, y_jy, z_iz, z_jz, txty, sxty, txsy, sxsy;
Calls_To_Noise++;
/*setup_lattice(&x, &y, &z, &ix, &iy, &iz, &jx, &jy, &jz, &sx, &sy, &sz, &tx, &ty, &tz);*/
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!
*/
x_ix = x - ix;
x_jx = x - jx;
y_iy = y - iy;
y_jy = y - jy;
z_iz = z - iz;
z_jz = z - jz;
txty = tx * ty;
sxty = sx * ty;
txsy = tx * sy;
sxsy = sx * sy;
ixiy_hash = Hash2d ( ix, iy );
jxiy_hash = Hash2d ( jx, iy );
ixjy_hash = Hash2d ( ix, jy );
jxjy_hash = Hash2d ( jx, jy );
mp = &RTable[(int) Hash1d(ixiy_hash, iz ) & 0xFF];
sum = INCRSUMP(mp,(txty*tz), x_ix, y_iy, z_iz);
mp = &RTable[(int) Hash1d( jxiy_hash, iz ) & 0xFF];
sum += INCRSUMP(mp,(sxty*tz), x_jx, y_iy, z_iz);
mp = &RTable[(int) Hash1d( ixjy_hash, iz ) & 0xFF];
sum += INCRSUMP(mp,(txsy*tz), x_ix, y_jy, z_iz);
mp = &RTable[(int) Hash1d( jxjy_hash, iz ) & 0xFF];
sum += INCRSUMP(mp,(sxsy*tz), x_jx, y_jy, z_iz);
mp = &RTable[(int) Hash1d( ixiy_hash, jz ) & 0xFF];
sum += INCRSUMP(mp,(txty*sz), x_ix, y_iy, z_jz);
mp = &RTable[(int) Hash1d( jxiy_hash, jz ) & 0xFF];
sum += INCRSUMP(mp,(sxty*sz), x_jx, y_iy, z_jz);
mp = &RTable[(int) Hash1d( ixjy_hash, jz ) & 0xFF];
sum += INCRSUMP(mp,(txsy*sz), x_ix, y_jy, z_jz);
mp = &RTable[(int) Hash1d( jxjy_hash, jz ) & 0xFF];
sum += INCRSUMP(mp,(sxsy*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;
{
DBL *mp;
long ix, iy, iz, jx, jy, jz;
int ixiy_hash, ixjy_hash, jxiy_hash, jxjy_hash;
DBL px, py, pz, s;
DBL sx, sy, sz, tx, ty, tz;
DBL txty, sxty, txsy, sxsy;
Calls_To_DNoise++;
/*setup_lattice(&x, &y, &z, &ix, &iy, &iz, &jx, &jy, &jz, &sx, &sy, &sz, &tx, &ty, &tz);*/
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!
*/
txty = tx * ty;
sxty = sx * ty;
txsy = tx * sy;
sxsy = sx * sy;
ixiy_hash = Hash2d ( ix, iy );
jxiy_hash = Hash2d ( jx, iy );
ixjy_hash = Hash2d ( ix, jy );
jxjy_hash = Hash2d ( jx, jy );
mp = &RTable[(int) Hash1d( ixiy_hash, iz ) & 0xFF];
px = x-ix; py = y-iy; pz = z-iz;
s = txty*tz;
result->x = INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y = INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z = INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( jxiy_hash, iz ) & 0xFF];
px = x-jx;
s = sxty*tz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( jxjy_hash, iz ) & 0xFF];
py = y-jy;
s = sxsy*tz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( ixjy_hash, iz ) & 0xFF];
px = x-ix;
s = txsy*tz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( ixjy_hash, jz ) & 0xFF];
pz = z-jz;
s = txsy*sz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( jxjy_hash, jz ) & 0xFF];
px = x-jx;
s = sxsy*sz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( jxiy_hash, jz ) & 0xFF];
py = y-iy;
s = sxty*sz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
mp = &RTable[(int) Hash1d( ixiy_hash, jz ) & 0xFF];
px = x-ix;
s = txty*sz;
result->x += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->y += INCRSUMP(mp,s,px,py,pz);
mp += 4;
result->z += INCRSUMP(mp,s,px,py,pz);
}
DBL Turbulence (x, y, z, omega, lambda, octaves)
DBL x, y, z,omega, lambda;
int octaves;
{
int i;
DBL l, o, value, tempx, tempy, tempz;
value = Noise(x, y, z);
l = lambda;
o = omega;
for (i = 2; i <= octaves; i++)
{
tempx = l * x;
tempy = l * y;
tempz = l * z;
value += o * Noise(tempx, tempy, tempz);
if (i < octaves)
{
l *= lambda;
o *= omega;
}
}
return (value);
}
void DTurbulence (result, x, y, z, omega, lambda, octaves)
VECTOR *result;
DBL x, y, z, omega, lambda;
int octaves;
{
int i;
DBL l, o;
VECTOR value, temp;
result -> x = 0.0;
result -> y = 0.0;
result -> z = 0.0;
value.x = value.y = value.z = 0.0;
DNoise(result, x,y,z);
l = lambda;
o = omega;
for (i = 2; i <= octaves; i++)
{
temp.x = l * x;
temp.y = l * y;
temp.z = l * z;
DNoise(&value, temp.x, temp.y, temp.z);
result->x += o * value.x;
result->y += o * value.y;
result->z += o * value.z;
if (i < octaves)
{
l *= lambda;
o *= omega;
}
}
}
DBL cycloidal (value)
DBL value;
{
register int indx;
if (value >= 0.0)
{
indx = (int)((value - floor (value)) * SINTABSIZE);
return (sintab [indx]);
}
else
{
indx = (int)((0.0 - (value + floor (0.0 - value))) * SINTABSIZE);
return (0.0 - sintab [indx]);
}
}
DBL Triangle_Wave (value)
DBL value;
{
register DBL offset,temp1;
if (value >= 0.0) offset = value - floor(value);
else
{
temp1 = -1.0 - floor(fabs(value));
offset = value - temp1;
}
if (offset >= 0.5) return (2.0 * (1.0 - offset));
else return (2.0 * offset);
}
void Translate_Textures (Textures, Vector)
TEXTURE *Textures;
VECTOR *Vector;
{
TRANSFORM Trans;
Compute_Translation_Transform (&Trans, Vector);
Transform_Textures (Textures, &Trans);
}
void Rotate_Textures (Textures, Vector)
TEXTURE *Textures;
VECTOR *Vector;
{
TRANSFORM Trans;
Compute_Rotation_Transform (&Trans, Vector);
Transform_Textures (Textures, &Trans);
}
void Scale_Textures (Textures, Vector)
TEXTURE *Textures;
VECTOR *Vector;
{
TRANSFORM Trans;
Compute_Scaling_Transform (&Trans, Vector);
Transform_Textures (Textures, &Trans);
}
void Transform_Textures (Textures, Trans)
TEXTURE *Textures;
TRANSFORM *Trans;
{
TEXTURE *Layer, *Material;
for (Layer = Textures;
Layer != NULL;
Layer = Layer->Next_Layer)
switch (Layer->Type)
{
case PNF_TEXTURE:
Transform_Pigment (Layer->Pigment, Trans);
Transform_Tnormal (Layer->Tnormal, Trans);
break;
case TILE_TEXTURE:
if (((TILES *)Layer)->Trans == NULL)
((TILES *)Layer)->Trans = Create_Transform ();
Compose_Transforms (((TILES *)Layer)->Trans, Trans);
Transform_Textures (((TILES *)Layer)->Tile1, Trans);
Transform_Textures (((TILES *)Layer)->Tile2, Trans);
break;
case MAT_TEXTURE:
if (((MATERIAL *)Layer)->Trans == NULL)
((MATERIAL *)Layer)->Trans = Create_Transform ();
Compose_Transforms (((MATERIAL *)Layer)->Trans, Trans);
for (Material = ((MATERIAL *)Layer)->Materials;
Material != NULL;
Material = Material->Next_Material)
Transform_Textures (Material, Trans);
break;
}
}
FINISH *Create_Finish ()
{
FINISH *New;
if ((New = (FINISH *) malloc (sizeof (FINISH))) == NULL)
MAError ("finish");
New->Reflection = 0.0;
New->Ambient = 0.1;
New->Diffuse = 0.6;
New->Brilliance = 1.0;
New->Index_Of_Refraction = 1.0;
New->Refraction = 0.0;
New->Specular = 0.0;
New->Roughness = 1.0/0.05; /* CEY 12/92 */
New->Phong = 0.0;
New->Phong_Size = 40.0;
New->Crand = 0.0;
New->Metallic_Flag = FALSE;
return (New);
}
FINISH *Copy_Finish (Old)
FINISH *Old;
{
FINISH *New;
if (Old != NULL)
{
New = Create_Finish ();
*New = *Old;
}
else
New = NULL;
return (New);
}
TEXTURE *Create_PNF_Texture ()
{
TEXTURE *New;
if ((New = (TEXTURE *) malloc (sizeof (TEXTURE))) == NULL)
MAError ("texture");
New->Type = PNF_TEXTURE;
New->Flags = NO_FLAGS;
New->Pigment = NULL;
New->Tnormal = NULL;
New->Finish = NULL;
New->Next_Layer = NULL;
New->Next_Material = NULL;
return (New);
}
TILES *Create_Tiles_Texture ()
{
TILES *New;
if ((New = (TILES *) malloc (sizeof (TILES))) == NULL)
MAError ("checker texture");
New->Type = TILE_TEXTURE;
New->Flags = NO_FLAGS;
New->Tile1 = NULL;
New->Tile2 = NULL;
New->Trans = NULL;
New->Next_Layer = NULL;
New->Next_Material = NULL;
return (New);
}
MATERIAL *Create_Material_Texture ()
{
MATERIAL *New;
if ((New = (MATERIAL *) malloc (sizeof (MATERIAL))) == NULL)
MAError ("material texture");
New->Type = MAT_TEXTURE;
New->Flags = NO_FLAGS;
New->Materials = NULL;
New->Num_Of_Mats = 0;
New->Trans = NULL;
New->Next_Layer = NULL;
New->Next_Material = NULL;
return (New);
}
TEXTURE *Copy_Textures (Textures)
TEXTURE *Textures;
{
TEXTURE *New, *First, *Previous, *Layer;
Previous = First = NULL;
for (Layer = Textures;
Layer != NULL;
Layer = Layer->Next_Layer)
{
switch (Layer->Type)
{
case PNF_TEXTURE:
New = Create_PNF_Texture ();
New->Pigment = Copy_Pigment (Layer->Pigment);
New->Tnormal = Copy_Tnormal (Layer->Tnormal);
New->Finish = Copy_Finish (Layer->Finish);
break;
case TILE_TEXTURE:
New = (TEXTURE *) Create_Tiles_Texture ();
((TILES *)New)->Tile1 = Copy_Textures (((TILES *)Layer)->Tile1);
((TILES *)New)->Tile2 = Copy_Textures (((TILES *)Layer)->Tile2);
((TILES *)New)->Trans = Copy_Transform (((TILES *)Layer)->Trans);
break;
case MAT_TEXTURE:
New = (TEXTURE *) Create_Material_Texture ();
((MATERIAL *)New)->Materials = Copy_Materials (((MATERIAL *)Layer)->Materials);
((MATERIAL *)New)->Trans = Copy_Transform (((MATERIAL *)Layer)->Trans);
((MATERIAL *)New)->Num_Of_Mats = (((MATERIAL *)Layer)->Num_Of_Mats);
break;
}
if (First == NULL)
First = New;
if (Previous != NULL)
Previous->Next_Layer = New;
Previous = New;
}
return (First);
}
TEXTURE *Copy_Materials (Old)
TEXTURE *Old;
{
TEXTURE *New, *First, *Previous, *Material;
Previous = First = NULL;
for (Material = Old;
Material != NULL;
Material = Material->Next_Material)
{
New = Copy_Textures (Material);
if (First == NULL)
First = New;
if (Previous != NULL)
Previous->Next_Material = New;
Previous = New;
}
return (First);
}
void Destroy_Textures (Textures)
TEXTURE *Textures;
{
TEXTURE *Layer=Textures;
TEXTURE *Mats;
TEXTURE *Temp;
while (Layer != NULL)
{
Mats = Layer->Next_Material;
while (Mats != NULL)
{
Temp = Mats->Next_Material;
Destroy_Textures (Mats);
Mats = Temp;
}
switch (Layer->Type)
{
case PNF_TEXTURE:
Destroy_Pigment (Layer->Pigment);
Destroy_Tnormal (Layer->Tnormal);
Destroy_Finish (Layer->Finish);
break;
case TILE_TEXTURE:
Destroy_Transform (((TILES *)Layer)->Trans);
Destroy_Textures (((TILES *)Layer)->Tile1);
Destroy_Textures (((TILES *)Layer)->Tile2);
break;
case MAT_TEXTURE:
Destroy_Transform (((MATERIAL *)Layer)->Trans);
Destroy_Textures (((MATERIAL *)Layer)->Materials);
Destroy_Image (((MATERIAL *)Layer)->Image);
break;
}
Temp = Layer->Next_Layer;
free (Layer);
Layer = Temp;
}
}
void Post_Textures (Textures)
TEXTURE *Textures;
{
TEXTURE *Layer, *Material;
if (Textures == NULL)
return;
for (Layer = Textures;
Layer != NULL;
Layer = Layer->Next_Layer)
{
if (!((Layer->Flags) & POST_DONE))
switch (Layer->Type)
{
case PNF_TEXTURE:
Post_Pigment (Layer->Pigment);
Post_Tnormal (Layer->Tnormal);
break;
case TILE_TEXTURE:
Post_Textures (((TILES *)Layer)->Tile1);
Post_Textures (((TILES *)Layer)->Tile2);
break;
case MAT_TEXTURE:
for (Material = ((MATERIAL *)Layer)->Materials;
Material != NULL;
Material = Material->Next_Material)
Post_Textures(Material);
break;
}
}
return;
}