public MyEngineerToolBase(MyHandItemDefinition definition, float toolDistance, int cooldownMs)
{
ToolCooldownMs = cooldownMs;
m_toolActionDistance = toolDistance;
m_handItemDef = definition;
System.Diagnostics.Debug.Assert(definition != null, "Missing definition for tool!");
if (definition != null)
{
m_physItemDef = MyDefinitionManager.Static.GetPhysicalItemForHandItem(definition.Id);
m_gunBase = new MyToolBase(m_handItemDef.MuzzlePosition, WorldMatrix);
}
else
{
m_gunBase = new MyToolBase(Vector3.Zero, WorldMatrix);
}
m_activated = false;
m_wasPowered = false;
NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME;
Render.NeedsDraw = true;
(PositionComp as MyPositionComponent).WorldPositionChanged = WorldPositionChanged;
Render = new Components.MyRenderComponentEngineerTool();
AddDebugRenderComponent(new MyDebugRenderComponentEngineerTool(this));
}
/// <summary>
/// Update and get current weights of the weapon variants.
/// </summary>
/// <returns>Weights. Normalized.</returns>
Vector4D UpdateAndGetWeaponVariantWeights(MyHandItemDefinition handItemDefinition)
{
float characterSpeed;
Character.AnimationController.Variables.GetValue(MyAnimationVariableStorageHints.StrIdSpeed, out characterSpeed);
bool isWalkingState = MyCharacter.IsRunningState(Character.GetCurrentMovementState()) && characterSpeed > Character.Definition.MaxWalkSpeed;
bool isShooting = Character.IsShooting(MyShootActionEnum.PrimaryAction) && (!Character.IsSprinting);
bool isInIronSight = Character.ZoomMode == MyZoomModeEnum.IronSight && (!Character.IsSprinting);
float deltaW = MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS / handItemDefinition.BlendTime;
float deltaShootW = MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS / handItemDefinition.ShootBlend;
// blend into the current variant
// if currently shooting/ironsight -> use "shooting" blend speed
m_weaponPositionVariantWeightCounters.X += !isWalkingState && !isShooting && !isInIronSight ? deltaW : (isShooting || isInIronSight ? -deltaShootW : -deltaW);
m_weaponPositionVariantWeightCounters.Y += isWalkingState && !isShooting && !isInIronSight ? deltaW : (isShooting || isInIronSight ? -deltaShootW : -deltaW);
m_weaponPositionVariantWeightCounters.Z += isShooting && !isInIronSight ? deltaShootW : (isInIronSight ? -deltaShootW : -deltaW);
m_weaponPositionVariantWeightCounters.W += isInIronSight ? deltaShootW : (isShooting ? -deltaShootW : -deltaW);
m_weaponPositionVariantWeightCounters = Vector4.Clamp(m_weaponPositionVariantWeightCounters, Vector4.Zero, Vector4.One);
Vector4D rtnWeights = new Vector4D(MathHelper.SmoothStep(0, 1, m_weaponPositionVariantWeightCounters.X),
MathHelper.SmoothStep(0, 1, m_weaponPositionVariantWeightCounters.Y),
MathHelper.SmoothStep(0, 1, m_weaponPositionVariantWeightCounters.Z),
MathHelper.SmoothStep(0, 1, m_weaponPositionVariantWeightCounters.W));
double weightSum = rtnWeights.X + rtnWeights.Y + rtnWeights.Z + rtnWeights.W;
return(rtnWeights / weightSum);
}
private unsafe void ApplyWeaponBouncing(MyHandItemDefinition handItemDefinition, ref MatrixD weaponMatrixLocal, float fpsBounceMultiplier, float ironsightWeight)
{
if (base.Character.AnimationController.CharacterBones.IsValidIndex <MyCharacterBone>(base.Character.SpineBoneIndex))
{
Vector3 * vectorPtr1;
float z;
bool flag = base.Character.ControllerInfo.IsLocallyControlled();
bool flag2 = (base.Character.IsInFirstPersonView || base.Character.ForceFirstPersonCamera) & flag;
Vector3 translation = base.Character.AnimationController.CharacterBonesSorted[0].Translation;
MyCharacterBone bone1 = base.Character.AnimationController.CharacterBones[base.Character.SpineBoneIndex];
Vector3 vector2 = bone1.AbsoluteTransform.Translation - translation;
this.m_spineRestPositionX.Add((double)vector2.X);
this.m_spineRestPositionY.Add((double)vector2.Y);
this.m_spineRestPositionZ.Add((double)vector2.Z);
Vector3 position = bone1.GetAbsoluteRigTransform().Translation;
Vector3 vector4 = new Vector3((double)position.X, this.m_spineRestPositionY.Get(), (double)position.Z);
Vector3 vector5 = (vector2 - vector4) * fpsBounceMultiplier;
if (!flag2)
{
z = 0f;
}
else
{
vectorPtr1 = (Vector3 *)ref vector5;
z = vector5.Z;
}
vectorPtr1->Z = z;
this.m_sprintStatusWeight += base.Character.IsSprinting ? this.m_sprintStatusGainSpeed : -this.m_sprintStatusGainSpeed;
this.m_sprintStatusWeight = MathHelper.Clamp(this.m_sprintStatusWeight, 0f, 1f);
if (!flag2)
{
vector5 *= handItemDefinition.AmplitudeMultiplier3rd;
}
else
{
vector5 *= 1f + (Math.Max((float)0f, (float)(handItemDefinition.RunMultiplier - 1f)) * this.m_sprintStatusWeight);
float *singlePtr1 = (float *)ref vector5.X;
singlePtr1[0] *= handItemDefinition.XAmplitudeScale;
float *singlePtr2 = (float *)ref vector5.Y;
singlePtr2[0] *= handItemDefinition.YAmplitudeScale;
float *singlePtr3 = (float *)ref vector5.Z;
singlePtr3[0] *= handItemDefinition.ZAmplitudeScale;
}
weaponMatrixLocal.Translation += vector5;
BoundingBox localAABB = base.Character.PositionComp.LocalAABB;
if ((ironsightWeight < 1f) && (weaponMatrixLocal.M43 > (((position.Z + translation.Z) - (localAABB.Max.Z * 0.5)) - (base.Character.HandItemDefinition.RightHand.Translation.Z * 0.75))))
{
double num = ((position.Z + translation.Z) - (localAABB.Max.Z * 0.5)) - (base.Character.HandItemDefinition.RightHand.Translation.Z * 0.75);
weaponMatrixLocal.M43 = MathHelper.Lerp(num, weaponMatrixLocal.M43, (double)ironsightWeight);
}
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW && MyDebugDrawSettings.DEBUG_DRAW_CHARACTER_TOOLS)
{
MatrixD?cameraViewMatrix = null;
MyDebugDrawHelper.DrawNamedPoint(Vector3D.Transform(position, base.Character.WorldMatrix), "spine", new Color?(Color.Gray), cameraViewMatrix);
}
}
}
private void UpdateScattering(ref MatrixD weaponAnimMatrix, MyHandItemDefinition handItemDefinition)
{
MyEngineerToolBase currentWeapon = base.Character.CurrentWeapon as MyEngineerToolBase;
bool flag = false;
if (handItemDefinition.ScatterSpeed > 0f)
{
bool hasHitBlock = false;
if (currentWeapon != null)
{
hasHitBlock = currentWeapon.HasHitBlock;
}
flag = this.IsShooting & hasHitBlock;
if (!flag && (this.m_currentScatterToAnimRatio >= 1f))
{
this.m_currentScatterBlend = 0f;
}
else
{
if (this.m_currentScatterBlend == 0f)
{
this.m_lastScatterPos = Vector3.Zero;
}
if (this.m_currentScatterBlend == handItemDefinition.ScatterSpeed)
{
this.m_lastScatterPos = this.m_currentScatterPos;
this.m_currentScatterBlend = 0f;
}
if ((this.m_currentScatterBlend == 0f) || (this.m_currentScatterBlend == handItemDefinition.ScatterSpeed))
{
this.m_currentScatterPos = new Vector3(MyUtils.GetRandomFloat(-handItemDefinition.ShootScatter.X / 2f, handItemDefinition.ShootScatter.X / 2f), MyUtils.GetRandomFloat(-handItemDefinition.ShootScatter.Y / 2f, handItemDefinition.ShootScatter.Y / 2f), MyUtils.GetRandomFloat(-handItemDefinition.ShootScatter.Z / 2f, handItemDefinition.ShootScatter.Z / 2f));
}
this.m_currentScatterBlend += 0.01f;
if (this.m_currentScatterBlend > handItemDefinition.ScatterSpeed)
{
this.m_currentScatterBlend = handItemDefinition.ScatterSpeed;
}
Vector3 vector = Vector3.Lerp(this.m_lastScatterPos, this.m_currentScatterPos, this.m_currentScatterBlend / handItemDefinition.ScatterSpeed);
weaponAnimMatrix.Translation += (1f - this.m_currentScatterToAnimRatio) * vector;
}
this.m_currentScatterToAnimRatio += flag ? -0.1f : 0.1f;
if (this.m_currentScatterToAnimRatio > 1f)
{
this.m_currentScatterToAnimRatio = 1f;
}
else if (this.m_currentScatterToAnimRatio < 0f)
{
this.m_currentScatterToAnimRatio = 0f;
}
}
}
private void TransformItem(MyHandItemDefinition item)
{
//SwapYZ(ref item.ItemLocation);
//SwapYZ(ref item.ItemLocation3rd);
//SwapYZ(ref item.ItemShootLocation);
//SwapYZ(ref item.ItemShootLocation3rd);
//SwapYZ(ref item.ItemWalkingLocation);
//SwapYZ(ref item.ItemWalkingLocation3rd);
////SwapYZ(ref CurrentSelectedItem.LeftHand);
////SwapYZ(ref CurrentSelectedItem.RightHand);
//SwapYZ(ref item.MuzzlePosition);
Reorientate(ref item.LeftHand);
Reorientate(ref item.RightHand);
}
/// <summary>
/// Apply bouncing movement on weapon.
/// </summary>
/// <param name="handItemDefinition">definition of hand item</param>
/// <param name="weaponMatrixLocal">current weapon matrix (character local space)</param>
private void ApplyWeaponBouncing(MyHandItemDefinition handItemDefinition, ref MatrixD weaponMatrixLocal, float fpsBounceMultiplier)
{
if (!Character.AnimationController.CharacterBones.IsValidIndex(Character.SpineBoneIndex))
{
return;
}
bool isLocallyControlled = Character.ControllerInfo.IsLocallyControlled();
bool isInFirstPerson = (Character.IsInFirstPersonView || Character.ForceFirstPersonCamera) && isLocallyControlled;
var spineBone = Character.AnimationController.CharacterBones[Character.SpineBoneIndex];
Vector3 spinePos = spineBone.AbsoluteTransform.Translation - Character.AnimationController.CharacterBonesSorted[0].Translation;
m_spineRestPositionX.Add(spinePos.X);
m_spineRestPositionY.Add(spinePos.Y);
m_spineRestPositionZ.Add(spinePos.Z);
Vector3 spineAbsRigPos = spineBone.GetAbsoluteRigTransform().Translation;
Vector3 spineRestPos = new Vector3(spineAbsRigPos.X, m_spineRestPositionY.Get(), spineAbsRigPos.Z);
Vector3 bounceOffset = (spinePos - spineRestPos) * fpsBounceMultiplier;
bounceOffset.Z = isInFirstPerson ? bounceOffset.Z : 0;
m_sprintStatusWeight += Character.IsSprinting ? m_sprintStatusGainSpeed : -m_sprintStatusGainSpeed;
m_sprintStatusWeight = MathHelper.Clamp(m_sprintStatusWeight, 0, 1);
if (isInFirstPerson)
{
// multiply only when in first person
bounceOffset *= 1 + Math.Max(0, handItemDefinition.RunMultiplier - 1) * m_sprintStatusWeight;
bounceOffset.X *= handItemDefinition.XAmplitudeScale;
bounceOffset.Y *= handItemDefinition.YAmplitudeScale;
bounceOffset.Z *= handItemDefinition.ZAmplitudeScale;
}
else
{
bounceOffset *= handItemDefinition.AmplitudeMultiplier3rd;
}
bounceOffset.Z += m_backkickPos;
weaponMatrixLocal.Translation += bounceOffset;
}
public void Init(MyObjectBuilder_EntityBase builder, MyHandItemDefinition definition)
{
m_handItemDef = definition;
System.Diagnostics.Debug.Assert(definition != null, "Missing definition for tool!");
if (definition != null)
{
m_physItemDef = MyDefinitionManager.Static.GetPhysicalItemForHandItem(definition.Id);
m_gunBase = new MyToolBase(m_handItemDef.MuzzlePosition, WorldMatrix);
}
else
{
m_gunBase = new MyToolBase(Vector3.Zero, WorldMatrix);
}
base.Init(builder);
if (PhysicalObject != null)
{
PhysicalObject.GunEntity = builder;
}
if ((definition as MyEngineerToolBaseDefinition) != null)
{
m_speedMultiplier = (m_handItemDef as MyEngineerToolBaseDefinition).SpeedMultiplier;
m_distanceMultiplier = (definition as MyEngineerToolBaseDefinition).DistanceMultiplier;
}
MyDrillSensorRayCast raycaster = new MyDrillSensorRayCast(0f, DEFAULT_REACH_DISTANCE * m_distanceMultiplier);
m_raycastComponent = new MyCasterComponent(raycaster);
m_raycastComponent.SetPointOfReference(m_gunBase.GetMuzzleWorldPosition());
Components.Add <MyCasterComponent>(m_raycastComponent);
var sinkComp = new MyResourceSinkComponent();
sinkComp.Init(
MyStringHash.GetOrCompute("Utility"),
MyEnergyConstants.REQUIRED_INPUT_ENGINEERING_TOOL,
CalculateRequiredPower);
SinkComp = sinkComp;
m_soundEmitter = new MyEntity3DSoundEmitter(this);
}
private void UpdateGraphicalWeaponPosition()
{
MyAnimationControllerComponent animationController = base.Character.AnimationController;
MyHandItemDefinition handItemDefinition = base.Character.HandItemDefinition;
if (((handItemDefinition != null) && (base.Character.CurrentWeapon != null)) && (animationController.CharacterBones != null))
{
bool flag = base.Character.ControllerInfo.IsLocallyControlled() && ReferenceEquals(MySession.Static.CameraController, base.Character);
bool flag2 = (base.Character.IsInFirstPersonView || base.Character.ForceFirstPersonCamera) & flag;
if (MyFakes.FORCE_CHARTOOLS_1ST_PERSON)
{
flag2 = true;
}
bool jetpackRunning = base.Character.JetpackRunning;
if (this.m_lastStateWasFalling & jetpackRunning)
{
this.m_currentAnimationToIkTime = this.m_animationToIKDelay * ((float)Math.Cos((double)(base.Character.HeadLocalXAngle - this.m_lastLocalRotX)));
}
if (this.m_lastStateWasCrouching != base.Character.IsCrouching)
{
this.m_suppressBouncingForTimeSec = m_suppressBouncingDelay;
}
if (this.m_suppressBouncingForTimeSec > 0f)
{
this.m_spineRestPositionX.Clear();
this.m_spineRestPositionY.Clear();
this.m_spineRestPositionZ.Clear();
}
this.m_lastLocalRotX = base.Character.HeadLocalXAngle;
if (flag2)
{
this.UpdateGraphicalWeaponPosition1st(handItemDefinition);
}
else
{
this.UpdateGraphicalWeaponPosition3rd(handItemDefinition);
}
}
}
protected MyBlockPlacerBase(MyHandItemDefinition definition)
: base(500)
{
m_definition = definition;
}
protected virtual void handItemsCombo_ItemSelected()
{
CurrentSelectedItem = m_handItemDefinitions[(int)m_handItemsCombo.GetSelectedKey()];;
}
/// <summary>
/// Update shown position of the weapon.
/// </summary>
private void UpdateGraphicalWeaponPosition()
{
var animController = Character.AnimationController;
MyHandItemDefinition handItemDefinition = Character.HandItemDefinition;
if (handItemDefinition == null || Character.CurrentWeapon == null || animController.CharacterBones == null)
{
return;
}
// ---------
// gather useful variables
bool isLocallyControlled = Character.ControllerInfo.IsLocallyControlled();
bool isInFirstPerson = (Character.IsInFirstPersonView || Character.ForceFirstPersonCamera) && isLocallyControlled;
var jetpack = Character.JetpackComp;
bool flying = jetpack != null && jetpack.Running;
if (m_lastStateWasFalling && flying)
{
m_currentAnimationToIkTime = m_animationToIKDelay * (float)Math.Cos(Character.HeadLocalXAngle - m_lastLocalRotX);
}
if (m_lastStateWasCrouching != Character.IsCrouching)
{
m_suppressBouncingForTimeSec = m_suppressBouncingDelay;
}
if (m_suppressBouncingForTimeSec > 0)
{
m_spineRestPositionX.Clear();
m_spineRestPositionY.Clear();
m_spineRestPositionZ.Clear();
}
m_lastLocalRotX = Character.HeadLocalXAngle;
// get head matrix
MatrixD weaponMatrixPositioned = Character.GetHeadMatrix(false, !flying, false, true, preferLocalOverSync: true) * Character.PositionComp.WorldMatrixInvScaled;
if (!isInFirstPerson && animController.CharacterBones.IsValidIndex(Character.HeadBoneIndex))
{
// apply feet ik (head bone is stabilized)
weaponMatrixPositioned.M42 += animController.CharacterBonesSorted[0].Translation.Y;
}
// ---------
// mix positioning matrices (variants: stand/walk/shoot/ironsight), all in character local space
// standing (IK)
MatrixD standingMatrix = isInFirstPerson ? handItemDefinition.ItemLocation : handItemDefinition.ItemLocation3rd;
// walking (IK)
MatrixD walkingMatrix = isInFirstPerson ? handItemDefinition.ItemWalkingLocation : handItemDefinition.ItemWalkingLocation3rd;
// shooting (IK)
MatrixD shootingMatrix = isInFirstPerson ? handItemDefinition.ItemShootLocation : handItemDefinition.ItemShootLocation3rd;
// ironsight (IK)
MatrixD ironsightMatrix = handItemDefinition.ItemIronsightLocation;
// animation pose
MatrixD weaponAnimMatrix = animController.CharacterBones.IsValidIndex(Character.WeaponBone)
? GetWeaponRelativeMatrix() * animController.CharacterBones[Character.WeaponBone].AbsoluteTransform
: GetWeaponRelativeMatrix();
ironsightMatrix.Translation = m_weaponIronsightTranslation;
if (Character.CurrentWeapon is MyEngineerToolBase)
{
ironsightMatrix.Translation = m_toolIronsightTranslation;
}
// get weights of all state variants
Vector4D variantWeights = UpdateAndGetWeaponVariantWeights(handItemDefinition);
// interpolate matrices to get the resulting one
MatrixD weaponMatrixLocal = variantWeights.X * standingMatrix
+ variantWeights.Y * walkingMatrix
+ variantWeights.Z * shootingMatrix
+ variantWeights.W * ironsightMatrix;
weaponMatrixLocal = MatrixD.Normalize(weaponMatrixLocal);
// weapon positioning - IK weight
double weaponDataPosWeight = 0;
if (handItemDefinition.ItemPositioning == MyItemPositioningEnum.TransformFromData && isInFirstPerson ||
handItemDefinition.ItemPositioning3rd == MyItemPositioningEnum.TransformFromData && !isInFirstPerson)
{
weaponDataPosWeight += variantWeights.X;
}
if (handItemDefinition.ItemPositioningWalk == MyItemPositioningEnum.TransformFromData && isInFirstPerson ||
handItemDefinition.ItemPositioningWalk3rd == MyItemPositioningEnum.TransformFromData && !isInFirstPerson)
{
weaponDataPosWeight += variantWeights.Y;
}
if (handItemDefinition.ItemPositioningShoot == MyItemPositioningEnum.TransformFromData && isInFirstPerson ||
handItemDefinition.ItemPositioningShoot3rd == MyItemPositioningEnum.TransformFromData && !isInFirstPerson)
{
weaponDataPosWeight += variantWeights.Z;
}
weaponDataPosWeight += variantWeights.W;
weaponDataPosWeight /= variantWeights.X + variantWeights.Y + variantWeights.Z + variantWeights.W;
// now computing hand IK weight
double armsIkWeight = 0;
if (handItemDefinition.ItemPositioning != MyItemPositioningEnum.TransformFromAnim && isInFirstPerson ||
handItemDefinition.ItemPositioning3rd != MyItemPositioningEnum.TransformFromAnim && !isInFirstPerson)
{
armsIkWeight += variantWeights.X;
}
if (handItemDefinition.ItemPositioningWalk != MyItemPositioningEnum.TransformFromAnim && isInFirstPerson ||
handItemDefinition.ItemPositioningWalk3rd != MyItemPositioningEnum.TransformFromAnim && !isInFirstPerson)
{
armsIkWeight += variantWeights.Y;
}
if (handItemDefinition.ItemPositioningShoot != MyItemPositioningEnum.TransformFromAnim && isInFirstPerson ||
handItemDefinition.ItemPositioningShoot3rd != MyItemPositioningEnum.TransformFromAnim && !isInFirstPerson)
{
armsIkWeight += variantWeights.Z;
}
armsIkWeight /= variantWeights.X + variantWeights.Y + variantWeights.Z + variantWeights.W;
ApplyWeaponBouncing(handItemDefinition, ref weaponMatrixLocal, (float)(1.0 - 0.95 * variantWeights.W));
// apply head transform on top of it
if (!isInFirstPerson)
{
weaponMatrixPositioned.M43 += 0.5 * weaponMatrixLocal.M43 * Math.Max(0, weaponMatrixPositioned.M32); // offset not to interfere with body
weaponMatrixPositioned.M42 += 0.5 * weaponMatrixLocal.M42 * Math.Max(0, weaponMatrixPositioned.M32); // offset not to interfere with body
}
MatrixD weaponMatrixPositionedLocal = weaponMatrixLocal * weaponMatrixPositioned;
// displace sensor (maybe move to logical part? does not seem to be used at all)
var characterWeaponEngToolBase = Character.CurrentWeapon as MyEngineerToolBase;
if (characterWeaponEngToolBase != null)
{
characterWeaponEngToolBase.SensorDisplacement = -weaponMatrixLocal.Translation;
}
// mix plain animation with (anim+ik) result - for example, medieval uses plain animations
double ikRatio = weaponDataPosWeight * m_currentAnimationToIkTime / m_animationToIKDelay;
MatrixD weaponFinalWorld = MatrixD.Lerp(weaponAnimMatrix, weaponMatrixPositionedLocal, ikRatio) * Character.WorldMatrix;
// propagate result to fields
GraphicalPositionWorld = weaponFinalWorld.Translation;
ArmsIkWeight = (float)armsIkWeight;
((MyEntity)Character.CurrentWeapon).WorldMatrix = weaponFinalWorld;
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW)
{
MyRenderProxy.DebugDrawAxis(weaponFinalWorld, 0.5f, false);
}
}
protected MyBlockPlacerBase(MyHandItemDefinition definition)
: base(definition, 0.5f, 500)
{
}
private unsafe void UpdateGraphicalWeaponPosition3rd(MyHandItemDefinition handItemDefinition)
{
bool jetpackRunning = base.Character.JetpackRunning;
MyAnimationControllerComponent animationController = base.Character.AnimationController;
MatrixD xd = base.Character.GetHeadMatrix(false, !jetpackRunning, false, true, true) * base.Character.PositionComp.WorldMatrixInvScaled;
if (animationController.CharacterBones.IsValidIndex <MyCharacterBone>(base.Character.HeadBoneIndex))
{
double *numPtr1 = (double *)ref xd.M42;
numPtr1[0] += animationController.CharacterBonesSorted[0].Translation.Y;
}
MatrixD xd2 = handItemDefinition.ItemLocation3rd;
MatrixD xd3 = handItemDefinition.ItemWalkingLocation3rd;
MatrixD xd4 = handItemDefinition.ItemShootLocation3rd;
MatrixD itemIronsightLocation = handItemDefinition.ItemIronsightLocation;
MatrixD xd6 = animationController.CharacterBones.IsValidIndex <MyCharacterBone>(base.Character.WeaponBone) ? (this.GetWeaponRelativeMatrix() * animationController.CharacterBones[base.Character.WeaponBone].AbsoluteTransform) : this.GetWeaponRelativeMatrix();
itemIronsightLocation.Translation = m_weaponIronsightTranslation;
if (base.Character.CurrentWeapon is MyEngineerToolBase)
{
itemIronsightLocation.Translation = m_toolIronsightTranslation;
}
Vector4D vectord = this.UpdateAndGetWeaponVariantWeights(handItemDefinition);
MatrixD weaponMatrixLocal = MatrixD.Normalize((MatrixD)((((vectord.X * xd2) + (vectord.Y * xd3)) + (vectord.Z * xd4)) + (vectord.W * itemIronsightLocation)));
double num = 0.0;
if (handItemDefinition.ItemPositioning3rd == MyItemPositioningEnum.TransformFromData)
{
num += vectord.X;
}
if (handItemDefinition.ItemPositioningWalk3rd == MyItemPositioningEnum.TransformFromData)
{
num += vectord.Y;
}
if (handItemDefinition.ItemPositioningShoot3rd == MyItemPositioningEnum.TransformFromData)
{
num += vectord.Z;
}
if (handItemDefinition.ItemPositioningIronsight3rd == MyItemPositioningEnum.TransformFromData)
{
num += vectord.W;
}
num /= ((vectord.X + vectord.Y) + vectord.Z) + vectord.W;
double num2 = 0.0;
if (handItemDefinition.ItemPositioning3rd != MyItemPositioningEnum.TransformFromAnim)
{
num2 += vectord.X;
}
if (handItemDefinition.ItemPositioningWalk3rd != MyItemPositioningEnum.TransformFromAnim)
{
num2 += vectord.Y;
}
if (handItemDefinition.ItemPositioningShoot3rd != MyItemPositioningEnum.TransformFromAnim)
{
num2 += vectord.Z;
}
if (handItemDefinition.ItemPositioningIronsight3rd != MyItemPositioningEnum.TransformFromAnim)
{
num2 += vectord.W;
}
num2 /= ((vectord.X + vectord.Y) + vectord.Z) + vectord.W;
this.ApplyWeaponBouncing(handItemDefinition, ref weaponMatrixLocal, (float)(1.0 - (0.95 * vectord.W)), 0f);
double *numPtr2 = (double *)ref xd.M43;
numPtr2[0] += (0.5 * weaponMatrixLocal.M43) * Math.Max(0.0, xd.M32);
double *numPtr3 = (double *)ref xd.M42;
numPtr3[0] += (0.5 * weaponMatrixLocal.M42) * Math.Max(0.0, xd.M32);
double *numPtr4 = (double *)ref xd.M42;
numPtr4[0] -= 0.25 * Math.Max(0.0, xd.M32);
double *numPtr5 = (double *)ref xd.M43;
numPtr5[0] -= 0.05 * Math.Min(0.0, xd.M32);
double *numPtr6 = (double *)ref xd.M41;
numPtr6[0] -= 0.25 * Math.Max(0.0, xd.M32);
MatrixD xd8 = weaponMatrixLocal * xd;
MyEngineerToolBase currentWeapon = base.Character.CurrentWeapon as MyEngineerToolBase;
if (currentWeapon != null)
{
currentWeapon.SensorDisplacement = (Vector3) - weaponMatrixLocal.Translation;
}
double amount = (num * this.m_currentAnimationToIkTime) / ((double)this.m_animationToIKDelay);
MatrixD weaponAnimMatrix = MatrixD.Lerp(xd6, xd8, amount);
this.UpdateScattering(ref weaponAnimMatrix, handItemDefinition);
this.ApplyBackkick(ref weaponAnimMatrix);
MatrixD matrix = weaponAnimMatrix * base.Character.WorldMatrix;
this.GraphicalPositionWorld = matrix.Translation;
this.ArmsIkWeight = (float)num2;
((MyEntity)base.Character.CurrentWeapon).WorldMatrix = matrix;
if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW && MyDebugDrawSettings.DEBUG_DRAW_CHARACTER_TOOLS)
{
MyDebugDrawHelper.DrawNamedColoredAxis(xd6 * base.Character.WorldMatrix, 0.25f, "weapon anim " + (100.0 - (100.0 * amount)) + "%", new Color?(Color.Orange));
MyDebugDrawHelper.DrawNamedColoredAxis(xd8 * base.Character.WorldMatrix, 0.25f, "weapon data " + (100.0 * amount) + "%", new Color?(Color.Magenta));
MyDebugDrawHelper.DrawNamedColoredAxis(matrix, 0.25f, "weapon final", new Color?(Color.White));
}
}
private unsafe Vector4D UpdateAndGetWeaponVariantWeights(MyHandItemDefinition handItemDefinition)
{
float num;
int num1;
int num5;
float single1;
float single2;
float single3;
base.Character.AnimationController.Variables.GetValue(MyAnimationVariableStorageHints.StrIdSpeed, out num);
if (base.Character.IsSprinting || MyCharacter.IsRunningState(base.Character.GetPreviousMovementState()))
{
num1 = (int)(num > base.Character.Definition.MaxWalkSpeed);
}
else
{
num1 = 0;
}
bool flag = (bool)num1;
if (base.Character.IsShooting(MyShootActionEnum.PrimaryAction) || ((base.Character.ZoomMode == MyZoomModeEnum.Classic) && (base.Character.IsShooting(MyShootActionEnum.SecondaryAction) || base.Character.IsShooting(MyShootActionEnum.TertiaryAction))))
{
num5 = (int)!base.Character.IsSprinting;
}
else
{
num5 = 0;
}
this.IsShooting = (bool)num5;
this.IsInIronSight = (base.Character.ZoomMode == MyZoomModeEnum.IronSight) && !base.Character.IsSprinting;
this.ShouldSupressShootAnimation = base.Character.ShouldSupressShootAnimation;
bool isShooting = this.IsShooting;
bool isInIronSight = this.IsInIronSight;
float num2 = 0.01666667f / handItemDefinition.BlendTime;
float num3 = 0.01666667f / handItemDefinition.ShootBlend;
float *singlePtr1 = &this.m_weaponPositionVariantWeightCounters.X;
if ((flag || isShooting) || isInIronSight)
{
single1 = (isShooting | isInIronSight) ? -num3 : -num2;
}
else
{
single1 = num2;
}
*(singlePtr1[0]) = singlePtr1 + single1;
float *singlePtr2 = (float *)ref this.m_weaponPositionVariantWeightCounters.Y;
if ((!flag || isShooting) || isInIronSight)
{
single2 = (isShooting | isInIronSight) ? -num3 : -num2;
}
else
{
single2 = num2;
}
singlePtr2[0] += single2;
float *singlePtr3 = (float *)ref this.m_weaponPositionVariantWeightCounters.Z;
if (!isShooting || isInIronSight)
{
single3 = isInIronSight ? -num3 : -num2;
}
else
{
single3 = num3;
}
singlePtr3[0] += single3;
float *singlePtr4 = (float *)ref this.m_weaponPositionVariantWeightCounters.W;
singlePtr4[0] += isInIronSight ? num3 : (isShooting ? -num3 : -num2);
this.m_weaponPositionVariantWeightCounters = Vector4.Clamp(this.m_weaponPositionVariantWeightCounters, Vector4.Zero, Vector4.One);
Vector4D vectord = new Vector4D((double)MathHelper.SmoothStep(0f, 1f, this.m_weaponPositionVariantWeightCounters.X), (double)MathHelper.SmoothStep(0f, 1f, this.m_weaponPositionVariantWeightCounters.Y), (double)MathHelper.SmoothStep(0f, 1f, this.m_weaponPositionVariantWeightCounters.Z), (double)MathHelper.SmoothStep(0f, 1f, this.m_weaponPositionVariantWeightCounters.W));
return(vectord / (((vectord.X + vectord.Y) + vectord.Z) + vectord.W));
}
