volumebrush.cpp

Blood 2全套源码

	m_fViscosity = 1.0f - m_fViscosity;
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::Update()
//
//	PURPOSE:	Update the brush
//
// ----------------------------------------------------------------------- //

void VolumeBrush::Update()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || m_bHidden) return;

	// Only do updates if we have a surface...

	if (m_hSurfaceObj)
	{
		pServerDE->SetNextUpdate(m_hObject, UPDATE_DELTA);
	}
	else
	{
		pServerDE->SetNextUpdate(m_hObject, 0.0f);
	}


	// See if we have moved...

	DVector vPos;
	pServerDE->GetObjectPos(m_hObject, &vPos);

	if (m_hSurfaceObj && !(m_vLastPos.x == vPos.x &&m_vLastPos.y == vPos.y && m_vLastPos.z == vPos.z))
	{
		VEC_COPY(m_vLastPos, vPos);

		// Set the surface to its new position...

		DVector vDims;
		pServerDE->GetObjectDims(m_hObject, &vDims);

		vPos.y += vDims.y - (m_fSurfaceHeight/2.0f); 

		pServerDE->SetObjectPos(m_hSurfaceObj, &vPos);		
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::CreateSurface()
//
//	PURPOSE:	Create the poly grid surface
//
// ----------------------------------------------------------------------- //

void VolumeBrush::CreateSurface()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	ObjectCreateStruct theStruct;
	INIT_OBJECTCREATESTRUCT(theStruct);

	DVector vPos, vDims, vScale;
	VEC_INIT(vScale);

	pServerDE->GetObjectDims(m_hObject, &vDims);
	pServerDE->GetObjectPos(m_hObject, &vPos);

	DRotation rRot;
	pServerDE->GetObjectRotation(m_hObject, &rRot);

	VEC_COPY(m_vLastPos, vPos);

	vPos.y += vDims.y - (m_fSurfaceHeight/2.0f); 
	VEC_COPY(theStruct.m_Pos, vPos);
	ROT_COPY(theStruct.m_Rotation, rRot);

	HCLASS hClass = pServerDE->GetClass("PolyGrid");

	PolyGrid* pSurface = DNULL;

	if (hClass)
	{
		pSurface = (PolyGrid *)pServerDE->CreateObject(hClass, &theStruct);
	}

	if (pSurface)
	{
		m_hSurfaceObj = pSurface->m_hObject;
		vDims.y		  = m_fSurfaceHeight;

		DFLOAT fXPan = 1.0f + (m_vCurrent.x * 0.01f);
		DFLOAT fYPan = 1.0f + (m_vCurrent.y * 0.01f);

		pSurface->Setup(&vDims, &m_vSurfaceColor1, &m_vSurfaceColor2,
						m_hstrSurfaceSprite, m_fXScaleMin, m_fXScaleMax, 
						m_fYScaleMin, m_fYScaleMax, m_fXScaleDuration, 
						m_fYScaleDuration, fXPan, fYPan, m_fSurfaceAlpha, 
						m_dwNumSurfacePolies);

//		pServerDE->SetObjectColor(m_hSurfaceObj,1.0f,0,0,0.1f);
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::UpdatePhysics()
//
//	PURPOSE:	Update the physics of the passed in object
//
// ----------------------------------------------------------------------- //

void VolumeBrush::UpdatePhysics(ContainerPhysics* pCPStruct)
{
	CServerDE* pServerDE = GetServerDE();
	if (m_bHidden || !pServerDE || !pCPStruct || !pCPStruct->m_hObject) return;

	DFLOAT fUpdateDelta = pServerDE->GetFrameTime();

	// Check to see if this object is the player object...

	if (!pServerDE->IsKindOf(pServerDE->GetObjectClass(pCPStruct->m_hObject), m_hPlayerClass))
	{
		// Check to see if this object is a character object...

		DBOOL bCharacter = DFALSE;
		HCLASS hBaseCharClass = pServerDE->GetClass("CBaseCharacter");

		if (pServerDE->IsKindOf(pServerDE->GetObjectClass(pCPStruct->m_hObject), hBaseCharClass))
		{
			bCharacter = DTRUE;

			if (m_bLocked)
			{
				// See if they have the key we need to unlock
				HMESSAGEWRITE hMessage = pServerDE->StartMessageToObject((LPBASECLASS)this, pCPStruct->m_hObject, MID_KEYQUERY);
				pServerDE->WriteToMessageHString(hMessage, m_hstrKeyName);
				pServerDE->EndMessage(hMessage);
			}
		}


		// Update velocity...

		// Dampen velocity and acceleration based on the viscosity of the container...

		if (m_fViscosity > 0.0f)
		{
			VEC_MULSCALAR(pCPStruct->m_Velocity, pCPStruct->m_Velocity, m_fViscosity);
			VEC_MULSCALAR(pCPStruct->m_Acceleration, pCPStruct->m_Acceleration, m_fViscosity);
		}


		// Do special liquid / zero gravity handling...

		if (IsLiquid(m_eContainerCode))
		{
			UpdateLiquidPhysics(pCPStruct, bCharacter);
		}

		
		// Add any current...

		// Make current relative to update delta (actually change the REAL velocity)...

		DVector vCurrent;
		VEC_MULSCALAR(vCurrent, m_vCurrent, fUpdateDelta);

		VEC_ADD(pCPStruct->m_Velocity, pCPStruct->m_Velocity, vCurrent);
	}
	
	// Update damage...

	// Make damage relative to update delta...

	if (m_fDamage)
	{
		DFLOAT fTime = pServerDE->GetTime();
		DFLOAT fDamageDeltaTime = fTime - m_fLastDamageTime;

		if (fDamageDeltaTime >= DAMAGE_UPDATE_DELTA || fTime == m_fLastDamageTime)
		{
			m_fLastDamageTime = fTime;

			DVector vDir;
			VEC_INIT(vDir);
	
			DamageObject(m_hObject, this, pCPStruct->m_hObject, m_fDamage * DAMAGE_UPDATE_DELTA, vDir, vDir, m_nDamageType);
		}
	}

}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::UpdateLiquidPhysics()
//
//	PURPOSE:	Update liquid specific physics of the passed in object
//				(really, under liquid physics)
//
// ----------------------------------------------------------------------- //

void VolumeBrush::UpdateLiquidPhysics(ContainerPhysics* pCPStruct, DBOOL bCharacter)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !pCPStruct || !pCPStruct->m_hObject) return;


	// If we are affecting a BaseCharacter object, let it do its own update...

	if (bCharacter)
	{
		CBaseCharacter* pCharacter = (CBaseCharacter*)pServerDE->HandleToObject(pCPStruct->m_hObject);
		if (pCharacter)
		{
			pCharacter->UpdateInLiquid(this, pCPStruct);
		}
	}
	else  // Apply liquid gravity to object...	
	{
		if (pCPStruct->m_Flags & FLAG_GRAVITY)
		{
			pCPStruct->m_Flags &= ~FLAG_GRAVITY;
			pCPStruct->m_Acceleration.y += m_fGravity;
		}
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::UpdateZeroGravity()
//
//	PURPOSE:	Update zero gravity specific physics
//
// ----------------------------------------------------------------------- //

void VolumeBrush::UpdateZeroGravity(ContainerPhysics* pCPStruct)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pCPStruct || !pCPStruct->m_hObject) return;

	if (pCPStruct->m_Flags & FLAG_GRAVITY)
	{
		pCPStruct->m_Flags &= ~FLAG_GRAVITY;
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::UndoVisocityCalculation()
//
//	PURPOSE:	Undo the viscosity calculation on this container physics
//				struct.
//
// ----------------------------------------------------------------------- //

void VolumeBrush::UndoViscosityCalculation(ContainerPhysics* pCPStruct)
{
	if (!pCPStruct) return;

	// Undo dampening...

	if (m_fViscosity > 0.0f)
	{
		VEC_DIVSCALAR(pCPStruct->m_Velocity, pCPStruct->m_Velocity, m_fViscosity);
		VEC_DIVSCALAR(pCPStruct->m_Acceleration, pCPStruct->m_Acceleration, m_fViscosity);
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::CacheFiles
//
//	PURPOSE:	Cache resources used by this the object
//
// ----------------------------------------------------------------------- //

void VolumeBrush::CacheFiles()
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE) return;

	// {MD 9/23/98}
	if(!(pServerDE->GetServerFlags() & SS_CACHING))
		return;

	char* pFile = DNULL;
	if (m_hstrSurfaceSprite)
	{
		pFile = pServerDE->GetStringData(m_hstrSurfaceSprite);
		if (pFile)
		{
			pServerDE->CacheFile(FT_SPRITE, pFile);
		}
	}
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::Save
//
//	PURPOSE:	Save the object
//
// ----------------------------------------------------------------------- //

void VolumeBrush::Save(HMESSAGEWRITE hWrite, DDWORD dwSaveFlags)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hWrite) return;

	DFLOAT fTime = pServerDE->GetTime();
	
//	pServerDE->WriteToLoadSaveMessageObject(hWrite, m_hSurfaceObj);

	pServerDE->WriteToMessageFloat(hWrite, m_fViscosity);
	pServerDE->WriteToMessageByte(hWrite, (DBYTE)m_eContainerCode);
	pServerDE->WriteToMessageVector(hWrite, &m_vCurrent);
	pServerDE->WriteToMessageFloat(hWrite, m_fDamage);
	pServerDE->WriteToMessageByte(hWrite, m_nDamageType);

	pServerDE->WriteToMessageFloat(hWrite, m_fSurfaceHeight);
	pServerDE->WriteToMessageByte(hWrite, m_bShowSurface);
	pServerDE->WriteToMessageVector(hWrite, &m_vSurfaceColor1);
	pServerDE->WriteToMessageVector(hWrite, &m_vSurfaceColor2);

	pServerDE->WriteToMessageVector(hWrite, &m_vLastPos);
	pServerDE->WriteToMessageByte(hWrite, m_bHidden);
	pServerDE->WriteToMessageFloat(hWrite, m_fGravity);
	pServerDE->WriteToMessageFloat(hWrite, (m_fLastDamageTime - fTime));
	pServerDE->WriteToMessageFloat(hWrite, m_fXScaleMin);

	pServerDE->WriteToMessageFloat(hWrite, m_fXScaleMax);
	pServerDE->WriteToMessageFloat(hWrite, m_fYScaleMin);
	pServerDE->WriteToMessageFloat(hWrite, m_fYScaleMax);
	pServerDE->WriteToMessageFloat(hWrite, m_fXScaleDuration);
	pServerDE->WriteToMessageFloat(hWrite, m_fYScaleDuration);

	pServerDE->WriteToMessageHString(hWrite, m_hstrSurfaceSprite);
	pServerDE->WriteToMessageDWord(hWrite, m_dwFlags);
	pServerDE->WriteToMessageDWord(hWrite, m_dwSaveFlags);
//		HOBJECT			m_hSurfaceObj;
	pServerDE->WriteToMessageByte(hWrite, m_bLocked);
	pServerDE->WriteToMessageByte(hWrite, m_bUnlockKeyRemove);
	pServerDE->WriteToMessageHString(hWrite, m_hstrKeyName);

	pServerDE->WriteToMessageByte(hWrite, m_bFogEnable);
	pServerDE->WriteToMessageFloat(hWrite, m_fFogFarZ);
	pServerDE->WriteToMessageFloat(hWrite, m_fFogNearZ);
	pServerDE->WriteToMessageVector(hWrite, &m_vFogColor);
	pServerDE->WriteToMessageFloat(hWrite, m_fSurfaceAlpha);
	pServerDE->WriteToMessageDWord(hWrite, m_dwNumSurfacePolies);
}


// ----------------------------------------------------------------------- //
//
//	ROUTINE:	VolumeBrush::Load
//
//	PURPOSE:	Load the object
//
// ----------------------------------------------------------------------- //

void VolumeBrush::Load(HMESSAGEREAD hRead, DDWORD dwLoadFlags)
{
	CServerDE* pServerDE = GetServerDE();
	if (!pServerDE || !hRead) return;

	DFLOAT fTime = pServerDE->GetTime();

//	pServerDE->ReadFromLoadSaveMessageObject(hRead, &m_hSurfaceObj);

	m_fViscosity			= pServerDE->ReadFromMessageFloat(hRead);
	m_eContainerCode		= (ContainerCode)pServerDE->ReadFromMessageByte(hRead);
	pServerDE->ReadFromMessageVector(hRead, &m_vCurrent);
	m_fDamage				= pServerDE->ReadFromMessageFloat(hRead);
	m_nDamageType			= pServerDE->ReadFromMessageByte(hRead);

	m_fSurfaceHeight		= pServerDE->ReadFromMessageFloat(hRead);
	m_bShowSurface			= pServerDE->ReadFromMessageByte(hRead);
	pServerDE->ReadFromMessageVector(hRead, &m_vSurfaceColor1);
	pServerDE->ReadFromMessageVector(hRead, &m_vSurfaceColor2);

	pServerDE->ReadFromMessageVector(hRead, &m_vLastPos);
	m_bHidden				= pServerDE->ReadFromMessageByte(hRead);
	m_fGravity				= pServerDE->ReadFromMessageFloat(hRead);
	m_fLastDamageTime		= pServerDE->ReadFromMessageFloat(hRead) + fTime;
	m_fXScaleMin			= pServerDE->ReadFromMessageFloat(hRead);

	m_fXScaleMax			= pServerDE->ReadFromMessageFloat(hRead);
	m_fYScaleMin			= pServerDE->ReadFromMessageFloat(hRead);
	m_fYScaleMax			= pServerDE->ReadFromMessageFloat(hRead);
	m_fXScaleDuration		= pServerDE->ReadFromMessageFloat(hRead);
	m_fYScaleDuration		= pServerDE->ReadFromMessageFloat(hRead);

	m_hstrSurfaceSprite		= pServerDE->ReadFromMessageHString(hRead);
	m_dwFlags				= pServerDE->ReadFromMessageDWord(hRead);
	m_dwSaveFlags			= pServerDE->ReadFromMessageDWord(hRead);

	m_bLocked				= pServerDE->ReadFromMessageByte(hRead);
	m_bUnlockKeyRemove		= pServerDE->ReadFromMessageByte(hRead);
	m_hstrKeyName			= pServerDE->ReadFromMessageHString(hRead);

	m_bFogEnable			= pServerDE->ReadFromMessageByte(hRead);
	m_fFogFarZ				= pServerDE->ReadFromMessageFloat(hRead);
	m_fFogNearZ				= pServerDE->ReadFromMessageFloat(hRead);
	pServerDE->ReadFromMessageVector(hRead, &m_vFogColor);
	m_fSurfaceAlpha			= pServerDE->ReadFromMessageFloat(hRead);
	m_dwNumSurfacePolies	= pServerDE->ReadFromMessageDWord(hRead);


	// Recreate the surface
	if (m_bShowSurface) 
	{
		CreateSurface();
	}

	DDWORD dwUserFlags = m_bHidden ? 0 : USRFLG_VISIBLE;
	dwUserFlags |= USRFLG_SAVEABLE;

	pServerDE->SetObjectUserFlags(m_hObject, dwUserFlags);

	if (m_hSurfaceObj) 
	{
		pServerDE->SetObjectUserFlags(m_hSurfaceObj, dwUserFlags);
	}

}