//------------------------------------------------------------------------
bool CVehicleSeatActionRotateTurret::InitRotationSounds(const CVehicleParams &rotationParams, EVehicleTurretRotationType eType)
{
CVehicleParams sound = rotationParams.findChild("Sound");
if (!sound)
return false;
if (sound.haveAttr("event"))
{
if (string helperName = sound.getAttr("helper"))
{
if (IVehicleHelper* pHelper = m_pVehicle->GetHelper(helperName))
{
SVehicleSoundInfo info;
info.name = sound.getAttr("event");
info.pHelper = pHelper;
m_rotations[eType].m_turnSoundId = m_pVehicle->AddSoundEvent(info);
if (sound.haveAttr("eventDamage"))
{
SVehicleSoundInfo dmgInfo;
info.name = sound.getAttr("eventDamage");
info.pHelper = pHelper;
m_rotations[eType].m_damageSoundId = m_pVehicle->AddSoundEvent(info);
}
return true;
}
}
return false;
}
return true;
}
//------------------------------------------------------------------------
bool CVehicleActionDeployRope::Init(IVehicle *pVehicle, IVehicleSeat *pSeat, const CVehicleParams &table)
{
m_pVehicle = pVehicle;
m_pSeat = pSeat;
CVehicleParams deployRopeTable = table.findChild("DeployRope");
if(!deployRopeTable)
return false;
if(deployRopeTable.haveAttr("helper"))
m_pRopeHelper = m_pVehicle->GetHelper(deployRopeTable.getAttr("helper"));
if(deployRopeTable.haveAttr("animation"))
{
if(m_pDeployAnim = m_pVehicle->GetAnimation(deployRopeTable.getAttr("animation")))
{
m_deployAnimOpenedId = m_pDeployAnim->GetStateId("opened");
m_deployAnimClosedId = m_pDeployAnim->GetStateId("closed");
if(m_deployAnimOpenedId == InvalidVehicleAnimStateId
|| m_deployAnimClosedId == InvalidVehicleAnimStateId)
{
m_pDeployAnim = NULL;
}
}
}
return m_pRopeHelper != NULL;
}
//------------------------------------------------------------------------
bool CVehicleActionEntityAttachment::Init(IVehicle *pVehicle, const CVehicleParams &table)
{
m_pVehicle = pVehicle;
CVehicleParams entityAttachmentTable = table.findChild("EntityAttachment");
if(!entityAttachmentTable)
return false;
if(entityAttachmentTable.haveAttr("helper"))
m_pHelper = m_pVehicle->GetHelper(entityAttachmentTable.getAttr("helper"));
if(entityAttachmentTable.haveAttr("class"))
{
IEntityClassRegistry *pClassRegistry = gEnv->pEntitySystem->GetClassRegistry();
assert(pClassRegistry);
m_entityClassName = entityAttachmentTable.getAttr("class");
if(IEntityClass *pEntityClass = pClassRegistry->FindClass(m_entityClassName.c_str()))
{
SpawnEntity();
return true;
}
}
return false;
}
//------------------------------------------------------------------------
bool CVehicleDamageBehaviorExplosion::Init(IVehicle* pVehicle, const CVehicleParams& table)
{
m_pVehicle = pVehicle;
m_exploded = false;
CVehicleParams explosionParams = table.findChild("Explosion");
if (!explosionParams)
return false;
explosionParams.getAttr("damage", m_damage);
explosionParams.getAttr("radius", m_radius);
explosionParams.getAttr("pressure", m_pressure);
if (!explosionParams.getAttr("minRadius", m_minRadius))
m_minRadius = m_radius/2.0f;
if (!explosionParams.getAttr("physRadius", m_physRadius))
m_physRadius = min(m_radius, 5.0f);
if (!explosionParams.getAttr("minPhysRadius", m_minPhysRadius))
m_minPhysRadius = m_physRadius/2.0f;
if (explosionParams.haveAttr("helper"))
m_pHelper = m_pVehicle->GetHelper(explosionParams.getAttr("helper"));
else
m_pHelper = NULL;
return true;
}
//------------------------------------------------------------------------
bool CVehicleDamageBehaviorImpulse::Init(IVehicle* pVehicle, const CVehicleParams& table)
{
m_pVehicle = (CVehicle*) pVehicle;
CVehicleParams impulseParams = table.findChild("Impulse");
if (!impulseParams)
return false;
impulseParams.getAttr("worldSpace", m_worldSpace);
impulseParams.getAttr("forceMin", m_forceMin);
impulseParams.getAttr("forceMax", m_forceMax);
impulseParams.getAttr("direction", m_impulseDir);
m_impulseDir.NormalizeSafe(Vec3(0,0,1));
if (!impulseParams.getAttr("momentum", m_angImpulse))
m_angImpulse.zero();
if (impulseParams.haveAttr("helper"))
m_pImpulseLocation = m_pVehicle->GetHelper(impulseParams.getAttr("helper"));
else
m_pImpulseLocation = NULL;
return true;
}
//------------------------------------------------------------------------
bool CVehicleMovementHelicopter::Init(IVehicle* pVehicle, const CVehicleParams& table)
{
if (!CVehicleMovementBase::Init(pVehicle, table))
return false;
// Initialise the arcade physics, handling helper
if (CVehicleParams handlingParams = table.findChild("HandlingArcade"))
if (!m_arcade.Init(pVehicle, handlingParams))
return false;
MOVEMENT_VALUE("engineWarmupDelay", m_engineWarmupDelay);
MOVEMENT_VALUE("enginePowerMax", m_enginePowerMax);
MOVEMENT_VALUE("yawPerRoll", m_yawPerRoll);
MOVEMENT_VALUE("maxSpeed", m_maxSpeed);
MOVEMENT_VALUE("maxPitchAngle", m_maxPitchAngle);
MOVEMENT_VALUE("maxRollAngle", m_maxRollAngle);
MOVEMENT_VALUE("rollDamping", m_rollDamping);
if(table.haveAttr("extendMoveTarget"))
{
table.getAttr("extendMoveTarget", m_bExtendMoveTarget);
}
table.getAttr("applyNoiseAsVelocity", m_bApplyNoiseAsVelocity);
if(CVehicleParams noiseParams = table.findChild("MovementNoise"))
{
InitMovementNoise(noiseParams, m_defaultNoise);
}
// high-level controller
Ang3 angles = m_pEntity->GetWorldAngles();
m_enginePower = 0.0f;
if (table.haveAttr("rotorPartName"))
m_pRotorPart = m_pVehicle->GetPart(table.getAttr("rotorPartName"));
m_isEngineGoingOff = true;
m_isEnginePowered = false;
ResetActions();
m_pVehicle->GetGameObject()->EnableUpdateSlot(m_pVehicle, IVehicle::eVUS_EnginePowered);
return true;
}
bool CVehicleSeatActionOrientateBoneToView::Init(IVehicle* pVehicle, IVehicleSeat* pSeat, const CVehicleParams& table)
{
m_pVehicle = pVehicle;
m_pSeat = pSeat;
IDefaultSkeleton& rIDefaultSkeleton = *GetCharacterModelSkeleton();
{
if(table.haveAttr("MoveBone") )
{
const char* boneName = table.getAttr("MoveBone");
m_MoveBoneId = rIDefaultSkeleton.GetJointIDByName(boneName);
}
if(table.haveAttr("LookBone") )
{
const char* boneName = table.getAttr("LookBone");
m_LookBoneId = rIDefaultSkeleton.GetJointIDByName(boneName);
}
}
if( table.haveAttr("Sluggishness") )
{
table.getAttr("Sluggishness", m_Sluggishness);
}
if ( CVehicleParams baseOrientationTable = table.findChild("MoveBoneBaseOrientation") )
{
float x, y, z;
baseOrientationTable.getAttr("x", x);
baseOrientationTable.getAttr("y", y);
baseOrientationTable.getAttr("z", z);
m_BoneBaseOrientation = Quat::CreateRotationXYZ( Ang3(x, y, z) );
}
else
{
m_BoneBaseOrientation.SetIdentity();
}
return true;
}
//------------------------------------------------------------------------
bool CVehicleSeatActionRotateTurret::InitRotation(IVehicle* pVehicle, const CVehicleParams &rotationTable, EVehicleTurretRotationType eType)
{
if (rotationTable)
{
if (rotationTable.haveAttr("part"))
m_rotations[eType].m_pPart = static_cast<CVehiclePartBase*>(m_pVehicle->GetPart(rotationTable.getAttr("part")));
if (rotationTable.getAttr("speed", m_rotations[eType].m_speed) && m_rotations[eType].m_pPart)
{
m_rotations[eType].m_pPart->SetMoveable();
rotationTable.getAttr("accel", m_rotations[eType].m_acceleration);
if (CVehicleParams limitsTable = rotationTable.findChild("Limits"))
{
// Forward facing limits
if (limitsTable.getChildCount() >= 2)
{
if (CVehicleParams limitRef = limitsTable.getChild(0))
m_rotations[eType].m_minLimitF = (float)DEG2RAD((float)atof(limitRef.getAttr("value")));
else
m_rotations[eType].m_minLimitF = 0.0f;
if (CVehicleParams limitRef = limitsTable.getChild(1))
m_rotations[eType].m_maxLimit = (float)DEG2RAD((float)atof(limitRef.getAttr("value")));
else
m_rotations[eType].m_maxLimit = 0.0f;
}
// Backwards facing limits
m_rotations[eType].m_minLimitB = m_rotations[eType].m_minLimitF;
if (limitsTable.getChildCount() >= 3)
{
if (CVehicleParams limitRef = limitsTable.getChild(2))
m_rotations[eType].m_minLimitB = (float)DEG2RAD((float)atof(limitRef.getAttr("value")));
}
}
}
rotationTable.getAttr("worldSpace", m_rotations[eType].m_worldSpace);
}
return true;
}
//------------------------------------------------------------------------
bool CVehicleSeatActionSound::Init(IVehicle* pVehicle, IVehicleSeat* pSeat, const CVehicleParams& table)
{
m_pVehicle = pVehicle;
m_pSeat = static_cast<CVehicleSeat*>(pSeat);
CVehicleParams soundTable = table.findChild("Audio");
if (!soundTable)
return false;
gEnv->pAudioSystem->GetAudioTriggerID(soundTable.getAttr("startTrigger"), m_nAudioControlIDStart);
gEnv->pAudioSystem->GetAudioTriggerID(soundTable.getAttr("stopTrigger"), m_nAudioControlIDStop);
if (soundTable.haveAttr("helper"))
m_pHelper = m_pVehicle->GetHelper(soundTable.getAttr("helper"));
if (!m_pHelper)
return false;
m_enabled = false;
return true;
}
//------------------------------------------------------------------------
bool CVehicleActionAutomaticDoor::Init(IVehicle* pVehicle, const CVehicleParams& table)
{
m_pVehicle = pVehicle;
CVehicleParams autoDoorTable = table.findChild("AutomaticDoor");
if (!autoDoorTable)
return false;
if (autoDoorTable.haveAttr("animation"))
m_pDoorAnim = m_pVehicle->GetAnimation(autoDoorTable.getAttr("animation"));
autoDoorTable.getAttr("timeMax", m_timeMax);
if (!m_pDoorAnim)
return false;
m_doorOpenedStateId = m_pDoorAnim->GetStateId("opened");
m_doorClosedStateId = m_pDoorAnim->GetStateId("closed");
autoDoorTable.getAttr("disabled", m_isDisabled);
m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
m_pVehicle->RegisterVehicleEventListener(this, "VehicleActionAutomaticDoor");
m_pDoorAnim->StopAnimation();
m_pDoorAnim->StartAnimation();
m_pDoorAnim->ToggleManualUpdate(true);
if(!m_isDisabled)
m_pDoorAnim->SetTime(DOOR_OPENED);
else
{
m_pDoorAnim->SetTime(DOOR_CLOSED);
m_animTime = DOOR_CLOSED;
m_animGoal = DOOR_CLOSED;
}
return true;
}
//------------------------------------------------------------------------
bool CVehicleSeatActionAnimation::Init(IVehicle* pVehicle, IVehicleSeat* pSeat, const CVehicleParams &table)
{
m_pVehicle = pVehicle;
CVehicleParams animTable = table.findChild("Animation");
if (!animTable)
return false;
if (animTable.haveAttr("vehicleAnimation"))
m_pVehicleAnim = m_pVehicle->GetAnimation(animTable.getAttr("vehicleAnimation"));
string control = animTable.getAttr("control");
if (!control.empty())
{
if (control == "roll")
{
m_control[0] = eVAI_RollLeft;
m_control[1] = eVAI_RollRight;
}
}
animTable.getAttr("manualUpdate", m_manualUpdate);
animTable.getAttr("speed", m_speed);
REINST("start/stop event?");
/*m_pIEntityAudioProxy = (IEntityAudioProxy*)m_pVehicle->GetEntity()->GetProxy(ENTITY_PROXY_AUDIO);
if (m_pIEntityAudioProxy)
{
if (animTable.haveAttr("sound"))
m_pSound = gEnv->pAudioSystem->CreateSound(animTable.getAttr("sound"), FLAG_SOUND_DEFAULT_3D);
if (animTable.haveAttr("stopSound"))
m_pStopSound = gEnv->pAudioSystem->CreateSound(animTable.getAttr("stopSound"), FLAG_SOUND_DEFAULT_3D);
}*/
return true;
}
//------------------------------------------------------------------------
bool CVehicleMovementHelicopter::Init(IVehicle *pVehicle, const CVehicleParams &table)
{
if(!CVehicleMovementBase::Init(pVehicle, table))
assert(0);
MOVEMENT_VALUE("engineWarmupDelay", m_engineWarmupDelay);
// heli abilities
MOVEMENT_VALUE("altitudeMax", m_altitudeMax);
MOVEMENT_VALUE("rotorDiskTiltScale", m_rotorDiskTiltScale);
MOVEMENT_VALUE("pitchResponsiveness", m_pitchResponsiveness);
MOVEMENT_VALUE("rollResponsiveness", m_rollResponsiveness);
MOVEMENT_VALUE("yawResponsiveness", m_yawResponsiveness);
MOVEMENT_VALUE("enginePowerMax", m_enginePowerMax);
MOVEMENT_VALUE("rotationDamping", m_rotationDamping);
MOVEMENT_VALUE("yawPerRoll", m_yawPerRoll);
// high-level controller abilities
MOVEMENT_VALUE("maxYawRate", m_maxYawRate);
MOVEMENT_VALUE("maxFwdSpeed", m_maxFwdSpeed);
MOVEMENT_VALUE("maxLeftSpeed", m_maxLeftSpeed);
MOVEMENT_VALUE("maxUpSpeed", m_maxUpSpeed);
MOVEMENT_VALUE("basicSpeedFraction", m_basicSpeedFraction);
MOVEMENT_VALUE("yawDecreaseWithSpeed", m_yawDecreaseWithSpeed);
MOVEMENT_VALUE("tiltPerVelDifference", m_tiltPerVelDifference);
MOVEMENT_VALUE("maxTiltAngle", m_maxTiltAngle);
MOVEMENT_VALUE("extraRollForTurn", m_extraRollForTurn);
MOVEMENT_VALUE("rollForTurnForce", m_rollForTurnForce);
MOVEMENT_VALUE("yawPerRoll", m_yawPerRoll);
MOVEMENT_VALUE("pitchActionPerTilt", m_pitchActionPerTilt);
MOVEMENT_VALUE("pitchInputConst", m_pitchInputConst);
MOVEMENT_VALUE("powerInputConst", m_powerInputConst);
MOVEMENT_VALUE("powerInputDamping", m_powerInputDamping);
MOVEMENT_VALUE("relaxForce", m_relaxForce);
MOVEMENT_VALUE("yawInputConst", m_yawInputConst);
MOVEMENT_VALUE("yawInputDamping", m_yawInputDamping);
MOVEMENT_VALUE("maxRollAngle", m_maxRollAngle);
MOVEMENT_VALUE("velDamping", m_velDamp);
// Initialise the power PID.
m_powerPID.Reset();
m_powerPID.m_kP = 0.2f;
m_powerPID.m_kD = 0.01f;
m_powerPID.m_kI = 0.0001f;
m_maxSpeed = 40.f; // empirically determined
m_liftPID.Reset();
m_yawPID.Reset();
m_liftPID.m_kP = 0.66f;
m_liftPID.m_kD = 0.2f;
m_liftPID.m_kI = 0.0f;
m_yawPID.m_kP = -0.03f;
m_yawPID.m_kI = 0.0f;
m_yawPID.m_kD = 0.0f;
// high-level controller
Ang3 angles = m_pEntity->GetWorldAngles();
m_desiredDir = angles.z;
m_desiredHeight = m_pEntity->GetWorldPos().z;
m_lastDir = m_desiredDir;
m_enginePower = 0.0f;
m_isTouchingGround = false;
m_timeOnTheGround = 50.0f;
if(table.haveAttr("rotorPartName"))
m_pRotorPart = m_pVehicle->GetPart(table.getAttr("rotorPartName"));
else
m_pRotorPart = NULL;
m_desiredPitch = 0.0f;
ResetActions();
m_playerDampingBase = 0.1f;
m_playerDampingRotation = 0.15f;
m_playerDimLowInput = 0.25f;
m_playerRotationMult.x = 60.0f;
m_playerRotationMult.y = 60.0f;
m_playerRotationMult.z = 10.0f;
m_strafeForce = 1.0f;
m_engineUpDir.Set(0.0f, 0.0f, 1.0f);
m_boostMult = 2.00f;
ICVar *pSensitivVar = gEnv->pConsole->GetCVar("cl_sensitivity");
m_playerControls.RegisterValue(&m_liftAction, false, 0.0f, "lift");
m_playerControls.RegisterAction(eVAI_MoveUp, CHelicopterPlayerControls::eVM_Positive, &m_liftAction);
m_playerControls.RegisterAction(eVAI_MoveDown, CHelicopterPlayerControls::eVM_Negative, &m_liftAction);
m_playerControls.RegisterValue(&m_turnAction, false, 0.0f, "roll");
m_playerControls.RegisterAction(eVAI_TurnLeft, CHelicopterPlayerControls::eVM_Negative, &m_turnAction);
m_playerControls.RegisterAction(eVAI_TurnRight, CHelicopterPlayerControls::eVM_Positive, &m_turnAction);
m_playerControls.RegisterAction(eVAI_RotateYaw, CHelicopterPlayerControls::eVM_Positive, &m_turnAction, pSensitivVar);
m_playerControls.SetActionMult(eVAI_RotateYaw, m_maxYawRate * 0.65f);
m_playerControls.RegisterValue(&m_desiredRoll, false, gf_PI * 4.0f, "turn");
m_playerControls.RegisterAction(eVAI_RollLeft, CHelicopterPlayerControls::eVM_Negative, &m_desiredRoll);
m_playerControls.RegisterAction(eVAI_RollRight, CHelicopterPlayerControls::eVM_Positive, &m_desiredRoll);
m_playerControls.RegisterAction(eVAI_RotateRoll, CHelicopterPlayerControls::eVM_Positive, &m_desiredRoll, pSensitivVar);
m_playerControls.RegisterValue(&m_desiredPitch, false, 0.0f, "pitch");
m_playerControls.RegisterAction(eVAI_RotatePitch, CHelicopterPlayerControls::eVM_Negative, &m_desiredPitch, pSensitivVar);
m_playerControls.SetActionMult(eVAI_RotatePitch, m_maxYawRate * 0.65f);
m_pInvertPitchVar = gEnv->pConsole->GetCVar("v_invertPitchControl");
m_pAltitudeLimitVar = gEnv->pConsole->GetCVar("v_altitudeLimit");
m_pAltitudeLimitLowerOffsetVar = gEnv->pConsole->GetCVar("v_altitudeLimitLowerOffset");
m_pStabilizeVTOL = gEnv->pConsole->GetCVar("v_stabilizeVTOL");
m_turbulenceMultMax = 0.25f;
return true;
}
//------------------------------------------------------------------------
bool CVehicleViewSteer::Init(IVehicleSeat* pSeat, const CVehicleParams &table)
{
if (!CVehicleViewBase::Init(pSeat, table))
return false;
m_pAimPart = pSeat->GetAimPart();
CVehicleParams params = table.findChild(m_name);
if (!params)
return false;
CVehicleParams posParams = params.findChild("Pos");
CVehicleParams rotationParams = params.findChild("Rotation");
CVehicleParams motionParams = params.findChild("Motion");
CVehicleParams backwardsParams = params.findChild("Backwards");
CVehicleParams radiusParams = params.findChild("Radius");
if (posParams)
{
posParams.getAttr("offset", m_localSpaceCameraOffset);
posParams.getAttr("aim", m_lookAt0);
posParams.getAttr("pivotOffset", m_pivotOffset);
}
if (rotationParams)
{
rotationParams.getAttr("rotationMax", m_maxRotation);
if (rotationParams.haveAttr("rotationMax2"))
{
rotationParams.getAttr("rotationMax2", m_maxRotation2);
}
else
{
m_maxRotation2 = m_maxRotation / 3.0f;
}
m_maxRotation = DEG2RAD(m_maxRotation);
m_maxRotation2 = DEG2RAD(m_maxRotation2);
rotationParams.getAttr("stickSensitivity", m_stickSensitivity);
rotationParams.getAttr("stickSensitivity2", m_stickSensitivity2);
rotationParams.getAttr("inheritedElev", m_inheritedElev);
getFlag(rotationParams, "canRotate", m_flags, eVCam_canRotate);
m_inheritedElev = clamp_tpl(m_inheritedElev, 0.f, 1.f);
}
if (motionParams)
{
motionParams.getAttr("returnSpeed", m_angReturnSpeed1);
motionParams.getAttr("returnSpeed2", m_angReturnSpeed2);
motionParams.getAttr("angFollow", m_angSpeedCorrection0);
}
if (backwardsParams)
{
getFlag(backwardsParams, "clamp", m_backwardsFlags, eVCam_rotationClamp);
getFlag(backwardsParams, "returnSpring", m_backwardsFlags, eVCam_rotationSpring);
}
if (radiusParams)
{
radiusParams.getAttr("min", m_radiusMin);
radiusParams.getAttr("max", m_radiusMax);
radiusParams.getAttr("relaxRate", m_radiusRelaxRate);
radiusParams.getAttr("dampRate", m_radiusDampRate);
radiusParams.getAttr("velInfluence", m_radiusVelInfluence);
}
Reset();
return true;
}
//------------------------------------------------------------------------
bool CVehiclePartTread::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
{
if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_Tread))
return false;
CVehicleParams subTable = table.findChild("Tread"); // Tread subtable
if (!subTable)
return false;
string filename = subTable.getAttr("filename");
if (filename.empty())
return false;
subTable.getAttr("uvSpeedMultiplier", m_uvSpeedMultiplier);
if (table.haveAttr("component"))
{
if (CVehicleComponent* pComponent = static_cast<CVehicleComponent*>(m_pVehicle->GetComponent(table.getAttr("component"))))
pComponent->AddPart(this);
}
m_slot = GetEntity()->LoadCharacter(m_slot, filename);
m_pCharInstance = GetEntity()->GetCharacter(m_slot);
if (!m_pCharInstance)
return false;
if (subTable.haveAttr("materialName"))
{
string materialName = subTable.getAttr("materialName");
materialName.MakeLower();
IMaterial* pMaterial = 0;
const char* subMtlName = 0;
int subMtlSlot = -1;
// find tread material
IEntityRenderProxy *pRenderProxy = (IEntityRenderProxy*)GetEntity()->GetProxy(ENTITY_PROXY_RENDER);
if (pRenderProxy)
{
pMaterial = pRenderProxy->GetRenderMaterial(m_slot);
if (pMaterial)
{
// if matname doesn't fit, look in submaterials
if (string(pMaterial->GetName()).MakeLower().find(materialName) == string::npos)
{
for (int i=0; i < pMaterial->GetSubMtlCount(); ++i)
{
if (string(pMaterial->GetSubMtl(i)->GetName()).MakeLower().find(materialName) != string::npos)
{
subMtlName = pMaterial->GetSubMtl(i)->GetName();
subMtlSlot = i;
break;
}
}
}
}
}
if (pMaterial)
{
// clone
IMaterial *pCloned = pMaterial->GetMaterialManager()->CloneMultiMaterial(pMaterial, subMtlName);
if (pCloned)
{
pRenderProxy->SetSlotMaterial(m_slot, pCloned);
pMaterial = pCloned;
m_pMaterial = pMaterial;
}
if (subMtlSlot > -1)
m_pShaderResources = pMaterial->GetShaderItem(subMtlSlot).m_pShaderResources;
else
m_pShaderResources = pMaterial->GetShaderItem().m_pShaderResources;
}
if (m_pShaderResources)
{
for (int i = 0; i < EFTT_MAX; ++i)
{
if (!m_pShaderResources->GetTexture(i))
continue;
SEfTexModificator& modif = *m_pShaderResources->GetTexture(i)->AddModificator();
modif.SetMember("m_eMoveType[0]", 1.0f); // ETMM_Fixed: u = m_OscRate[0] + sourceU
modif.SetMember("m_OscRate[0]", 0.0f);
}
}
}
char wheelName[256];
IDefaultSkeleton& rIDefaultSkeleton = m_pCharInstance->GetIDefaultSkeleton();
for (int i=0; i<rIDefaultSkeleton.GetJointCount(); ++i)
{
const char* boneName = rIDefaultSkeleton.GetJointNameByID(i);
if (0 != boneName)
{
// extract wheel name
const size_t len = strcspn(boneName, "_");
if (len < strlen(boneName) && len < sizeof(wheelName))
{
cry_strcpy(wheelName, boneName, len);
CVehiclePartSubPartWheel* pWheel = (CVehiclePartSubPartWheel*)m_pVehicle->GetPart(wheelName);
if (pWheel)
{
SWheelInfo wheelInfo;
wheelInfo.slot = pWheel->m_slot;
wheelInfo.jointId = i;
wheelInfo.pWheel = pWheel;
m_wheels.push_back(wheelInfo);
m_lastWheelIndex = pWheel->GetWheelIndex();
}
}
}
}
m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_AlwaysUpdate);
m_state = eVGS_Default;
return true;
}
//------------------------------------------------------------------------
bool CVehicleMovementStdBoat::Init(IVehicle* pVehicle, const CVehicleParams& table)
{
if (!CVehicleMovementBase::Init(pVehicle, table))
return false;
MOVEMENT_VALUE("velMax", m_velMax);
MOVEMENT_VALUE("velMaxReverse", m_velMaxReverse);
MOVEMENT_VALUE("acceleration", m_accel);
MOVEMENT_VALUE("accelerationVelMax", m_accelVelMax);
MOVEMENT_VALUE("accelerationMultiplier", m_accelCoeff);
MOVEMENT_VALUE("pushTilt", m_pushTilt);
MOVEMENT_VALUE("turnRateMax", m_turnRateMax);
MOVEMENT_VALUE("turnAccel", m_turnAccel);
MOVEMENT_VALUE("cornerForce", m_cornerForceCoeff);
MOVEMENT_VALUE("cornerTilt", m_cornerTilt);
MOVEMENT_VALUE("turnDamping", m_turnDamping);
MOVEMENT_VALUE("turnAccelMultiplier", m_turnAccelCoeff);
MOVEMENT_VALUE_OPT("rollAccel", m_rollAccel, table);
MOVEMENT_VALUE_OPT("pedalLimitReverse", m_pedalLimitReverse, table);
MOVEMENT_VALUE_OPT("turnVelocityMult", m_turnVelocityMult, table);
MOVEMENT_VALUE_OPT("velLift", m_velLift, table);
MOVEMENT_VALUE_OPT("lateralDamping", m_lateralDamping, table);
table.getAttr("waveIdleStrength", m_waveIdleStrength);
table.getAttr("waveSpeedMult", m_waveSpeedMult);
if (table.haveAttr("cornerHelper"))
{
if (IVehicleHelper* pHelper = m_pVehicle->GetHelper(table.getAttr("cornerHelper")))
m_cornerOffset = pHelper->GetVehicleSpaceTranslation();
}
if (table.haveAttr("pushHelper"))
{
if (IVehicleHelper* pHelper = m_pVehicle->GetHelper(table.getAttr("pushHelper")))
m_pushOffset = pHelper->GetVehicleSpaceTranslation();
}
// compute inertia [assumes box]
AABB bbox;
IVehiclePart* pMassPart = pVehicle->GetPart("mass");
if (!pMassPart)
pMassPart = pVehicle->GetPart("massBox");
if (pMassPart)
{
bbox = pMassPart->GetLocalBounds();
}
else
{
GameWarning("[CVehicleMovementStdBoat]: initialization: No \"mass\" geometry found!");
m_pEntity->GetLocalBounds(bbox);
}
m_maxSpeed = m_velMax;
float mass = pVehicle->GetMass();
float width = bbox.max.x - bbox.min.x;
float length = bbox.max.y - bbox.min.y;
float height = bbox.max.z - bbox.min.z;
m_Inertia.x = mass * (sqr(length)+ sqr(height)) / 12;
m_Inertia.y = mass * (sqr(width) + sqr(height)) / 12;
m_Inertia.z = mass * (sqr(width) + sqr(length)) / 12;
m_massOffset = bbox.GetCenter();
//CryLog("[StdBoat movement]: got mass offset (%f, %f, %f)", m_massOffset.x, m_massOffset.y, m_massOffset.z);
m_pSplashPos = m_pVehicle->GetHelper("splashPos");
if (m_pSplashPos)
m_lastWakePos = m_pSplashPos->GetWorldSpaceTranslation();
else
m_lastWakePos = m_pVehicle->GetEntity()->GetWorldTM().GetTranslation();
const char* waveEffect = "";
MOVEMENT_VALUE_OPT("waveEffect", &waveEffect, table);
m_pWaveEffect = gEnv->pParticleManager->FindEffect(waveEffect, "MovementStdBoat");
m_waveTimer = cry_random(0.0f, gf_PI);
m_diving = false;
m_wakeSlot = -1;
m_waveSoundPitch = 0.f;
m_rpmPitchDir = 0;
m_waveSoundAmount = 0.1f;
// AI related
m_prevAngle = 0.0f;
m_factorMaxSpeed = 1.f;
m_factorAccel = 1.f;
return true;
}
//------------------------------------------------------------------------
bool CVehicleDamagesGroup::ParseDamagesGroup(const CVehicleParams& table)
{
if (table.haveAttr("useTemplate"))
{
IVehicleSystem* pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
CRY_ASSERT(pVehicleSystem);
if (IVehicleDamagesTemplateRegistry* pDamageTemplReg = pVehicleSystem->GetDamagesTemplateRegistry())
pDamageTemplReg->UseTemplate(table.getAttr("useTemplate"), this);
}
if (CVehicleParams damagesSubGroupsTable = table.findChild("DamagesSubGroups"))
{
int i = 0;
int c = damagesSubGroupsTable.getChildCount();
for (; i < c; i++)
{
if (CVehicleParams groupTable = damagesSubGroupsTable.getChild(i))
{
m_damageSubGroups.resize(m_damageSubGroups.size() + 1);
SDamagesSubGroup& subGroup = m_damageSubGroups.back();
subGroup.id = m_damageSubGroups.size() - 1;
subGroup.m_isAlreadyInProcess = false;
if (!groupTable.getAttr("delay", subGroup.m_delay))
subGroup.m_delay = 0.0f;
if (!groupTable.getAttr("randomness", subGroup.m_randomness))
subGroup.m_randomness = 0.0f;
if (CVehicleParams damageBehaviorsTable = groupTable.findChild("DamageBehaviors"))
{
int k = 0;
int numDamageBehaviors = damageBehaviorsTable.getChildCount();
subGroup.m_damageBehaviors.reserve(c);
for (; k < numDamageBehaviors; k++)
{
if (CVehicleParams behaviorTable = damageBehaviorsTable.getChild(k))
{
if (IVehicleDamageBehavior* pDamageBehavior = ParseDamageBehavior(behaviorTable))
{
subGroup.m_damageBehaviors.push_back(pDamageBehavior);
CVehicleDamageBehaviorDestroy *pDamageDestroy = CAST_VEHICLEOBJECT(CVehicleDamageBehaviorDestroy, pDamageBehavior);
if (pDamageDestroy)
{
TVehiclePartVector& parts = m_pVehicle->GetParts();
for (TVehiclePartVector::iterator ite = parts.begin(); ite != parts.end(); ++ite)
{
IVehiclePart* pPart = ite->second;
if (CVehiclePartAnimatedJoint* pAnimJoint = CAST_VEHICLEOBJECT(CVehiclePartAnimatedJoint, pPart))
{
if (pAnimJoint->IsPhysicalized() && !pAnimJoint->GetDetachBaseForce().IsZero())
{
CVehicleDamageBehaviorDetachPart* pDetachBehavior = new CVehicleDamageBehaviorDetachPart;
pDetachBehavior->Init(m_pVehicle, pAnimJoint->GetName(), pDamageDestroy->GetEffectName());
subGroup.m_damageBehaviors.push_back(pDetachBehavior);
}
}
}
}
}
}
}
}
}
}
}
return true;
}
