mirror of
https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
synced 2025-07-21 04:39:45 +00:00
Hoist MOULOpenSourceClientPlugin/Plasma20/* to top level
to match H'uru layout and make patching/cherry-picking easier.
This commit is contained in:
rarified
530
Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp
Normal file
530
Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp
Normal file
@ -0,0 +1,530 @@
|
||||
/*==LICENSE==*
|
||||
|
||||
CyanWorlds.com Engine - MMOG client, server and tools
|
||||
Copyright (C) 2011 Cyan Worlds, Inc.
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
Additional permissions under GNU GPL version 3 section 7
|
||||
|
||||
If you modify this Program, or any covered work, by linking or
|
||||
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
|
||||
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
|
||||
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
|
||||
(or a modified version of those libraries),
|
||||
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
|
||||
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
|
||||
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
|
||||
licensors of this Program grant you additional
|
||||
permission to convey the resulting work. Corresponding Source for a
|
||||
non-source form of such a combination shall include the source code for
|
||||
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
|
||||
work.
|
||||
|
||||
You can contact Cyan Worlds, Inc. by email legal@cyan.com
|
||||
or by snail mail at:
|
||||
Cyan Worlds, Inc.
|
||||
14617 N Newport Hwy
|
||||
Mead, WA 99021
|
||||
|
||||
*==LICENSE==*/
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// //
|
||||
// plDXDeviceRefs.cpp - Functions for the various DX DeviceRef classes //
|
||||
// Cyan, Inc. //
|
||||
// //
|
||||
//// Version History //////////////////////////////////////////////////////////
|
||||
// //
|
||||
// 4.25.2001 mcn - Created. //
|
||||
// //
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "hsTypes.h"
|
||||
|
||||
#include <d3d9.h>
|
||||
#include <ddraw.h>
|
||||
|
||||
#include "hsWinRef.h"
|
||||
|
||||
#include "plDXPipeline.h"
|
||||
#include "plDXDeviceRef.h"
|
||||
#include "plDXBufferRefs.h"
|
||||
#include "plDXLightRef.h"
|
||||
#include "plDXTextureRef.h"
|
||||
#include "plDXRenderTargetRef.h"
|
||||
#include "plGBufferGroup.h"
|
||||
#include "../plDrawable/plGeometrySpan.h"
|
||||
#include "../plDrawable/plDrawableSpans.h"
|
||||
#include "../plGLight/plLightInfo.h"
|
||||
#include "plRenderTarget.h"
|
||||
#include "plCubicRenderTarget.h"
|
||||
#include "plDynamicEnvMap.h"
|
||||
|
||||
#include "plProfile.h"
|
||||
#include "../plStatusLog/plStatusLog.h"
|
||||
|
||||
plProfile_CreateMemCounter("Vertices", "Memory", MemVertex);
|
||||
plProfile_CreateMemCounter("Indices", "Memory", MemIndex);
|
||||
plProfile_CreateMemCounter("Textures", "Memory", MemTexture);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//// Generic plDXDeviceRef Functions /////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
plDXDeviceRef::plDXDeviceRef()
|
||||
{
|
||||
fNext = nil;
|
||||
fBack = nil;
|
||||
}
|
||||
|
||||
plDXDeviceRef::~plDXDeviceRef()
|
||||
{
|
||||
if( fNext != nil || fBack != nil )
|
||||
Unlink();
|
||||
}
|
||||
|
||||
void plDXDeviceRef::Unlink( void )
|
||||
{
|
||||
hsAssert( fBack, "plDXDeviceRef not in list" );
|
||||
if( fNext )
|
||||
fNext->fBack = fBack;
|
||||
*fBack = fNext;
|
||||
|
||||
fBack = nil;
|
||||
fNext = nil;
|
||||
}
|
||||
|
||||
void plDXDeviceRef::Link( plDXDeviceRef **back )
|
||||
{
|
||||
hsAssert( fNext == nil && fBack == nil, "Trying to link a plDXDeviceRef that's already linked" );
|
||||
|
||||
fNext = *back;
|
||||
if( *back )
|
||||
(*back)->fBack = &fNext;
|
||||
fBack = back;
|
||||
*back = this;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//// plDXVertex/IndexBufferRef Funktions /////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//// Destructors //////////////////////////////////////////////////////////////
|
||||
|
||||
plDXVertexBufferRef::~plDXVertexBufferRef()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
plDXIndexBufferRef::~plDXIndexBufferRef()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
//// Releases /////////////////////////////////////////////////////////////////
|
||||
|
||||
void plDXVertexBufferRef::Release( void )
|
||||
{
|
||||
if( fD3DBuffer != nil )
|
||||
{
|
||||
ReleaseObject(fD3DBuffer);
|
||||
if (!Volatile())
|
||||
{
|
||||
plProfile_DelMem(MemVertex, fCount * fVertexSize);
|
||||
PROFILE_POOL_MEM(D3DPOOL_MANAGED, fCount * fVertexSize, false, "VtxBuff");
|
||||
plDXPipeline::FreeManagedVertex(fCount * fVertexSize);
|
||||
}
|
||||
}
|
||||
delete [] fData;
|
||||
fData = nil;
|
||||
|
||||
SetDirty( true );
|
||||
}
|
||||
|
||||
void plDXIndexBufferRef::Release( void )
|
||||
{
|
||||
if( fD3DBuffer != nil )
|
||||
{
|
||||
plProfile_DelMem(MemIndex, fCount * sizeof(UInt16));
|
||||
PROFILE_POOL_MEM(fPoolType, fCount * sizeof(UInt16), false, "IndexBuff");
|
||||
ReleaseObject( fD3DBuffer );
|
||||
}
|
||||
|
||||
SetDirty( true );
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//// plDXTextureRef Funktions ////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//// Set //////////////////////////////////////////////////////////////////////
|
||||
|
||||
plDXTextureRef& plDXTextureRef::Set( D3DFORMAT ft, UInt32 ml, UInt32 mw, UInt32 mh, UInt32 np,
|
||||
UInt32 sz, UInt32 manSize, UInt32* lSz, void* pd, hsBool ed, hsBool renderTarget )
|
||||
{
|
||||
if( fDataSize > 0 )
|
||||
plProfile_DelMem(MemTexture, fDataSize + sizeof(plDXTextureRef));
|
||||
|
||||
if( ( fFormatType != ft || fMMLvs != ml || fMaxWidth != mw || fMaxHeight != mh ) && fD3DTexture != nil )
|
||||
ReleaseObject( fD3DTexture );
|
||||
if( !fD3DTexture )
|
||||
fUseTime = 0;
|
||||
|
||||
fFormatType = ft;
|
||||
fMMLvs = ml;
|
||||
fMaxWidth = mw;
|
||||
fMaxHeight = mh;
|
||||
fNumPix = np;
|
||||
fDataSize = manSize;
|
||||
if( fLevelSizes != nil )
|
||||
delete [] fLevelSizes;
|
||||
if( lSz )
|
||||
fLevelSizes = lSz;
|
||||
else
|
||||
{
|
||||
fLevelSizes = TRACKED_NEW UInt32[1];
|
||||
fLevelSizes[0] = sz;
|
||||
}
|
||||
fData = pd;
|
||||
fFlags = ( ed ? kExternData : 0 ) | ( renderTarget ? kRenderTarget : 0 );
|
||||
|
||||
plProfile_NewMem(MemTexture, fDataSize + sizeof(plDXTextureRef));
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
//// Constructor & Destructor /////////////////////////////////////////////////
|
||||
|
||||
plDXTextureRef::plDXTextureRef( D3DFORMAT ft, UInt32 ml, UInt32 mw, UInt32 mh, UInt32 np,
|
||||
UInt32 sz, UInt32 manSize, UInt32* lSz, void* pd, hsBool ed, hsBool renderTarget )
|
||||
{
|
||||
fLevelSizes = nil;
|
||||
fOwner = nil;
|
||||
fD3DTexture = nil;
|
||||
fDataSize = 0;
|
||||
fFlags = 0;
|
||||
fFormatType = D3DFMT_UNKNOWN;
|
||||
fMMLvs = 0;
|
||||
fMaxWidth = 0;
|
||||
fMaxHeight = 0;
|
||||
Set( ft, ml, mw, mh, np, sz, manSize, lSz, pd, ed, renderTarget );
|
||||
}
|
||||
|
||||
plDXTextureRef::~plDXTextureRef()
|
||||
{
|
||||
Release();
|
||||
|
||||
delete [] fLevelSizes;
|
||||
}
|
||||
|
||||
//// Release //////////////////////////////////////////////////////////////////
|
||||
|
||||
void plDXTextureRef::Release( void )
|
||||
{
|
||||
plProfile_DelMem(MemTexture, fDataSize + sizeof(plDXTextureRef));
|
||||
plProfile_Extern(ManagedMem);
|
||||
PROFILE_POOL_MEM(D3DPOOL_MANAGED, fDataSize, false, (fOwner ? fOwner->GetKey() ? fOwner->GetKey()->GetUoid().GetObjectName() : "(UnknownTexture)" : "(UnknownTexture)"));
|
||||
plDXPipeline::FreeManagedTexture(fDataSize);
|
||||
fDataSize = 0;
|
||||
|
||||
ReleaseObject( fD3DTexture );
|
||||
SetDirty( true );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//// plDXLightRef Funktions //////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//// UpdateD3DInfo ////////////////////////////////////////////////////////////
|
||||
|
||||
#define SET_D3DCOLORVALUE( v, color ) { v.r = color.r; v.g = color.g; v.b = color.b; v.a = color.a; }
|
||||
|
||||
void plDXLightRef::UpdateD3DInfo( IDirect3DDevice9 *dev, plDXLightSettings *settings )
|
||||
{
|
||||
plDirectionalLightInfo *dirOwner;
|
||||
plOmniLightInfo *omniOwner;
|
||||
plSpotLightInfo *spotOwner;
|
||||
const float maxRange = 32767.f;
|
||||
|
||||
|
||||
/// Properties that are set for all types
|
||||
fD3DDevice = dev;
|
||||
fParentSettings = settings;
|
||||
|
||||
memset( &fD3DInfo, 0, sizeof( D3DLIGHT9 ) );
|
||||
SET_D3DCOLORVALUE( fD3DInfo.Diffuse, fOwner->GetDiffuse() );
|
||||
SET_D3DCOLORVALUE( fD3DInfo.Ambient, fOwner->GetAmbient() );
|
||||
SET_D3DCOLORVALUE( fD3DInfo.Specular, fOwner->GetSpecular() );
|
||||
|
||||
if( ( omniOwner = plOmniLightInfo::ConvertNoRef( fOwner ) ) != nil )
|
||||
{
|
||||
fD3DInfo.Type = D3DLIGHT_POINT;
|
||||
|
||||
hsPoint3 position = omniOwner->GetWorldPosition();
|
||||
fD3DInfo.Position.x = position.fX;
|
||||
fD3DInfo.Position.y = position.fY;
|
||||
fD3DInfo.Position.z = position.fZ;
|
||||
|
||||
if( omniOwner->GetRadius() == 0 )
|
||||
fD3DInfo.Range = maxRange;
|
||||
else
|
||||
fD3DInfo.Range = omniOwner->GetRadius();
|
||||
fD3DInfo.Attenuation0 = omniOwner->GetConstantAttenuation();
|
||||
fD3DInfo.Attenuation1 = omniOwner->GetLinearAttenuation();
|
||||
fD3DInfo.Attenuation2 = omniOwner->GetQuadraticAttenuation();
|
||||
|
||||
// If the light is a spot, but it has a projected texture, then
|
||||
// the cone attenuation is handled by the texture. We're only using
|
||||
// the D3D light for distance attenuation and the N*L term. So
|
||||
// we can just leave the D3D light as the cheaper and more stable
|
||||
// Omni light. This sort of obviates the change below. - mf
|
||||
if( !omniOwner->GetProjection()
|
||||
&& (spotOwner = plSpotLightInfo::ConvertNoRef(fOwner)) )
|
||||
{
|
||||
fD3DInfo.Type = D3DLIGHT_SPOT;
|
||||
|
||||
hsVector3 direction = spotOwner->GetWorldDirection();
|
||||
fD3DInfo.Direction.x = direction.fX;
|
||||
fD3DInfo.Direction.y = direction.fY;
|
||||
fD3DInfo.Direction.z = direction.fZ;
|
||||
|
||||
fD3DInfo.Falloff = spotOwner->GetFalloff();
|
||||
fD3DInfo.Theta = spotOwner->GetSpotInner() * 2;
|
||||
// fD3DInfo.Phi = spotOwner->GetProjection() ? hsScalarPI : spotOwner->GetSpotOuter() * 2;
|
||||
// D3D doesn't seem to like a Phi of PI, even though that's supposed to be the
|
||||
// largest legal value. Symptom is an erratic, intermitant, unpredictable failure
|
||||
// of the light to light, with bizarreness like lighting one object but not the object
|
||||
// next to it, alternating which object it fails on each frame (or less often).
|
||||
// So, whatever. - mf
|
||||
fD3DInfo.Phi = spotOwner->GetSpotOuter() * 2;
|
||||
}
|
||||
}
|
||||
else if( ( dirOwner = plDirectionalLightInfo::ConvertNoRef( fOwner ) ) != nil )
|
||||
{
|
||||
fD3DInfo.Type = D3DLIGHT_DIRECTIONAL;
|
||||
|
||||
hsVector3 direction = dirOwner->GetWorldDirection();
|
||||
fD3DInfo.Direction.x = direction.fX;
|
||||
fD3DInfo.Direction.y = direction.fY;
|
||||
fD3DInfo.Direction.z = direction.fZ;
|
||||
}
|
||||
else
|
||||
{
|
||||
hsAssert( false, "Unrecognized light type passed to plDXLightRef::UpdateD3DInfo()" );
|
||||
return;
|
||||
}
|
||||
|
||||
fD3DDevice->SetLight( fD3DIndex, &fD3DInfo );
|
||||
fScale = 1.f;
|
||||
}
|
||||
|
||||
//// Destructor ///////////////////////////////////////////////////////////////
|
||||
|
||||
plDXLightRef::~plDXLightRef()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
//// Release //////////////////////////////////////////////////////////////////
|
||||
|
||||
void plDXLightRef::Release( void )
|
||||
{
|
||||
// Ensure that this light is disabled
|
||||
if( fD3DDevice )
|
||||
{
|
||||
fD3DDevice->LightEnable( fD3DIndex, false );
|
||||
fD3DDevice = nil;
|
||||
}
|
||||
|
||||
if( fParentSettings )
|
||||
{
|
||||
fParentSettings->fEnabledFlags.SetBit( fD3DIndex, false );
|
||||
fParentSettings->ReleaseD3DIndex( fD3DIndex );
|
||||
fParentSettings = nil;
|
||||
}
|
||||
fD3DIndex = 0;
|
||||
|
||||
SetDirty( true );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//// plDXRenderTargetRef Functions ///////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//// Constructor //////////////////////////////////////////////////////////////
|
||||
|
||||
plDXRenderTargetRef::plDXRenderTargetRef( D3DFORMAT tp, UInt32 ml, plRenderTarget *owner, hsBool releaseDepthOnDelete )
|
||||
: plDXTextureRef( tp, ml, owner->GetWidth(), owner->GetHeight(),
|
||||
owner->GetWidth() * owner->GetHeight(),
|
||||
owner->GetWidth() * owner->GetHeight() * ( owner->GetPixelSize() >> 3 ),
|
||||
0,
|
||||
nil,
|
||||
nil, true, true )
|
||||
{
|
||||
fD3DColorSurface = nil;
|
||||
fD3DDepthSurface = nil;
|
||||
fReleaseDepth = releaseDepthOnDelete;
|
||||
fOwner = owner;
|
||||
|
||||
if( owner->GetFlags() & plRenderTarget::kIsTexture )
|
||||
fFlags |= kOffscreenRT;
|
||||
|
||||
if( owner->GetFlags() & plRenderTarget::kIsProjected )
|
||||
{
|
||||
if( owner->GetFlags() & plRenderTarget::kIsOrtho )
|
||||
fFlags |= kOrthoProjection;
|
||||
else
|
||||
fFlags |= kPerspProjection;
|
||||
}
|
||||
|
||||
if( plCubicRenderTarget::ConvertNoRef( owner ) != nil )
|
||||
fFlags |= kCubicMap;
|
||||
}
|
||||
|
||||
//// Set //////////////////////////////////////////////////////////////////////
|
||||
|
||||
plDXRenderTargetRef& plDXRenderTargetRef::Set( D3DFORMAT tp, UInt32 ml, plRenderTarget *owner )
|
||||
{
|
||||
fOwner = owner;
|
||||
|
||||
plDXTextureRef::Set( tp, ml, owner->GetWidth(), owner->GetHeight(),
|
||||
owner->GetWidth() * owner->GetHeight(),
|
||||
owner->GetWidth() * owner->GetHeight() * ( owner->GetPixelSize() >> 3 ),
|
||||
0,
|
||||
nil,
|
||||
nil, true, true );
|
||||
|
||||
if( owner->GetFlags() & plRenderTarget::kIsTexture )
|
||||
fFlags |= kOffscreenRT;
|
||||
|
||||
if( owner->GetFlags() & plRenderTarget::kIsProjected )
|
||||
{
|
||||
if( owner->GetFlags() & plRenderTarget::kIsOrtho )
|
||||
fFlags |= kOrthoProjection;
|
||||
else
|
||||
fFlags |= kPerspProjection;
|
||||
}
|
||||
|
||||
if( plCubicRenderTarget::ConvertNoRef( owner ) != nil )
|
||||
fFlags |= kCubicMap;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
//// SetTexture ///////////////////////////////////////////////////////////////
|
||||
|
||||
void plDXRenderTargetRef::SetTexture( IDirect3DSurface9 *surface, IDirect3DSurface9 *depth )
|
||||
{
|
||||
fD3DColorSurface = surface;
|
||||
fD3DTexture = nil;
|
||||
fD3DDepthSurface = depth;
|
||||
}
|
||||
|
||||
void plDXRenderTargetRef::SetTexture( IDirect3DTexture9 *surface, IDirect3DSurface9 *depth )
|
||||
{
|
||||
fD3DTexture = surface;
|
||||
fD3DColorSurface = nil;
|
||||
fD3DDepthSurface = depth;
|
||||
}
|
||||
|
||||
void plDXRenderTargetRef::SetTexture( IDirect3DCubeTexture9 *surface, IDirect3DSurface9 *depth )
|
||||
{
|
||||
int i;
|
||||
IDirect3DSurface9 *surf;
|
||||
plDXRenderTargetRef *ref;
|
||||
plCubicRenderTarget *cubic;
|
||||
D3DCUBEMAP_FACES faces[ 6 ] = { D3DCUBEMAP_FACE_NEGATIVE_X, // Left
|
||||
D3DCUBEMAP_FACE_POSITIVE_X, // Right
|
||||
D3DCUBEMAP_FACE_POSITIVE_Z, // Front
|
||||
D3DCUBEMAP_FACE_NEGATIVE_Z, // Back
|
||||
D3DCUBEMAP_FACE_POSITIVE_Y, // Top
|
||||
D3DCUBEMAP_FACE_NEGATIVE_Y }; // Bottom
|
||||
|
||||
|
||||
fD3DTexture = surface;
|
||||
fD3DDepthSurface = depth;
|
||||
fD3DColorSurface = nil;
|
||||
|
||||
/// Get the faces and assign to each of the child targets
|
||||
cubic = plCubicRenderTarget::ConvertNoRef( fOwner );
|
||||
for( i = 0; i < 6; i++ )
|
||||
{
|
||||
if( surface->GetCubeMapSurface( faces[ i ], 0, &surf ) != D3D_OK )
|
||||
{
|
||||
hsAssert( false, "Unable to get cube map surface" );
|
||||
continue;
|
||||
}
|
||||
ref = (plDXRenderTargetRef *)cubic->GetFace( i )->GetDeviceRef();
|
||||
|
||||
ref->SetTexture( surf, depth );
|
||||
}
|
||||
}
|
||||
|
||||
//// Destructor ///////////////////////////////////////////////////////////////
|
||||
|
||||
plDXRenderTargetRef::~plDXRenderTargetRef()
|
||||
{
|
||||
Release();
|
||||
}
|
||||
|
||||
//// Release //////////////////////////////////////////////////////////////////
|
||||
|
||||
void plDXRenderTargetRef::Release( void )
|
||||
{
|
||||
int i;
|
||||
plCubicRenderTarget *cubic;
|
||||
plDXRenderTargetRef *ref;
|
||||
|
||||
|
||||
/// Get rid of the children's deviceRefs
|
||||
if( fFlags & kCubicMap )
|
||||
{
|
||||
cubic = plCubicRenderTarget::ConvertNoRef( fOwner );
|
||||
for( i = 0; i < 6; i++ )
|
||||
{
|
||||
ref = (plDXRenderTargetRef *)cubic->GetFace( i )->GetDeviceRef();
|
||||
ref->Release();
|
||||
ref->SetDirty( true );
|
||||
}
|
||||
// No need to call D3DSURF_MEMDEL on our fD3DTexture. It'll get
|
||||
// accounted for by our children's surfaces.
|
||||
}
|
||||
else
|
||||
{
|
||||
// We do internal accounting here. Actual release of fD3DTexture
|
||||
// happens in plDXTextureRef::Release()
|
||||
D3DSURF_MEMDEL((IDirect3DTexture9*)fD3DTexture);
|
||||
}
|
||||
|
||||
D3DSURF_MEMDEL(fD3DColorSurface);
|
||||
ReleaseObject( fD3DColorSurface );
|
||||
if( fReleaseDepth )
|
||||
{
|
||||
// TODO:
|
||||
// We don't know who all is sharing this depth surface, so we can't
|
||||
// confidently say this memory is free now. We're reffing and releasing
|
||||
// it properly as far as DirectX is concerned, but our internal memory
|
||||
// counter is ignoring it.
|
||||
//D3DSURF_MEMDEL(fD3DDepthSurface);
|
||||
ReleaseObject( fD3DDepthSurface );
|
||||
}
|
||||
|
||||
plDXTextureRef::Release();
|
||||
|
||||
SetDirty( true );
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user