void VLineFollowerComponent::PerFrameUpdate()
{
VisBaseEntity_cl* pOwner = (VisBaseEntity_cl *)GetOwner();
if (!pOwner || !m_pFollowPath)
return;
hkvVec3 vPos;
hkvVec3 vDir;
m_pFollowPath->EvalPoint(m_fCurrentPathPos, vPos, &vDir);
vPos.z = pOwner->GetPosition().z;
float fDiff = Vision::GetTimer()->GetTimeDifference();
if((vPos - pOwner->GetPosition()).getLength() < Path_TriggerDistance)
{
if(fDiff>0.1)
m_fCurrentPathPos += (3/Path_NumberSteps);
else
m_fCurrentPathPos += (1/Path_NumberSteps);
if (m_fCurrentPathPos>1.f)
{
if (m_pFollowPath->IsClosed())
m_fCurrentPathPos = hkvMath::mod (m_fCurrentPathPos,1.f);
else
m_fCurrentPathPos = 1.f;
}
m_pFollowPath->EvalPoint(m_fCurrentPathPos, vPos, &vDir);
vPos.z = pOwner->GetPosition().z;
if(Vision::Editor.IsAnimatingOrPlaying() && Debug_DisplayBoxes)
Vision::Game.DrawCube(vPos,80.f);
}
else
{
if(Vision::Editor.IsAnimatingOrPlaying() && Debug_DisplayBoxes)
Vision::Game.DrawCube(vPos,80.f,V_RGBA_YELLOW);
}
// Orient the entity in the right direction
hkvMat3 mRot(hkvNoInitialization);
mRot.setLookInDirectionMatrix (vPos - pOwner->GetPosition());
mRot = mRot.multiply (m_mDeltaRotation);
pOwner->SetRotationMatrix(mRot);
// The animation we are playing should have motion delta which will
// move towards the target position. No animation, well lets add at
// least some motion delta
if (!m_bPlayingAnim)
{
pOwner->SetMotionDeltaLocalSpace( hkvVec3(1.f,0.f,0.f)*(Model_CapsuleRadius*fDiff) );
}
}
void VAnimationEventEffectTrigger::OnAnimationEvent()
{
// Get the active event trigger info
VEventEffectTriggerInfo_t* info = (VEventEffectTriggerInfo_t*) m_pActiveTriggerInfo;
// Check if effect file is specified
if (info == NULL || info->m_spEffectFile == NULL)
return;
// Get bone translation and orientation (if bone ID is 0 no bone has been specified)
VisBaseEntity_cl* pEntity = (VisBaseEntity_cl *)m_pOwner;
hkvVec3 vPos = pEntity->GetPosition() + info->m_vPositionOffset;
hkvVec3 vOri = pEntity->GetOrientation() + info->m_vOrientationOffset;
if (info->m_iAttachToBone != -1)
{
hkvQuat vRot;
pEntity->GetBoneCurrentWorldSpaceTransformation(info->m_iAttachToBone, vPos, vRot);
// Add position and orientation offset
vPos = PositionOffset + vPos;
hkvQuat vOffsetRot; vOffsetRot.setFromEulerAngles (vOri.data[2], vOri.data[1], vOri.data[0]);
vRot = vRot.multiplyReverse (vOffsetRot);
vRot.getAsEulerAngles (vOri.z, vOri.y, vOri.x);
}
// Trigger effect
VisParticleEffect_cl* pEffectInstance = info->m_spEffectFile->CreateParticleEffectInstance(vPos, vOri);
pEffectInstance->SetRemoveWhenFinished(true);
}
void VFmodAnimationEventSoundTrigger::OnAnimationEvent()
{
// Get the active event trigger info
VFmodEventSoundTriggerInfo_t* info = (VFmodEventSoundTriggerInfo_t*) m_pActiveTriggerInfo;
// Check if effect file is specified
if (info == NULL || info->m_spSoundResource == NULL)
return;
// Get entity position
VisBaseEntity_cl* pEntity = (VisBaseEntity_cl *)m_pOwner;
hkvVec3 vPos = pEntity->GetPosition();
// Trigger sound effect
VFmodSoundObject* pSound = info->m_spSoundResource->CreateInstance(vPos, VFMOD_FLAG_NONE);
if(pSound)
pSound->Play();
}
// ---------------------------------------------------------------------------------
// Method: LoadMap
// Notes:
// ---------------------------------------------------------------------------------
void LoadMap(int iMap, BOOL bLoadEntities)
{
g_spMap = NULL;
// load map
strcpy(g_pszCurrentMap, g_pszMaps[iMap]);
g_iCurrentMap = iMap;
spApp->LoadScene(g_pszCurrentMap);
hkvVec3 vStart;
// try to find the Player_Start placeholder entity
VisBaseEntity_cl* pStart = Vision::Game.SearchEntity("Player_Start");
if (pStart)
vStart = pStart->GetPosition();
else
vStart.set (-350.f, 200.f, 200.f);
if ( bLoadEntities )
{
// create player entity (in case the entities are not loaded from the savegame)
Vision::Game.CreateEntity("SerializePlayer_cl", vStart);
// create 3 spotlight entities
hkvVec3 Placement;
Placement.set ( -200, 500, 200 );
Vision::Game.CreateEntity("SerializeSpotlight_cl", Placement );
Placement.set ( -300, 0, 100 );
Vision::Game.CreateEntity("SerializeSpotlight_cl", Placement );
Placement.set ( 40, -600, 100 );
Vision::Game.CreateEntity("SerializeSpotlight_cl", Placement );
}
// create some screen masks
int w = Vision::Video.GetXRes();
int h = Vision::Video.GetYRes();
// set up "current map" screen mask
g_spMap = new VisScreenMask_cl(g_pszMapIcons[iMap], TEXTURE_LOADING_FLAGS);
g_spMap->SetPos( w - 48.f - 8.f, (float)h - 48.f - 8.f );
g_spMap->SetTransparency(VIS_TRANSP_ALPHA);
g_spMap->SetColor(g_iOverlayColor);
g_spMap->SetVisible(TRUE);
}
void VLineFollowerComponent::InitPhysics(float fPathPos)
{
VisBaseEntity_cl* pOwner = (VisBaseEntity_cl *)GetOwner();
if (!pOwner)
return;
hkvVec3 vPos;
hkvVec3 vDir;
hkvAlignedBBox bbox;
m_fCurrentPathPos = fPathPos;
if(m_pFollowPath)
m_pFollowPath->EvalPoint(fPathPos, vPos, &vDir);
else
vPos = pOwner->GetPosition();
// to determine correct height on the ground, perform a ray-cast:
if (Vision::GetApplication()->GetPhysicsModule()!=NULL && Model_CapsuleHeight>0)
{
hkvVec3 vRayStart(vPos.x,vPos.y,vPos.z+Model_CapsuleHeight);
hkvVec3 vRayEnd(vPos.x,vPos.y,vPos.z-Model_CapsuleHeight);
VisPhysicsHit_t hitPoint;
if (Vision::GetApplication()->GetPhysicsModule()->Raycast(vRayStart, vRayEnd, hitPoint)) // hit?
{
vPos.z = hitPoint.vImpactPoint.z + 5.f*Vision::World.GetGlobalUnitScaling(); // add some margin
}
}
VDynamicMesh *pMesh = pOwner->GetMesh();
if (pMesh)
{
pMesh->GetCollisionBoundingBox(bbox);
vPos.z -= bbox.m_vMin.z;
// Use model size if not set
if (Model_CapsuleRadius<=0.f) Model_CapsuleRadius = hkvMath::Min( bbox.getSizeX(), bbox.getSizeY() )/2.f;
if (Model_CapsuleHeight<=0.f) Model_CapsuleHeight = bbox.getSizeZ();
} else
{
// No model - set some sane values if not set
if (Model_CapsuleRadius<=0.f) Model_CapsuleRadius = 40.f;
if (Model_CapsuleHeight<=0.f) Model_CapsuleHeight = 90.f;
}
// Create the physics object
pOwner->SetPosition(vPos);
if (!m_pPhys)
{
m_pPhys = new vHavokCharacterController();
m_pPhys->Capsule_Radius = Model_CapsuleRadius;
float h = Model_CapsuleHeight * 0.5f;
float fPivot = Model_GroundOffset;
m_pPhys->Character_Top.set(0, 0, h - fPivot);
m_pPhys->Character_Bottom.set(0, 0, -h - fPivot);
pOwner->AddComponent(m_pPhys);
}
// Update position
m_pPhys->SetPosition(vPos);
// Enable debug rendering
m_pPhys->SetDebugRendering(Debug_RenderMesh);
m_pPhys->SetDebugColor(V_RGBA_RED);
}
void VLineFollowerComponent::OnHandleCallback(IVisCallbackDataObject_cl *pData)
{
VisBaseEntity_cl* pOwner = (VisBaseEntity_cl *)GetOwner();
if (!pOwner)
return;
// Update callback
if (pData->m_pSender == &Vision::Callbacks.OnUpdateSceneFinished)
{
// Update
PerFrameUpdate();
// Debug Render
if (!Vision::Editor.IsAnimatingOrPlaying())
{
if (Debug_RenderMesh)
{
hkvVec3 pos = pOwner->GetPosition();
hkvMat3 rotMat;
// Setup all coordinates of a single spline
hkvVec3 p1(0,0,-Model_CapsuleHeight*0.5f-Model_CapsuleRadius);
hkvVec3 p2(Model_CapsuleRadius*0.7f,0,-Model_CapsuleHeight*0.5f-Model_CapsuleRadius*0.7f);
hkvVec3 p3(Model_CapsuleRadius,0,-Model_CapsuleHeight*0.5f);
hkvVec3 p4(Model_CapsuleRadius,0,Model_CapsuleHeight*0.5f);
hkvVec3 p5(Model_CapsuleRadius*0.7f,0,Model_CapsuleHeight*0.5f+Model_CapsuleRadius*0.7f);
hkvVec3 p6(0,0,Model_CapsuleHeight*0.5f+Model_CapsuleRadius);
rotMat.setRotationMatrix (hkvVec3(0,0,1), 60.f);
pos.z -= Model_GroundOffset;
// Draw and rotate the spline (6 times)
int i;
for(i=0;i<6;i++)
{
Vision::Game.DrawSingleLine(pos-p1, pos-p2,V_RGBA_RED);
Vision::Game.DrawSingleLine(pos-p2, pos-p3,V_RGBA_RED);
Vision::Game.DrawSingleLine(pos-p3, pos-p4,V_RGBA_RED);
Vision::Game.DrawSingleLine(pos-p4, pos-p5,V_RGBA_RED);
Vision::Game.DrawSingleLine(pos-p5, pos-p6,V_RGBA_RED);
p1 = rotMat.transformDirection(p1);
p2 = rotMat.transformDirection(p2);
p3 = rotMat.transformDirection(p3);
p4 = rotMat.transformDirection(p4);
p5 = rotMat.transformDirection(p5);
p6 = rotMat.transformDirection(p6);
}
}
}
}
// Initialization
if (pData->m_pSender == &Vision::Callbacks.OnAfterSceneLoaded)
{
// Find the path to follow
if (m_pFollowPath==NULL && Path_Key[0])
{
m_pFollowPath = Vision::Game.SearchPath(Path_Key);
InitPhysics(hkvMath::mod (Path_InitialOffset, 1.f));
}
return;
}
// Event handling
if (pData->m_pSender==&PathCameraAction::OnTriggerEvent)
{
TiXmlElement *pEventNode = ((VPathEventCallbackDataObject *)pData)->m_pEventNode;
const char *szEntityKey = pEventNode->Attribute(ENTITY_PROPERTY);
if (szEntityKey && pOwner->GetEntityKey() && !_stricmp(szEntityKey, pOwner->GetEntityKey()))
{
const char *szAction = pEventNode->Attribute(ACTION_PROPERTY);
if(szAction && !_stricmp(szAction,RESET_ACTION))
{
InitPhysics(hkvMath::mod (Path_InitialOffset, 1.f));
}
else if(szAction && !_stricmp(szAction,SET_ACTION))
{
const char *szPos = pEventNode->Attribute(TO_PROPERTY);
float fPos = Path_InitialOffset;
if(szPos) fPos = hkvMath::mod ((float)atof(szPos),1.f);
InitPhysics(fPos);
}
}
return;
}
}
