|
|
/******************************Module*Header**********************************\
* * ******************* * * D3D SAMPLE CODE * * ******************* * * Module Name: d3dsurf.c * * Content: Surface management callbacks for D3D * * Copyright (c) 1994-1999 3Dlabs Inc. Ltd. All rights reserved. * Copyright (c) 1995-2003 Microsoft Corporation. All rights reserved. \*****************************************************************************/
#include "glint.h"
#include "dma.h"
//@@BEGIN_DDKSPLIT
#if DBG
// Whistler bug 281090 detection func, print warning msg only, remove later
void vDetectMixedMIPLevels( LPDDRAWI_DDRAWSURFACE_LCL pTopLevel) { LPDDRAWI_DDRAWSURFACE_LCL pCurLevel; DWORD dwMIPCaps;
// Check whether this is a MIP texture
dwMIPCaps = DDSCAPS_COMPLEX | DDSCAPS_TEXTURE | DDSCAPS_MIPMAP; if ((pTopLevel->ddsCaps.dwCaps & dwMIPCaps) != dwMIPCaps) { return; }
// Check whether all the levels have the same cap bits
pCurLevel = pTopLevel; do { if (pCurLevel->ddsCaps.dwCaps != pTopLevel->ddsCaps.dwCaps) { DISPDBG((ERRLVL, "BUG281090 : MIP levels of mixed type (0x%x : 0x%x, 0x%x)", pTopLevel->lpSurfMore->dwSurfaceHandle, pCurLevel->ddsCaps.dwCaps, pTopLevel->ddsCaps.dwCaps)); }
if (pCurLevel->lpAttachList) { pCurLevel = pCurLevel->lpAttachList->lpAttached; } else { break; } } while ((pCurLevel != NULL) && (pCurLevel != pTopLevel)); }
#endif
//@@END_DDKSPLIT
//-----------------------------Public Routine----------------------------------
//
// D3DCreateSurfaceEx
//
// D3dCreateSurfaceEx creates a Direct3D surface from a DirectDraw surface and
// associates a requested handle value to it.
//
// All Direct3D drivers must support D3dCreateSurfaceEx.
//
// D3dCreateSurfaceEx creates an association between a DirectDraw surface and
// a small integer surface handle. By creating these associations between a
// handle and a DirectDraw surface, D3dCreateSurfaceEx allows a surface handle
// to be imbedded in the Direct3D command stream. For example when the
// D3DDP2OP_TEXBLT command token is sent to D3dDrawPrimitives2 to load a texture
// map, it uses a source handle and destination handle which were associated
// with a DirectDraw surface through D3dCreateSurfaceEx.
//
// For every DirectDraw surface created under the local DirectDraw object, the
// runtime generates a valid handle that uniquely identifies the surface and
// places it in pcsxd->lpDDSLcl->lpSurfMore->dwSurfaceHandle. This handle value
// is also used with the D3DRENDERSTATE_TEXTUREHANDLE render state to enable
// texturing, and with the D3DDP2OP_SETRENDERTARGET and D3DDP2OP_CLEAR commands
// to set and/or clear new rendering and depth buffers. The driver should fail
// the call and return DDHAL_DRIVER_HANDLE if it cannot create the Direct3D
// surface.
//
// As appropriate, the driver should also store any surface-related information
// that it will subsequently need when using the surface. The driver must create
// a new surface table for each new lpDDLcl and implicitly grow the table when
// necessary to accommodate more surfaces. Typically this is done with an
// exponential growth algorithm so that you don't have to grow the table too
// often. Direct3D calls D3dCreateSurfaceEx after the surface is created by
// DirectDraw by request of the Direct3D runtime or the application.
//
// Parameters
//
// lpcsxd
// pointer to CreateSurfaceEx structure that contains the information
// required for the driver to create the surface (described below).
//
// dwFlags
// Currently unused
// lpDDLcl
// Handle to the DirectDraw object created by the application.
// This is the scope within which the lpDDSLcl handles exist.
// A DD_DIRECTDRAW_LOCAL structure describes the driver.
// lpDDSLcl
// Handle to the DirectDraw surface we are being asked to
// create for Direct3D. These handles are unique within each
// different DD_DIRECTDRAW_LOCAL. A DD_SURFACE_LOCAL structure
// represents the created surface object.
// ddRVal
// Specifies the location in which the driver writes the return
// value of the D3dCreateSurfaceEx callback. A return code of
// DD_OK indicates success.
//
// Return Value
//
// DDHAL_DRIVER_HANDLE
// DDHAL_DRIVER_NOTHANDLE
//
//-----------------------------------------------------------------------------
DWORD CALLBACK D3DCreateSurfaceEx( LPDDHAL_CREATESURFACEEXDATA lpcsxd ) { P3_THUNKEDDATA *pThisDisplay; PointerArray* pSurfaceArray; GET_THUNKEDDATA(pThisDisplay, lpcsxd->lpDDLcl->lpGbl);
DBG_CB_ENTRY(D3DCreateSurfaceEx);
DISPDBG((DBGLVL,"D3DCreateSurfaceEx surface %d @ %x caps = %x", (DWORD)lpcsxd->lpDDSLcl->lpSurfMore->dwSurfaceHandle, lpcsxd->lpDDSLcl->lpGbl->fpVidMem, lpcsxd->lpDDSLcl->ddsCaps.dwCaps));
// Get a pointer to an array of DWORD's containing surfaces
pSurfaceArray = (PointerArray*)HT_GetEntry(pThisDisplay->pDirectDrawLocalsHashTable, (ULONG_PTR)lpcsxd->lpDDLcl);
// If there isn't a handle set for this directdraw object, create one.
if (!pSurfaceArray) { DISPDBG((DBGLVL,"Creating new pointer array for PDDLcl 0x%x", lpcsxd->lpDDLcl));
pSurfaceArray = PA_CreateArray();
if (pSurfaceArray) { PA_SetDataDestroyCallback(pSurfaceArray, _D3D_SU_SurfaceArrayDestroyCallback);
if(!HT_AddEntry(pThisDisplay->pDirectDrawLocalsHashTable, (ULONG_PTR)lpcsxd->lpDDLcl, pSurfaceArray)) { // failed to add entry, noe cleanup and exit
// We ran out of memory. Cleanup before we leave
PA_DestroyArray(pSurfaceArray, pThisDisplay); DISPDBG((ERRLVL,"ERROR: Couldn't allocate " "surface internal data mem for pSurfaceArray")); lpcsxd->ddRVal = DDERR_OUTOFMEMORY; DBG_CB_EXIT(D3DCreateSurfaceEx,lpcsxd->ddRVal); return DDHAL_DRIVER_HANDLED; } } else { DISPDBG((ERRLVL,"ERROR: Couldn't allocate " "surface internal data mem")); lpcsxd->ddRVal = DDERR_OUTOFMEMORY; DBG_CB_EXIT(D3DCreateSurfaceEx,lpcsxd->ddRVal); return DDHAL_DRIVER_HANDLED; } }
// Recursively record the surface(s)
lpcsxd->ddRVal = _D3D_SU_SurfInternalSetDataRecursive(pThisDisplay, pSurfaceArray, lpcsxd->lpDDLcl, lpcsxd->lpDDSLcl, lpcsxd->lpDDSLcl);
//@@BEGIN_DDKSPLIT
#if DBG
// Whistler bug 281090 detection code, print warning msg only, remove later
vDetectMixedMIPLevels(lpcsxd->lpDDSLcl);
#endif
//@@END_DDKSPLIT
DBG_CB_EXIT(D3DCreateSurfaceEx,lpcsxd->ddRVal); return DDHAL_DRIVER_HANDLED; } // D3DCreateSurfaceEx
//-----------------------------Public Routine----------------------------------
//
// D3DDestroyDDLocal
//
// D3dDestroyDDLocal destroys all the Direct3D surfaces previously created by
// D3DCreateSurfaceEx that belong to the same given local DirectDraw object.
//
// All Direct3D drivers must support D3dDestroyDDLocal.
// Direct3D calls D3dDestroyDDLocal when the application indicates that the
// Direct3D context is no longer required and it will be destroyed along with
// all surfaces associated to it. The association comes through the pointer to
// the local DirectDraw object. The driver must free any memory that the
// driver's D3dCreateSurfaceExDDK_D3dCreateSurfaceEx_GG callback allocated for
// each surface if necessary. The driver should not destroy the DirectDraw
// surfaces associated with these Direct3D surfaces; this is the application's
// responsibility.
//
// Parameters
//
// lpdddd
// Pointer to the DestroyLocalDD structure that contains the
// information required for the driver to destroy the surfaces.
//
// dwFlags
// Currently unused
// pDDLcl
// Pointer to the local Direct Draw object which serves as a
// reference for all the D3D surfaces that have to be
// destroyed.
// ddRVal
// Specifies the location in which the driver writes the
// return value of D3dDestroyDDLocal. A return code of DD_OK
// indicates success.
//
// Return Value
//
// DDHAL_DRIVER_HANDLED
// DDHAL_DRIVER_NOTHANDLED
//-----------------------------------------------------------------------------
DWORD CALLBACK D3DDestroyDDLocal( LPDDHAL_DESTROYDDLOCALDATA pddl) { P3_THUNKEDDATA *pThisDisplay; GET_THUNKEDDATA(pThisDisplay, pddl->pDDLcl->lpGbl);
DBG_CB_ENTRY(D3DDestroyDDLocal); // Removing this entry from the hash table will cause the data destroy
// callback to be called, which will in turn free all of the texture
// structures that were allocated for this LCL
HT_RemoveEntry(pThisDisplay->pDirectDrawLocalsHashTable, (ULONG_PTR)pddl->pDDLcl, pThisDisplay);
pddl->ddRVal = DD_OK; DBG_CB_EXIT(D3DDestroyDDLocal, DDHAL_DRIVER_HANDLED); return DDHAL_DRIVER_HANDLED; } // D3DDestroyDDLocal
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
HRESULT _D3D_SU_SurfInternalSetDataRecursive( P3_THUNKEDDATA* pThisDisplay, PointerArray* pSurfaceArray, LPDDRAWI_DIRECTDRAW_LCL pDDLcl, LPDDRAWI_DDRAWSURFACE_LCL pRootDDSurfLcl, LPDDRAWI_DDRAWSURFACE_LCL pCurDDSurfLcl) { P3_SURF_INTERNAL* pSurfInternal; DWORD dwSurfaceHandle; LPATTACHLIST pCurAttachList; HRESULT hRes;
DBG_CB_ENTRY(_D3D_SU_SurfInternalSetDataRecursive);
dwSurfaceHandle = (DWORD)pCurDDSurfLcl->lpSurfMore->dwSurfaceHandle; #if DBG
DISPDBG((DBGLVL, "D3DCreateSuraceEx Handle = %d fpVidMem = 0x%x (%s)", dwSurfaceHandle, pCurDDSurfLcl->lpGbl->fpVidMem, pcSimpleCapsString(pCurDDSurfLcl->ddsCaps.dwCaps))); #endif
DBGDUMP_DDRAWSURFACE_LCL(10, pCurDDSurfLcl);
// If this surface doesn't have a handle, return safely
if (! dwSurfaceHandle) { return (DD_OK); }
DISPDBG((DBGLVL,"Surface has a valid handle. Setting it up"));
// Get the texture from within the surface array
pSurfInternal = PA_GetEntry(pSurfaceArray, dwSurfaceHandle);
// If we didn't find the texture, create one
if (! pSurfInternal) { DISPDBG((DBGLVL,"Creating new internal surface for handle: 0x%x", dwSurfaceHandle));
// Allocate the texture data space, because it hasn't
// been done already
pSurfInternal = (P3_SURF_INTERNAL*)HEAP_ALLOC(HEAP_ZERO_MEMORY, sizeof(P3_SURF_INTERNAL), ALLOC_TAG_DX(A)); if (pSurfInternal == NULL) { DISPDBG((ERRLVL,"ERROR: Couldn't allocate surface " "internal data mem")); DBG_CB_EXIT(_D3D_SU_SurfInternalSetDataRecursive, DDERR_OUTOFMEMORY); return (DDERR_OUTOFMEMORY); } } else { DISPDBG((DBGLVL,"Surface handle re-used: 0x%x", dwSurfaceHandle)); }
// Add this texture to the surface list
if (! PA_SetEntry(pSurfaceArray, dwSurfaceHandle, pSurfInternal)) { return (DDERR_OUTOFMEMORY); }
// Setup the surface structure
_D3D_SU_SurfInternalSetData(pThisDisplay, pSurfInternal, pCurDDSurfLcl, dwSurfaceHandle);
// Keep a pointer to the DD_DIRECTDRAW_LOCAL in order to
// update colorkeying in DDSetColorKey possible. Notice
// this is stored in DD_SURFACE_LOCAL.dwReserved1 as
// DD_SURFACE_GLOBAL.dwReserved1 is being used for other
// purpouses
pCurDDSurfLcl->dwReserved1 = (ULONG_PTR)pDDLcl; // Don't need a seperate handle for mipmaps
// or cubemaps as they are atomic in DX7.
if ((pCurDDSurfLcl->ddsCaps.dwCaps & DDSCAPS_MIPMAP) || (pCurDDSurfLcl->lpSurfMore->ddsCapsEx.dwCaps2 & DDSCAPS2_CUBEMAP)) { return (DD_OK); }
pCurAttachList = pCurDDSurfLcl->lpAttachList; // Simple surface, mission accomplished
if (! pCurAttachList) { return (DD_OK); }
// This recursion is usually needed for complex flipping chains
pCurDDSurfLcl = pCurAttachList->lpAttached; if (pCurDDSurfLcl && (pCurDDSurfLcl != pRootDDSurfLcl)) { hRes = _D3D_SU_SurfInternalSetDataRecursive(pThisDisplay, pSurfaceArray, pDDLcl, pRootDDSurfLcl, pCurDDSurfLcl); if (FAILED(hRes)) { return (hRes); } } // This part will normally be enterned when stereo mode is on
if (pCurAttachList->lpLink) { pCurDDSurfLcl = pCurAttachList->lpLink->lpAttached; if (pCurDDSurfLcl && (pCurDDSurfLcl != pRootDDSurfLcl)) { hRes = _D3D_SU_SurfInternalSetDataRecursive(pThisDisplay, pSurfaceArray, pDDLcl, pRootDDSurfLcl, pCurDDSurfLcl); if (FAILED(hRes)) { return (hRes); } } }
return (DD_OK); }
//-----------------------------------------------------------------------------
//
// _D3D_SU_SurfInternalSetMipMapLevelData
//
// Records the a LOD level and all associated information so that the chip
// can use it later.
//
// Notice that ONLY while the D3DCreateSurfaceEx call is being made is the
// LPDDRAWI_DDRAWSURFACE_LCL/PDD_LOCAL_SURFACE structure valid (Win9x/Win2K)
// so we cannot just cache a pointer to it for later use.
//
//-----------------------------------------------------------------------------
void _D3D_SU_SurfInternalSetMipMapLevelData( P3_THUNKEDDATA *pThisDisplay, P3_SURF_INTERNAL* pTexture, LPDDRAWI_DDRAWSURFACE_LCL pSurf, int LOD) { ASSERTDD(pSurf != NULL, "ERROR: NULL surface!");
DISPDBG((6,"Storing LOD: %d, Pitch: %d, Width: %d", LOD, pSurf->lpGbl->lPitch, pSurf->lpGbl->wWidth));
// Get the byte offset to the texture map from the base of video
// memory or as a physical mem address (for AGP surfaces). This
// cases will be taken care of by DDSurf_SurfaceOffsetFromMemoryBase.
pTexture->MipLevels[LOD].dwOffsetFromMemoryBase = DDSurf_SurfaceOffsetFromMemoryBase(pThisDisplay, pSurf);
// Store the DD surface's fpVidMem ptr
pTexture->MipLevels[LOD].fpVidMem = pSurf->lpGbl->fpVidMem;
// The TextureMapWidth hardware register holds width, layout, border and
// AGP settings, and we will create an instance for each miplevel we'll use
// Store the layout for this texture map
// (linear layout is always used in this driver, we don't use patched surfs)
pTexture->MipLevels[LOD].P3RXTextureMapWidth.Layout = P3RX_LAYOUT_LINEAR;
// Store the pitch for this texture map level
pTexture->MipLevels[LOD].P3RXTextureMapWidth.Width = DDSurf_GetPixelPitch(pSurf);
// Store the DD surface's lPitch
pTexture->MipLevels[LOD].lPitch = pSurf->lpGbl->lPitch; // Store AGP settings for this texture map
if( pSurf->ddsCaps.dwCaps & DDSCAPS_NONLOCALVIDMEM ) pTexture->MipLevels[LOD].P3RXTextureMapWidth.HostTexture = 1; else pTexture->MipLevels[LOD].P3RXTextureMapWidth.HostTexture = 0;
// Store mip level size
pTexture->MipLevels[LOD].wWidth = (int)pSurf->lpGbl->wWidth; pTexture->MipLevels[LOD].wHeight = (int)pSurf->lpGbl->wHeight; pTexture->MipLevels[LOD].logWidth = log2((int)pSurf->lpGbl->wWidth); pTexture->MipLevels[LOD].logHeight = log2((int)pSurf->lpGbl->wHeight); } // _D3D_SU_SurfInternalSetMipMapLevelData
//-----------------------------------------------------------------------------
//
// _D3D_SU_SurfInternalSetData
//
// Sets up all the necessary data for an internal surface structure.
//
//-----------------------------------------------------------------------------
BOOL _D3D_SU_SurfInternalSetData( P3_THUNKEDDATA *pThisDisplay, P3_SURF_INTERNAL *pSurface, LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl, DWORD dwSurfaceHandle) { DBG_ENTRY(_D3D_SU_SurfInternalSetData);
// Store the pointer to the texture in the structure
pSurface->pFormatSurface = _DD_SUR_GetSurfaceFormat(pDDSLcl); DBGDUMP_DDRAWSURFACE_LCL(DBGLVL, pDDSLcl);
// Initially no LUT
pSurface->dwLUTOffset = 0;
// Need to remember the sizes and the log of the sizes of the maps
pSurface->wWidth = (WORD)(pDDSLcl->lpGbl->wWidth); pSurface->wHeight = (WORD)(pDDSLcl->lpGbl->wHeight); pSurface->fArea = (float)pSurface->wWidth * (float)pSurface->wHeight; pSurface->logWidth = log2((int)pDDSLcl->lpGbl->wWidth); pSurface->logHeight = log2((int)pDDSLcl->lpGbl->wHeight);
// Store the pointer to surface memory
pSurface->fpVidMem = pDDSLcl->lpGbl->fpVidMem;
// Magic number for validity check
pSurface->MagicNo = SURF_MAGIC_NO;
// This value is used if the texture turns out to be agp
pSurface->dwGARTDevLast = pThisDisplay->dwGARTDev;
// For AGP and correct rendering we need to know where the surface is stored
if(pDDSLcl->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) { if (pDDSLcl->ddsCaps.dwCaps & DDSCAPS_NONLOCALVIDMEM) { DISPDBG((DBGLVL," Surface %d is in AGP Memory",dwSurfaceHandle)); pSurface->Location = AGPMemory; } else { DISPDBG((DBGLVL," Surface %d is in Video Memory",dwSurfaceHandle)); pSurface->Location = VideoMemory; } } else { DISPDBG((DBGLVL," Surface %d is in system memory - " "disabling use for rendering", dwSurfaceHandle)); pSurface->Location = SystemMemory; }
// Store caps & other DD fields for later
pSurface->ddsCapsInt = pDDSLcl->ddsCaps; pSurface->dwFlagsInt = pDDSLcl->dwFlags; pSurface->dwCKLow = pDDSLcl->ddckCKSrcBlt.dwColorSpaceLowValue; pSurface->dwCKHigh = pDDSLcl->ddckCKSrcBlt.dwColorSpaceHighValue; pSurface->pixFmt = *DDSurf_GetPixelFormat(pDDSLcl); pSurface->dwPixelSize = DDSurf_GetChipPixelSize(pDDSLcl); pSurface->dwPixelPitch = DDSurf_GetPixelPitch(pDDSLcl); pSurface->dwPatchMode = P3RX_LAYOUT_LINEAR; pSurface->lOffsetFromMemoryBase = DDSurf_SurfaceOffsetFromMemoryBase(pThisDisplay, pDDSLcl); pSurface->lPitch = pDDSLcl->lpGbl->lPitch; pSurface->dwBitDepth = DDSurf_BitDepth(pDDSLcl);
#if DX7_TEXMANAGEMENT
_D3D_TM_InitSurfData(pSurface, pDDSLcl); #endif
#if DX8_MULTISAMPLING
pSurface->dwSampling = (pDDSLcl->lpSurfMore->ddsCapsEx.dwCaps3 & DDSCAPS3_MULTISAMPLE_MASK ); #endif // DX8_MULTISAMPLING
// Additional surface setup if it is a texture
if (pDDSLcl->ddsCaps.dwCaps & DDSCAPS_TEXTURE ) { LPDDRAWI_DDRAWSURFACE_LCL lpNextSurf; int iLOD; lpNextSurf = pDDSLcl; iLOD = 0;
#if DX8_3DTEXTURES
if ((pDDSLcl->lpSurfMore->ddsCapsEx.dwCaps2 & DDSCAPS2_VOLUME) && (pSurface->dwBitDepth != 0)) { // Mark this texture as 3D texture.
pSurface->b3DTexture = TRUE; pSurface->wDepth = LOWORD(pDDSLcl->lpSurfMore->ddsCapsEx.dwCaps4); pSurface->logDepth = log2((int)pSurface->wDepth); pSurface->dwSlice = pDDSLcl->lpGbl->dwBlockSizeY; pSurface->dwSliceInTexel = pDDSLcl->lpGbl->dwBlockSizeY / (DDSurf_BitDepth(pDDSLcl) / 8); } else { // Not a 3D texture
pSurface->b3DTexture = FALSE; pSurface->wDepth = 0; pSurface->logDepth = 0; pSurface->dwSlice = 0; pSurface->dwSliceInTexel = 0; } #endif // DX8_3DTEXTURES
// For Permedia the texture offset is in pixels.
// Store the offsets for each of the mipmap levels
if (pDDSLcl->ddsCaps.dwCaps & DDSCAPS_MIPMAP) { BOOL bMoreSurfaces = TRUE;
pSurface->bMipMap = TRUE;
// Walk the chain of surfaces and find all of the mipmap levels
do { DISPDBG((DBGLVL, "Loading texture iLOD:%d, Ptr:0x%x", iLOD, lpNextSurf->lpGbl->fpVidMem));
_D3D_SU_SurfInternalSetMipMapLevelData(pThisDisplay, pSurface, lpNextSurf, iLOD);
// Is there another surface in the chain?
if (lpNextSurf->lpAttachList) lpNextSurf = lpNextSurf->lpAttachList->lpAttached; else bMoreSurfaces = FALSE;
iLOD++; } while( bMoreSurfaces );
// This isn't really a MipMap if iLOD is 1
if (iLOD == 1) { DISPDBG((DBGLVL, "Texture was not a mipmap - only 1 level")); pSurface->bMipMap = FALSE; }
pSurface->iMipLevels = iLOD; } else // NOT A MIPMAP, simply store away the offset
{ pSurface->bMipMap = FALSE; pSurface->iMipLevels = 1; _D3D_SU_SurfInternalSetMipMapLevelData(pThisDisplay, pSurface, lpNextSurf, iLOD); } } // if (pDDSLcl->ddsCaps.dwCaps & DDSCAPS_TEXTURE )
#if DX7_PALETTETEXTURE
// Initialize the palette handle and flags
pSurface->dwPaletteHandle = 0; pSurface->dwPaletteFlags = 0; #endif
DBG_EXIT(_D3D_SU_SurfInternalSetData, TRUE); return TRUE; } // _D3D_SU_SurfInternalSetData
//-----------------------------------------------------------------------------
//
// _D3D_SU_SurfaceArrayDestroyCallback
//
// Called when a surface is removed from the pointer array associated with a
// DirectDraw local. Simply frees the memory
//-----------------------------------------------------------------------------
void _D3D_SU_SurfaceArrayDestroyCallback( PointerArray* pArray, void* pData, void* pExtra) { P3_SURF_INTERNAL* pTexture = (P3_SURF_INTERNAL*)pData; P3_THUNKEDDATA *pThisDisplay = (P3_THUNKEDDATA*)pExtra; DBG_ENTRY(_D3D_SU_SurfaceArrayDestroyCallback);
#if DX7_TEXMANAGEMENT
if (pTexture->dwCaps2 & DDSCAPS2_TEXTUREMANAGE) { _D3D_TM_RemoveTexture(pThisDisplay, pTexture); } #endif
// Simply free the data
HEAP_FREE(pData);
DBG_EXIT(_D3D_SU_SurfaceArrayDestroyCallback, TRUE); } // _D3D_SU_SurfaceArrayDestroyCallback
//-----------------------------------------------------------------------------
//
// _D3D_SU_DirectDrawLocalDestroyCallback
//
// Called when a directdraw local is removed from the hash table.
// We use the pointer associated with it to free the pointer array that
// was created.
//
//-----------------------------------------------------------------------------
void _D3D_SU_DirectDrawLocalDestroyCallback( HashTable* pTable, void* pData, void* pExtra) { PointerArray* pPointerArray = (PointerArray*)pData;
DBG_ENTRY(_D3D_SU_DirectDrawLocalDestroyCallback);
if (pPointerArray) {
DISPDBG((DBGLVL, "Destroying an array of surface pointers for this " "LCL ddraw object")); // The data hanging off the local object is a pointerarray.
// Calling destory will cause it to free the data items through the
// callback if one is registered.
PA_DestroyArray(pPointerArray, pExtra); } DBG_EXIT(_D3D_SU_DirectDrawLocalDestroyCallback, TRUE); } // _D3D_SU_DirectDrawLocalDestroyCallback
#if DX7_PALETTETEXTURE
//-----------------------------------------------------------------------------
//
// _D3D_SU_PaletteArrayDestroyCallback
//
// Called when a palette is removed from the pointer array.
// Simply frees the memory
//-----------------------------------------------------------------------------
void _D3D_SU_PaletteArrayDestroyCallback( PointerArray* pArray, void* pData, void* pExtra) { DBG_ENTRY(_D3D_SU_PaletteArrayDestroyCallback);
// Simply free the data
HEAP_FREE(pData);
DBG_EXIT(_D3D_SU_PaletteArrayDestroyCallback, TRUE);
} // _D3D_SU_PaletteArrayDestroyCallback
#endif // DX7_PALETTESURFACE
//-----------------------------------------------------------------------------
//
// _D3D_SU_DumpSurfInternal
//
// Dumps into the debugger the drivers private data structure for the surface
//
//-----------------------------------------------------------------------------
void _D3D_SU_DumpSurfInternal( DWORD lvl, char *psHeader, P3_SURF_INTERNAL *pSurface) { int i; DISPDBG((lvl,"Dumping %s surface @ %x",psHeader,pSurface)); DISPDBG((lvl," MagicNo = 0x%x",pSurface->MagicNo)); DISPDBG((lvl," pFormatSurface = 0x%x",pSurface->pFormatSurface)); // P3_SURF_FORMAT* pFormatSurface;
DISPDBG((lvl," Location = %d",pSurface->Location)); DISPDBG((lvl," dwLUTOffset = 0x%x",pSurface->dwLUTOffset)); DISPDBG((lvl," dwGARTDevLast = 0x%x",pSurface->dwGARTDevLast)); DISPDBG((lvl," wWidth = %d",(LONG)pSurface->wWidth)); DISPDBG((lvl," wHeight = %d",(LONG)pSurface->wHeight)); DISPDBG((lvl," logWidth = %d",pSurface->logWidth)); DISPDBG((lvl," logHeight = %d",pSurface->logHeight)); DISPDBG((lvl," fArea = 0x%x",*(DWORD *)&pSurface->fArea)); // DDSCAPS ddsCapsInt;
DISPDBG((lvl," dwFlagsInt = 0x%x",pSurface->dwFlagsInt)); DISPDBG((lvl," dwCKLow = 0x%x",pSurface->dwCKLow)); DISPDBG((lvl," dwCKHigh = 0x%x",pSurface->dwCKHigh)); // DDPIXELFORMAT pixFmt;
DISPDBG((lvl," dwPixelSize = 0x%x",pSurface->dwPixelSize)); DISPDBG((lvl," dwPixelPitch = 0x%x",pSurface->dwPixelPitch)); DISPDBG((lvl," dwPatchMode = 0x%x",pSurface->dwPatchMode)); DISPDBG((lvl," lPitch = 0x%x",pSurface->lPitch)); DISPDBG((lvl," fpVidMem = 0x%x",pSurface->fpVidMem)); #if DX8_3DTEXTURES
DISPDBG((lvl," b3DTexture = 0x%x",pSurface->b3DTexture)); DISPDBG((lvl," wDepth = %d",(LONG)pSurface->wDepth)); #endif // DX8_3DTEXTURES
DISPDBG((lvl," bMipMap = 0x%x",pSurface->bMipMap)); DISPDBG((lvl," iMipLevels = %d",pSurface->iMipLevels));
for (i = 0; i < pSurface->iMipLevels; i++) { DISPDBG((lvl," MipLevels[%d].logWidth = 0x%x", i,pSurface->MipLevels[i].logWidth)); DISPDBG((lvl," MipLevels[%d].logHeight = 0x%x", i,pSurface->MipLevels[i].logHeight)); DISPDBG((lvl," MipLevels[%d].dwOffsetFromMemoryBase = 0x%x", i,pSurface->MipLevels[i].dwOffsetFromMemoryBase)); DISPDBG((lvl," MipLevels[%d].fpVidMem = 0x%x", i,pSurface->MipLevels[i].fpVidMem)); DISPDBG((lvl," MipLevels[%d].lPitch = 0x%x", i,pSurface->MipLevels[i].lPitch)); DISPDBG((lvl," MipLevels[%d].P3RXTextureMapWidth = 0x%x", i,*(DWORD*)(&pSurface->MipLevels[i].P3RXTextureMapWidth))); }
} // _D3D_SU_DumpSurfInternal
|