CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plPipeline/plDXDeviceRefs.cpp

/*==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/>.

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 );
}