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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
d3dtextr.cpp
资源名称：Mir2ExCodev1.rar　[点击查看]
上传用户：cydong117
上传日期：2009-11-10
资源大小：638k
文件大小：33k
源码类别：

模拟服务器

开发平台：

Visual C++

d3dtextr.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DTextr.cpp
  3. //
  4. // Desc: Functions to manage textures, including creating (loading from a
  5. //       file), restoring lost surfaces, invalidating, and destroying.
  6. //
  7. //       Note: the implementation of these fucntions maintain an internal list
  8. //       of loaded textures. After creation, individual textures are referenced
  9. //       via their ASCII names.
  10. //
  11. // Copyright (c) 1996-1999 Microsoft Corporation. All rights reserved
  12. //-----------------------------------------------------------------------------
  13. //#define STRICT
  14. #include "StdAfx.h"
  15. //#include <tchar.h>
  16. //#include <stdio.h>
  17. //#include "D3DTextr.h"
  18. //#include "D3DUtil.h"
  23. //-----------------------------------------------------------------------------
  24. // Macros, function prototypes and static variable
  25. //-----------------------------------------------------------------------------
  26. static TCHAR  g_strTexturePath[512] = _T(""); // Path for files
  31. //-----------------------------------------------------------------------------
  32. // Name: TextureContainer
  33. // Desc: Linked list structure to hold info per texture
  34. //-----------------------------------------------------------------------------
  35. struct TextureContainer
  36. {
  37.     TextureContainer* m_pNext; // Linked list ptr
  39.     TCHAR   m_strName[80];     // Name of texture (doubles as image filename)
  40.     DWORD   m_dwWidth;
  41.     DWORD   m_dwHeight;
  42.     DWORD   m_dwStage;         // Texture stage (for multitexture devices)
  43.     DWORD   m_dwBPP;
  44.     DWORD   m_dwFlags;
  45.     BOOL    m_bHasAlpha;
  47.     LPDIRECTDRAWSURFACE7 m_pddsSurface; // Surface of the texture
  48.     HBITMAP m_hbmBitmap;       // Bitmap containing texture image
  49.     DWORD*  m_pRGBAData;
  51. public:
  52.     HRESULT LoadImageData();
  53.     HRESULT LoadBitmapFile( TCHAR* strPathname );
  54.     HRESULT LoadTargaFile( TCHAR* strPathname );
  55.     HRESULT Restore( LPDIRECT3DDEVICE7 pd3dDevice );
  56.     HRESULT CopyBitmapToSurface();
  57.     HRESULT CopyRGBADataToSurface();
  59.     TextureContainer( TCHAR* strName, DWORD dwStage, DWORD dwFlags );
  60.     ~TextureContainer();
  61. };
  63. // Local list of textures
  64. static TextureContainer* g_ptcTextureList = NULL;
  69. //-----------------------------------------------------------------------------
  70. // Name: CD3DTextureManager
  71. // Desc: Class used to automatically construct and destruct the static
  72. //       texture engine class.
  73. //-----------------------------------------------------------------------------
  74. class CD3DTextureManager
  75. {
  76. public:
  77.     CD3DTextureManager() {}
  78.     ~CD3DTextureManager() { if( g_ptcTextureList ) delete g_ptcTextureList; }
  79. };
  81. // Global instance
  82. CD3DTextureManager g_StaticTextureEngine;
  87. //-----------------------------------------------------------------------------
  88. // Name: struct TEXTURESEARCHINFO
  89. // Desc: Structure used to search for texture formats
  90. //-----------------------------------------------------------------------------
  91. struct TEXTURESEARCHINFO
  92. {
  93.     DWORD dwDesiredBPP;   // Input for texture format search
  94.     BOOL  bUseAlpha;
  95.     BOOL  bUsePalette;
  96.     BOOL  bFoundGoodFormat;
  98.     DDPIXELFORMAT* pddpf; // Output of texture format search
  99. };
  104. //-----------------------------------------------------------------------------
  105. // Name: TextureSearchCallback()
  106. // Desc: Enumeration callback routine to find a best-matching texture format.
  107. //       The param data is the DDPIXELFORMAT of the best-so-far matching
  108. //       texture. Note: the desired BPP is passed in the dwSize field, and the
  109. //       default BPP is passed in the dwFlags field.
  110. //-----------------------------------------------------------------------------
  111. static HRESULT CALLBACK TextureSearchCallback( DDPIXELFORMAT* pddpf,
  112.                                                VOID* param )
  113. {
  114.     if( NULL==pddpf || NULL==param )
  115.         return DDENUMRET_OK;
  117.     TEXTURESEARCHINFO* ptsi = (TEXTURESEARCHINFO*)param;
  119.     // Skip any funky modes
  120.     if( pddpf->dwFlags & (DDPF_LUMINANCE|DDPF_BUMPLUMINANCE|DDPF_BUMPDUDV) )
  121.         return DDENUMRET_OK;
  123.     // Check for palettized formats
  124.     if( ptsi->bUsePalette )
  125.     {
  126.         if( !( pddpf->dwFlags & DDPF_PALETTEINDEXED8 ) )
  127.             return DDENUMRET_OK;
  129.         // Accept the first 8-bit palettized format we get
  130.         memcpy( ptsi->pddpf, pddpf, sizeof(DDPIXELFORMAT) );
  131.         ptsi->bFoundGoodFormat = TRUE;
  132.         return DDENUMRET_CANCEL;
  133.     }
  135.     // Else, skip any paletized formats (all modes under 16bpp)
  136.     if( pddpf->dwRGBBitCount < 16 )
  137.         return DDENUMRET_OK;
  139.     // Skip any FourCC formats
  140.     if( pddpf->dwFourCC != 0 )
  141.         return DDENUMRET_OK;
  143.     // Skip any ARGB 4444 formats (which are best used for pre-authored
  144.     // content designed speciafically for an ARGB 4444 format).
  145.     if( pddpf->dwRGBAlphaBitMask == 0x0000f000 )
  146.         return DDENUMRET_OK;
  148.     // Make sure current alpha format agrees with requested format type
  149.     if( (ptsi->bUseAlpha==TRUE) && !(pddpf->dwFlags&DDPF_ALPHAPIXELS) )
  150.         return DDENUMRET_OK;
  151.     if( (ptsi->bUseAlpha==FALSE) && (pddpf->dwFlags&DDPF_ALPHAPIXELS) )
  152.         return DDENUMRET_OK;
  154.     // Check if we found a good match
  155.     if( pddpf->dwRGBBitCount == ptsi->dwDesiredBPP )
  156.     {
  157.         memcpy( ptsi->pddpf, pddpf, sizeof(DDPIXELFORMAT) );
  158.         ptsi->bFoundGoodFormat = TRUE;
  159.         return DDENUMRET_CANCEL;
  160.     }
  162.     return DDENUMRET_OK;
  163. }
  168. //-----------------------------------------------------------------------------
  169. // Name: FindTexture()
  170. // Desc: Searches the internal list of textures for a texture specified by
  171. //       its name. Returns the structure associated with that texture.
  172. //-----------------------------------------------------------------------------
  173. static TextureContainer* FindTexture( TCHAR* strTextureName )
  174. {
  175.     TextureContainer* ptcTexture = g_ptcTextureList;
  177.     while( ptcTexture )
  178.     {
  179.         if( !lstrcmpi( strTextureName, ptcTexture->m_strName ) )
  180.             return ptcTexture;
  181.         ptcTexture = ptcTexture->m_pNext;
  182.     }
  184.     return NULL;
  185. }
  190. //-----------------------------------------------------------------------------
  191. // Name: TextureContainer()
  192. // Desc: Constructor for a texture object
  193. //-----------------------------------------------------------------------------
  194. TextureContainer::TextureContainer( TCHAR* strName, DWORD dwStage,
  195.                                     DWORD dwFlags )
  196. {
  197.     lstrcpy( m_strName, strName );
  198.     m_dwWidth     = 0;
  199.     m_dwHeight    = 0;
  200.     m_dwStage     = dwStage;
  201.     m_dwBPP       = 0;
  202.     m_dwFlags     = dwFlags;
  203.     m_bHasAlpha   = 0;
  205.     m_pddsSurface = NULL;
  206.     m_hbmBitmap   = NULL;
  207.     m_pRGBAData   = NULL;
  209.     // Add the texture to the head of the global texture list
  210.     m_pNext = g_ptcTextureList;
  211.     g_ptcTextureList = this;
  213. }
  218. //-----------------------------------------------------------------------------
  219. // Name: ~TextureContainer()
  220. // Desc: Destructs the contents of the texture container
  221. //-----------------------------------------------------------------------------
  222. TextureContainer::~TextureContainer()
  223. {
  224.     SAFE_RELEASE( m_pddsSurface );
  225.     SAFE_DELETE(  m_pRGBAData );
  226.     DeleteObject( m_hbmBitmap );
  228.     // Remove the texture container from the global list
  229.     if( g_ptcTextureList == this )
  230.         g_ptcTextureList = m_pNext;
  231.     else
  232.     {
  233.         for( TextureContainer* ptc=g_ptcTextureList; ptc; ptc=ptc->m_pNext )
  234.             if( ptc->m_pNext == this )
  235.                 ptc->m_pNext = m_pNext;
  236.     }
  237. }
  242. //-----------------------------------------------------------------------------
  243. // Name: LoadImageData()
  244. // Desc: Loads the texture map's image data
  245. //-----------------------------------------------------------------------------
  246. HRESULT TextureContainer::LoadImageData()
  247. {
  248.     TCHAR* strExtension;
  249.     TCHAR  strPathname[256];
  250.     FILE*  file;
  252.     // Check the executable's resource. If it's there, we're done!
  253.     m_hbmBitmap = (HBITMAP)LoadImage( GetModuleHandle(NULL), m_strName,
  254.                                       IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION );
  255.     if( m_hbmBitmap )
  256.         return S_OK;
  258.     // First check if the file exists in the global texture path
  259.     lstrcpy( strPathname, g_strTexturePath );
  260.     lstrcat( strPathname, m_strName );
  261.     if( NULL == ( file = fopen( strPathname, "rb" ) ) )
  262.     {
  263.         // Then check if the file exists in the DirectX SDK media path
  264.         lstrcpy( strPathname, D3DUtil_GetDXSDKMediaPath() );
  265.         lstrcat( strPathname, m_strName );
  266.         if( NULL == ( file = fopen( strPathname, "rb" ) ) )
  267.             return DDERR_NOTFOUND;
  268.     }
  269.     fclose( file );
  271.     // Get the filename extension
  272.     if( NULL == ( strExtension = _tcsrchr( m_strName, _T('.') ) ) )
  273.         return DDERR_UNSUPPORTED;
  275.     // Load bitmap files
  276.     if( !lstrcmpi( strExtension, _T(".bmp") ) )
  277.         return LoadBitmapFile( strPathname );
  279.     // Load targa files
  280.     if( !lstrcmpi( strExtension, _T(".tga") ) )
  281.         return LoadTargaFile( strPathname );
  283.     // Can add code here to check for other file formats before failing
  284.     return DDERR_UNSUPPORTED;
  285. }
  290. //-----------------------------------------------------------------------------
  291. // Name: LoadBitmapFile()
  292. // Desc: Loads data from a .bmp file, and stores it in a bitmap structure.
  293. //-----------------------------------------------------------------------------
  294. HRESULT TextureContainer::LoadBitmapFile( TCHAR* strPathname )
  295. {
  296.     // Try to load the bitmap as a file
  297.     m_hbmBitmap = (HBITMAP)LoadImage( NULL, strPathname, IMAGE_BITMAP, 0, 0,
  298.                                       LR_LOADFROMFILE|LR_CREATEDIBSECTION );
  299.     if( m_hbmBitmap )
  300.         return S_OK;
  301.     
  302.     return DDERR_NOTFOUND;
  303. }
  308. //-----------------------------------------------------------------------------
  309. // Name: LoadTargaFile()
  310. // Desc: Loads RGBA data from a .tga file, and stores it in allocated memory
  311. //       for the specified texture container
  312. //-----------------------------------------------------------------------------
  313. HRESULT TextureContainer::LoadTargaFile( TCHAR* strPathname )
  314. {
  315.     FILE* file = fopen( strPathname, "rb" );
  316.     if( NULL == file )
  317.         return E_FAIL;
  319.     struct TargaHeader
  320.     {
  321.         BYTE IDLength;
  322.         BYTE ColormapType;
  323.         BYTE ImageType;
  324.         BYTE ColormapSpecification[5];
  325.         WORD XOrigin;
  326.         WORD YOrigin;
  327.         WORD ImageWidth;
  328.         WORD ImageHeight;
  329.         BYTE PixelDepth;
  330.         BYTE ImageDescriptor;
  331.     } tga;
  333.     fread( &tga, sizeof(TargaHeader), 1, file );
  335.     // Only true color, non-mapped images are supported
  336.     if( ( 0 != tga.ColormapType ) || 
  337.         ( tga.ImageType != 10 && tga.ImageType != 2 ) )
  338.     {
  339.         fclose( file );
  340.         return E_FAIL;
  341.     }
  343.     // Skip the ID field. The first byte of the header is the length of this field
  344.     if( tga.IDLength )
  345.         fseek( file, tga.IDLength, SEEK_CUR );
  347.     m_dwWidth   = tga.ImageWidth;
  348.     m_dwHeight  = tga.ImageHeight;
  349.     m_dwBPP     = tga.PixelDepth;
  350.     m_pRGBAData = new DWORD[m_dwWidth*m_dwHeight];
  352.     if( m_pRGBAData == NULL )
  353.     {
  354.         fclose(file);
  355.         return E_FAIL;
  356.     }
  358.     for( DWORD y=0; y<m_dwHeight; y++ )
  359.     {
  360.         DWORD dwOffset = y*m_dwWidth;
  362.         if( 0 == ( tga.ImageDescriptor & 0x0010 ) )
  363.             dwOffset = (m_dwHeight-y-1)*m_dwWidth;
  365.         for( DWORD x=0; x<m_dwWidth; x )
  366.         {
  367.             if( tga.ImageType == 10 )
  368.             {
  369.                 BYTE PacketInfo = getc( file );
  370.                 WORD PacketType = 0x80 & PacketInfo;
  371.                 WORD PixelCount = ( 0x007f & PacketInfo ) + 1;
  373.                 if( PacketType )
  374.                 {
  375.                     DWORD b = getc( file );
  376.                     DWORD g = getc( file );
  377.                     DWORD r = getc( file );
  378.                     DWORD a = 0xff;
  379.                     if( m_dwBPP == 32 )
  380.                         a = getc( file );
  382.                     while( PixelCount-- )
  383.                     {
  384.                         m_pRGBAData[dwOffset+x] = (r<<24L)+(g<<16L)+(b<<8L)+(a);
  385.                         x++;
  386.                     }
  387.                 }
  388.                 else
  389.                 {
  390.                     while( PixelCount-- )
  391.                     {
  392.                         BYTE b = getc( file );
  393.                         BYTE g = getc( file );
  394.                         BYTE r = getc( file );
  395.                         BYTE a = 0xff;
  396.                         if( m_dwBPP == 32 )
  397.                             a = getc( file );
  399.                         m_pRGBAData[dwOffset+x] = (r<<24L)+(g<<16L)+(b<<8L)+(a);
  400.                         x++;
  401.                     }
  402.                 }
  403.             }
  404.             else
  405.             {
  406.                 BYTE b = getc( file );
  407.                 BYTE g = getc( file );
  408.                 BYTE r = getc( file );
  409.                 BYTE a = 0xff;
  410.                 if( m_dwBPP == 32 )
  411.                     a = getc( file );
  413.                 m_pRGBAData[dwOffset+x] = (r<<24L)+(g<<16L)+(b<<8L)+(a);
  414.                 x++;
  415.             }
  416.         }
  417.     }
  419.     fclose( file );
  421.     // Check for alpha content
  422.     for( DWORD i=0; i<(m_dwWidth*m_dwHeight); i++ )
  423.     {
  424.         if( m_pRGBAData[i] & 0x000000ff != 0xff )
  425.         {
  426.             m_bHasAlpha = TRUE;
  427.             break;
  428.         }
  429.     }
  430.     
  431.     return S_OK;
  432. }
  437. //-----------------------------------------------------------------------------
  438. // Name: Restore()
  439. // Desc: Rebuilds the texture surface using the new device.
  440. //-----------------------------------------------------------------------------
  441. HRESULT TextureContainer::Restore( LPDIRECT3DDEVICE7 pd3dDevice )
  442. {
  443.     // Release any previously created objects
  444.     SAFE_RELEASE( m_pddsSurface );
  446.     // Check params
  447.     if( NULL == pd3dDevice )
  448.         return DDERR_INVALIDPARAMS;
  450.     // Get the device caps
  451.     D3DDEVICEDESC7 ddDesc;
  452.     if( FAILED( pd3dDevice->GetCaps( &ddDesc) ) )
  453.         return E_FAIL;
  455.     // Setup the new surface desc
  456.     DDSURFACEDESC2 ddsd;
  457.     D3DUtil_InitSurfaceDesc( ddsd );
  458.     ddsd.dwFlags         = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|
  459.                            DDSD_PIXELFORMAT|DDSD_TEXTURESTAGE;
  460.     ddsd.ddsCaps.dwCaps  = DDSCAPS_TEXTURE;
  461.     ddsd.dwTextureStage  = m_dwStage;
  462.     ddsd.dwWidth         = m_dwWidth;
  463.     ddsd.dwHeight        = m_dwHeight;
  465.     // Turn on texture management for hardware devices
  466.     if( ddDesc.deviceGUID == IID_IDirect3DHALDevice )
  467.         ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
  468.     else if( ddDesc.deviceGUID == IID_IDirect3DTnLHalDevice )
  469.         ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
  470.     else
  471.         ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  473.     // Adjust width and height to be powers of 2, if the device requires it
  474.     if( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2 )
  475.     {
  476.         for( ddsd.dwWidth=1;  m_dwWidth>ddsd.dwWidth;   ddsd.dwWidth<<=1 );
  477.         for( ddsd.dwHeight=1; m_dwHeight>ddsd.dwHeight; ddsd.dwHeight<<=1 );
  478.     }
  480.     // Limit max texture sizes, if the driver can't handle large textures
  481.     DWORD dwMaxWidth  = ddDesc.dwMaxTextureWidth;
  482.     DWORD dwMaxHeight = ddDesc.dwMaxTextureHeight;
  483.     ddsd.dwWidth  = min( ddsd.dwWidth,  ( dwMaxWidth  ? dwMaxWidth  : 256 ) );
  484.     ddsd.dwHeight = min( ddsd.dwHeight, ( dwMaxHeight ? dwMaxHeight : 256 ) );
  486.     // Make the texture square, if the driver requires it
  487.     if( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_SQUAREONLY )
  488.     {
  489.         if( ddsd.dwWidth > ddsd.dwHeight ) ddsd.dwHeight = ddsd.dwWidth;
  490.         else                               ddsd.dwWidth  = ddsd.dwHeight;
  491.     }
  493.     // Setup the structure to be used for texture enumration.
  494.     TEXTURESEARCHINFO tsi;
  495.     tsi.bFoundGoodFormat = FALSE;
  496.     tsi.pddpf            = &ddsd.ddpfPixelFormat;
  497.     tsi.dwDesiredBPP     = m_dwBPP;
  498.     tsi.bUsePalette      = ( m_dwBPP <= 8 );
  499.     tsi.bUseAlpha        = m_bHasAlpha;
  500.     if( m_dwFlags & D3DTEXTR_16BITSPERPIXEL )
  501.         tsi.dwDesiredBPP = 16;
  502.     else if( m_dwFlags & D3DTEXTR_32BITSPERPIXEL )
  503.         tsi.dwDesiredBPP = 32;
  505.     if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) )
  506.     {
  507.         if( tsi.bUsePalette )
  508.         {
  509.             if( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE )
  510.             {
  511.                 tsi.bUseAlpha   = TRUE;
  512.                 tsi.bUsePalette = TRUE;
  513.             }
  514.             else
  515.             {
  516.                 tsi.bUseAlpha   = TRUE;
  517.                 tsi.bUsePalette = FALSE;
  518.             }
  519.         }
  520.     }
  522.     // Enumerate the texture formats, and find the closest device-supported
  523.     // texture pixel format
  524.     pd3dDevice->EnumTextureFormats( TextureSearchCallback, &tsi );
  526.     // If we couldn't find a format, let's try a default format
  527.     if( FALSE == tsi.bFoundGoodFormat )
  528.     {
  529.         tsi.bUsePalette  = FALSE;
  530.         tsi.dwDesiredBPP = 16;
  531.         pd3dDevice->EnumTextureFormats( TextureSearchCallback, &tsi );
  533.         // If we still fail, we cannot create this texture
  534.         if( FALSE == tsi.bFoundGoodFormat )
  535.             return E_FAIL;
  536.     }
  538.     // Get the DirectDraw interface for creating surfaces
  539.     LPDIRECTDRAW7        pDD;
  540.     LPDIRECTDRAWSURFACE7 pddsRender;
  541.     pd3dDevice->GetRenderTarget( &pddsRender );
  542.     pddsRender->GetDDInterface( (VOID**)&pDD );
  543.     pddsRender->Release();
  545.     // Create a new surface for the texture
  546.     HRESULT hr = pDD->CreateSurface( &ddsd, &m_pddsSurface, NULL );
  548.     // Done with DDraw
  549.     pDD->Release();
  551.     if( FAILED(hr) )
  552.         return hr;
  554.     // For bitmap-based textures, copy the bitmap image.
  555.     if( m_hbmBitmap )
  556.         return CopyBitmapToSurface();
  558.     if( m_pRGBAData )
  559.         return CopyRGBADataToSurface();
  561.     // At this point, code can be added to handle other file formats (such as
  562.     // .dds files, .jpg files, etc.).
  563.     return S_OK;
  564. }
  569. //-----------------------------------------------------------------------------
  570. // Name: CopyBitmapToSurface()
  571. // Desc: Copies the image of a bitmap into a surface
  572. //-----------------------------------------------------------------------------
  573. HRESULT TextureContainer::CopyBitmapToSurface()
  574. {
  575.     // Get a DDraw object to create a temporary surface
  576.     LPDIRECTDRAW7 pDD;
  577.     m_pddsSurface->GetDDInterface( (VOID**)&pDD );
  579.     // Get the bitmap structure (to extract width, height, and bpp)
  580.     BITMAP bm;
  581.     GetObject( m_hbmBitmap, sizeof(BITMAP), &bm );
  583.     // Setup the new surface desc
  584.     DDSURFACEDESC2 ddsd;
  585.     ddsd.dwSize = sizeof(ddsd);
  586.     m_pddsSurface->GetSurfaceDesc( &ddsd );
  587.     ddsd.dwFlags          = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|
  588.                             DDSD_TEXTURESTAGE;
  589.     ddsd.ddsCaps.dwCaps   = DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY;
  590.     ddsd.ddsCaps.dwCaps2  = 0L;
  591.     ddsd.dwWidth          = bm.bmWidth;
  592.     ddsd.dwHeight         = bm.bmHeight;
  594.     // Create a new surface for the texture
  595.     LPDIRECTDRAWSURFACE7 pddsTempSurface;
  596.     HRESULT hr;
  597.     if( FAILED( hr = pDD->CreateSurface( &ddsd, &pddsTempSurface, NULL ) ) )
  598.     {
  599.         pDD->Release();
  600.         return hr;
  601.     }
  603.     // Get a DC for the bitmap
  604.     HDC hdcBitmap = CreateCompatibleDC( NULL );
  605.     if( NULL == hdcBitmap )
  606.     {
  607.         pddsTempSurface->Release();
  608.         pDD->Release();
  609.         return hr;
  610.     }
  611.     SelectObject( hdcBitmap, m_hbmBitmap );
  613.     // Handle palettized textures. Need to attach a palette
  614.     if( ddsd.ddpfPixelFormat.dwRGBBitCount == 8 )
  615.     {
  616.         LPDIRECTDRAWPALETTE  pPalette;
  617.         DWORD dwPaletteFlags = DDPCAPS_8BIT|DDPCAPS_ALLOW256;
  618.         DWORD pe[256];
  619.         WORD  wNumColors     = GetDIBColorTable( hdcBitmap, 0, 256, (RGBQUAD*)pe );
  621.         // Create the color table
  622.         for( WORD i=0; i<wNumColors; i++ )
  623.         {
  624.             pe[i] = RGB( GetBValue(pe[i]), GetGValue(pe[i]), GetRValue(pe[i]) );
  626.             // Handle textures with transparent pixels
  627.             if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) )
  628.             {
  629.                 // Set alpha for opaque pixels
  630.                 if( m_dwFlags & D3DTEXTR_TRANSPARENTBLACK )
  631.                 {
  632.                     if( pe[i] != 0x00000000 )
  633.                         pe[i] |= 0xff000000;
  634.                 }
  635.                 else if( m_dwFlags & D3DTEXTR_TRANSPARENTWHITE )
  636.                 {
  637.                     if( pe[i] != 0x00ffffff )
  638.                         pe[i] |= 0xff000000;
  639.                 }
  640.             }
  641.         }
  642.         // Add DDPCAPS_ALPHA flag for textures with transparent pixels
  643.         if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) )
  644.             dwPaletteFlags |= DDPCAPS_ALPHA;
  646.         // Create & attach a palette
  647.         pDD->CreatePalette( dwPaletteFlags, (PALETTEENTRY*)pe, &pPalette, NULL );
  648.         pddsTempSurface->SetPalette( pPalette );
  649.         m_pddsSurface->SetPalette( pPalette );
  650.         SAFE_RELEASE( pPalette );
  651.     }
  653.     // Copy the bitmap image to the surface.
  654.     HDC hdcSurface;
  655.     if( SUCCEEDED( pddsTempSurface->GetDC( &hdcSurface ) ) )
  656.     {
  657.         BitBlt( hdcSurface, 0, 0, bm.bmWidth, bm.bmHeight, hdcBitmap, 0, 0,
  658.                 SRCCOPY );
  659.         pddsTempSurface->ReleaseDC( hdcSurface );
  660.     }
  661.     DeleteDC( hdcBitmap );
  663.     // Copy the temp surface to the real texture surface
  664.     m_pddsSurface->Blt( NULL, pddsTempSurface, NULL, DDBLT_WAIT, NULL );
  666.     // Done with the temp surface
  667.     pddsTempSurface->Release();
  669.     // For textures with real alpha (not palettized), set transparent bits
  670.     if( ddsd.ddpfPixelFormat.dwRGBAlphaBitMask )
  671.     {
  672.         if( m_dwFlags & (D3DTEXTR_TRANSPARENTWHITE|D3DTEXTR_TRANSPARENTBLACK) )
  673.         {
  674.             // Lock the texture surface
  675.             DDSURFACEDESC2 ddsd;
  676.             ddsd.dwSize = sizeof(ddsd);
  677.             while( m_pddsSurface->Lock( NULL, &ddsd, 0, NULL ) ==
  678.                    DDERR_WASSTILLDRAWING );
  680.             DWORD dwAlphaMask = ddsd.ddpfPixelFormat.dwRGBAlphaBitMask;
  681.             DWORD dwRGBMask   = ( ddsd.ddpfPixelFormat.dwRBitMask |
  682.                                   ddsd.ddpfPixelFormat.dwGBitMask |
  683.                                   ddsd.ddpfPixelFormat.dwBBitMask );
  684.             DWORD dwColorkey  = 0x00000000; // Colorkey on black
  685.             if( m_dwFlags & D3DTEXTR_TRANSPARENTWHITE )
  686.                 dwColorkey = dwRGBMask;     // Colorkey on white
  688.             // Add an opaque alpha value to each non-colorkeyed pixel
  689.             for( DWORD y=0; y<ddsd.dwHeight; y++ )
  690.             {
  691.                 WORD*  p16 =  (WORD*)((BYTE*)ddsd.lpSurface + y*ddsd.lPitch);
  692.                 DWORD* p32 = (DWORD*)((BYTE*)ddsd.lpSurface + y*ddsd.lPitch);
  694.                 for( DWORD x=0; x<ddsd.dwWidth; x++ )
  695.                 {
  696.                     if( ddsd.ddpfPixelFormat.dwRGBBitCount == 16 )
  697.                     {
  698.                         if( ( *p16 &= dwRGBMask ) != dwColorkey )
  699.                             *p16 |= dwAlphaMask;
  700.                         p16++;
  701.                     }
  702.                     if( ddsd.ddpfPixelFormat.dwRGBBitCount == 32 )
  703.                     {
  704.                         if( ( *p32 &= dwRGBMask ) != dwColorkey )
  705.                             *p32 |= dwAlphaMask;
  706.                         p32++;
  707.                     }
  708.                 }
  709.             }
  710.             m_pddsSurface->Unlock( NULL );
  711.         }
  712.     }
  714.     pDD->Release();
  716.     return S_OK;;
  717. }
  722. //-----------------------------------------------------------------------------
  723. // Name: CopyRGBADataToSurface()
  724. // Desc: Invalidates the current texture objects and rebuilds new ones
  725. //       using the new device.
  726. //-----------------------------------------------------------------------------
  727. HRESULT TextureContainer::CopyRGBADataToSurface()
  728. {
  729.     // Get a DDraw object to create a temporary surface
  730.     LPDIRECTDRAW7 pDD;
  731.     m_pddsSurface->GetDDInterface( (VOID**)&pDD );
  733.     // Setup the new surface desc
  734.     DDSURFACEDESC2 ddsd;
  735.     ddsd.dwSize = sizeof(ddsd);
  736.     m_pddsSurface->GetSurfaceDesc( &ddsd );
  737.     ddsd.dwFlags         = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|
  738.                            DDSD_TEXTURESTAGE;
  739.     ddsd.ddsCaps.dwCaps  = DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY;
  740.     ddsd.ddsCaps.dwCaps2 = 0L;
  741.     ddsd.dwWidth         = m_dwWidth;
  742.     ddsd.dwHeight        = m_dwHeight;
  744.     // Create a new surface for the texture
  745.     LPDIRECTDRAWSURFACE7 pddsTempSurface;
  746.     HRESULT hr;
  747.     if( FAILED( hr = pDD->CreateSurface( &ddsd, &pddsTempSurface, NULL ) ) )
  748.     {
  749.         pDD->Release();
  750.         return NULL;
  751.     }
  753.     while( pddsTempSurface->Lock( NULL, &ddsd, 0, 0 ) == DDERR_WASSTILLDRAWING );
  754.     DWORD lPitch = ddsd.lPitch;
  755.     BYTE* pBytes = (BYTE*)ddsd.lpSurface;
  757.     DWORD dwRMask = ddsd.ddpfPixelFormat.dwRBitMask;
  758.     DWORD dwGMask = ddsd.ddpfPixelFormat.dwGBitMask;
  759.     DWORD dwBMask = ddsd.ddpfPixelFormat.dwBBitMask;
  760.     DWORD dwAMask = ddsd.ddpfPixelFormat.dwRGBAlphaBitMask;
  762.     DWORD dwRShiftL = 8, dwRShiftR = 0;
  763.     DWORD dwGShiftL = 8, dwGShiftR = 0;
  764.     DWORD dwBShiftL = 8, dwBShiftR = 0;
  765.     DWORD dwAShiftL = 8, dwAShiftR = 0;
  767.     DWORD dwMask;
  768.     for( dwMask=dwRMask; dwMask && !(dwMask&0x1); dwMask>>=1 ) dwRShiftR++;
  769.     for( ; dwMask; dwMask>>=1 ) dwRShiftL--;
  771.     for( dwMask=dwGMask; dwMask && !(dwMask&0x1); dwMask>>=1 ) dwGShiftR++;
  772.     for( ; dwMask; dwMask>>=1 ) dwGShiftL--;
  774.     for( dwMask=dwBMask; dwMask && !(dwMask&0x1); dwMask>>=1 ) dwBShiftR++;
  775.     for( ; dwMask; dwMask>>=1 ) dwBShiftL--;
  777.     for( dwMask=dwAMask; dwMask && !(dwMask&0x1); dwMask>>=1 ) dwAShiftR++;
  778.     for( ; dwMask; dwMask>>=1 ) dwAShiftL--;
  780.     for( DWORD y=0; y<ddsd.dwHeight; y++ )
  781.     {
  782.         DWORD* pDstData32 = (DWORD*)pBytes;
  783.         WORD*  pDstData16 = (WORD*)pBytes;
  785.         for( DWORD x=0; x<ddsd.dwWidth; x++ )
  786.         {
  787.             DWORD dwPixel = m_pRGBAData[y*ddsd.dwWidth+x];
  789.             BYTE r = (BYTE)((dwPixel>>24)&0x000000ff);
  790.             BYTE g = (BYTE)((dwPixel>>16)&0x000000ff);
  791.             BYTE b = (BYTE)((dwPixel>> 8)&0x000000ff);
  792.             BYTE a = (BYTE)((dwPixel>> 0)&0x000000ff);
  794.             DWORD dr = ((r>>(dwRShiftL))<<dwRShiftR)&dwRMask;
  795.             DWORD dg = ((g>>(dwGShiftL))<<dwGShiftR)&dwGMask;
  796.             DWORD db = ((b>>(dwBShiftL))<<dwBShiftR)&dwBMask;
  797.             DWORD da = ((a>>(dwAShiftL))<<dwAShiftR)&dwAMask;
  799.             if( 32 == ddsd.ddpfPixelFormat.dwRGBBitCount )
  800.                 pDstData32[x] = (DWORD)(dr+dg+db+da);
  801.             else
  802.                 pDstData16[x] = (WORD)(dr+dg+db+da);
  803.         }
  804.     
  805.         pBytes += ddsd.lPitch;
  806.     }
  808.     pddsTempSurface->Unlock(0);
  810.     // Copy the temp surface to the real texture surface
  811.     m_pddsSurface->Blt( NULL, pddsTempSurface, NULL, DDBLT_WAIT, NULL );
  813.     // Done with the temp objects
  814.     pddsTempSurface->Release();
  815.     pDD->Release();
  817.     return S_OK;
  818. }
  823. //-----------------------------------------------------------------------------
  824. // Name: D3DTextr_SetTexturePath()
  825. // Desc: Enumeration callback routine to find a best-matching texture format.
  826. //-----------------------------------------------------------------------------
  827. VOID D3DTextr_SetTexturePath( TCHAR* strTexturePath )
  828. {
  829.     if( NULL == strTexturePath )
  830.         strTexturePath = _T("");
  831.     lstrcpy( g_strTexturePath, strTexturePath );
  832. }
  837. //-----------------------------------------------------------------------------
  838. // Name: D3DTextr_CreateTextureFromFile()
  839. // Desc: Is passed a filename and creates a local Bitmap from that file.
  840. //       The texture can not be used until it is restored, however.
  841. //-----------------------------------------------------------------------------
  842. HRESULT D3DTextr_CreateTextureFromFile( TCHAR* strName, DWORD dwStage,
  843.                                         DWORD dwFlags )
  844. {
  845.     // Check parameters
  846.     if( NULL == strName )
  847.         return E_INVALIDARG;
  849.     // Check first to see if the texture is already loaded
  850.     if( NULL != FindTexture( strName ) )
  851.         return S_OK;
  853.     // Allocate and add the texture to the linked list of textures;
  854.     TextureContainer* ptcTexture = new TextureContainer( strName, dwStage,
  855.                                                          dwFlags );
  856.     if( NULL == ptcTexture )
  857.         return E_OUTOFMEMORY;
  859.     // Create a bitmap and load the texture file into it,
  860.     if( FAILED( ptcTexture->LoadImageData() ) )
  861.     {
  862.         delete ptcTexture;
  863.         return E_FAIL;
  864.     }
  866.     // Save the image's dimensions
  867.     if( ptcTexture->m_hbmBitmap )
  868.     {
  869.         BITMAP bm;
  870.         GetObject( ptcTexture->m_hbmBitmap, sizeof(BITMAP), &bm );
  871.         ptcTexture->m_dwWidth  = (DWORD)bm.bmWidth;
  872.         ptcTexture->m_dwHeight = (DWORD)bm.bmHeight;
  873.         ptcTexture->m_dwBPP    = (DWORD)bm.bmBitsPixel;
  874.     }
  876.     return S_OK;
  877. }
  882. //-----------------------------------------------------------------------------
  883. // Name: D3DTextr_CreateEmptyTexture()
  884. // Desc: Creates an empty texture.
  885. //-----------------------------------------------------------------------------
  886. HRESULT D3DTextr_CreateEmptyTexture( TCHAR* strName, DWORD dwWidth,
  887.                                      DWORD dwHeight, DWORD dwStage, 
  888.                                      DWORD dwFlags )
  889. {
  890.     // Check parameters
  891.     if( NULL == strName )
  892.         return E_INVALIDARG;
  894.     // Check first to see if the texture is already loaded
  895.     if( NULL != FindTexture( strName ) )
  896.         return E_FAIL;
  898.     // Allocate and add the texture to the linked list of textures;
  899.     TextureContainer* ptcTexture = new TextureContainer( strName, dwStage,
  900.                                                          dwFlags );
  901.     if( NULL == ptcTexture )
  902.         return E_OUTOFMEMORY;
  904.     // Save dimensions
  905.     ptcTexture->m_dwWidth  = dwWidth;
  906.     ptcTexture->m_dwHeight = dwHeight;
  907.     ptcTexture->m_dwBPP    = 16;
  908.     if( ptcTexture->m_dwFlags & D3DTEXTR_32BITSPERPIXEL )
  909.         ptcTexture->m_dwBPP = 32;
  911.     // Save alpha usage flag
  912.     if( dwFlags & D3DTEXTR_CREATEWITHALPHA )
  913.         ptcTexture->m_bHasAlpha = TRUE;
  915.     return S_OK;
  916. }
  921. //-----------------------------------------------------------------------------
  922. // Name: D3DTextr_Restore()
  923. // Desc: Invalidates the current texture objects and rebuilds new ones
  924. //       using the new device.
  925. //-----------------------------------------------------------------------------
  926. HRESULT D3DTextr_Restore( TCHAR* strName, LPDIRECT3DDEVICE7 pd3dDevice )
  927. {
  928.     TextureContainer* ptcTexture = FindTexture( strName );
  929.     if( NULL == ptcTexture )
  930.         return DDERR_NOTFOUND;
  932.     // Restore the texture (this recreates the new surface for this device).
  933.     return ptcTexture->Restore( pd3dDevice );
  934. }
  939. //-----------------------------------------------------------------------------
  940. // Name: D3DTextr_RestoreAllTextures()
  941. // Desc: This function is called when a mode is changed. It updates all
  942. //       texture objects to be valid with the new device.
  943. //-----------------------------------------------------------------------------
  944. HRESULT D3DTextr_RestoreAllTextures( LPDIRECT3DDEVICE7 pd3dDevice )
  945. {
  946.     TextureContainer* ptcTexture = g_ptcTextureList;
  948.     while( ptcTexture )
  949.     {
  950.         D3DTextr_Restore( ptcTexture->m_strName, pd3dDevice );
  951.         ptcTexture = ptcTexture->m_pNext;
  952.     }
  954.     return S_OK;
  955. }
  960. //-----------------------------------------------------------------------------
  961. // Name: D3DTextr_Invalidate()
  962. // Desc: Used to bump a texture out of (video) memory, this function
  963. //       actually destroys the d3dtexture and ddsurface of the texture
  964. //-----------------------------------------------------------------------------
  965. HRESULT D3DTextr_Invalidate( TCHAR* strName )
  966. {
  967.     TextureContainer* ptcTexture = FindTexture( strName );
  968.     if( NULL == ptcTexture )
  969.         return DDERR_NOTFOUND;
  971.     SAFE_RELEASE( ptcTexture->m_pddsSurface );
  973.     return S_OK;
  974. }
  979. //-----------------------------------------------------------------------------
  980. // Name: D3DTextr_InvalidateAllTextures()
  981. // Desc: This function is called when a mode is changed. It invalidates
  982. //       all texture objects so their device can be safely released.
  983. //-----------------------------------------------------------------------------
  984. HRESULT D3DTextr_InvalidateAllTextures()
  985. {
  986.     TextureContainer* ptcTexture = g_ptcTextureList;
  988.     while( ptcTexture )
  989.     {
  990.         SAFE_RELEASE( ptcTexture->m_pddsSurface );
  991.         ptcTexture = ptcTexture->m_pNext;
  992.     }
  994.     return S_OK;
  995. }
  1000. //-----------------------------------------------------------------------------
  1001. // Name: D3DTextr_DestroyTexture()
  1002. // Desc: Frees the resources for the specified texture container
  1003. //-----------------------------------------------------------------------------
  1004. HRESULT D3DTextr_DestroyTexture( TCHAR* strName )
  1005. {
  1006.     TextureContainer* ptcTexture = FindTexture( strName );
  1008.     SAFE_DELETE( ptcTexture );
  1010.     return S_OK;
  1011. }
  1016. //-----------------------------------------------------------------------------
  1017. // Name: D3DTextr_GetSurface()
  1018. // Desc: Returns a pointer to a d3dSurface from the name of the texture
  1019. //-----------------------------------------------------------------------------
  1020. LPDIRECTDRAWSURFACE7 D3DTextr_GetSurface( TCHAR* strName )
  1021. {
  1022.     TextureContainer* ptcTexture = FindTexture( strName );
  1024.     return ptcTexture ? ptcTexture->m_pddsSurface : NULL;
  1025. }