void vHavokDisplayGeometryList::Add(vHavokDisplayGeometry *pGeometry)
{
VVERIFY_OR_RET(pGeometry);
pGeometry->AddRef();
m_List[m_iSize] = pGeometry;
m_iSize++;
}
// **************************************************
// SETUP ANIMATIONS
// **************************************************
void TransitionBarbarian_cl::SetupAnimations()
{
m_bModelValid = false;
VDynamicMesh *pModel = GetMesh();
VVERIFY_OR_RET(pModel);
m_pSkeletalSequenceList[ANIMID_IDLE] = (VisSkeletalAnimSequence_cl*)pModel->GetSequence("Idle", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_pSkeletalSequenceList[ANIMID_IDLE]);
m_pSkeletalSequenceList[ANIMID_WALK] = (VisSkeletalAnimSequence_cl*)pModel->GetSequence("Walk", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_pSkeletalSequenceList[ANIMID_WALK]);
m_pSkeletalSequenceList[ANIMID_RUN] = (VisSkeletalAnimSequence_cl*)pModel->GetSequence("Run", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_pSkeletalSequenceList[ANIMID_RUN]);
m_bModelValid = true;
}
void RPG_Action_Dodge::Start(bool forced, RPG_ActionType_e prevAction, RPG_BaseEntity *interactionEntity, hkvVec3 const& interactionPosition)
{
RPG_Action::Start(forced, prevAction, interactionEntity, interactionPosition);
//Vision::Error.SystemMessage("StartAction: Dodge");
VVERIFY_OR_RET(m_characterOwner);
// cancel any ongoing move
m_characterOwner->GetController()->CancelRequestedPath();
// play any visual and/or sound effects associated with this action
m_characterOwner->CreateCharacterEffect(FX_Dodge);
vHavokBehaviorComponent *const behaviorComponent = m_characterOwner->GetBehaviorComponent();
VVERIFY_OR_RET(behaviorComponent);
VASSERT(!m_behaviorTriggerVarName.IsEmpty());
behaviorComponent->SetBoolVar(m_behaviorTriggerVarName.AsChar(), true); // tell the behavior component to execute the dodge event. Dodging resets to false when the dodge anim is complete.
}
void RPG_Action_Challenge::Start(bool forced, RPG_ActionType_e prevAction, RPG_BaseEntity *interactionEntity, hkvVec3 const& interactionPosition)
{
RPG_Action::Start(forced, prevAction, interactionEntity, interactionPosition);
VVERIFY_OR_RET(m_characterOwner);
// cancel any ongoing move
m_characterOwner->GetController()->CancelRequestedPath();
// play any visual and/or sound effects associated with this action
m_characterOwner->CreateCharacterEffect(FX_Challenge);
// grab the behavior component and tell it to set the associated variable
vHavokBehaviorComponent *const behaviorComponent = m_characterOwner->GetBehaviorComponent();
VVERIFY_OR_RET(behaviorComponent);
VASSERT(!m_behaviorTriggerVarName.IsEmpty());
behaviorComponent->SetBoolVar(m_behaviorTriggerVarName.AsChar(), true); // tell the behavior component to execute the associated animation. Resets to false when the anim is complete.
}
void vHavokTerrain::Init(const VTerrainSector &terrainSector)
{
// Init may only be called once
VVERIFY_OR_RET(m_bInitialized == false);
m_bInitialized = true;
m_terrainSector = &terrainSector;
// Build the Havok shape
CreateHkRigidBody();
}
// **************************************************
// SETUP ANIMATIONS
// **************************************************
void TransitionCharacter_cl::SetupAnimations()
{
m_bModelValid = false;
VDynamicMesh *pMesh = GetMesh();
VVERIFY_OR_RET(pMesh);
// idle animations
m_spSkeletalSequenceList[ANIMID_IDLE] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Idle", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_IDLE]);
// run animations
m_spSkeletalSequenceList[ANIMID_RUN] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Run", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_RUN]);
// walk animations
m_spSkeletalSequenceList[ANIMID_WALK] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Walk", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_WALK]);
// turn animations
m_spSkeletalSequenceList[ANIMID_TURN] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Turn", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_TURN]);
// walk backwards animation
m_spSkeletalSequenceList[ANIMID_WALKBACKWARDS] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Run_BWD", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_WALKBACKWARDS]);
m_bModelValid = true;
}
void RPG_Action_Dodge::Tick(float const deltaTime)
{
RPG_Action::Tick(deltaTime);
vHavokBehaviorComponent *const behaviorComponent = m_characterOwner->GetBehaviorComponent();
VVERIFY_OR_RET(behaviorComponent);
// Dodging was set to true when dodge was initiated. Is reset to false by Behavior when the dodge anim finishes.
if (!RPG_VisionHavokBehaviorHelper::BehaviorGetVarNamed<bool>(*behaviorComponent, m_behaviorTriggerVarName.AsChar()))
{
End();
}
}
void vHavokStaticMesh::Init(VisStaticMeshInstance_cl &meshInstance)
{
// Init may only be called once
VVERIFY_OR_RET(m_bInitialized == false);
// Add the static mesh instance
m_staticMeshes.Append(&meshInstance);
meshInstance.SetPhysicsObject(this);
m_iNumValidStaticMeshes = 1;
m_bInitialized = true;
// Build the Havok shape
CreateHkRigidBody();
}
void vHavokStaticMesh::Init(VisStaticMeshInstCollection &meshInstances)
{
// Init may only be called once
VVERIFY_OR_RET(m_bInitialized == false);
// Add the static mesh instances
int iCount = meshInstances.GetLength();
for (int i = 0; i < iCount; i++)
{
m_staticMeshes.Append(meshInstances[i]);
meshInstances[i]->SetPhysicsObject(this);
m_iNumValidStaticMeshes++;
}
m_bInitialized = true;
CreateHkRigidBody();
}
// ----------------------------------------------------------------------------
void vHavokDebugConstraintChainRenderer::OnRender()
{
VVERIFY_OR_RET(m_pConstraintChain);
float fLinkExtent = (m_pConstraintChain->GetLinkLength() - m_pConstraintChain->GetLinkGap()) / 2.f;
for (unsigned int i = 0; i < m_pConstraintChain->GetNumLinks(); ++i)
{
hkvVec3 vTranslation;
hkvMat3 mRotation;
if (!m_pConstraintChain->GetLinkTransform(i, mRotation, vTranslation))
continue;
hkvVec3 v1 = hkvVec3(-fLinkExtent, 0.f, 0.f);
hkvVec3 v2 = -v1;
v1 = (mRotation * v1) + vTranslation;
v2 = (mRotation * v2) + vTranslation;
Vision::Game.DrawSingleLine(v1, v2, Render_Color);
}
}
void vHavokStaticMesh::RemoveStaticMesh(VisStaticMeshInstance_cl *pMesh)
{
VVERIFY_OR_RET(pMesh != NULL);
for (int i = 0; i < m_staticMeshes.GetLength(); ++i)
{
if (m_staticMeshes[i] != pMesh)
continue;
m_staticMeshes[i]->SetPhysicsObject(NULL);
m_staticMeshes[i] = NULL;
m_iNumValidStaticMeshes--;
VASSERT(m_iNumValidStaticMeshes >= 0);
break;
}
// Get rid of the Havok rigid body if there are no more meshes left.
if (m_iNumValidStaticMeshes == 0)
RemoveHkRigidBody();
}
void RPG_Action_RangedAttack::Tick(float const deltaTime)
{
RPG_Action_AttackBase::Tick(deltaTime);
if(m_attacking)
{
// RangedAttacking was set to true when the action was initiated. Is reset to false by Behavior when the attack anim finishes.
vHavokBehaviorComponent *const behaviorComponent = m_characterOwner->GetBehaviorComponent();
VVERIFY_OR_RET(behaviorComponent);
VASSERT(!m_behaviorTriggerVarName.IsEmpty());
if (!RPG_VisionHavokBehaviorHelper::BehaviorGetVarNamed<bool>(*behaviorComponent, m_behaviorTriggerVarName.AsChar()))
{
if (m_flags == 1)
{
if(m_updatedInteraction)
{
m_updatedInteraction = false;
if(!m_updatedInteractionEntity && m_interactionEntity)
{
// Do not lose the player's intended target
ValidateInteractionEntity();
if(!m_interactionEntity->Components().GetComponentOfType(V_RUNTIME_CLASS(RPG_AttackableComponent)))
{
m_interactionEntity = NULL;
}
else
{
if(m_interactionEntity->GetPosition().getDistanceToSquared(m_updatedInteractionPosition) > s_retargetingRadius * s_retargetingRadius)
{
m_interactionEntity = NULL;
}
}
}
else
{
m_interactionEntity = m_updatedInteractionEntity;
ValidateInteractionEntity();
}
m_interactionPosition = m_updatedInteractionPosition;
}
m_startTime = Vision::GetTimer()->GetTime();
StartAttack();
}
else
{
// if we've gotten to the end and haven't fired the projectile, fire it now
if (!m_hasFired)
{
VString msg;
msg.Format("RPG_Action_RangedAttack never received expected %s event from Behavior.", m_behaviorFireEventName.AsChar());
Vision::Error.Warning(msg.AsChar());
//VASSERT_MSG(false, msg.AsChar());
FireAttack();
}
End();
}
}
else
{
// we're currently attacking
hkvVec3 const targetPosition = m_interactionEntity ? m_interactionEntity->GetPosition() : m_interactionPosition;
FaceTargetPoint(targetPosition);
#ifdef _DEBUG
if (m_debugDisplayInfo)
{
Vision::Game.DrawSingleLine(m_characterOwner->GetPosition(), targetPosition, VColorRef(255, 0, 255));
}
#endif
}
}
else
{
StartAttack();
}
}
void AnimatedWarrior_cl::SetupAnimations()
{
m_bModelValid = false;
VDynamicMesh *pMesh = GetMesh();
VVERIFY_OR_RET(pMesh);
VisAnimEventList_cl *pEventList = NULL;
// idle animations
m_spSkeletalSequenceList[ANIMID_IDLE] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Idle", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_IDLE]);
m_spSkeletalSequenceList[ANIMID_IDLE_TORCH] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Idle_Look_Torch", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_IDLE_TORCH]);
// run animation
m_spSkeletalSequenceList[ANIMID_RUN] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Run", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_RUN]);
pEventList = m_spSkeletalSequenceList[ANIMID_RUN]->GetEventList();
pEventList->AddEvent(0.0f, EVENT_ANIM_LEGSPARALLEL_FIRSTTIME);
pEventList->AddEvent(0.396f, EVENT_ANIM_LEGSPARALLEL_SECONDTIME);
// run with torch animation
m_spSkeletalSequenceList[ANIMID_RUN_TORCH] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Run_Torch", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_RUN_TORCH]);
pEventList = m_spSkeletalSequenceList[ANIMID_RUN_TORCH]->GetEventList();
pEventList->AddEvent(0.0f, EVENT_ANIM_LEGSPARALLEL_FIRSTTIME);
pEventList->AddEvent(0.396f, EVENT_ANIM_LEGSPARALLEL_SECONDTIME);
// walk animation
m_spSkeletalSequenceList[ANIMID_WALK] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Walk", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_WALK]);
pEventList = m_spSkeletalSequenceList[ANIMID_WALK]->GetEventList();
pEventList->AddEvent(0.0f, EVENT_ANIM_LEGSPARALLEL_FIRSTTIME);
pEventList->AddEvent(0.495f, EVENT_ANIM_LEGSPARALLEL_SECONDTIME);
// walk with torch animation
m_spSkeletalSequenceList[ANIMID_WALK_TORCH] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Walk_Torch", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_WALK_TORCH]);
pEventList = m_spSkeletalSequenceList[ANIMID_WALK_TORCH]->GetEventList();
pEventList->AddEvent(0.0f, EVENT_ANIM_LEGSPARALLEL_FIRSTTIME);
pEventList->AddEvent(0.495f, EVENT_ANIM_LEGSPARALLEL_SECONDTIME);
// turn animation
m_spSkeletalSequenceList[ANIMID_TURN] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Turn", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_TURN]);
// turn with torch animation
m_spSkeletalSequenceList[ANIMID_TURN_TORCH] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Turn_Torch", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_TURN_TORCH]);
// walk backwards animation
m_spSkeletalSequenceList[ANIMID_WALKBACKWARDS] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Run_BWD_V2", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_WALKBACKWARDS]);
// walk backwards with torch animation
m_spSkeletalSequenceList[ANIMID_WALKBACKWARDS_TORCH] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Run_BWD_Torch_V2", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_WALKBACKWARDS_TORCH]);
// upper body animations (torch)
m_spSkeletalSequenceList[ANIMID_UPPERBODY_ARM] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Draw_Dagger", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_UPPERBODY_ARM]);
m_spSkeletalSequenceList[ANIMID_UPPERBODY_ARM]->RemoveOffsetDeltaTrack();
pEventList = m_spSkeletalSequenceList[ANIMID_UPPERBODY_ARM]->GetEventList();
pEventList->AddEvent(m_spSkeletalSequenceList[ANIMID_UPPERBODY_ARM]->GetLength(), EVENT_ANIM_UPPERBODY_ARMING_FINISHED);
m_spSkeletalSequenceList[ANIMID_UPPERBODY_DISARM] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Holster_Dagger", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_UPPERBODY_DISARM]);
m_spSkeletalSequenceList[ANIMID_UPPERBODY_DISARM]->RemoveOffsetDeltaTrack();
pEventList = m_spSkeletalSequenceList[ANIMID_UPPERBODY_DISARM]->GetEventList();
pEventList->AddEvent(m_spSkeletalSequenceList[ANIMID_UPPERBODY_DISARM]->GetLength(), EVENT_ANIM_UPPERBODY_DISARMING_FINISHED);
m_spSkeletalSequenceList[ANIMID_UPPERBODY_ATTACK] = (VisSkeletalAnimSequence_cl*)pMesh->GetSequence("Strike_Dagger", VIS_MODELANIM_SKELETAL);
VVERIFY_OR_RET(m_spSkeletalSequenceList[ANIMID_UPPERBODY_ATTACK]);
m_spSkeletalSequenceList[ANIMID_UPPERBODY_ATTACK]->RemoveOffsetDeltaTrack();
pEventList = m_spSkeletalSequenceList[ANIMID_UPPERBODY_ATTACK]->GetEventList();
pEventList->AddEvent(m_spSkeletalSequenceList[ANIMID_UPPERBODY_ATTACK]->GetLength(), EVENT_ANIM_UPPERBODY_ATTACK_FINISHED);
m_bModelValid = true;
}
void vHavokStaticMesh::UpdateVision2Havok()
{
VVERIFY_OR_RET(m_staticMeshes.GetLength() >= 1 && m_pRigidBody);
int iCount = m_staticMeshes.GetLength();
for (int i=0;i<iCount;i++)
{
// since collision mesh does not provide a bounding box, use bounding box of render mesh as approximation
const hkvAlignedBBox& bbox = m_staticMeshes[i]->GetBoundingBox();
hkVector4 bbox_min; vHavokConversionUtils::VisVecToPhysVec_noscale(bbox.m_vMin, bbox_min);
hkVector4 bbox_max; vHavokConversionUtils::VisVecToPhysVec_noscale(bbox.m_vMax, bbox_max);
hkVector4 bbox_extent; bbox_extent.setSub(bbox_max,bbox_min); bbox_extent.mul(vHavokConversionUtils::GetVision2HavokScaleSIMD());
hkVector4 meshTol; meshTol.setAll(hkReal(HKVIS_MESH_SHAPE_TOLERANCE));
hkVector4Comparison::Mask largeEnough = bbox_extent.greaterEqual(meshTol).getMask<hkVector4ComparisonMask::MASK_XYZ>();
if (hkMath::countBitsSet(largeEnough) < 2)
{
Vision::Error.Warning("Attempted to create a vHavokStaticMesh with undersized extents (%.4f, %4f, %.4f)",
bbox_extent(0), bbox_extent(1), bbox_extent(2));
return;
}
}
// We use the first static mesh instance as origin reference
VisStaticMeshInstance_cl *pMeshInstance = m_staticMeshes[0];
// Get the static mesh instance position and rotation
hkMatrix4 mTransform;
vHavokConversionUtils::VisMatrixToHkMatrix(pMeshInstance->GetTransform(), mTransform, false, false, true);
// Split the rotation into scale and normal matrix
hkRotation mRotation;
mRotation.setCols(mTransform.getColumn<0>(),mTransform.getColumn<1>(),mTransform.getColumn<2>());
hkVector4 vScale;
vScale.set(mRotation.getColumn<0>().normalizeWithLength<3>(),
mRotation.getColumn<1>().normalizeWithLength<3>(),
mRotation.getColumn<2>().normalizeWithLength<3>(),
hkSimdReal_1);
bool bUpdateDebugRendering = false;
//Check here if we need to recalculate the precomputed collision mesh
//should only happen inside the editor
//if((vScale.x != m_vScale.x || vScale.y != m_vScale.y || vScale.z != m_vScale.z) && m_pRigidBody != NULL)
hkVector4 mvScale; vHavokConversionUtils::VisVecToPhysVec_noscale(m_vScale,mvScale);
if (!vScale.allEqual<3>(mvScale, hkSimdReal::fromFloat(HKVMATH_LARGE_EPSILON)) && (m_pRigidBody != NULL))
{
// Keep our object alive
VSmartPtr<vHavokStaticMesh> keepAlive = this;
RemoveHkRigidBody(); //Remove the old collision object
CreateHkRigidBody(); //Create a new one (because the scale changed)
VASSERT_MSG(m_pRigidBody != NULL, "Creating new rigid body failed");
vHavokConversionUtils::PhysVecToVisVec_noscale(vScale, m_vScale);
bUpdateDebugRendering = true;
}
// Set the transformation in Havok
hkTransform hkTfOut;
hkTfOut.setRotation(mRotation);
hkTfOut.getTranslation().setMul(mTransform.getColumn<3>(),vHavokConversionUtils::GetVision2HavokScaleSIMD());
m_pRigidBody->setTransform(hkTfOut);
if (bUpdateDebugRendering)
{
SetDebugRendering (false);
}
}
