开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
texture.cpp
资源名称：3D_OnlineGame_Humen.rar　[点击查看]
上传用户：garry_shen
上传日期：2015-04-15
资源大小：45647k
文件大小：16k
源码类别：

游戏引擎

开发平台：

Visual C++

texture.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "XMudClient.h"
  3. #include "d3dappi.h"
  5. #define MAGICBYTES 2
  8. void D3DAppIAddPathList(const char *path);
  9. void D3DAppIInitialisePathList();
  10. FILE * D3DAppIFindFile(const char *name, const char *mode);
  11. BOOL loadPPMHeader(FILE *fp, DWORD *width, DWORD *height, int *maxgrey);
  13. BOOL D3DAppILoadTextureSurf(int n, BOOL* bInVideo)
  14. {
  15.   DDSURFACEDESC ddsd;
  16.   LPDIRECTDRAWSURFACE lpSrcTextureSurf = NULL;
  17.   LPDIRECT3DTEXTURE2 lpSrcTexture = NULL;
  18.   LPDIRECTDRAWPALETTE lpDstPalette = NULL;
  19.   PALETTEENTRY ppe[256];
  20.   DWORD pcaps;
  21.   RELEASE(d3dappi.lpTextureSurf[n]);
  22.   lpSrcTextureSurf = D3DAppILoadSurface(d3dappi.lpDD, d3dappi.ImageFile[n],
  23.     &d3dappi.ThisTextureFormat.ddsd,
  24.     DDSCAPS_SYSTEMMEMORY);
  25.   if (!lpSrcTextureSurf)
  26.     goto exit_with_error;
  27.   LastError = lpSrcTextureSurf->QueryInterface(IID_IDirect3DTexture2,
  28.     (LPVOID*)&lpSrcTexture);
  29.   if (LastError != DD_OK)
  30.   {
  31.     D3DAppISetErrorString("Failed to obtain D3D texture interface for a source texture.n%s", D3DAppErrorToString(LastError));
  32.     goto exit_with_error;
  33.   }
  34.   LastError = D3DAppIGetSurfDesc(&ddsd, lpSrcTextureSurf);
  35.   if (LastError != DD_OK) {
  36.     D3DAppISetErrorString("Could not get the surface description of the source texture.n%s",
  37.       D3DAppErrorToString(LastError));
  38.     goto exit_with_error;
  39.   }
  40.   ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  41.   ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_ALLOCONLOAD;
  42.   if (!d3dappi.ThisDriver.bIsHardware)
  43.     ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  44.   LastError = D3DAppICreateSurface(&ddsd, &d3dappi.lpTextureSurf[n]);
  45.   if (LastError != DD_OK) {
  46.     D3DAppISetErrorString("Could not create the destination texture surface.n%s",
  47.       D3DAppErrorToString(LastError));
  48.     goto exit_with_error;
  49.   }
  50.   if (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
  51.     pcaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
  52.   } else if (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4) {
  53.     pcaps = DDPCAPS_4BIT;
  54.   } else {
  55.     pcaps = 0;
  56.   }
  57.   if (pcaps) {
  58.     memset(ppe, 0, sizeof(PALETTEENTRY) * 256);
  59.     LastError = d3dappi.lpDD->CreatePalette(pcaps,
  60.       ppe, &lpDstPalette, NULL);
  61.     if (LastError != DD_OK)
  62.     {
  63.       D3DAppISetErrorString("Failed to create a palette for the destination texture.n%s",
  64.         D3DAppErrorToString(LastError));
  65.       goto exit_with_error;
  66.     }
  67.     LastError = d3dappi.lpTextureSurf[n]->SetPalette(lpDstPalette);
  68.     if (LastError != DD_OK)
  69.     {
  70.       D3DAppISetErrorString("Failed to set the destination texture's palette.n%s",
  71.         D3DAppErrorToString(LastError));
  72.       goto exit_with_error;
  73.     }
  74.     lpDstPalette->Release( );
  75.   }
  77.   LastError = d3dappi.lpTextureSurf[n]->QueryInterface(IID_IDirect3DTexture2,
  78.     (LPVOID*)&d3dappi.lpTexture[n]);
  79.   if (LastError != DD_OK){
  80.     D3DAppISetErrorString("Failed to obtain D3D texture interface for a destination texture.n%s",
  81.       D3DAppErrorToString(LastError));
  82.     goto exit_with_error;
  83.   }
  84.   LastError = d3dappi.lpTexture[n]->Load(lpSrcTexture);
  85.   if (LastError != DD_OK)
  86.   {
  87.     D3DAppISetErrorString("Could not load a source texture into a destination texture.n%s",
  88.       D3DAppErrorToString(LastError));
  89.     goto exit_with_error;
  90.   }
  92.   RELEASE(lpSrcTexture);
  93.   RELEASE(lpSrcTextureSurf);
  95.   LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpTextureSurf[n]);
  96.   if (LastError != DD_OK){
  97.     D3DAppISetErrorString("Could not get the surface description of the loaded texture surface.n%s",
  98.       D3DAppErrorToString(LastError));
  99.     goto exit_with_error;
  100.   }
  101.   if (ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY)
  102.     *bInVideo = TRUE;
  103.   else
  104.     *bInVideo = FALSE;
  105.   
  106.   
  107.   return TRUE;
  108.   
  109. exit_with_error:
  110.   RELEASE(lpSrcTexture);
  111.   RELEASE(lpSrcTextureSurf);
  112.   RELEASE(lpDstPalette);
  113.   RELEASE(d3dappi.lpTexture[n]);
  114.   RELEASE(d3dappi.lpTextureSurf[n]);
  115.   return FALSE;
  116. }
  118. BOOL D3DAppIReloadTextureSurf(int n)
  119. {
  120.   LPDIRECTDRAWSURFACE lpSrcTextureSurf = NULL;
  121.   LPDIRECT3DTEXTURE2 lpSrcTexture = NULL;
  122.   
  123.   lpSrcTextureSurf = D3DAppILoadSurface(d3dappi.lpDD, d3dappi.ImageFile[n],
  124.     &d3dappi.ThisTextureFormat.ddsd,
  125.     DDSCAPS_SYSTEMMEMORY);
  126.   if (!lpSrcTextureSurf)
  127.     goto exit_with_error;
  128.   LastError = lpSrcTextureSurf->QueryInterface(IID_IDirect3DTexture2,
  129.     (LPVOID*)&lpSrcTexture);
  130.   if (LastError != DD_OK) {
  131.     D3DAppISetErrorString("Failed to obtain D3D texture interface for a source texture.n%s", D3DAppErrorToString(LastError));
  132.     goto exit_with_error;
  133.   }
  135.   LastError = d3dappi.lpTexture[n]->Load(lpSrcTexture);
  136.   if (LastError != DD_OK)
  137.   {
  138.     D3DAppISetErrorString("Could not load a source texture into a destination texture.n%s",
  139.       D3DAppErrorToString(LastError));
  140.     goto exit_with_error;
  141.   }
  143.   RELEASE(lpSrcTexture);
  144.   RELEASE(lpSrcTextureSurf);
  145.   
  146.   return TRUE;
  147.   
  148. exit_with_error:
  149.   RELEASE(lpSrcTexture);
  150.   RELEASE(lpSrcTextureSurf);
  151.   return FALSE;
  152. }
  154. BOOL D3DAppIGetTextureHandle(int n)
  155. {
  156.   LastError = d3dappi.lpTexture[n]->GetHandle(d3dappi.lpD3DDevice, &MasterTextureHandle[n]);
  157.   if (LastError != DD_OK) {
  158.     D3DAppISetErrorString("Could not get a handle to loaded texture %i.n%s",
  159.       n, D3DAppErrorToString(LastError));
  160.     goto exit_with_error;
  161.   }
  163.   if (!d3dappi.bTexturesDisabled){
  164.     d3dappi.TextureHandle[n] = MasterTextureHandle[n];
  165.   }else{
  166.     d3dappi.TextureHandle[n] = 0;
  167.   }
  168.   return TRUE;
  169. exit_with_error:
  170.   MasterTextureHandle[n] = 0;
  171.   d3dappi.TextureHandle[n] = 0;
  172.   return FALSE;
  173. }
  175. void
  176. D3DAppIReleaseTexture(int n)
  177. {
  178.   RELEASE(d3dappi.lpTexture[n]);
  179.   RELEASE(d3dappi.lpTextureSurf[n]);
  180.   MasterTextureHandle[n] = 0;
  181.   d3dappi.TextureHandle[n] = 0;
  182. }
  184. void
  185. D3DAppIReleaseAllTextures(void)
  186. {
  187.   int i;
  188.   for (i = 0; i < d3dappi.NumTextures; i++) {
  189.     D3DAppIReleaseTexture(i);
  190.   }
  191. }
  193. BOOL D3DAppILoadAllTextures(void)
  194. {
  195.   int i;
  196.   if (d3dappi.ThisDriver.bDoesTextures)
  197.   {
  198.     d3dappi.NumUsableTextures = 0;
  199.     for (i = 0; i < d3dappi.NumTextures; i++)
  200.     {
  201.       BOOL bInVideo;
  202.       ATTEMPT(D3DAppILoadTextureSurf(i, &bInVideo));
  203.       if (!bInVideo && d3dappi.ThisDriver.bIsHardware)
  204.       {
  205.         D3DAppIReleaseTexture(i);
  206.         break;
  207.       }
  208.       else
  209.       {
  210.         ++d3dappi.NumUsableTextures;
  211.       }
  212.     }
  213.     for (i = 0; i < d3dappi.NumUsableTextures; i++)
  214.     {
  215.       ATTEMPT(D3DAppIGetTextureHandle(i));
  216.     }
  217.   }
  218.   else
  219.   {
  220.     d3dappi.NumUsableTextures = 0;
  221.   }
  222.   return TRUE;
  223.   
  224. exit_with_error:
  225.   for (i = 0; i < d3dappi.NumTextures; i++)
  226.   {
  227.     D3DAppIReleaseTexture(i);
  228.   }
  229.   return FALSE;
  230. }
  231. LPDIRECTDRAWSURFACE D3DAppILoadSurface(LPDIRECTDRAW lpDD, LPCSTR lpName,
  232.                                        LPDDSURFACEDESC lpFormat, DWORD memoryflag)
  233. {
  234.   LPDIRECTDRAWSURFACE lpDDS;
  235.   DDSURFACEDESC ddsd, format;
  236.   D3DCOLOR colors[256];
  237.   D3DCOLOR c;
  238.   DWORD dwWidth, dwHeight;
  239.   int i, j;
  240.   FILE *fp;
  241.   char *lpC;
  242.   LPDIRECTDRAWPALETTE lpDDPal;
  243.   PALETTEENTRY ppe[256];
  244.   int psize;
  245.   DWORD pcaps;
  246.   int color_count;
  247.   BOOL bQuant = FALSE;
  248.   HRESULT ddrval;
  250.   fp = D3DAppIFindFile(lpName, "rb");
  251.   if (fp == NULL)
  252.   {
  253.     D3DAppISetErrorString("Cannot find %s.n", lpName);
  254.     return NULL;
  255.   }
  257.   if (!loadPPMHeader(fp, &dwWidth, &dwHeight, &i))
  258.   {
  259.     fclose(fp);
  260.     D3DAppISetErrorString("Could not load or parse PPM header in %s.n", lpName);
  261.     return NULL;
  262.   }
  264.   memcpy(&format, lpFormat, sizeof(DDSURFACEDESC));
  265.   if (format.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8)
  266.   {
  267.     bQuant = TRUE;
  268.     psize = 256;
  269.     pcaps = DDPCAPS_8BIT | DDPCAPS_ALLOW256;
  270.   } else if (format.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED4)
  271.   {
  272.     bQuant = TRUE;
  273.     psize = 16;
  274.     pcaps = DDPCAPS_4BIT;
  275.   }
  276.   memcpy(&ddsd, &format, sizeof(ddsd));
  277.   ddsd.dwSize = sizeof(ddsd);
  278.   ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  279.   ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | memoryflag;
  280.   ddsd.dwHeight = dwHeight;
  281.   ddsd.dwWidth = dwWidth;
  282.   
  283.   ddrval = lpDD->CreateSurface(&ddsd, &lpDDS, NULL);
  284.   if (ddrval != DD_OK) {
  285.     D3DAppISetErrorString("CreateSurface for texture failed (loadtex).n%s",
  286.       D3DAppErrorToString(ddrval));
  287.     return NULL;
  288.   }
  290.   memset(&ddsd, 0, sizeof(ddsd));
  291.   ddsd.dwSize = sizeof(ddsd);
  292.   ddrval = lpDDS->Lock(NULL, &ddsd, 0, NULL);
  293.   if (ddrval != DD_OK)
  294.   {
  295.     lpDDS->Release( );
  296.     D3DAppISetErrorString("Lock failed while loading surface (loadtex).n%s",
  297.       D3DAppErrorToString(ddrval));
  298.     return NULL;
  299.   }
  301.   if (!bQuant)
  302.   {
  304.     unsigned long* lpLP;
  305.     unsigned short* lpSP;
  306.     unsigned char* lpCP;
  307.     unsigned long m;
  308.     int s;
  309.     int red_shift, red_scale;
  310.     int green_shift, green_scale;
  311.     int blue_shift, blue_scale;
  313.     for (s = 0, m = format.ddpfPixelFormat.dwRBitMask; !(m & 1);
  314.     s++, m >>= 1);
  315.     red_shift = s;
  316.     red_scale = 255 / (format.ddpfPixelFormat.dwRBitMask >> s);
  317.     for (s = 0, m = format.ddpfPixelFormat.dwGBitMask; !(m & 1);
  318.     s++, m >>= 1);
  319.     green_shift = s;
  320.     green_scale = 255 / (format.ddpfPixelFormat.dwGBitMask >> s);
  321.     for (s = 0, m = format.ddpfPixelFormat.dwBBitMask; !(m & 1);
  322.     s++, m >>= 1);
  323.     blue_shift = s;
  324.     blue_scale = 255 / (format.ddpfPixelFormat.dwBBitMask >> s);
  326.     switch (format.ddpfPixelFormat.dwRGBBitCount)
  327.     {
  328.     case 32 :
  329.       for (j = 0; j < (int)dwHeight; j++) 
  330.       {
  332.         lpLP = (unsigned long*)(((char*)ddsd.lpSurface) +
  333.           ddsd.lPitch * j);
  334.         for (i = 0; i < (int)dwWidth; i++)
  335.         {
  336.           int r, g, b;
  338.           r = getc(fp) / red_scale;
  339.           g = getc(fp) / green_scale;
  340.           b = getc(fp) / blue_scale;
  341.           *lpLP = (r << red_shift) | (g << green_shift) |
  342.             (b << blue_shift);
  343.           lpLP++;
  344.         }
  345.       }
  346.       break;
  347.     case 16 :
  348.       for (j = 0; j < (int)dwHeight; j++) {
  349.         lpSP = (unsigned short*)(((char*)ddsd.lpSurface) +
  350.           ddsd.lPitch * j);
  351.         for (i = 0; i < (int)dwWidth; i++) {
  352.           int r, g, b;
  353.           r = getc(fp) / red_scale;
  354.           g = getc(fp) / green_scale;
  355.           b = getc(fp) / blue_scale;
  356.           *lpSP = (r << red_shift) | (g << green_shift) |
  357.             (b << blue_shift);
  358.           lpSP++;
  359.         }
  360.       }
  361.       break;
  362.     case 8:
  363.       for (j = 0; j < (int)dwHeight; j++) {
  364.         lpCP = (unsigned char*)(((char*)ddsd.lpSurface) +
  365.           ddsd.lPitch * j);
  366.         for (i = 0; i < (int)dwWidth; i++) {
  367.           int r, g, b;
  368.           r = getc(fp) / red_scale;
  369.           g = getc(fp) / green_scale;
  370.           b = getc(fp) / blue_scale;
  371.           *lpCP = (r << red_shift) | (g << green_shift) |
  372.             (b << blue_shift);
  373.           lpCP++;
  374.         }
  375.       }
  376.       break;
  377.     default:
  379.       lpDDS->Unlock(NULL);
  380.       fclose(fp);
  381.       lpDDS->Release( );
  382.       D3DAppISetErrorString("Unknown pixel format (loadtex).");
  383.       return NULL;
  384.     }
  386.     lpDDS->Unlock( NULL);
  387.     fclose(fp);
  388.     return (lpDDS);
  389.     }
  391.     color_count = 0;
  392.     for (j = 0; j < (int)dwHeight; j++)    {
  393.       lpC = ((char*)ddsd.lpSurface) + ddsd.lPitch * j;
  394.       for (i = 0; i < (int)dwWidth; i++)
  395.       {
  396.         int r, g, b, k;
  397.         r = getc(fp);
  398.         g = getc(fp);
  399.         b = getc(fp);
  400.         c = RGB_MAKE(r, g, b);
  401.         for (k = 0; k < color_count; k++)
  402.           if (c == colors[k]) break;
  403.           if (k == color_count) {
  404.             color_count++;
  405.             if (color_count > psize) {
  406.               color_count--;
  407.               k = color_count - 1;
  408.             }
  409.             colors[k] = c;
  410.           }
  411.           if (psize == 16) {
  412.             if ((i & 1) == 0)
  413.               *lpC = k & 0xf;
  414.             else {
  415.               *lpC |= (k & 0xf) << 4;
  416.               lpC++;
  417.             }
  418.           } else {
  419.             *lpC = (char)k;
  420.             lpC++;
  421.           }
  422.       }
  423.     }
  424.     fclose(fp);
  425.     lpDDS->Unlock(NULL);
  426.     
  427.     if (color_count > psize) {
  428.       lpDDS->Unlock(NULL);
  429.       lpDDS->Release( );
  430.       D3DAppISetErrorString("Palette burst. (loadtex).n");
  431.       return (NULL);
  432.     }
  433.     
  434.     memset(ppe, 0, sizeof(PALETTEENTRY) * 256);
  435.     for (i = 0; i < color_count; i++) {
  436.       ppe[i].peRed = (unsigned char)RGB_GETRED(colors[i]);
  437.       ppe[i].peGreen = (unsigned char)RGB_GETGREEN(colors[i]);
  438.       ppe[i].peBlue = (unsigned char)RGB_GETBLUE(colors[i]);
  439.     }
  440.     for (; i < 256; i++)
  441.       ppe[i].peFlags = D3DPAL_RESERVED;
  442.     ddrval = lpDD->CreatePalette(DDPCAPS_INITIALIZE | pcaps,
  443.       ppe, &lpDDPal, NULL);
  444.     if (ddrval != DD_OK){
  445.       lpDDS->Release( );
  446.       D3DAppISetErrorString("Create palette failed while loading surface (loadtex).n%s",
  447.         D3DAppErrorToString(ddrval));
  448.       return (NULL);
  449.     }
  450.     ddrval = lpDDS->SetPalette( lpDDPal);
  451.     if (ddrval != DD_OK){
  452.       lpDDS->Release( );
  453.       lpDDPal->Release( );
  454.       D3DAppISetErrorString("SetPalette failed while loading surface (loadtex).n%s",
  455.         D3DAppErrorToString(ddrval));
  456.       return (NULL);
  457.     }
  458.     
  459.     lpDDPal->Release( );
  460.     
  461.     return lpDDS;
  462. }
  464. BOOL ppm_getbyte(FILE *fp, char *newByte)
  465. {
  466.   char cchar;
  467.   int cc;
  468.   cchar = cc = getc(fp);
  469.   
  470.   if (cc == EOF) {
  471.     return FALSE;
  472.   }
  473.   
  474.   if (cchar == '#') {
  475.     do {
  476.       cchar = cc = getc(fp);
  477.       if (cc == EOF)
  478.         return FALSE;
  479.     } while (cchar != 'n' && cchar != 'r');
  480.   }
  481.   
  482.   *newByte = cchar;
  483.   
  484.   return TRUE;
  485. }
  487. BOOL ppm_getint(FILE *fp, DWORD *newInt)
  488. {
  489.   DWORD cint;
  490.   char cchar;
  491.   
  492.   do {
  493.     if (!ppm_getbyte(fp, &cchar)) return FALSE;
  494.   } while (isspace(cchar));
  495.   
  496.   if (!isdigit(cchar)) {
  497.     return FALSE;
  498.   }
  499.   
  500.   cint = 0;
  501.   
  502.   do {
  503.     cint = (cint * 10) + (cchar - '0');
  504.     if (!ppm_getbyte(fp, &cchar)) return FALSE;
  505.   } while(isdigit(cchar));
  506.   
  507.   *newInt = cint;
  508.   
  509.   return TRUE;
  510. }
  512. BOOL loadPPMHeader(FILE *fp, DWORD *width, DWORD *height, int *maxgrey)
  513. {
  514.   char magic[MAGICBYTES], cchar;
  515.   if (fread(magic, MAGICBYTES, 1, fp) != 1)
  516.     return FALSE;
  517.   if (magic[0] != 'P' || magic[1] != '6')
  518.     return FALSE;
  519.   if (!ppm_getint(fp, width))
  520.     return FALSE;
  521.   if (!ppm_getint(fp, height))
  522.     return FALSE;
  523.   if (!ppm_getint(fp, (DWORD * )maxgrey))
  524.     return FALSE;
  525.   do {
  526.     if (!ppm_getbyte(fp, &cchar))
  527.       return FALSE;
  528.   } while (cchar == ' ' || cchar == 't' || cchar == 'n' || cchar == 'r');
  529.   
  530.   fseek(fp, -1, SEEK_CUR);
  531.   
  532.   return TRUE;
  533. }
  536. #define MAXPATH    256
  537. #define PATHSEP    ';'
  538. #define FILESEP    '\'
  539. #define MAXCONTENTS 25
  540. #define RESPATH     "Software\Microsoft\Direct3D"
  542. int PathListInitialised = FALSE;
  544. static struct {
  545.   int count;
  546.   char *contents[MAXCONTENTS];
  547. } PathList;
  549. void D3DAppIAddPathList(const char *path)
  550. {
  551.   char *p;
  552.   char *elt;
  553.   int len;
  554.   
  555.   while (path) {
  556.     p = strchr(path, PATHSEP);
  557.     if (p)
  558.       len = p - path;
  559.     else
  560.       len = lstrlen(path);
  561.     elt = (char *) malloc(len + 1);
  562.     if (elt == NULL)
  563.       return;
  564.     lstrcpyn(elt, path, len + 1);
  565.     elt[len] = '';
  566.     PathList.contents[PathList.count] = elt;
  567.     PathList.count++;
  568.     if (p)
  569.       path = p + 1;
  570.     else
  571.       path = NULL;
  572.     if (PathList.count == MAXCONTENTS)
  573.       return;
  574.   }
  575.   return;
  576. }
  578. void D3DAppIInitialisePathList()
  579. {
  580.   long result;
  581.   HKEY key;
  582.   DWORD type, size;
  583.   static char buf[512];
  584.   char* path;
  585.   
  586.   if (PathListInitialised)
  587.     return;
  588.   PathListInitialised = TRUE;
  589.   
  590.   PathList.count = 0;
  591.   path = getenv("D3DPATH");
  592.   D3DAppIAddPathList(".");
  593.   if (path != NULL) {
  594.     D3DAppIAddPathList(path);
  595.     return;
  596.   }
  597.   result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, RESPATH, 0, KEY_READ, &key);
  598.   if (result == ERROR_SUCCESS) {
  599.     size = sizeof(buf);
  600.     result = RegQueryValueEx(key, "D3D Path", NULL, &type, (LPBYTE) buf,
  601.       &size);
  602.     RegCloseKey(key);
  603.     if (result == ERROR_SUCCESS && type == REG_SZ)
  604.       D3DAppIAddPathList(buf);
  605.   }
  606. }
  609. FILE* D3DAppIFindFile(const char *name, const char *mode)
  610. {
  611.   FILE *fp;
  612.   char buf[MAXPATH];
  613.   static char filesep[] = {FILESEP, 0};
  614.   int i;
  615.   
  616.   D3DAppIInitialisePathList();
  617.   
  618.   fp = fopen(name, mode);
  619.   if (fp != NULL)
  620.     return fp;
  621.   
  622.   for (i = 0; i < PathList.count; i++) {
  623.     lstrcpy(buf, PathList.contents[i]);
  624.     lstrcat(buf, filesep);
  625.     lstrcat(buf, name);
  626.     fp = fopen(buf, mode);
  627.     if (fp)
  628.       return fp;
  629.   }
  630.   return NULL;
  631. }
  633. void
  634. D3DAppIReleasePathList(void)
  635. {
  636.   int i;
  637.   for (i = 0; i < PathList.count; i++) {
  638.     free(PathList.contents[i]);
  639.     PathList.contents[i] = NULL;
  640.   }
  641.   PathList.count = 0;
  642.   PathListInitialised = FALSE;
  643. }