sfxmgr.cpp

Blood 2全套源码

			pSFX = new CWarpGateSpriteFX();
		}
		break;

		case SFX_WARPGATEPARTICLE_ID :
		{
			pSFX = new CWarpGateParticleFX();
		}
		break;

		case SFX_OBJECTFX_ID :
		{
			pSFX = new CObjectGeneralFX();
		}
		break;

		case SFX_OBJECTPARTICLES_ID :
		{
			pSFX = new CObjectParticleFX();
		}
		break;

		case SFX_SHELLCASING_ID :
		{
			pSFX = new CShellCasingFX();
		}
		break;

		case SFX_POWERUP_ID :
		{
			pSFX = new CPickupObjectFX();
		}
		break;

		case SFX_FLASHLIGHT_ID :
		{
			pSFX = new CFlashlightFX();
		}
		break;

#ifdef _ADD_ON
		case SFX_FLAYER_CHAIN_ID :
		{
			pSFX = new CIKChainFX();
		}
		break;
#endif

		default : return DNULL;
	}

	// Initialize the sfx, and add it to the appropriate array...
	if (!pSFX) return DNULL;


	if (!pSFX->Init(psfxCreateStruct))
	{
		delete pSFX;
		return DNULL;
	}

	// Only create the sfx if we are connected to the server...

	if (!m_pClientDE->IsConnected())
	{
		delete pSFX;
		return DNULL;
	}

	if (!pSFX->CreateObject(m_pClientDE))
	{
		delete pSFX;
		return DNULL;
	}

	if (bStatic) 
	{
		CSpecialFX* pFX = m_staticSFXList.Add(pSFX);

		if(pFX)
		{
			if(pFX->Term())
				delete pFX;
			else
			{
				CSpecialFX* pDelFX = m_termSFXList.Add(pFX);
				if(pDelFX)
					delete pDelFX;
			}
		}
	}
	else 
	{
		AddDynamicSpecialFX(pSFX, nId, pParentFX);
	}

	return pSFX;
}



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::UpdateSpecialFX()
//
//	PURPOSE:	Update any the special FX
//
// ----------------------------------------------------------------------- //

