explosionfx.cpp

Blood 2全套源码

		DVector		vUp;
		DRotation	rRot;
		DFLOAT		rotate = 0.0f;

		VEC_SET(vUp, 0.0f, 1.0f, 0.0f);

		switch(m_bRotateType)
		{
			case	1:	rotate = m_fRotation;									break;	// Constant rotation
			case	2:	rotate = m_fRotation * (1.0f - fRatio);					break;	// Slow down from initial
			case	3:	rotate = 1.0f - ((1.0f - m_fRotation) * fRatio);		break;	// Complete rotation to destination
			case	4:	rotate = m_fRotation * fRatio;							break;	// No rotation to destination
			case	5:	rotate = m_fRotation + ((1.0f - m_fRotation) * fRatio);	break;	// Speed up from initial
		}

		rotate *= MATH_PI;

		m_pClientDE->GetObjectRotation(m_hObject, &rRot);

		if(m_bAlign)	m_pClientDE->RotateAroundAxis(&rRot, &m_vNormal, rotate);
			else		m_pClientDE->RotateAroundAxis(&rRot, &vUp, rotate);

		m_pClientDE->SetObjectRotation(m_hObject, &rRot);
	}

	if(m_bFadeType)
	{
		DFLOAT		alpha;

		switch(m_bFadeType)
		{
			case	1:	alpha = m_fInitAlpha * (1.0f - fRatio);					break;	// InitAlpha to zero
			case	2:	alpha = 1.0f - ((1.0f - m_fInitAlpha) * fRatio);		break;	// Solid to InitAlpha
			case	3:	alpha = m_fInitAlpha * fRatio;							break;	// Zero to InitAlpha
			case	4:	alpha = m_fInitAlpha + ((1.0f - m_fInitAlpha) * fRatio);break;	// InitAlpha to Solid
			case	5:	if(fTime < (m_fDuration / 2))
							alpha = m_fInitAlpha * fRatio * 2.0f;
						else
							alpha = m_fInitAlpha * 2.0f * (1.0f - fRatio);		break;

		}

		m_pClientDE->SetObjectColor(m_hObject, m_vColor.x, m_vColor.y, m_vColor.z, alpha);
	}

	return (fTime < m_fDuration);
}

// ----------------------------------------------------------------------- //

