home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / TEXTURE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  15.1 KB  |  533 lines
  1. /****************************************************************************
  2. *                texture.c
  3. *
  4. *  This module implements texturing functions such as noise, turbulence and
  5. *  texture transformation functions. The actual texture routines are in the
  6. *  files txtcolor.c, txtbump.c, txtmap.c, etc.
  7. *  The noise function used here is the one described by Ken Perlin in
  8. *  "Hypertexture", SIGGRAPH '89 Conference Proceedings page 253.
  9. *
  10. *  from Persistence of Vision Raytracer 
  11. *  Copyright 1992 Persistence of Vision Team
  12. *---------------------------------------------------------------------------
  13. *  Copying, distribution and legal info is in the file povlegal.doc which
  14. *  should be distributed with this file. If povlegal.doc is not available
  15. *  or for more info please contact:
  16. *
  17. *       Drew Wells [POV-Team Leader] 
  18. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  19. *       Phone: (213) 254-4041
  20. * 
  21. * This program is based on the popular DKB raytracer version 2.12.
  22. * DKBTrace was originally written by David K. Buck.
  23. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  24. *
  25. *****************************************************************************/
  26. /*
  27.    Some texture ideas garnered from SIGGRAPH '85 Volume 19 Number 3, 
  28.    "An Image Synthesizer" By Ken Perlin.
  29.    Further Ideas Garnered from "The RenderMan Companion" (Addison Wesley)
  30. */
  31.  
  32. #include "frame.h"
  33. #include "vector.h"
  34. #include "povproto.h"
  35. #include "texture.h"
  36.  
  37. DBL *sintab;
  38. DBL frequency[NUMBER_OF_WAVES];
  39. VECTOR Wave_Sources[NUMBER_OF_WAVES];
  40. DBL *RTable;
  41. short *hashTable;
  42.  
  43. unsigned short crctab[256] =
  44. {
  45.    0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
  46.    0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
  47.    0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
  48.    0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
  49.    0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
  50.    0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
  51.    0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
  52.    0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
  53.    0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
  54.    0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
  55.    0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
  56.    0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
  57.    0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
  58.    0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
  59.    0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
  60.    0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
  61.    0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
  62.    0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
  63.    0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
  64.    0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
  65.    0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
  66.    0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
  67.    0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
  68.    0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
  69.    0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
  70.    0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
  71.    0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
  72.    0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
  73.    0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
  74.    0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
  75.    0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
  76.    0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040
  77. };
  78.  
  79.  
  80.  
  81. void Compute_Colour (Colour, Colour_Map, value)
  82. COLOUR *Colour;
  83. COLOUR_MAP *Colour_Map;
  84. DBL value;
  85. {
  86.    register int i;
  87.    COLOUR_MAP_ENTRY *Ent;
  88.    register DBL fraction;
  89.  
  90.    if (value > 1.0)
  91.       value = 1.0;
  92.  
  93.    if (value < 0.0)
  94.       value = 0.0;
  95.  
  96.    for (i = 0, Ent = &(Colour_Map->Colour_Map_Entries[0]) ; i < Colour_Map -> Number_Of_Entries ; i++, Ent++)
  97.       if ((value >= Ent->start) && (value <= Ent->end))
  98.       {
  99.          fraction = (value - Ent->start) / (Ent->end - Ent->start);
  100.          Colour -> Red = Ent->Start_Colour.Red + fraction * (Ent->End_Colour.Red - Ent->Start_Colour.Red);
  101.          Colour -> Green = Ent->Start_Colour.Green + fraction * (Ent->End_Colour.Green - Ent->Start_Colour.Green);
  102.          Colour -> Blue = Ent->Start_Colour.Blue + fraction * (Ent->End_Colour.Blue - Ent->Start_Colour.Blue);
  103.          Colour -> Alpha = Ent->Start_Colour.Alpha + fraction * (Ent->End_Colour.Alpha - Ent->Start_Colour.Alpha);
  104.          return;
  105.       }
  106.  
  107.    Colour -> Red = 0.0;
  108.    Colour -> Green = 0.0;
  109.    Colour -> Blue = 0.0;
  110.    Colour -> Alpha = 0.0;
  111.    printf ("No colour for value: %g\n", value);
  112.    return;
  113. }
  114.  
  115. void Initialize_Noise ()
  116. {
  117.    register int i = 0;
  118.    VECTOR point;
  119.  
  120.    InitRTable();
  121.  
  122.    if ((sintab = (DBL *)malloc(SINTABSIZE * sizeof(DBL))) == NULL) {
  123.       printf("Cannot allocate memory for sine table\n");
  124.       exit(1);
  125.    }
  126.  
  127.    for (i = 0 ; i < SINTABSIZE ; i++)
  128.       sintab[i] = sin(i/(DBL)SINTABSIZE * (3.14159265359 * 2.0));
  129.  
  130.    for (i = 0 ; i < NUMBER_OF_WAVES ; i++)
  131.    {
  132.       DNoise (&point, (DBL) i, 0.0, 0.0);
  133.       VNormalize (Wave_Sources[i], point);
  134.       frequency[i] = (rand() & RNDMASK) / RNDDIVISOR + 0.01;
  135.    }
  136. }
  137.  
  138. void InitTextureTable()
  139. {
  140.    int i, j, temp;
  141.  
  142.    srand(0);
  143.  
  144.    if ((hashTable = (short int *) malloc(4096*sizeof(short int))) == NULL) {
  145.       printf("Cannot allocate memory for hash table\n");
  146.       exit(1);
  147.    }
  148.    for (i = 0; i < 4096; i++)
  149.       hashTable[i] = i;
  150.    for (i = 4095; i >= 0; i--) {
  151.       j = rand() % 4096;
  152.       temp = hashTable[i];
  153.       hashTable[i] = hashTable[j];
  154.       hashTable[j] = temp;
  155.    }
  156. }
  157.  
  158.  
  159. /* modified by AAC to work properly with little bitty integers (16 bits) */
  160.  
  161. void InitRTable()
  162. {
  163.    int i;
  164.    VECTOR rp;
  165.  
  166.    InitTextureTable();
  167.  
  168.    if ((RTable = (DBL *)malloc(MAXSIZE * sizeof(DBL))) == NULL) {
  169.       printf("Cannot allocate memory for RTable\n");
  170.       exit(1);
  171.    }
  172.  
  173.    for (i = 0; i < MAXSIZE; i++)
  174.    {
  175.       rp.x = rp.y = rp.z = (DBL)i;
  176.       RTable[i] = (unsigned int) R(&rp) * REALSCALE - 1.0;
  177.    }
  178. }
  179.  
  180.  
  181. int R(v)
  182. VECTOR *v;
  183. {
  184.    v->x *= .12345;
  185.    v->y *= .12345;
  186.    v->z *= .12345;
  187.  
  188.    return (Crc16((char *) v, sizeof(VECTOR)));
  189. }
  190.  
  191. /*
  192.  * Note that passing a VECTOR array to Crc16 and interpreting it as
  193.  * an array of chars means that machines with different floating-point
  194.  * representation schemes will evaluate Noise(point) differently.
  195.  */
  196.  
  197. int Crc16(buf, count)
  198. register char *buf;
  199. register int  count;
  200. {
  201.    register unsigned short crc = 0;
  202.  
  203.    while (count--)
  204.       crc = (crc >> 8) ^ crctab[ (unsigned char) (crc ^ *buf++) ];
  205.  
  206.    return ((int) crc);
  207. }
  208.  
  209.  
  210. /*
  211.     Robert's Skinner's Perlin-style "Noise" function - modified by AAC
  212.     to ensure uniformly distributed clamped values between 0 and 1.0...
  213. */
  214.  
  215. void setup_lattice(x, y, z, ix, iy, iz, jx, jy, jz, sx, sy, sz, tx, ty, tz)
  216. DBL *x, *y, *z, *sx, *sy, *sz, *tx, *ty, *tz;
  217. long *ix, *iy, *iz, *jx, *jy, *jz;
  218. {
  219.    /* ensures the values are positive. */
  220.    *x -= MINX;
  221.    *y -= MINY;
  222.    *z -= MINZ;
  223.  
  224.    /* its equivalent integer lattice point. */
  225.    *ix = (long)*x; *iy = (long)*y; *iz = (long)*z;
  226.    *jx = *ix + 1; *jy = *iy + 1; *jz = *iz + 1;
  227.  
  228.    *sx = SCURVE(*x - *ix); *sy = SCURVE(*y - *iy); *sz = SCURVE(*z - *iz);
  229.  
  230.    /* the complement values of sx,sy,sz */
  231.    *tx = 1.0 - *sx; *ty = 1.0 - *sy; *tz = 1.0 - *sz;
  232.    return;
  233. }
  234.  
  235.  
  236. DBL Noise(x, y, z)
  237. DBL x, y, z;
  238. {
  239.    long ix, iy, iz, jx, jy, jz;
  240.    DBL sx, sy, sz, tx, ty, tz;
  241.    DBL sum;
  242.    short m;
  243.  
  244.  
  245.    Calls_To_Noise++;
  246.  
  247.    setup_lattice(&x, &y, &z, &ix, &iy, &iz, &jx, &jy, &jz, &sx, &sy, &sz, &tx, &ty, &tz);
  248.  
  249.    /*
  250.     *  interpolate!
  251.     */
  252.    m = Hash3d( ix, iy, iz ) & 0xFF;
  253.    sum = INCRSUM(m,(tx*ty*tz),(x-ix),(y-iy),(z-iz));
  254.  
  255.    m = Hash3d( jx, iy, iz ) & 0xFF;
  256.    sum += INCRSUM(m,(sx*ty*tz),(x-jx),(y-iy),(z-iz));
  257.  
  258.    m = Hash3d( ix, jy, iz ) & 0xFF;
  259.    sum += INCRSUM(m,(tx*sy*tz),(x-ix),(y-jy),(z-iz));
  260.  
  261.    m = Hash3d( jx, jy, iz ) & 0xFF;
  262.    sum += INCRSUM(m,(sx*sy*tz),(x-jx),(y-jy),(z-iz));
  263.  
  264.    m = Hash3d( ix, iy, jz ) & 0xFF;
  265.    sum += INCRSUM(m,(tx*ty*sz),(x-ix),(y-iy),(z-jz));
  266.  
  267.    m = Hash3d( jx, iy, jz ) & 0xFF;
  268.    sum += INCRSUM(m,(sx*ty*sz),(x-jx),(y-iy),(z-jz));
  269.  
  270.    m = Hash3d( ix, jy, jz ) & 0xFF;
  271.    sum += INCRSUM(m,(tx*sy*sz),(x-ix),(y-jy),(z-jz));
  272.  
  273.    m = Hash3d( jx, jy, jz ) & 0xFF;
  274.    sum += INCRSUM(m,(sx*sy*sz),(x-jx),(y-jy),(z-jz));
  275.  
  276.    sum = sum + 0.5;          /* range at this point -0.5 - 0.5... */
  277.  
  278.    if (sum < 0.0)
  279.       sum = 0.0;
  280.    if (sum > 1.0)
  281.       sum = 1.0;
  282.  
  283.    return (sum);
  284. }
  285.  
  286.  
  287. /*
  288.        Vector-valued version of "Noise"
  289. */
  290.  
  291. void DNoise(result, x, y, z)
  292. VECTOR *result;
  293. DBL x, y, z;
  294. {
  295.    long ix, iy, iz, jx, jy, jz;
  296.    DBL px, py, pz, s;
  297.    DBL sx, sy, sz, tx, ty, tz;
  298.    short m;
  299.  
  300.    Calls_To_DNoise++;
  301.  
  302.    setup_lattice(&x, &y, &z, &ix, &iy, &iz, &jx, &jy, &jz, &sx, &sy, &sz, &tx, &ty, &tz);
  303.  
  304.    /*
  305.     *  interpolate!
  306.     */
  307.    m = Hash3d( ix, iy, iz ) & 0xFF;
  308.    px = x-ix;  py = y-iy;  pz = z-iz;
  309.    s = tx*ty*tz;
  310.    result->x = INCRSUM(m,s,px,py,pz);
  311.    result->y = INCRSUM(m+4,s,px,py,pz);
  312.    result->z = INCRSUM(m+8,s,px,py,pz);
  313.  
  314.    m = Hash3d( jx, iy, iz ) & 0xFF;
  315.    px = x-jx;
  316.    s = sx*ty*tz;
  317.    result->x += INCRSUM(m,s,px,py,pz);
  318.    result->y += INCRSUM(m+4,s,px,py,pz);
  319.    result->z += INCRSUM(m+8,s,px,py,pz);
  320.  
  321.    m = Hash3d( jx, jy, iz ) & 0xFF;
  322.    py = y-jy;
  323.    s = sx*sy*tz;
  324.    result->x += INCRSUM(m,s,px,py,pz);
  325.    result->y += INCRSUM(m+4,s,px,py,pz);
  326.    result->z += INCRSUM(m+8,s,px,py,pz);
  327.  
  328.    m = Hash3d( ix, jy, iz ) & 0xFF;
  329.    px = x-ix;
  330.    s = tx*sy*tz;
  331.    result->x += INCRSUM(m,s,px,py,pz);
  332.    result->y += INCRSUM(m+4,s,px,py,pz);
  333.    result->z += INCRSUM(m+8,s,px,py,pz);
  334.  
  335.    m = Hash3d( ix, jy, jz ) & 0xFF;
  336.    pz = z-jz;
  337.    s = tx*sy*sz;
  338.    result->x += INCRSUM(m,s,px,py,pz);
  339.    result->y += INCRSUM(m+4,s,px,py,pz);
  340.    result->z += INCRSUM(m+8,s,px,py,pz);
  341.  
  342.    m = Hash3d( jx, jy, jz ) & 0xFF;
  343.    px = x-jx;
  344.    s = sx*sy*sz;
  345.    result->x += INCRSUM(m,s,px,py,pz);
  346.    result->y += INCRSUM(m+4,s,px,py,pz);
  347.    result->z += INCRSUM(m+8,s,px,py,pz);
  348.  
  349.    m = Hash3d( jx, iy, jz ) & 0xFF;
  350.    py = y-iy;
  351.    s = sx*ty*sz;
  352.    result->x += INCRSUM(m,s,px,py,pz);
  353.    result->y += INCRSUM(m+4,s,px,py,pz);
  354.    result->z += INCRSUM(m+8,s,px,py,pz);
  355.  
  356.    m = Hash3d( ix, iy, jz ) & 0xFF;
  357.    px = x-ix;
  358.    s = tx*ty*sz;
  359.    result->x += INCRSUM(m,s,px,py,pz);
  360.    result->y += INCRSUM(m+4,s,px,py,pz);
  361.    result->z += INCRSUM(m+8,s,px,py,pz);
  362. }
  363.  
  364. DBL Turbulence (x, y, z, octaves)
  365. DBL x, y, z;
  366. int octaves;
  367. {
  368.    int i;                               /* added -dmf */
  369.    register DBL t = 0.0;
  370.    register DBL scale, value;
  371.  
  372.    for (i=0, scale = 1; i < octaves; i++, scale *= 0.5) {
  373.       value = Noise (x/scale, y/scale, z/scale);
  374.       t += FABS (value) * scale;
  375.    }
  376.    return (t);
  377. }
  378.  
  379. void DTurbulence (result, x, y, z,octaves)
  380. VECTOR *result;
  381. DBL x, y, z;
  382. int octaves;
  383. {
  384.    int i;                               /* added -dmf */
  385.    register DBL scale;
  386.    VECTOR value;
  387.  
  388.    result -> x = 0.0;
  389.    result -> y = 0.0;
  390.    result -> z = 0.0;
  391.  
  392.    value.x = value.y = value.z = 0.0;
  393.  
  394.    for (i=0, scale = 1; i < octaves ; i++, scale *= 0.5) {
  395.       DNoise(&value, x/scale, y/scale, z/scale);
  396.       result -> x += value.x * scale;
  397.       result -> y += value.y * scale;
  398.       result -> z += value.z * scale;
  399.    }
  400. }
  401.  
  402. DBL cycloidal (value)
  403. DBL value;
  404. {
  405.    register int indx;
  406.  
  407.    if (value >= 0.0)
  408.    {
  409.       indx = (int)((value - floor (value)) * SINTABSIZE);
  410.       return (sintab [indx]);
  411.    }
  412.    else
  413.    {
  414.       indx = (int)((0.0 - (value + floor (0.0 - value))) * SINTABSIZE);
  415.       return (0.0 - sintab [indx]);
  416.    }
  417. }
  418.  
  419.  
  420. DBL Triangle_Wave (value)
  421. DBL value;
  422. {
  423.    register DBL offset,temp1;
  424.  
  425.    if (value >= 0.0) offset = value - floor(value);
  426.    else {
  427.       temp1 = -1.0 - floor(fabs(value));
  428.       offset = value - temp1;
  429.    }
  430.    if (offset >= 0.5) return (2.0 * (1.0 - offset));
  431.    else return (2.0 * offset);
  432. }
  433.  
  434.    void Translate_Texture (Texture_Ptr, Vector)
  435.       TEXTURE **Texture_Ptr;
  436. VECTOR *Vector;
  437. {
  438.    TEXTURE *Texture = *Texture_Ptr;
  439.    TRANSFORMATION Transformation;
  440.  
  441.    while (Texture != NULL) {
  442.       if (((Texture->Texture_Number != NO_TEXTURE)
  443.          && (Texture->Texture_Number != COLOUR_TEXTURE))
  444.          || (Texture->Bump_Number != NO_BUMPS)) {
  445.  
  446.          if (Texture->Constant_Flag) {
  447.             Texture = Copy_Texture (Texture);
  448.             *Texture_Ptr = Texture;
  449.             Texture->Constant_Flag = FALSE;
  450.          }
  451.  
  452.          if (!Texture -> Texture_Transformation)
  453.             Texture -> Texture_Transformation = Get_Transformation ();
  454.          Get_Translation_Transformation (&Transformation, Vector);
  455.          Compose_Transformations (Texture -> Texture_Transformation,
  456.             &Transformation);
  457.          if (Texture->Texture_Number == CHECKER_TEXTURE_TEXTURE) {
  458.             Translate_Texture ((TEXTURE **) &Texture->Colour1, Vector);
  459.             Translate_Texture ((TEXTURE **) &Texture->Colour2, Vector);
  460.          }
  461.       }
  462.       Texture_Ptr = &Texture->Next_Texture;
  463.       Texture = Texture->Next_Texture;
  464.    }
  465. }
  466.  
  467. void Rotate_Texture (Texture_Ptr, Vector)
  468. TEXTURE **Texture_Ptr;
  469. VECTOR *Vector;
  470. {
  471.    TEXTURE *Texture = *Texture_Ptr;
  472.    TRANSFORMATION Transformation;
  473.  
  474.    while (Texture != NULL) {
  475.       if (((Texture->Texture_Number != NO_TEXTURE)
  476.          && (Texture->Texture_Number != COLOUR_TEXTURE))
  477.          || (Texture->Bump_Number != NO_BUMPS)) {
  478.  
  479.          if (Texture->Constant_Flag) {
  480.             Texture = Copy_Texture (Texture);
  481.             *Texture_Ptr = Texture;
  482.             Texture->Constant_Flag = FALSE;
  483.          }
  484.  
  485.          if (!Texture -> Texture_Transformation)
  486.             Texture -> Texture_Transformation = Get_Transformation ();
  487.          Get_Rotation_Transformation (&Transformation, Vector);
  488.          Compose_Transformations (Texture -> Texture_Transformation,
  489.             &Transformation);
  490.          if (Texture->Texture_Number == CHECKER_TEXTURE_TEXTURE) {
  491.             Rotate_Texture ((TEXTURE **) &Texture->Colour1, Vector);
  492.             Rotate_Texture ((TEXTURE **) &Texture->Colour2, Vector);
  493.          }
  494.       }
  495.       Texture_Ptr = &Texture->Next_Texture;
  496.       Texture = Texture->Next_Texture;
  497.    }
  498. }
  499.  
  500. void Scale_Texture (Texture_Ptr, Vector)
  501. TEXTURE **Texture_Ptr;
  502. VECTOR *Vector;
  503. {
  504.    TEXTURE *Texture = *Texture_Ptr;
  505.    TRANSFORMATION Transformation;
  506.  
  507.    while (Texture != NULL) {
  508.       if (((Texture->Texture_Number != NO_TEXTURE)
  509.          && (Texture->Texture_Number != COLOUR_TEXTURE))
  510.          || (Texture->Bump_Number != NO_BUMPS)) {
  511.  
  512.          if (Texture->Constant_Flag) {
  513.             Texture = Copy_Texture (Texture);
  514.             *Texture_Ptr = Texture;
  515.             Texture->Constant_Flag = FALSE;
  516.          }
  517.  
  518.          if (!Texture -> Texture_Transformation)
  519.             Texture -> Texture_Transformation = Get_Transformation ();
  520.          Get_Scaling_Transformation (&Transformation, Vector);
  521.          Compose_Transformations (Texture -> Texture_Transformation,
  522.             &Transformation);
  523.  
  524.          if (Texture->Texture_Number == CHECKER_TEXTURE_TEXTURE) {
  525.             Scale_Texture ((TEXTURE **) &Texture->Colour1, Vector);
  526.             Scale_Texture ((TEXTURE **) &Texture->Colour2, Vector);
  527.          }
  528.       }
  529.       Texture_Ptr = &Texture->Next_Texture;
  530.       Texture = Texture->Next_Texture;
  531.    }
  532. }
  533.