lightfx.cpp

Blood 2全套源码

	if (fDeltaTime <= m_fRadiusMaxTime)
	{
		m_fRadius = m_fRadiusMax;
        SetRadius(m_fRadius);
	}
	else
	{
		InitRadiusTransition(LFX_RADIUS_RAMP_DOWN);
		UpdateRadiusRampDown();
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateRadiusRampUp()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	DFLOAT fDeltaTime = pServerDE->GetTime() - m_fRadiusTime;

	if (fDeltaTime <= m_fRadiusRampUpTime && m_fRadiusRampUpTime > 0)
	{
		DFLOAT vTemp = m_fRadiusMin + (fDeltaTime/m_fRadiusRampUpTime)*(m_fRadiusMax - m_fRadiusMin);

		m_fRadius = vTemp;
        SetRadius(m_fRadius);
	}
	else
	{
		InitRadiusTransition(LFX_RADIUS_MAX);
		UpdateRadiusMax();
	}
}



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateRadiusRampDown()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	DFLOAT fDeltaTime = pServerDE->GetTime() - m_fRadiusTime;

	if (fDeltaTime <= m_fRadiusRampDownTime && m_fRadiusRampDownTime > 0)
	{
		DFLOAT vTemp = m_fRadiusMax - (fDeltaTime/m_fRadiusRampDownTime)*(m_fRadiusMax - m_fRadiusMin);

		m_fRadius = vTemp;
        SetRadius(m_fRadius);
	}
	else
	{
		DecNumRadiusCycles();
		InitRadiusTransition(LFX_RADIUS_MIN);
		UpdateRadiusMin();
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::DecNumRadiusCycles()
{
	if (m_nNumRadiusCycles > 0)
	{
		m_nNumRadiusCycles = m_nNumRadiusCycles - 1;

		if (m_nNumRadiusCycles < 0) m_nNumRadiusCycles = 0;
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::InitRadiusTransition(int NextState)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	m_fRadiusTime	 = pServerDE->GetTime();
	m_nCurRadiusState = NextState;
}

// End of Light Radius related methods ////////////////////////////////////////



// The following are Light Intensity related methods //////////////////////////

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateLightIntensity()
{
	switch(m_nCurIntensityState)
	{
		case LFX_INTENSITY_INIT:
        {
        	CServerDE* pServerDE = GetServerDE();
        	if (!pServerDE) return;

			m_fIntensityTime		= pServerDE->GetTime();
			m_nCurIntensityState    = LFX_INTENSITY_MIN;
            
        } break;
        
		case LFX_INTENSITY_MIN:         UpdateIntensityMin();     break;
		case LFX_INTENSITY_RAMP_UP:	    UpdateIntensityRampUp();  break;
		case LFX_INTENSITY_MAX:		    UpdateIntensityMax();     break;
		case LFX_INTENSITY_RAMP_DOWN:   UpdateIntensityRampDown();break;
		default: return;
	}
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateIntensityMin()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	DFLOAT fDeltaTime = pServerDE->GetTime() - m_fIntensityTime;

	if (fDeltaTime <= m_fIntensityMinTime)
	{
		m_fRedValue = m_vCurrentColor.x * m_fIntensityMin;
		m_fGreenValue = m_vCurrentColor.y * m_fIntensityMin;
		m_fBlueValue = m_vCurrentColor.z * m_fIntensityMin; 
        
       	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
	}
	else
	{
		InitIntensityTransition(LFX_INTENSITY_RAMP_UP);
        PlayRampSound(UPSOUND);
		UpdateIntensityRampUp();
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateIntensityMax()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	DFLOAT fDeltaTime = pServerDE->GetTime() - m_fIntensityTime;

	if (fDeltaTime <= m_fIntensityMinTime)
	{
		m_fRedValue = m_vCurrentColor.x * m_fIntensityMax;
		m_fGreenValue = m_vCurrentColor.y * m_fIntensityMax;
		m_fBlueValue = m_vCurrentColor.z * m_fIntensityMax; 
        
       	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
	}
	else
	{
		InitIntensityTransition(LFX_INTENSITY_RAMP_DOWN);
        PlayRampSound(DOWNSOUND);
		UpdateIntensityRampDown();
	}
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateIntensityRampUp()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	DFLOAT fDeltaTime = pServerDE->GetTime() - m_fIntensityTime;

	if (fDeltaTime <= m_fIntensityRampUpTime && m_fIntensityRampUpTime > 0)
	{
		DFLOAT vTemp = m_fIntensityMin + (fDeltaTime/m_fIntensityRampUpTime)*((m_fIntensityMax - m_fIntensityMin));

		m_fRedValue = m_vCurrentColor.x * vTemp;
		m_fGreenValue = m_vCurrentColor.y * vTemp;
		m_fBlueValue = m_vCurrentColor.z * vTemp;
        
       	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
	}
	else
	{
		InitIntensityTransition(LFX_INTENSITY_MAX);
		UpdateIntensityMax();
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateIntensityRampDown()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	DFLOAT fDeltaTime = pServerDE->GetTime() - m_fIntensityTime;

	if (fDeltaTime <= m_fIntensityRampDownTime && m_fIntensityRampDownTime > 0)
	{
		DFLOAT vTemp = m_fIntensityMax - (fDeltaTime/m_fIntensityRampDownTime)*((m_fIntensityMax - m_fIntensityMin));

		m_fRedValue = m_vCurrentColor.x * vTemp;
		m_fGreenValue = m_vCurrentColor.y * vTemp;
		m_fBlueValue = m_vCurrentColor.z * vTemp;
        
       	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
	}
	else
	{
		DecNumIntensityCycles();
		InitIntensityTransition(LFX_INTENSITY_MIN);
		UpdateIntensityMin();
	}
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::DecNumIntensityCycles()
{
	if (m_nNumIntensityCycles > 0)
	{
		m_nNumIntensityCycles = m_nNumIntensityCycles - 1;

		if (m_nNumIntensityCycles < 0) m_nNumIntensityCycles = 0;
	}
}

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::InitIntensityTransition(int NextState)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	m_fIntensityTime		= pServerDE->GetTime();
	m_nCurIntensityState    = NextState;
}


// End of Light Intensity related methods /////////////////////////////////////



// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::PlayRampSound(int nDirection)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;
    
	char *sound = DNULL;
    
    // Set the char pointer    
	if (nDirection == 1 && m_hstrRampUpSound)
	{
		sound = pServerDE->GetStringData(m_hstrRampUpSound);
	}
	else if (m_hstrRampDownSound)
	{
		sound = pServerDE->GetStringData(m_hstrRampDownSound);
	}

    // Play the sound if valid pointer
	if (sound && _mbstrlen(sound) > 0)
	{
		DFLOAT Radius = 1000.0f;
		PlaySoundFromObject(m_hObject, sound, Radius, SOUNDPRIORITY_MISC_HIGH);
	}

}





// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::SetRadius(DFLOAT fRadius, DBOOL bForce)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;
    
    if (fRadius > 10000.0f) fRadius = 10000.0f;
    if (fRadius < 0.0f)     fRadius = 0.0f;

	// Only change radius if it has changed by more than 10%, or if it is forced (at init)
	if( bForce || fabs( fRadius - m_fCurrentRadius ) / m_fCurrentRadius > 0.10f )
	{
		g_pServerDE->SetLightRadius(m_hObject, fRadius);
		m_fCurrentRadius = fRadius;
	}
	
}




// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::SetColor(DFLOAT fRedValue, DFLOAT fGreenValue, DFLOAT fBlueValue)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;
    
    if (fRedValue > 1.0f)       fRedValue = 1.0f;
    if (fRedValue < 0.0f)       fRedValue = 0.0f;
        
    if (fGreenValue > 1.0f)     fGreenValue = 1.0f;
    if (fGreenValue < 0.0f)     fGreenValue = 0.0f;
        
    if (fBlueValue > 1.0f)      fBlueValue = 1.0f;
    if (fBlueValue < 0.0f)      fBlueValue = 0.0f;

//    char buf[128];
//    sprintf(buf, "r=%f g=%f b=%f ", fRedValue, fGreenValue, fBlueValue);
//    BPrint(buf);

   	pServerDE->SetLightColor(m_hObject, fRedValue, fGreenValue, fBlueValue);
    
}




////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////