void CSFXMgr::UpdateSpecialFX()
{
	if (!m_pClientDE) return;

	DFLOAT fTime = m_pClientDE->GetTime();

	// Update static sfx...

	int nNumSFX = m_staticSFXList.GetSize();
	
	for (int i=0; i < nNumSFX; i++)
	{
		if (m_staticSFXList[i]) 
		{
			if (fTime >= m_staticSFXList[i]->m_fNextUpdateTime)
			{
				if(!m_staticSFXList[i]->Update())
					m_staticSFXList.Remove(m_staticSFXList[i]);
				else
					m_staticSFXList[i]->m_fNextUpdateTime = fTime + m_staticSFXList[i]->GetUpdateDelta();
			}
		}
	}

	// Update dynamic sfx...

	UpdateDynamicSpecialFX();

	// Update camera sfx...

	nNumSFX = m_cameraSFXList.GetSize();
	
	for (i=0; i < nNumSFX; i++)
	{
		if (m_cameraSFXList[i]) 
		{
			if (!m_cameraSFXList[i]->Update())
			{
				m_cameraSFXList.Remove(m_cameraSFXList[i]);
			}
		}
	}

	//slow terminating FX update
	nNumSFX = m_termSFXList.GetSize();
	
	for (i=0; i < nNumSFX; i++)
	{
		if (m_termSFXList[i]) 
		{
			if (fTime >= m_termSFXList[i]->m_fNextUpdateTime)
			{
				if(!m_termSFXList[i]->Update())
					m_termSFXList.Remove(m_termSFXList[i]);
				else
					m_termSFXList[i]->m_fNextUpdateTime = fTime + m_termSFXList[i]->GetUpdateDelta();
			}
		}
	}

	return;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::RemoveSpecialFX()
//
//	PURPOSE:	Remove the specified special fx
//
// ----------------------------------------------------------------------- //

void CSFXMgr::RemoveSpecialFX(HLOCALOBJ hObj)
{
	if (!m_pClientDE) return;

	// Remove the dynamic special fx associated with this object..

	RemoveDynamicSpecialFX(hObj);

	int nNumSFX = m_staticSFXList.GetSize();

	for (int i=0; i < nNumSFX; i++)
	{
		if (m_staticSFXList[i] && m_staticSFXList[i]->GetServerObj() == hObj)
		{
			m_staticSFXList[i]->WantRemove();
		}
	}

	// Check camera list...

	nNumSFX = m_cameraSFXList.GetSize();

	for (i=0; i < nNumSFX; i++)
	{
		if (m_cameraSFXList[i] && m_cameraSFXList[i]->GetServerObj() == hObj)
		{
			m_cameraSFXList[i]->WantRemove();
		}
	}

	//slow terminating FX
	nNumSFX = m_termSFXList.GetSize();

	for (i=0; i < nNumSFX; i++)
	{
		if (m_termSFXList[i] && m_termSFXList[i]->GetServerObj() == hObj)
		{
			m_termSFXList[i]->WantRemove();
		}
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::RemoveAll()
//
//	PURPOSE:	Remove all the special fx
//
// ----------------------------------------------------------------------- //

void CSFXMgr::RemoveAll()
{
	RemoveAllDynamicSpecialFX();

	int nNumSFX = m_staticSFXList.GetSize();

	for (int i=0; i < nNumSFX; i++)
	{
		m_staticSFXList.Remove(m_staticSFXList[i]);
	}

	nNumSFX = m_cameraSFXList.GetSize();

	for (i=0; i < nNumSFX; i++)
	{
		m_cameraSFXList.Remove(m_cameraSFXList[i]);
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::FindStaticSpecialFX()
//
//	PURPOSE:	Find a static special fx associated with an object
//
// ----------------------------------------------------------------------- //

CSpecialFX* CSFXMgr::FindStaticSpecialFX(HLOCALOBJ hObj)
{
	CSpecialFX* pFX = DNULL;
	int nNumSFX = m_staticSFXList.GetSize();

	for (int i=0; i < nNumSFX; i++)
	{
		if (m_staticSFXList[i] && m_staticSFXList[i]->GetServerObj() == hObj)
		{
			pFX = m_staticSFXList[i];
			break;
		}
	}

	return pFX;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::AddDynamicSpecialFX()
//
//	PURPOSE:	Add a dyanamic special fx to our lists
//
// ----------------------------------------------------------------------- //

void CSFXMgr::AddDynamicSpecialFX(CSpecialFX* pSFX, DBYTE nId, CSpecialFX* pParentFX)
{
	int nIndex = GetDynArrayIndex(nId);

	if (0 <= nIndex && nIndex < DYN_ARRAY_SIZE)
	{
		CSpecialFX* pFX = m_dynSFXLists[nIndex].Add(pSFX, pParentFX);

		if(pFX)
		{
			if(pFX->Term())
				delete pFX;
			else
			{
				CSpecialFX* pDelFX = m_termSFXList.Add(pFX);
				if(pDelFX)
					delete pDelFX;
			}
		}
	}

}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::UpdateDynamicSpecialFX()
//
//	PURPOSE:	Update the dyanamic special fxs
//
// ----------------------------------------------------------------------- //

void CSFXMgr::UpdateDynamicSpecialFX()
{
	if (!m_pClientDE) return;

	DFLOAT fTime = m_pClientDE->GetTime();

	for (int j=0; j < DYN_ARRAY_SIZE; j++)
	{
		int nNumSFX  = m_dynSFXLists[j].GetSize();

		for (int i=0; i < nNumSFX; i++)
		{
			if (m_dynSFXLists[j][i]) 
			{
				if (fTime >= m_dynSFXLists[j][i]->m_fNextUpdateTime)
				{
					if (!m_dynSFXLists[j][i]->Update())
					{
						m_dynSFXLists[j].Remove(m_dynSFXLists[j][i]);
					}
					else
					{
						m_dynSFXLists[j][i]->m_fNextUpdateTime = fTime + m_dynSFXLists[j][i]->GetUpdateDelta();
					}
				}
			}
		}
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::RemoveDynamicSpecialFX()
//
//	PURPOSE:	Remove the specified special fx
//
// ----------------------------------------------------------------------- //

void CSFXMgr::RemoveDynamicSpecialFX(HOBJECT hObj)
{
	for (int j=0; j < DYN_ARRAY_SIZE; j++)
	{
		int nNumSFX  = m_dynSFXLists[j].GetSize();

		for (int i=0; i < nNumSFX; i++)
		{
			// More than one sfx may have the same server handle, so let them
			// all have an opportunity to remove themselves...

			if (m_dynSFXLists[j][i] && m_dynSFXLists[j][i]->GetServerObj() == hObj)
			{
				m_dynSFXLists[j][i]->WantRemove();
			}
		}
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::RemoveAllDynamicSpecialFX()
//
//	PURPOSE:	Remove all dynamic special fx
//
// ----------------------------------------------------------------------- //

void CSFXMgr::RemoveAllDynamicSpecialFX()
{
	for (int j=0; j < DYN_ARRAY_SIZE; j++)
	{
		int nNumSFX  = m_dynSFXLists[j].GetSize();

		for (int i=0; i < nNumSFX; i++)
		{
			m_dynSFXLists[j].Remove(m_dynSFXLists[j][i]);
		}
	}

	int nNumSFX = m_termSFXList.GetSize();

	for (int i=0; i < nNumSFX; i++)
	{
		m_termSFXList.Remove(m_termSFXList[i]);
	}

}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::FindDynamicSpecialFX()
//
//	PURPOSE:	Find a dyanamic special fx associated with an object
//
// ----------------------------------------------------------------------- //

CSpecialFX* CSFXMgr::FindDynamicSpecialFX(HLOCALOBJ hObj)
{
	for (int j=0; j < DYN_ARRAY_SIZE; j++)
	{
		int nNumSFX  = m_dynSFXLists[j].GetSize();

		for (int i=0; i < nNumSFX; i++)
		{
			if (m_dynSFXLists[j][i] && m_dynSFXLists[j][i]->GetServerObj() == hObj)
			{
				return m_dynSFXLists[j][i];
			}
		}
	}

	return DNULL;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::GetDynArrayIndex()
//
//	PURPOSE:	Get the array index associated with a particular type of
//				dynamic special fx
//
// ----------------------------------------------------------------------- //

int	CSFXMgr::GetDynArrayIndex(DBYTE nFXId)
{
	int nIndex = 0;

	switch (nFXId)
	{
		case SFX_POLYGRID_ID :
		case SFX_PARTICLESYSTEM_ID :
		case SFX_RAIN_ID :
		case SFX_VOLUMEBRUSH_ID :
		case SFX_CAMERA_ID :
		case SFX_LIGHT_ID :
		case SFX_WEAPONPOWERUP_ID :
		case SFX_PARTICLESTREAM_ID :
		case SFX_POWERUP_ID :
			nIndex = 0;
			break;
		
		case SFX_MARK_ID :
			nIndex = 1;
			break;
		
		case SFX_WEAPON_ID :
		case SFX_ROCKETFLARE_ID :
		case SFX_TRACER_ID :
		case SFX_LASER_ID :
		case SFX_LIGHTNING_ID :
		case SFX_LIGHTNINGSEG_ID :
		case SFX_LASERBEAM_ID :
		case SFX_WARPGATESPRITE_ID :
		case SFX_WARPGATEPARTICLE_ID :
		case SFX_FLASHLIGHT_ID :
		case SFX_WEAPONSOUND_ID :
			nIndex = 2;
			break;

		case SFX_SMOKETRAIL_ID :
		case SFX_SMOKETRAILSEG_ID :
		case SFX_SPARKS_ID :
		case SFX_SMOKEPUFF_ID :
		case SFX_SMOKEIMPACT_ID :
		case SFX_SPLASH_ID :
		case SFX_RIPPLE_ID :
		case SFX_FRAGMENTS_ID :
			nIndex = 3;
			break;

		case SFX_EXPLOSION_ID :
		case SFX_EXPLOSIONSPRITE_ID :
		case SFX_EXPLOSIONRING_ID :
		case SFX_EXPLOSIONWAVE_ID :
		case SFX_EXPLOSIONLIGHT_ID :
		case SFX_EXPLOSIONFRAG_ID :
		case SFX_EXPLOSIONFX_ID :
		case SFX_EXPLOSIONFLAME_ID :
			nIndex = 4;
			break;

		case SFX_GIB_ID:
		case SFX_BLOODTRAIL_ID :
		case SFX_BLOODTRAILSEG_ID :
		case SFX_BLOODSPLAT_ID:
		case SFX_PARTICLEEXPLOSION_ID:
			nIndex = 5;
			break;
		
		case SFX_SHELLCASING_ID:
			nIndex = 6;
			break;
		
		case SFX_OBJECTFX_ID :
		case SFX_OBJECTPARTICLES_ID :
			nIndex = 7;
			break;
		
	}

	return nIndex;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CSFXMgr::GetDynArrayMaxNum()
//
//	PURPOSE:	Find a dyanamic special fx associated with an object
//
// ----------------------------------------------------------------------- //

static unsigned int s_nDynArrayMaxNums[DYN_ARRAY_SIZE] =
{
	300,	// General FX
	300,	// Marks - bullet holes
	80,		// Weapon, Tracers, Lasers
	80,		// Smoke, Smoke trail seg, Sparks, Smokepuff, Smokeimpact, Splashes, ripples, Fragments
	80,		// Explosions, Explosion sprites, Explosion rings, Explosion wave, Explosion light, Explosion frag
	80,		// gibs, Blood trail, Blood trail seg, blood splat
	100,	// shell casings
	80		// Object
};

unsigned int CSFXMgr::GetDynArrayMaxNum(DBYTE nIndex)
{
	if (0 <= nIndex && nIndex < DYN_ARRAY_SIZE)
	{
		return s_nDynArrayMaxNums[nIndex];
	}

	return 0;
}