lightfx.cpp

Blood 2全套源码

		m_fIntensityRampDownTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("NumRadiusCycles", &genProp) == DE_OK)
		m_nNumRadiusCycles = genProp.m_Long;

	if (pServerDE->GetPropGeneric("RadiusMin", &genProp) == DE_OK)
		m_fRadiusMin = genProp.m_Float;

    if (m_fRadiusMin < 0.0f) m_fRadiusMin = 0.0f;


	if (pServerDE->GetPropGeneric("RadiusMax", &genProp) == DE_OK)
		m_fRadiusMax = genProp.m_Float;

	if (pServerDE->GetPropGeneric("RadiusMinTime", &genProp) == DE_OK)
		m_fRadiusMinTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("RadiusMaxTime", &genProp) == DE_OK)
		m_fRadiusMaxTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("RadiusRampUpTime", &genProp) == DE_OK)
		m_fRadiusRampUpTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("RadiusRampDownTime", &genProp) == DE_OK)
		m_fRadiusRampDownTime = genProp.m_Float;

	if (pServerDE->GetPropGeneric("RampUpSound", &genProp) == DE_OK)
	{
		if (genProp.m_String[0])
			 m_hstrRampUpSound = pServerDE->CreateString(genProp.m_String);
	}

	if (pServerDE->GetPropGeneric("RampDownSound", &genProp) == DE_OK)
	{
		if (genProp.m_String[0])
			 m_hstrRampDownSound = pServerDE->CreateString(genProp.m_String);
	}

	return DTRUE;
}

      
// ----------------------------------------------------------------------- //
//
//	ROUTINE:	PostPropRead()
//
//	PURPOSE:	Update properties
//
// ----------------------------------------------------------------------- //

void LightFX::PostPropRead(ObjectCreateStruct *pStruct)
{
	if (!pStruct) return;

    // Set the Update!

	if (m_bOn)
	{	
		pStruct->m_NextUpdate = 0.01f;
		pStruct->m_Flags |= FLAG_VISIBLE;
	}
	else
	{
		pStruct->m_NextUpdate = 0.0f;
	}

	pStruct->m_Flags |= FLAG_GOTHRUWORLD;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	InitialUpdate()
//
//	PURPOSE:	Handle initial update
//
// ----------------------------------------------------------------------- //

DBOOL LightFX::InitialUpdate(DVector *pMovement)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return DFALSE;

	m_damage.SetMaxHitPoints(m_fHitPts);
	m_damage.SetHitPoints(m_fHitPts);

    // Set Next update (randomize it if this object was loaded from the
	// level - so we don't have all the lights updating on the same frame)...
	
	DFLOAT fOffset = 0.0f;
	if (!m_bDynamic) fOffset = pServerDE->Random(0.01f, 0.5f);

	if (m_bOn)
	{
		pServerDE->SetNextUpdate(m_hObject, UPDATE_DELTA + fOffset);
	}

	return Init();
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	Init()
//
//	PURPOSE:	Initialize data members
//
// ----------------------------------------------------------------------- //

DBOOL LightFX::Init()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return DFALSE;

 	// Normalize colors (0-1)
	if (m_nNumColorCycles != 0)
	{
		m_vColor1.x = m_vColor1.x/255.0f;
		m_vColor1.y = m_vColor1.y/255.0f;
		m_vColor1.z = m_vColor1.z/255.0f;

		m_vColor2.x = m_vColor2.x/255.0f;
		m_vColor2.y = m_vColor2.y/255.0f;
		m_vColor2.z = m_vColor2.z/255.0f;

		m_vColor3.x = m_vColor3.x/255.0f;
		m_vColor3.y = m_vColor3.y/255.0f;
		m_vColor3.z = m_vColor3.z/255.0f;

		m_fRedValue     = m_vColor1.x;
		m_fGreenValue   = m_vColor1.y;
		m_fBlueValue    = m_vColor1.z;
	}
	else
	{
		m_fRedValue     = m_vColor1.x;
		m_fGreenValue   = m_vColor1.y;
		m_fBlueValue    = m_vColor1.z;
        
		m_fRedValue     = m_fRedValue/255.0f;
		m_fGreenValue   = m_fGreenValue/255.0f;
		m_fBlueValue    = m_fBlueValue/255.0f;
	}


	m_vCurrentColor.x = m_fRedValue;
	m_vCurrentColor.y = m_fGreenValue;
	m_vCurrentColor.z = m_fBlueValue;

	m_fCurrentRadius		= m_fRadius = m_fRadiusMin;

	m_nCurIntensityState	= LFX_INTENSITY_INIT;
	m_nCurRadiusState	    = LFX_RADIUS_INIT;
	m_nCurColorUsed		    = 0;

	m_fStartTime = pServerDE->GetTime();

	SetRadius(m_fRadius, DTRUE);
	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);

	return DTRUE;
}





// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::Update
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
DBOOL LightFX::Update()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return DFALSE;

	pServerDE->SetNextUpdate(m_hObject, UPDATE_DELTA);
    
	//if (m_bOn)
	//{
		if (m_nNumColorCycles != 0)	    
        {
            UpdateLightColor();
        }            
		
        if (m_nNumIntensityCycles != 0)
        {
            UpdateLightIntensity();
        }
                     
		if (m_nNumRadiusCycles != 0)	
        {
            UpdateLightRadius();
        }            
	//}
	//else
	//{
        // Its NOT turned on, so reset the start time
        // So if there is a duration, then it will start timing when the switch is turned on
    //	m_fStartTime = pServerDE->GetTime();
        
	//	m_fRadius = 0.0f;  // Effectively turn light off
	//	return DTRUE;
	//}

	// See if we should remove the light...

	DBOOL bRemove = DFALSE;
	if (m_fLifeTime > 0 && (pServerDE->GetTime() - m_fStartTime) >= m_fLifeTime)
	{
		bRemove = DTRUE;
	}

	return (!bRemove);
}

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


// The following are Light Color related methods //////////////////////////////

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

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

	switch(m_nCurColorUsed)
	{
		case 0:
        {
			m_fColorTime        = pServerDE->GetTime();
			m_nCurColorUsed     = 1;
            
        } break;
		case 1:
        {
			if (fDeltaTime >= m_fColor1Time)
			{
				m_fRedValue = m_vCurrentColor.x = m_vColor2.x;
				m_fGreenValue = m_vCurrentColor.y = m_vColor2.y;
				m_fBlueValue = m_vCurrentColor.z = m_vColor2.z;
				m_fColorTime		 = pServerDE->GetTime();
				m_nCurColorUsed		 = 2;
               	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
			}
        } break;
		case 2:
        {
			if (fDeltaTime >= m_fColor2Time)
			{
				if (m_vColor3.x != -1)
				{
					m_fRedValue = m_vCurrentColor.x = m_vColor3.x;
					m_fGreenValue = m_vCurrentColor.y = m_vColor3.y;
					m_fBlueValue = m_vCurrentColor.z = m_vColor3.z;
					m_fColorTime		 = pServerDE->GetTime();
					m_nCurColorUsed		 = 3;
                   	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
				}
				else
				{
					m_fRedValue     = m_vCurrentColor.x = m_vColor1.x;
					m_fGreenValue   = m_vCurrentColor.y = m_vColor1.y;
					m_fBlueValue    = m_vCurrentColor.z = m_vColor1.z;
					m_fColorTime 	= pServerDE->GetTime();

					DecNumColorCycles();
					m_nCurColorUsed		 = 0;
                   	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
				}

			}
        } break;
		case 3:
        {
			if (fDeltaTime >= m_fColor3Time)
			{
                m_fRedValue     = m_vCurrentColor.x = m_vColor1.x;
				m_fGreenValue   = m_vCurrentColor.y = m_vColor1.y;
				m_fBlueValue    = m_vCurrentColor.z = m_vColor1.z;
				m_fColorTime    = pServerDE->GetTime();
					
				DecNumColorCycles();
				m_nCurColorUsed		 = 0;
               	SetColor(m_fRedValue, m_fGreenValue, m_fBlueValue);
			}
        } break;
		default: return;
	}

}


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

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

// End of the Light Color related methods /////////////////////////////////////



// The following are Light Radius related methods /////////////////////////////

// ----------------------------------------------------------------------- //
//
//	ROUTINE:	LightFX::
//
//	PURPOSE:
//
// ----------------------------------------------------------------------- //
void LightFX::UpdateLightRadius()
{
//    char buf[128];
//    sprintf(buf, "r=%f ", m_fRadius);
//    BPrint(buf);

	switch(m_nCurRadiusState)
	{
		case LFX_RADIUS_INIT:
        {
        	CServerDE* pServerDE = GetServerDE();
        	if (!pServerDE) return;

			m_fRadiusTime	    = pServerDE->GetTime();
			m_nCurRadiusState   = LFX_RADIUS_MIN;
            
        } break;
        
		case LFX_RADIUS_MIN:	   UpdateRadiusMin();       break;
		case LFX_RADIUS_RAMP_UP:   UpdateRadiusRampUp();    break;
		case LFX_RADIUS_MAX:	   UpdateRadiusMax();       break;
		case LFX_RADIUS_RAMP_DOWN: UpdateRadiusRampDown();  break;
		default: return;
	}
}


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

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

	if (fDeltaTime <= m_fRadiusMinTime)
	{
		m_fRadius = m_fRadiusMin;
        SetRadius(m_fRadius);
	}
	else
	{
		InitRadiusTransition(LFX_RADIUS_RAMP_UP);
		UpdateRadiusRampUp();
	}
}



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

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