/// \brief
/// Helper function to retrieve current distance to a given plane
///
/// \param vCameraPos
/// Camera position to test the distance against
/// \param fLODScaleSqr
/// Square of the LOD scaling factor
/// \param fPlane
/// Reference plane distance, will be subtracted from final result
///
/// \returns
/// Relative distance from object to given plane
inline float GetDistanceToPlane(const hkvVec3& vCameraPos, float fLODScaleSqr=1.f, float fPlane=0.f) const
{
int iLODMode = m_iPerformTestFlags&VIS_PERFORM_LODTEST;
float fDistSqr;
switch (iLODMode)
{
case VIS_LOD_TEST_NONE:
fDistSqr = 0.0f;
break;
case VIS_LOD_TEST_CLIPPOSITION:
fDistSqr = vCameraPos.getDistanceToSquared(m_vClipReference);
break;
case VIS_LOD_TEST_CLIPPOSITION|VIS_LOD_TEST_APPLYLODSCALING:
fDistSqr = vCameraPos.getDistanceToSquared(m_vClipReference)*fLODScaleSqr;
break;
case VIS_LOD_TEST_BOUNDINGBOX:
fDistSqr = m_BoundingBox.getDistanceToSquared(vCameraPos);
break;
case VIS_LOD_TEST_BOUNDINGBOX|VIS_LOD_TEST_APPLYLODSCALING:
fDistSqr = m_BoundingBox.getDistanceToSquared(vCameraPos)*fLODScaleSqr;
break;
default:
VASSERT_MSG(false,"Invalid combination of LOD flags");
return false;
}
return hkvMath::sqrt(fDistSqr) - fPlane;
}
VOVERRIDE void OnClick(VMenuEventDataObject *pEvent)
{
VDialog::OnClick(pEvent);
hkvVec2 vMousePos = GetContext()->GetCurrentMousePos();
hkvVec3 vDir;
Vision::Contexts.GetCurrentContext()->GetTraceDirFromScreenPos(vMousePos.x, vMousePos.y, vDir, 10000.f);
hkvVec3 vFrom = Vision::Camera.GetCurrentCameraPosition();
hkvVec3 vTo = vFrom + vDir;
const float v2h = vHavokConversionUtils::GetVision2HavokScale();
hkVector4 from; from.set( vFrom.x*v2h, vFrom.y*v2h, vFrom.z*v2h );
hkVector4 to; to.set( vTo.x*v2h, vTo.y*v2h, vTo.z*v2h );
hkaiNavMeshQueryMediator::HitDetails hit;
hit.m_hitFaceKey = HKAI_INVALID_PACKED_KEY;
hit.m_hitFraction = -1.f;
if (vHavokAiModule::GetInstance()->GetAiWorld()->getDynamicQueryMediator()->castRay(from, to, hit))
{
hkVector4 hitPoint; hitPoint.setInterpolate(from, to, hit.m_hitFraction);
hitPoint.mul4( vHavokConversionUtils::GetHavok2VisionScale() );
if (pEvent->m_iButtons & BUTTON_LMOUSE)
{
vStartPoint.set( hitPoint(0), hitPoint(1), hitPoint(2) );
}
else
{
vEndPoint.set( hitPoint(0), hitPoint(1), hitPoint(2) );
}
}
}
/// \brief
/// Helper function for visibility loop implementations
///
/// \param vCameraPos
/// Camera position to test LOD clipping
/// \param fLODScaleSqr
/// Square of the LOD scaling factor
///
/// \returns
/// true if the object is clipped either by near of far clip distance (if specified)
inline bool IsNearOrFarClipped(const hkvVec3& vCameraPos, float fLODScaleSqr=1.f) const
{
// changes in this function have to be reflected in SPU version IsNearOrFarClipped
int iLODMode = m_iPerformTestFlags&VIS_PERFORM_LODTEST;
float fDistSqr;
switch (iLODMode)
{
case VIS_LOD_TEST_NONE:
return false;
case VIS_LOD_TEST_CLIPPOSITION:
fDistSqr = vCameraPos.getDistanceToSquared(m_vClipReference);
break;
case VIS_LOD_TEST_CLIPPOSITION|VIS_LOD_TEST_APPLYLODSCALING:
fDistSqr = vCameraPos.getDistanceToSquared(m_vClipReference)*fLODScaleSqr;
break;
case VIS_LOD_TEST_BOUNDINGBOX:
fDistSqr = m_BoundingBox.getDistanceToSquared(vCameraPos);
break;
case VIS_LOD_TEST_BOUNDINGBOX|VIS_LOD_TEST_APPLYLODSCALING:
fDistSqr = m_BoundingBox.getDistanceToSquared(vCameraPos)*fLODScaleSqr;
break;
default:
VASSERT_MSG(false,"Invalid combination of LOD flags");
return false;
}
return ((m_fNearClipDistance>0.f) && (fDistSqr<(m_fNearClipDistance*m_fNearClipDistance)))
|| ((m_fFarClipDistance>0.f) && (fDistSqr>=(m_fFarClipDistance*m_fFarClipDistance)));
}
bool LineConeIntersection(IVRenderInterface *pRenderer, const hkvVec3 &vConePos, const hkvVec3 &vConeAxis, float fConeAngle,
const hkvVec3 &vLineStart, const hkvVec3 &vLineDir, hkvVec3 &vIntersection)
{
// cull back cone
float fConeLineAngle = vConeAxis.dot(vLineDir);
if (fConeLineAngle < 0)
return false;
float fCosAngle = hkvMath::cosDeg(fConeAngle);
float fCosSquared = fCosAngle*fCosAngle;
hkvVec3 vLineToCone = vLineStart - vConePos;
float fDotA = vConeAxis.dot(vLineToCone);
float fDotB = vLineDir.dot(vLineToCone);
float fDotC = vLineToCone.dot(vLineToCone);
float a = fConeLineAngle*fConeLineAngle - fCosSquared;
float b = fConeLineAngle*fDotA - fCosSquared*fDotB;
float c = fDotA*fDotA - fCosSquared*fDotC;
float fInnerValue = b*b-4*a*c;
float fDenominator = 2*a;
if(fInnerValue < 0.0f || fDenominator == 0.0f)
return false;
float fSqrtInnerValue = sqrt(fInnerValue);
float t1 = (-b + fSqrtInnerValue)/fDenominator;
float t2 = (-b - fSqrtInnerValue)/fDenominator;
// choose front cone
float t = (t1 > t2) ? t1 : t2;
vIntersection = vLineStart+vLineDir*t;
return true;
}
bool RPG_PlayerCharacterSynchronizationGroup::QuerySynchronize(const VNetworkViewContext& context, VNetworkSynchronizationGroupInstanceInfo_t &instanceInfo, VMessageSettings& out_paketSettings)
{
RPG_PlayerCharacter *pObj = (RPG_PlayerCharacter*) instanceInfo.m_pInstance;
VHistoryData* pData = (VHistoryData*) instanceInfo.m_pCustomData;
// Save previously changed data, will be compared against the current changes.
BYTE iPreviousChangedDataFlags = pData->m_iChangedDataFlags;
// Add data flags, will be removed if following extrapolation tests succeed.
pData->m_iChangedDataFlags |= VCD_DataFlags;
hkvVec3 vInterpolatedEntry(false);
float fEpsilon = 0.5f * Vision::World.GetGlobalUnitScaling();
// Extrapolate current position
pData->m_positionHistory.Interpolate (&vInterpolatedEntry, context.m_iCurrentServerTimeMS);
const hkvVec3 vCurrentPos = pObj->GetPosition();
if (vCurrentPos.Equals(vInterpolatedEntry, fEpsilon))
pData->m_iChangedDataFlags &= ~VCD_POSITION; // Remove position flag
// Extrapolate current rotation
pData->m_rotationHistory.Interpolate (&vInterpolatedEntry, context.m_iCurrentServerTimeMS);
const hkvVec3 vCurrentOrientation = pObj->GetOrientation();
if (vCurrentOrientation.Equals(vInterpolatedEntry, fEpsilon))
pData->m_iChangedDataFlags &= ~VCD_ROTATION; // Remove rotation flag
// Change from previous tick, send changes reliably
if ((iPreviousChangedDataFlags^pData->m_iChangedDataFlags) != 0)
{
pData->m_iDataFlagsToSend = (iPreviousChangedDataFlags^pData->m_iChangedDataFlags) | pData->m_iChangedDataFlags;
out_paketSettings.SetReliability (VMR_Reliable_Ordered);
out_paketSettings.SetPriority (VMP_HighPriority);
out_paketSettings.SetOrderingChannel (1);
return true;
}
// No change from previous tick
else
{
// Is there anything to send?
if ((pData->m_iChangedDataFlags & VCD_DataFlags) != 0)
{
// Continuous changes are sent unreliably
pData->m_iDataFlagsToSend = pData->m_iChangedDataFlags;
out_paketSettings.SetReliability (VMR_Unreliable_Sequenced);
out_paketSettings.SetPriority (VMP_MediumPriority);
out_paketSettings.SetOrderingChannel (1);
return true;
}
else
{
return false;
}
}
}
void VFpsCameraEntity::GetCurrentMoveAxes(hkvVec3& vForward, hkvVec3& vRight, hkvVec3& vUp) const
{
VFreeCamera::GetCurrentMoveAxes(vForward, vRight, vUp);
// Disable vertical movement.
vUp = hkvVec3::ZeroVector();
// Constrain horizontal movement to the XY-plane.
vForward.z = vRight.z = 0.0f;
vForward.normalize();
vRight.normalize();
}
hkvVec3 RPG_Explosion::GetHerringBoneImpulse( hkvVec3 const& position )
{
hkvVec3 impulse(0.0f, 0.0f, 0.0f);
hkvVec3 attackLine = m_direction;
attackLine.z = 0.0f;
attackLine.normalize();
float const lineProjection = hkvMath::Max(0.0f, position.dot(attackLine) - m_center.dot(attackLine));
hkvVec3 const& closestPointOnAttackLine = m_center + lineProjection * attackLine;
impulse = (position - closestPointOnAttackLine);
impulse.z = 0.0f;
float distanceLineToImpact = impulse.getLengthAndNormalize();
if(hkvMath::isFloatEqual(0.0f, distanceLineToImpact))
{
if(Vision::Game.GetFloatRand() > 0.5)
{
impulse.x = attackLine.y;
impulse.y = -attackLine.x;
}
else
{
impulse.x = -attackLine.y;
impulse.y = -attackLine.x;
}
}
impulse += attackLine;
impulse.normalize();
float const strengthScale = hkvMath::Max(0.0f, (m_length - lineProjection) / m_length) *
hkvMath::Max(0.0f, (m_radius - distanceLineToImpact) / m_radius);
impulse.z = 0.1f;
return impulse * strengthScale * m_impulseStrength;
}
// Idling
void RPG_PlayerControllerState::Idling::OnTick(RPG_ControllerComponent *const controller, float const deltaTime)
{
RPG_ControllerStateBase::OnTick(controller, deltaTime);
RPG_PlayerControllerComponent *playerController = vstatic_cast<RPG_PlayerControllerComponent*>(controller);
RPG_PlayerControllerInput const& input = playerController->GetInput();
RPG_PlayerControllerInput const& prevInput = playerController->GetPrevInput();
// Tick special attacks
if(RPG_PlayerControllerState::OnTickSpecialAttacks(playerController, input, prevInput))
{
return;
}
// Move
bool const primaryDown = input.IsDown(RPG_PlayerControllerInput::B_PRIMARY, prevInput);
bool const primaryHeld = input.IsPressed(RPG_PlayerControllerInput::B_PRIMARY) && prevInput.IsPressed(RPG_PlayerControllerInput::B_PRIMARY);
if(primaryDown || primaryHeld)
{
if(primaryDown && input.m_targetEntity)
{
// Move to target
controller->SetTarget(input.m_targetEntity);
controller->SetTargetPoint(input.m_targetEntity->GetPosition());
}
else
{
// Move to point
controller->SetTarget(NULL);
controller->SetTargetPoint(input.m_targetPoint);
}
hkvVec3 const targetPoint = controller->GetTargetPoint();
hkvVec3 const targetPointToCharacter(controller->GetCharacter()->GetPosition() - targetPoint);
float const targetPointToCharactedDistSqr = targetPointToCharacter.getLengthSquared();
float const distTolerance = hkvMath::Max(60.0f, controller->GetPathGoalReachedTolerance());
float const distToleranceSqr = distTolerance * distTolerance;
if(targetPointToCharactedDistSqr > distToleranceSqr)
{
controller->SetState(RPG_ControllerStateId::kMoving);
return;
}
}
}
void VFreeCamera::GetCurrentMoveAxes(hkvVec3& vForward, hkvVec3& vRight, hkvVec3& vUp) const
{
vUp.set(0.0f, 0.0f, 1.0f);
hkvMat3 mat(hkvNoInitialization);
GetRotationMatrix(mat);
vForward = mat.getAxis(0);
vRight = mat.getAxis(1);
}
bool VWallmarkManager::IsTracePointOnPlane(const hkvVec3& vPos, const hkvVec3& vNormal, float fTraceRad, float fEpsilon, hkvVec3& vNewNormal)
{
hkvVec3 vStart = vPos + vNormal*fTraceRad;
hkvVec3 vEnd = vPos - vNormal*fTraceRad;
#ifdef WALLMARKS_USE_VISION_TRACELINES
VisTraceLineInfo_t result;
if (Vision::CollisionToolkit.TraceLine(vStart,vEnd,(ULONG)VIS_TRACE_ALL,(ULONG)VIS_TRACE_NONE,NULL,NULL,&result))
return false; // no hit
// only allow wallmarks on static geometry and terrain
if (result.hitType != VIS_TRACETYPE_STATICGEOMETRY && result.hitType != VIS_TRACETYPE_TERRAIN)
return false;
if (hkvMath::Abs (result.distance - fTraceRad)>fEpsilon)
return false;
// too much deviation from plane normal
vNewNormal = result.primitivePlane.m_vNormal;
float fDot = vNewNormal.dot(vNormal);
if (hkvMath::Abs (fDot-1.f)>fEpsilon)
return false;
#else
IVisPhysicsModule_cl *pPhysMod = Vision::GetApplication()->GetPhysicsModule();
VisPhysicsHit_t result;
if (pPhysMod==NULL || !pPhysMod->Raycast(vStart,vEnd,result))
return false;
// only allow wallmarks on static geometry and terrain
if (result.eHitType != VIS_TRACETYPE_STATICGEOMETRY && result.eHitType != VIS_TRACETYPE_TERRAIN)
return false;
if (hkvMath::Abs ((result.fHitFraction - 0.5f)*fTraceRad)>fEpsilon)
return false;
//NOTE: result.vImpactNormal is the interpolated vertex normal and thus not useful here
vNewNormal = vNormal;
#endif
// Vision::Game.DrawSingleLine(vPos,vPos+vNewNormal*20.f);
return true;
}
void RPG_Projectile::Fire(hkvVec3 position, hkvVec3 direction, float speed)
{
VASSERT(m_characterOwner);
m_spawnTime = Vision::GetTimer()->GetTime();
m_currentPosition = position;
SetPosition(position);
VASSERT_MSG(direction.isNormalized(), "Please normalize your projectile fire direction.");
m_direction = direction;
m_speed = speed;
hkvMat3 vRotation;
vRotation.setLookInDirectionMatrix(m_direction);
SetRotationMatrix(vRotation);
CreateShapePhantom();
// create inflight effect
CreateEffect(PFX_Inflight);
}
/// \brief
/// Initializes useful default
inline void InitDefaults()
{
m_bSortTextureChannels = false;
m_bUseTempFolder = false;
m_sTerrainFolder = "TerrainScene";
m_iSectorCount[0] = m_iSectorCount[1] = 16;
m_fViewDistance = 100000.f;
m_iHeightSamplesPerSector[0] = m_iHeightSamplesPerSector[1] = 128; ///< ideal size
m_vSectorSize.set(10000.f,10000.f);
m_iTilesPerSector[0] = m_iTilesPerSector[1] = 16;
m_iDensityMapSamplesPerSector[0] = m_iDensityMapSamplesPerSector[1] = 32;
m_vTerrainPos.set(0.f,0.f,0.f);
m_fPurgeInterval = 100.f;
m_iMemoryLimit = 500;
m_iDefaultWeightmapResolution[0] = m_iDefaultWeightmapResolution[1] = 512;
m_iMaterialMapResolution[0] = m_iMaterialMapResolution[1] = 0; // no material map by default
m_fVisibilityHeightOverTerrain = 2000.f;
m_iReplacementLOD = -1;
m_fReplacementDistance = -1.f;
m_bDistanceBasedLODOnly = false;
m_bIgnoreHeightForLOD = false;
m_bNormalmapUsesBorder = false;
m_bSceneSpecificLightmaps = false;
m_bUseThreeWayMapping = false;
m_bUseNormalMapping = false;
m_bUseLightMapping = false;
m_fPrecacheMargin = 1.0f;
m_iOldSectorCount[0] = 0;
m_iOldSectorCount[1] = 0;
m_iOldSectorStartIndex[0] = 0; // For Terrain sector expansion
m_iOldSectorStartIndex[1] = 0;
m_iNewSectorStartIndex[0] = 0; // For Terrain sector expansion
m_iNewSectorStartIndex[1] = 0;
Finalize();
}
// Moving
void RPG_PlayerControllerState::Moving::OnTick(RPG_ControllerComponent *const controller, float const deltaTime)
{
RPG_ControllerStateBase::OnTick(controller, deltaTime);
RPG_PlayerControllerComponent *playerController = vstatic_cast<RPG_PlayerControllerComponent*>(controller);
RPG_PlayerControllerInput const& input = playerController->GetInput();
RPG_PlayerControllerInput const& prevInput = playerController->GetPrevInput();
// Tick special attacks
if(RPG_PlayerControllerState::OnTickSpecialAttacks(playerController, input, prevInput))
{
return;
}
// Move or melee
bool const primaryDown = input.IsDown(RPG_PlayerControllerInput::B_PRIMARY, prevInput);
bool const primaryHeld = input.IsPressed(RPG_PlayerControllerInput::B_PRIMARY) && prevInput.IsPressed(RPG_PlayerControllerInput::B_PRIMARY);
// Update target on click
if(primaryDown)
{
playerController->SetTarget(input.m_targetEntity);
}
RPG_Character *const character = playerController->GetCharacter();
RPG_DamageableEntity *const target = playerController->GetTarget();
if(target)
{
hkvVec3 targetToCharacterProjectedDir;
float targetToCharacterProjectedDist;
RPG_ControllerUtil::GetProjectedDirAndDistanceFromTarget(character, target, targetToCharacterProjectedDir, targetToCharacterProjectedDist);
float const minDist = RPG_ControllerUtil::GetMinimumDistanceToAttack(character, target);
if(targetToCharacterProjectedDist > minDist)
{
controller->SetTargetPoint(target->GetPosition() + (target->GetCollisionRadius() + character->GetCollisionRadius()) * targetToCharacterProjectedDir);
}
else
{
controller->GetCharacter()->RaiseAnimationEvent(RPG_CharacterAnimationEvent::kMeleeAttack);
controller->SetState(RPG_ControllerStateId::kMeleeAttacking);
return;
}
}
else if(primaryDown || primaryHeld)
{
controller->SetTargetPoint(input.m_targetPoint);
}
// Handle target reached or target update
hkvVec3 const targetPoint = controller->GetTargetPoint();
hkvVec3 const targetPointToCharacter(character->GetPosition() - targetPoint);
float const targetPointToCharactedDistSqr = targetPointToCharacter.getLengthSquared();
float const pathGoaltoleranceSqr = controller->GetPathGoalReachedTolerance() * controller->GetPathGoalReachedTolerance();
if(targetPointToCharactedDistSqr <= pathGoaltoleranceSqr)
{
controller->SetState(RPG_ControllerStateId::kIdling);
return;
}
else if(primaryDown || primaryHeld)
{
controller->RequestPath(targetPoint);
}
// Reorient
hkvVec3 dir;
RPG_ControllerUtil::CalcDirection(dir, controller->GetCharacter()->GetDirection(), controller->GetDirection(), 0.25f);
controller->GetCharacter()->SetDirection(dir);
}
void vHavokShapeFactory::ExtractScaling(const hkvMat4 &mat, hkvVec3& destScaling)
{
hkvVec3 vx(hkvNoInitialization),vy(hkvNoInitialization),vz(hkvNoInitialization);
mat.getAxisXYZ (&vx, &vy, &vz);
destScaling.set(vx.getLength(),vy.getLength(),vz.getLength());
}