home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rsg_ray / tex.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-12  |  3.4 KB  |  188 lines
  1. /*
  2.  
  3. TEX.C  Handle 3D texture map data
  4.  
  5. */
  6.  
  7. /*...sincludes:0:*/
  8. #include <stdio.h>
  9. #include <ctype.h>
  10. #include <stdlib.h>
  11. #include <stddef.h>
  12. #include <stdarg.h>
  13. #include <string.h>
  14. #include <memory.h>
  15. #include <malloc.h>
  16. #ifdef AIX
  17. #include <unistd.h>
  18. #else
  19. #include <io.h>
  20. #endif
  21. #include <fcntl.h>
  22. #include <sys/types.h>
  23. #include <sys/stat.h>
  24. #include "standard.h"
  25.  
  26. #ifndef O_BINARY
  27. #define    O_BINARY 0
  28. #endif
  29. /*...e*/
  30.  
  31. typedef struct { byte b, g, r, dummy; } PAL;
  32.  
  33. typedef struct
  34.     {
  35.     dword w, h, d, bpv, stride;
  36.     PAL pals [0x100];
  37.     byte *data;
  38.     int ref_count;
  39.     } TEX;
  40.  
  41. #define    TEX_MAGIC    ((dword) 0x1a584554)
  42.  
  43. /*...sread_tex:0:*/
  44. /*...sread_dword:0:*/
  45. static dword read_dword(int fd)
  46.     {
  47.     byte b [4];
  48.  
  49.     read(fd, b, 4);
  50.     return (  (dword) b [0]        +
  51.          ((dword) b [1] <<  8) +
  52.          ((dword) b [2] << 16) +
  53.          ((dword) b [3] << 24) );
  54.     }
  55. /*...e*/
  56.  
  57. TEX *read_tex(char *fn)
  58.     {
  59.     TEX *tex;
  60.     int fd, i;
  61.     dword bytes;
  62.  
  63.     if ( (fd = open(fn, O_RDONLY | O_BINARY)) == -1 )
  64.         return ( NULL );
  65.  
  66.     if ( (tex = malloc(sizeof(TEX))) == NULL )
  67.         { close(fd); return ( NULL ); }
  68.  
  69.     if ( read_dword(fd) != TEX_MAGIC )
  70.         { free(tex); close(fd); return ( NULL ); }
  71.  
  72.     tex -> w   = read_dword(fd);
  73.     tex -> h   = read_dword(fd);
  74.     tex -> d   = read_dword(fd);
  75.     tex -> bpv = read_dword(fd);
  76.  
  77.     if ( tex -> bpv != 1 && tex -> bpv != 4 && tex -> bpv != 8 && tex -> bpv != 24 )
  78.         { free(tex); close(fd); return ( NULL ); }
  79.  
  80.     for ( i = 0; i < ((1 << tex -> bpv) & 0x1ff); i++ )
  81.         if ( read(fd, (char *) &(tex -> pals [i]), sizeof(PAL)) != sizeof(PAL) )
  82.             { free(tex); close(fd); return ( NULL ); }
  83.  
  84.     tex -> stride = ((tex -> w * tex -> bpv + 31)/32)*4;
  85.     bytes = tex -> stride * tex -> h * tex -> d;
  86.  
  87.     if ( (tex -> data = malloc((size_t) bytes)) == NULL )
  88.         { free(tex); close(fd); return ( NULL ); }
  89.  
  90.     if ( read(fd, tex -> data, (unsigned int) bytes) != (int) bytes )
  91.         { free(tex -> data); free(tex); close(fd); return ( NULL ); }
  92.  
  93.     close(fd);
  94.  
  95.     tex -> ref_count = 1;
  96.  
  97.     return ( tex );
  98.     }
  99. /*...e*/
  100. /*...scopy_tex:0:*/
  101. TEX *copy_tex(TEX *tex)
  102.     {
  103.     (tex -> ref_count)++;
  104.     return ( tex );
  105.     }
  106. /*...e*/
  107. /*...sdestroy_tex:0:*/
  108. void destroy_tex(TEX *tex)
  109.     {
  110.     if ( --(tex -> ref_count) == 0 )
  111.         {
  112.         free(tex -> data);
  113.         free(tex);
  114.         }
  115.     }
  116. /*...e*/
  117.  
  118. /*...sget_voxel_tex:0:*/
  119. void get_voxel_tex(
  120.     TEX *tex,
  121.     int x, int y, int z,
  122.     byte *r, byte *g, byte *b
  123.     )
  124.     {
  125.     byte inx, *data = tex -> data + (z * tex -> h + y) * tex -> stride;
  126.  
  127.     switch ( tex -> bpv )
  128.         {
  129. /*...s1:16:*/
  130. case 1:
  131.     inx = data [x >> 3];
  132.     inx >>= ( 7 - (x & 7) );
  133.     inx &= 1;    
  134.     *b = tex -> pals [inx].b;
  135.     *g = tex -> pals [inx].g;
  136.     *r = tex -> pals [inx].r;
  137.     break;
  138. /*...e*/
  139. /*...s4:16:*/
  140. case 4:
  141.     inx = data [x >> 1];
  142.     if ( x & 1 )
  143.         inx &= 0x0f;
  144.     else
  145.         inx >>= 4;
  146.     *b = tex -> pals [inx].b;
  147.     *g = tex -> pals [inx].g;
  148.     *r = tex -> pals [inx].r;
  149.     break;
  150. /*...e*/
  151. /*...s8:16:*/
  152. case 8:
  153.     inx = data [x];
  154.     *b = tex -> pals [inx].b;
  155.     *g = tex -> pals [inx].g;
  156.     *r = tex -> pals [inx].r;
  157.     break;
  158. /*...e*/
  159. /*...s24:16:*/
  160. case 24:
  161.     data += (x * 3);
  162.     *b = *data++;
  163.     *g = *data++;
  164.     *r = *data;
  165.     break;
  166. /*...e*/
  167.         }
  168.     }
  169. /*...e*/
  170. /*...swidth_tex:0:*/
  171. int width_tex(TEX *tex)
  172.     {
  173.     return ( (int) tex -> w );
  174.     }
  175. /*...e*/
  176. /*...sheight_tex:0:*/
  177. int height_tex(TEX *tex)
  178.     {
  179.     return ( (int) tex -> h );
  180.     }
  181. /*...e*/
  182. /*...sdepth_tex:0:*/
  183. int depth_tex(TEX *tex)
  184.     {
  185.     return ( (int) tex -> d );
  186.     }
  187. /*...e*/
  188.