void CExplosionRingFX::AddParticles()
{
	// Add the particles to the system
	DFLOAT		rotValue;
	DVector		start, vel, tempColor, vUp, vU, vR, vF;
	DRotation	rRot;

	VEC_SET(vUp, 0.0f, 1.0f, 0.0f);
	VEC_SET(tempColor, 255.0f, 255.0f, 255.0f);
	rotValue = 2 * MATH_PI / m_nParticles;

	if(m_bAlign)	m_pClientDE->AlignRotation(&rRot, &m_vNormal, &vUp);
		else		m_pClientDE->AlignRotation(&rRot, &vUp, &vUp);

	for(DDWORD i = 0; i < m_nParticles; i++)
	{
		m_pClientDE->GetRotationVectors(&rRot, &vU, &vR, &vF);
		m_pClientDE->RotateAroundAxis(&rRot, &vF, rotValue);

		VEC_NORM(vR);
		VEC_COPY(start, vR);
		VEC_COPY(vel, vR);
		VEC_MULSCALAR(start, start, m_fPosRadius);
		VEC_MULSCALAR(vel, vel, m_fVelocity);

		m_pClientDE->AddParticle(m_hObject, &start, &vel, &tempColor, m_fDuration);
	}
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionFlameFX::Init
//
//	PURPOSE:	Init the splash
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionFlameFX::Init(SFXCREATESTRUCT* psfxCreateStruct)
{
	if (!psfxCreateStruct)		return	DFALSE;
	CBaseParticleSystemFX::Init(psfxCreateStruct);

	EXPLOSIONFLAMECS* pEFCS = (EXPLOSIONFLAMECS*)psfxCreateStruct;

	VEC_COPY(m_vPos, pEFCS->vPos);
	VEC_COPY(m_vNormal, pEFCS->vNormal);

	VEC_COPY(m_vColor1, pEFCS->vColor1);
	VEC_COPY(m_vColor2, pEFCS->vColor2);
	VEC_COPY(m_vColor3, pEFCS->vColor3);

	VEC_COPY(m_vLifeTimes, pEFCS->vLifeTimes);
	VEC_COPY(m_vLifeOffsets, pEFCS->vLifeOffsets);

	m_fRampUp = pEFCS->vFXTimes.x;
	m_fDuration = pEFCS->vFXTimes.y;
	m_fRampDown = pEFCS->vFXTimes.z;

	m_nParticles		= pEFCS->nParticles;
	m_fRadius			= pEFCS->fRadius;
	m_fPosRadius		= pEFCS->fPosRadius;
	m_fGravity			= pEFCS->fGravity;
	m_fVelocity			= pEFCS->fVelocity;
	m_fDelay			= pEFCS->fDelay;
	m_fAlpha			= pEFCS->fAlpha;
	m_bFadeType			= pEFCS->bFadeType;
	m_bRampFlags		= pEFCS->bRampFlags;

	m_szParticle		= pEFCS->szParticle;

	return DTRUE;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionFlameFX::CreateObject
//
//	PURPOSE:	Create object associated the particle system.
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionFlameFX::CreateObject(CClientDE *pClientDE)
{
	if(!pClientDE ) return DFALSE;

	if(m_szParticle)	m_pTextureName = pClientDE->GetStringData(m_szParticle);
		else			m_pTextureName = "SpriteTextures\\drop32_1.dtx";

	m_pClientDE = pClientDE;
	DBOOL bRet = CBaseParticleSystemFX::CreateObject(pClientDE);

	if(bRet)
	{
		if(!m_bFadeType)
			pClientDE->SetObjectColor(m_hObject, 1.0f, 1.0f, 1.0f, m_fAlpha);

		m_fStartTime = m_pClientDE->GetTime();
		m_fAddTime = m_fDelay;
		AddParticles();
	}

	return bRet;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionFlameFX::Update
//
//	PURPOSE:	Update the particles
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionFlameFX::Update()
{
	if(!m_hObject || !m_pClientDE) return DFALSE;
	DFLOAT		fTime = m_pClientDE->GetTime() - m_fStartTime;
	DFLOAT		fRatio = fTime / m_fDuration;

	if(fTime >= m_fAddTime)
	{
		AddParticles();
		m_fAddTime += m_fDelay;
	}

	if(m_bFadeType)
	{
		DFLOAT		alpha;

		switch(m_bFadeType)
		{
			case	1:	alpha = m_fAlpha * (1.0f - fRatio);					break;	// InitAlpha to zero
			case	2:	alpha = 1.0f - ((1.0f - m_fAlpha) * fRatio);		break;	// Solid to InitAlpha
			case	3:	alpha = m_fAlpha * fRatio;							break;	// Zero to InitAlpha
			case	4:	alpha = m_fAlpha + ((1.0f - m_fAlpha) * fRatio);	break;	// InitAlpha to Solid
			case	5:	if(fTime < (m_fDuration / 2))
							alpha = m_fAlpha * fRatio * 2.0f;
						else
							alpha = m_fAlpha * 2.0f * (1.0f - fRatio);		break;

		}

		m_pClientDE->SetObjectColor(m_hObject, 1.0f, 1.0f, 1.0f, alpha);
	}

	return (fTime < m_fDuration);
}

// ----------------------------------------------------------------------- //

void CExplosionFlameFX::AddParticles()
{
	// Add the particles to the system
	DVector		minOffset, maxOffset, minVel, maxVel;
	DFLOAT		minLifetime = 0, maxLifetime = 0;
	DFLOAT		radius1 = m_fPosRadius / 3, radius2 = radius1 * 2;

	VEC_SET(minVel, -m_fVelocity, -m_fVelocity, -m_fVelocity);
	VEC_SET(maxVel, m_fVelocity, m_fVelocity, m_fVelocity);

	VEC_SET(minOffset, -radius1, -radius1, -radius1);
	VEC_SET(maxOffset, radius1, radius1, radius1);
	minLifetime = m_vLifeTimes.x - m_vLifeOffsets.x;
	maxLifetime = m_vLifeTimes.x + m_vLifeOffsets.x;

	m_pClientDE->AddParticles(m_hObject, m_nParticles, &minOffset, &maxOffset, &minVel, &maxVel,
								&m_vColor1, &m_vColor1, minLifetime, maxLifetime);

	VEC_SET(minOffset, -radius2, -radius2, -radius2);
	VEC_SET(maxOffset, radius2, radius2, radius2);
	minLifetime = m_vLifeTimes.y - m_vLifeOffsets.y;
	maxLifetime = m_vLifeTimes.y + m_vLifeOffsets.y;

	m_pClientDE->AddParticles(m_hObject, m_nParticles * 2, &minOffset, &maxOffset, &minVel, &maxVel,
								&m_vColor2, &m_vColor2, minLifetime, maxLifetime);

	VEC_SET(minOffset, -m_fPosRadius, -m_fPosRadius, -m_fPosRadius);
	VEC_SET(maxOffset, m_fPosRadius, m_fPosRadius, m_fPosRadius);
	minLifetime = m_vLifeTimes.z - m_vLifeOffsets.z;
	maxLifetime = m_vLifeTimes.z + m_vLifeOffsets.z;

	m_pClientDE->AddParticles(m_hObject, m_nParticles * 3, &minOffset, &maxOffset, &minVel, &maxVel,
								&m_vColor3, &m_vColor3, minLifetime, maxLifetime);
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionWaveFX::Init
//
//	PURPOSE:	Init the splash
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionWaveFX::Init(SFXCREATESTRUCT* psfxCreateStruct)
{
	if (!psfxCreateStruct)		return	DFALSE;
	CSpecialFX::Init(psfxCreateStruct);

	EXPLOSIONWAVECS* pEWCS = (EXPLOSIONWAVECS*)psfxCreateStruct;

	VEC_COPY(m_vPos, pEWCS->vPos);
	VEC_COPY(m_vNormal, pEWCS->vNormal);
	VEC_COPY(m_vScale1, pEWCS->vScale1);
	VEC_COPY(m_vScale2, pEWCS->vScale2);

	m_fDuration			= pEWCS->fDuration;
	m_fInitAlpha		= pEWCS->fAlpha;
	m_fDelay			= pEWCS->fDelay;
	m_bWaveForm			= pEWCS->bWaveForm;
	m_bFadeType			= pEWCS->bFadeType;
	m_bAlign			= pEWCS->bAlign;

	m_szWave			= pEWCS->szWave;

	if((m_vScale1.x != m_vScale2.x) || (m_vScale1.y != m_vScale2.y) || (m_vScale1.z != m_vScale2.z))
		m_bScale = 1;

	return DTRUE;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionWaveFX::CreateObject
//
//	PURPOSE:	Create object associated the particle system.
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionWaveFX::CreateObject(CClientDE *pClientDE)
{
	if (!pClientDE ) return DFALSE;
	m_pClientDE = pClientDE;

	ObjectCreateStruct	ocStruct;
	INIT_OBJECTCREATESTRUCT(ocStruct);

	ocStruct.m_ObjectType = OT_SPRITE;
	ocStruct.m_Flags = FLAG_VISIBLE | FLAG_SPRITECHROMAKEY | FLAG_ROTATEABLESPRITE;
	VEC_COPY(ocStruct.m_Pos, m_vPos);

	DVector	vUp;
	VEC_SET(vUp, 0.0f, 1.0f, 0.0f);

	if(m_bAlign)
		m_pClientDE->AlignRotation(&(ocStruct.m_Rotation), &m_vNormal, &vUp);
	else
		m_pClientDE->AlignRotation(&(ocStruct.m_Rotation), &vUp, &vUp);

	if(m_szWave)
		_mbscpy((unsigned char*)ocStruct.m_Filename, (const unsigned char*)pClientDE->GetStringData(m_szWave));
	else
		_mbscpy((unsigned char*)ocStruct.m_Filename, (const unsigned char*)"Sprites\\Shockring.spr");

	m_hObject = pClientDE->CreateObject(&ocStruct);
	pClientDE->SetObjectScale(m_hObject, &m_vScale1);

	if(m_fDelay)
		pClientDE->SetObjectColor(m_hObject, 1.0f, 1.0f, 1.0f, 0.0f);
	else
		pClientDE->SetObjectColor(m_hObject, 1.0f, 1.0f, 1.0f, m_fInitAlpha);

	m_fStartTime = pClientDE->GetTime();

	return DTRUE;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionWaveFX::Update
//
//	PURPOSE:	Update the particles
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionWaveFX::Update()
{
	if(!m_hObject || !m_pClientDE) return DFALSE;
	DFLOAT		fTime = m_pClientDE->GetTime() - m_fStartTime;
	DFLOAT		fRatio = fTime / m_fDuration;

	if(m_fDelay)
	{
		if(fTime >= m_fDelay)
		{
			m_pClientDE->SetObjectColor(m_hObject, 1.0f, 1.0f, 1.0f, m_fInitAlpha);
			m_fStartTime = m_pClientDE->GetTime();
			m_fDelay = 0.0f;
		}
		return	DTRUE;
	}

	if(m_bScale)
	{
		DFLOAT		fTemp = fRatio;
		DVector		vScale;
		VEC_SUB(vScale, m_vScale2, m_vScale1);

		if(m_bWaveForm == 1)		fTemp = (DFLOAT)pow(fRatio, 0.5);
		else if(m_bWaveForm == 2)	fTemp = (DFLOAT)pow(fRatio, 2.0);

		VEC_MULSCALAR(vScale, vScale, fTemp);
		VEC_ADD(vScale, vScale, m_vScale1);
		m_pClientDE->SetObjectScale(m_hObject, &vScale);
	}

	if(m_bFadeType)
	{
		DFLOAT		alpha;

		switch(m_bFadeType)
		{
			case	1:	alpha = m_fInitAlpha * (1.0f - fRatio);					break;	// InitAlpha to zero
			case	2:	alpha = 1.0f - ((1.0f - m_fInitAlpha) * fRatio);		break;	// Solid to InitAlpha
			case	3:	alpha = m_fInitAlpha * fRatio;							break;	// Zero to InitAlpha
			case	4:	alpha = m_fInitAlpha + ((1.0f - m_fInitAlpha) * fRatio);break;	// InitAlpha to Solid
		}

		m_pClientDE->SetObjectColor(m_hObject, 1.0f, 1.0f, 1.0f, alpha);
	}

	return (fTime < m_fDuration);
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionLightFX::Init
//
//	PURPOSE:	Init the splash
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionLightFX::Init(SFXCREATESTRUCT* psfxCreateStruct)
{
	if (!psfxCreateStruct)		return	DFALSE;
	CSpecialFX::Init(psfxCreateStruct);

	EXPLOSIONLIGHTCS* pELCS = (EXPLOSIONLIGHTCS*)psfxCreateStruct;

	VEC_COPY(m_vPos, pELCS->vPos);
	VEC_COPY(m_vColor1, pELCS->vColor1);
	VEC_COPY(m_vColor2, pELCS->vColor2);

	m_fDuration			= pELCS->fDuration;
	m_fDelay			= pELCS->fDelay;
	m_fRadius1			= pELCS->fRadius1;
	m_fRadius2			= pELCS->fRadius2;

	if((m_vColor1.x != m_vColor2.x) || (m_vColor1.y != m_vColor2.y) || (m_vColor1.z != m_vColor2.z))
		m_bChangeColor = 1;

	if(m_fRadius1 != m_fRadius2)
		m_bScale = 1;

	return DTRUE;
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	CExplosionLightFX::CreateObject
//
//	PURPOSE:	Create object associated the particle system.
//
// ----------------------------------------------------------------------- //

DBOOL CExplosionLightFX::CreateObject(CClientDE *pClientDE)
{
	if (!pClientDE ) return DFALSE;
	m_pClientDE = pClientDE;

	ObjectCreateStruct	ocStruct;
	INIT_OBJECTCREATESTRUCT(ocStruct);

	ocStruct.m_ObjectType = OT_LIGHT;
	ocStruct.m_Flags = FLAG_VISIBLE;
	VEC_COPY(ocStruct.m_Pos, m_vPos);

	m_hObject = pClientDE->CreateObject(&ocStruct);
	pClientDE->SetLightColor(m_hObject, m_vColor1.x, m_vColor1.y, m_vColor1.z);

	if(m_fDelay)
		pClientDE->SetLightRadius(m_hObject, 0.0f);
	else
		pClientDE->SetLightRadius(m_hObject, m_fRadius1);