D3DFORMAT CDxtexDoc::GetFormat(LPDIRECT3DBASETEXTURE9 ptex)
{
LPDIRECT3DTEXTURE9 pmiptex = NULL;
LPDIRECT3DCUBETEXTURE9 pcubetex = NULL;
LPDIRECT3DVOLUMETEXTURE9 pvoltex = NULL;
D3DFORMAT fmt = D3DFMT_UNKNOWN;
if (IsVolumeMap())
pvoltex = (LPDIRECT3DVOLUMETEXTURE9)ptex;
else if (IsCubeMap())
pcubetex = (LPDIRECT3DCUBETEXTURE9)ptex;
else
pmiptex = (LPDIRECT3DTEXTURE9)ptex;
if (pvoltex != NULL)
{
D3DVOLUME_DESC vd;
pvoltex->GetLevelDesc(0, &vd);
fmt = vd.Format;
}
else if (pcubetex != NULL)
{
D3DSURFACE_DESC sd;
pcubetex->GetLevelDesc(0, &sd);
fmt = sd.Format;
}
else if( pmiptex != NULL )
{
D3DSURFACE_DESC sd;
pmiptex->GetLevelDesc(0, &sd);
fmt = sd.Format;
}
return fmt;
}
void SetD3DResourcePrivateData(LPDIRECT3DRESOURCE9 res, const char* FName)
{
#if R3D_SET_DEBUG_D3D_NAMES
DWORD sz = strlen(FName);
res->SetPrivateData(WKPDID_D3DDebugObjectName, FName, sz, 0);
void* p = 0;
res->QueryInterface(IID_IDirect3DTexture9, &p);
if(p)
{
LPDIRECT3DTEXTURE9 t = (LPDIRECT3DTEXTURE9)p;
int mipsCount = t->GetLevelCount();
for (int i = 0; i < mipsCount; ++i)
{
LPDIRECT3DSURFACE9 surf;
t->GetSurfaceLevel(i, &surf);
surf->SetPrivateData(WKPDID_D3DDebugObjectName, FName, sz, 0);
surf->Release();
}
t->Release();
return;
}
p = 0;
res->QueryInterface(IID_IDirect3DCubeTexture9, &p);
if(p)
{
LPDIRECT3DCUBETEXTURE9 t = (LPDIRECT3DCUBETEXTURE9)p;
int mipsCount = t->GetLevelCount();
for (int i = 0; i < mipsCount; ++i)
{
for (int j = D3DCUBEMAP_FACE_POSITIVE_X; j <= D3DCUBEMAP_FACE_NEGATIVE_Z; ++j)
{
LPDIRECT3DSURFACE9 surf;
t->GetCubeMapSurface((D3DCUBEMAP_FACES)j, i, &surf);
surf->SetPrivateData(WKPDID_D3DDebugObjectName, FName, sz, 0);
surf->Release();
}
}
t->Release();
return;
}
#endif
}
void CDxtexDoc::OnFormatChangeCubeMapFaces()
{
HRESULT hr;
LPDIRECT3DDEVICE9 pd3ddev = PDxtexApp()->Pd3ddev();
D3DSURFACE_DESC sd;
LPDIRECT3DCUBETEXTURE9 ptexCube;
DWORD iLevel;
LPDIRECT3DSURFACE9 psurfSrc;
LPDIRECT3DSURFACE9 psurfDest;
CCubeMapDlg cubeMapDlg;
if (IDCANCEL == cubeMapDlg.DoModal())
return;
// Change m_ptexOrig into a cubemap
((LPDIRECT3DTEXTURE9)m_ptexOrig)->GetLevelDesc(0, &sd);
hr = D3DXCreateCubeTexture(pd3ddev, m_dwWidth, m_numMips, 0, sd.Format, D3DPOOL_MANAGED, &ptexCube);
for (iLevel = 0; iLevel < m_numMips; iLevel++)
{
hr = ((LPDIRECT3DTEXTURE9)m_ptexOrig)->GetSurfaceLevel(iLevel, &psurfSrc);
hr = ptexCube->GetCubeMapSurface((D3DCUBEMAP_FACES)cubeMapDlg.m_iFace, iLevel, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL,
psurfSrc, NULL, NULL, D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
}
ReleasePpo(&m_ptexOrig);
m_ptexOrig = ptexCube;
// Change m_ptexNew into a cubemap too
if (m_ptexNew != NULL)
{
((LPDIRECT3DTEXTURE9)m_ptexNew)->GetLevelDesc(0, &sd);
hr = D3DXCreateCubeTexture(pd3ddev, m_dwWidth, m_numMips, 0, sd.Format, D3DPOOL_MANAGED, &ptexCube);
for (iLevel = 0; iLevel < m_numMips; iLevel++)
{
hr = ((LPDIRECT3DTEXTURE9)m_ptexNew)->GetSurfaceLevel(iLevel, &psurfSrc);
hr = ptexCube->GetCubeMapSurface((D3DCUBEMAP_FACES)cubeMapDlg.m_iFace, iLevel, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL,
psurfSrc, NULL, NULL, D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
}
ReleasePpo(&m_ptexNew);
m_ptexNew = ptexCube;
}
m_dwCubeMapFlags = DDS_CUBEMAP_ALLFACES;
SetModifiedFlag();
UpdateAllViews(NULL, 1); // tell CView to pick up new surface pointers
}
HRESULT KG3DPointLightShadow::ComputeCubeMapForPosition(D3DXVECTOR3 vPosition,KG3DScenePvsEditor* pScene,LPDIRECT3DCUBETEXTURE9 pCubeColor,LPDIRECT3DCUBETEXTURE9 pCubeDepth,KG3DRenderTargetTool* pToolColor,KG3DRenderTargetTool* pToolDepth)
{
HRESULT hr = E_FAIL;
for( UINT i = 0; i < 6; i++ )
{
// Set the view transform for this cubemap surface
D3DUtil_GetCubeMapViewMatrix( (D3DCUBEMAP_FACES) i ,vPosition,m_vShadowMap.m_vCameraLight);
m_vShadowMap.m_vCameraLight.SetPerspective(D3DX_PI / 2,1,5,40000 );
m_vShadowMap.m_vCameraLight.SetCamera();
m_vShadowMap.ProcessShadowMapWithPVS((KG3DRepresentObjectPVS*)pScene->GetPvs());
//////////////////////////////////////////////////////////////////////////
if(pCubeDepth)
{
LPDIRECT3DSURFACE9 pDest = NULL;
hr = pCubeDepth->GetCubeMapSurface((D3DCUBEMAP_FACES)i,0,&pDest);
KGLOG_COM_PROCESS_ERROR(hr);
ExportToCubeSurface(pToolDepth,pDest,TRUE);
SAFE_RELEASE(pDest);
}
if(pCubeColor)
{
LPDIRECT3DSURFACE9 pDest = NULL;
hr = pCubeColor->GetCubeMapSurface((D3DCUBEMAP_FACES)i,0,&pDest);
KGLOG_COM_PROCESS_ERROR(hr);
ExportToCubeSurface(pToolColor,pDest,FALSE);
SAFE_RELEASE(pDest);
}
}
//////////////////////////////////////////////////////////////////////////
hr = S_OK;
Exit0:
return hr;
}
void Cleanup()
{
// 폰트를 release 한다.
if (gpFont)
{
gpFont->Release();
gpFont = NULL;
}
// 모델을 release 한다.
if (gpTeapot)
{
gpTeapot->Release();
gpTeapot = NULL;
}
// 쉐이더를 release 한다.
if (gpEnvironmentMappingShader)
{
gpEnvironmentMappingShader->Release();
gpEnvironmentMappingShader = NULL;
}
// 텍스처를 release 한다.
if (gpStoneDM)
{
gpStoneDM->Release();
gpStoneDM = NULL;
}
if (gpStoneSM)
{
gpStoneSM->Release();
gpStoneSM = NULL;
}
if (gpStoneNM)
{
gpStoneNM->Release();
gpStoneNM = NULL;
}
if (gpSnowENV)
{
gpSnowENV->Release();
gpSnowENV = NULL;
}
// D3D를 release 한다.
if (gpD3DDevice)
{
gpD3DDevice->Release();
gpD3DDevice = NULL;
}
if (gpD3D)
{
gpD3D->Release();
gpD3D = NULL;
}
}
void Cleanup()
{
// release fonts
if (gpFont)
{
gpFont->Release();
gpFont = NULL;
}
// release models
if (gpTeapot)
{
gpTeapot->Release();
gpTeapot = NULL;
}
// release shaders
if (gpEnvironmentMappingShader)
{
gpEnvironmentMappingShader->Release();
gpEnvironmentMappingShader = NULL;
}
if (gpNoEffect)
{
gpNoEffect->Release();
gpNoEffect = NULL;
}
if (gpGrayScale)
{
gpGrayScale->Release();
gpGrayScale = NULL;
}
if (gpSepia)
{
gpSepia->Release();
gpSepia = NULL;
}
// release textures
if (gpStoneDM)
{
gpStoneDM->Release();
gpStoneDM = NULL;
}
if (gpStoneSM)
{
gpStoneSM->Release();
gpStoneSM = NULL;
}
if (gpStoneNM)
{
gpStoneNM->Release();
gpStoneNM = NULL;
}
if (gpSnowENV)
{
gpSnowENV->Release();
gpSnowENV = NULL;
}
// Release the fullscreen quad
if (gpFullscreenQuadDecl)
{
gpFullscreenQuadDecl->Release();
gpFullscreenQuadDecl = NULL;
}
if (gpFullscreenQuadVB)
{
gpFullscreenQuadVB->Release();
gpFullscreenQuadVB = NULL;
}
if (gpFullscreenQuadIB)
{
gpFullscreenQuadIB->Release();
gpFullscreenQuadIB = NULL;
}
// release the render target
if (gpSceneRenderTarget)
{
gpSceneRenderTarget->Release();
gpSceneRenderTarget = NULL;
}
// release D3D
if (gpD3DDevice)
{
gpD3DDevice->Release();
gpD3DDevice = NULL;
}
if (gpD3D)
{
gpD3D->Release();
gpD3D = NULL;
}
}
void CDxtexDoc::GenerateMipMaps()
{
LONG lwTempH;
LONG lwTempW;
LONG lwPowsW;
LONG lwPowsH;
LPDIRECT3DTEXTURE9 pddsNew = NULL;
D3DFORMAT fmt;
HRESULT hr;
LPDIRECT3DDEVICE9 pd3ddev = PDxtexApp()->Pd3ddev();
LPDIRECT3DTEXTURE9 pmiptex = NULL;
LPDIRECT3DCUBETEXTURE9 pcubetex = NULL;
LPDIRECT3DVOLUMETEXTURE9 pvoltex = NULL;
LPDIRECT3DTEXTURE9 pmiptexNew = NULL;
LPDIRECT3DCUBETEXTURE9 pcubetexNew = NULL;
LPDIRECT3DVOLUMETEXTURE9 pvoltexNew = NULL;
LPDIRECT3DSURFACE9 psurfSrc;
LPDIRECT3DSURFACE9 psurfDest;
LPDIRECT3DVOLUME9 pvolSrc;
LPDIRECT3DVOLUME9 pvolDest;
if (IsVolumeMap())
pvoltex = (LPDIRECT3DVOLUMETEXTURE9)m_ptexOrig;
else if (IsCubeMap())
pcubetex = (LPDIRECT3DCUBETEXTURE9)m_ptexOrig;
else
pmiptex = (LPDIRECT3DTEXTURE9)m_ptexOrig;
if (pvoltex != NULL)
{
D3DVOLUME_DESC vd;
pvoltex->GetLevelDesc(0, &vd);
fmt = vd.Format;
}
else if (pcubetex != NULL)
{
D3DSURFACE_DESC sd;
pcubetex->GetLevelDesc(0, &sd);
fmt = sd.Format;
}
else
{
D3DSURFACE_DESC sd;
pmiptex->GetLevelDesc(0, &sd);
fmt = sd.Format;
}
lwTempW = m_dwWidth;
lwTempH = m_dwHeight;
lwPowsW = 0;
lwPowsH = 0;
while (lwTempW > 0)
{
lwPowsW++;
lwTempW = lwTempW / 2;
}
while (lwTempH > 0)
{
lwPowsH++;
lwTempH = lwTempH / 2;
}
m_numMips = lwPowsW > lwPowsH ? lwPowsW : lwPowsH;
// Create destination mipmap surface - same format as source
if (pvoltex != NULL)
{
if (FAILED(hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, m_dwDepth,
m_numMips, 0, fmt, D3DPOOL_SYSTEMMEM, &pvoltexNew, NULL)))
{
goto LFail;
}
hr = pvoltex->GetVolumeLevel(0, &pvolSrc);
hr = pvoltexNew->GetVolumeLevel(0, &pvolDest);
hr = D3DXLoadVolumeFromVolume(pvolDest, NULL, NULL, pvolSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&pvolSrc);
ReleasePpo(&pvolDest);
hr = D3DXFilterVolumeTexture(pvoltexNew, NULL, 0, D3DX_DEFAULT);
}
else if (pmiptex != NULL)
{
if (FAILED(hr = pd3ddev->CreateTexture(m_dwWidth, m_dwHeight, m_numMips,
0, fmt, D3DPOOL_MANAGED, &pmiptexNew, NULL)))
{
goto LFail;
}
hr = pmiptex->GetSurfaceLevel(0, &psurfSrc);
hr = pmiptexNew->GetSurfaceLevel(0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = D3DXFilterTexture(pmiptexNew, NULL, 0, D3DX_DEFAULT);
}
else
{
if (FAILED(hr = pd3ddev->CreateCubeTexture(m_dwWidth, m_numMips,
0, fmt, D3DPOOL_MANAGED, &pcubetexNew, NULL)))
{
goto LFail;
}
hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &psurfSrc);
hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_X, 0, &psurfSrc);
hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_X, 0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Y, 0, &psurfSrc);
hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Y, 0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Y, 0, &psurfSrc);
hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Y, 0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Z, 0, &psurfSrc);
hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Z, 0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Z, 0, &psurfSrc);
hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Z, 0, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL,
D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
hr = D3DXFilterCubeTexture(pcubetexNew, NULL, 0, D3DX_DEFAULT);
}
ReleasePpo(&m_ptexOrig);
if (pvoltexNew != NULL)
m_ptexOrig = pvoltexNew;
else if (pcubetexNew != NULL)
m_ptexOrig = pcubetexNew;
else
m_ptexOrig = pmiptexNew;
if (m_ptexNew != NULL)
{
// Rather than filtering down the (probably-compressed) m_ptexNew
// top level, compress each mip level from the (probably-uncompressed)
// m_ptexOrig levels.
if (pvoltexNew != NULL)
{
D3DVOLUME_DESC vd;
((LPDIRECT3DVOLUMETEXTURE9)m_ptexNew)->GetLevelDesc(0, &vd);
fmt = vd.Format;
}
else if (pcubetexNew != NULL)
{
D3DSURFACE_DESC sd;
((LPDIRECT3DTEXTURE9)m_ptexNew)->GetLevelDesc(0, &sd);
fmt = sd.Format;
}
else
{
D3DSURFACE_DESC sd;
((LPDIRECT3DCUBETEXTURE9)m_ptexNew)->GetLevelDesc(0, &sd);
fmt = sd.Format;
}
Compress(fmt, FALSE);
}
m_bTitleModsChanged = TRUE; // Generate title bar update
UpdateAllViews(NULL, 1); // tell CView to pick up new surface pointers
SetModifiedFlag();
return;
LFail:
ReleasePpo(&pddsNew);
}
HRESULT CDxtexDoc::ChangeFormat(LPDIRECT3DBASETEXTURE9 ptexCur, D3DFORMAT fmtTo,
LPDIRECT3DBASETEXTURE9* pptexNew)
{
HRESULT hr;
LPDIRECT3DDEVICE9 pd3ddev = PDxtexApp()->Pd3ddev();
LPDIRECT3DTEXTURE9 pmiptex;
LPDIRECT3DCUBETEXTURE9 pcubetex;
LPDIRECT3DVOLUMETEXTURE9 pvoltex;
D3DFORMAT fmtFrom;
LPDIRECT3DTEXTURE9 pmiptexNew;
LPDIRECT3DCUBETEXTURE9 pcubetexNew;
LPDIRECT3DVOLUMETEXTURE9 pvoltexNew;
if (IsVolumeMap())
{
pvoltex = (LPDIRECT3DVOLUMETEXTURE9)ptexCur;
D3DVOLUME_DESC vd;
pvoltex->GetLevelDesc(0, &vd);
fmtFrom = vd.Format;
}
else if (IsCubeMap())
{
pcubetex = (LPDIRECT3DCUBETEXTURE9)ptexCur;
D3DSURFACE_DESC sd;
pcubetex->GetLevelDesc(0, &sd);
fmtFrom = sd.Format;
}
else
{
pmiptex = (LPDIRECT3DTEXTURE9)ptexCur;
D3DSURFACE_DESC sd;
pmiptex->GetLevelDesc(0, &sd);
fmtFrom = sd.Format;
}
if (fmtFrom == D3DFMT_DXT2 || fmtFrom == D3DFMT_DXT4)
{
if (fmtTo == D3DFMT_DXT1)
{
AfxMessageBox(ID_ERROR_PREMULTTODXT1);
}
else if (fmtTo != D3DFMT_DXT2 && fmtTo != D3DFMT_DXT4)
{
AfxMessageBox(ID_ERROR_PREMULTALPHA);
return S_OK;
}
}
if (IsVolumeMap())
{
hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, m_dwDepth, m_numMips,
0, fmtTo, D3DPOOL_SYSTEMMEM, &pvoltexNew, NULL);
if (FAILED(hr))
return hr;
*pptexNew = pvoltexNew;
if (FAILED(BltAllLevels(D3DCUBEMAP_FACE_FORCE_DWORD, ptexCur, *pptexNew)))
return hr;
}
else if (IsCubeMap())
{
hr = pd3ddev->CreateCubeTexture(m_dwWidth, m_numMips,
0, fmtTo, D3DPOOL_MANAGED, &pcubetexNew, NULL);
if (FAILED(hr))
return hr;
*pptexNew = pcubetexNew;
if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_X, ptexCur, *pptexNew)))
return hr;
if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_X, ptexCur, *pptexNew)))
return hr;
if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_Y, ptexCur, *pptexNew)))
return hr;
if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_Y, ptexCur, *pptexNew)))
return hr;
if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_Z, ptexCur, *pptexNew)))
return hr;
if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_Z, ptexCur, *pptexNew)))
return hr;
}
else
{
if ((fmtTo == D3DFMT_DXT1 || fmtTo == D3DFMT_DXT2 ||
fmtTo == D3DFMT_DXT3 || fmtTo == D3DFMT_DXT4 ||
fmtTo == D3DFMT_DXT5) && (m_dwWidth % 4 != 0 || m_dwHeight % 4 != 0))
{
AfxMessageBox(ID_ERROR_NEEDMULTOF4);
return E_FAIL;
}
hr = pd3ddev->CreateTexture(m_dwWidth, m_dwHeight, m_numMips,
0, fmtTo, D3DPOOL_MANAGED, &pmiptexNew, NULL);
if (FAILED(hr))
return hr;
*pptexNew = pmiptexNew;
if (FAILED(BltAllLevels(D3DCUBEMAP_FACE_FORCE_DWORD, ptexCur, *pptexNew)))
return hr;
}
return S_OK;
}
HRESULT CDxtexDoc::BltAllLevels(D3DCUBEMAP_FACES FaceType,
LPDIRECT3DBASETEXTURE9 ptexSrc, LPDIRECT3DBASETEXTURE9 ptexDest)
{
HRESULT hr;
LPDIRECT3DTEXTURE9 pmiptexSrc;
LPDIRECT3DTEXTURE9 pmiptexDest;
LPDIRECT3DCUBETEXTURE9 pcubetexSrc;
LPDIRECT3DCUBETEXTURE9 pcubetexDest;
LPDIRECT3DVOLUMETEXTURE9 pvoltexSrc;
LPDIRECT3DVOLUMETEXTURE9 pvoltexDest;
DWORD iLevel;
if (IsVolumeMap())
{
pvoltexSrc = (LPDIRECT3DVOLUMETEXTURE9)ptexSrc;
pvoltexDest = (LPDIRECT3DVOLUMETEXTURE9)ptexDest;
}
else if (IsCubeMap())
{
pcubetexSrc = (LPDIRECT3DCUBETEXTURE9)ptexSrc;
pcubetexDest = (LPDIRECT3DCUBETEXTURE9)ptexDest;
}
else
{
pmiptexSrc = (LPDIRECT3DTEXTURE9)ptexSrc;
pmiptexDest = (LPDIRECT3DTEXTURE9)ptexDest;
}
for (iLevel = 0; iLevel < m_numMips; iLevel++)
{
if (IsVolumeMap())
{
LPDIRECT3DVOLUME9 pvolSrc = NULL;
LPDIRECT3DVOLUME9 pvolDest = NULL;
hr = pvoltexSrc->GetVolumeLevel(iLevel, &pvolSrc);
hr = pvoltexDest->GetVolumeLevel(iLevel, &pvolDest);
hr = D3DXLoadVolumeFromVolume(pvolDest, NULL, NULL,
pvolSrc, NULL, NULL, D3DX_DEFAULT, 0);
ReleasePpo(&pvolSrc);
ReleasePpo(&pvolDest);
}
else if (IsCubeMap())
{
LPDIRECT3DSURFACE9 psurfSrc = NULL;
LPDIRECT3DSURFACE9 psurfDest = NULL;
hr = pcubetexSrc->GetCubeMapSurface(FaceType, iLevel, &psurfSrc);
hr = pcubetexDest->GetCubeMapSurface(FaceType, iLevel, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL,
psurfSrc, NULL, NULL, D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
}
else
{
LPDIRECT3DSURFACE9 psurfSrc = NULL;
LPDIRECT3DSURFACE9 psurfDest = NULL;
hr = pmiptexSrc->GetSurfaceLevel(iLevel, &psurfSrc);
hr = pmiptexDest->GetSurfaceLevel(iLevel, &psurfDest);
hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL,
psurfSrc, NULL, NULL, D3DX_DEFAULT, 0);
ReleasePpo(&psurfSrc);
ReleasePpo(&psurfDest);
}
}
return S_OK;
}
