public VoxelCollisionDmgThreadEvent(MyEntity entity, DefenseShields shield, float damage, Vector3D collisionAvg)
{
Entity = entity;
Shield = shield;
Damage = damage;
CollisionAvg = collisionAvg;
}
public void Init(DefenseShields shield, float damage, Vector3D collisionAvg, long attackerId)
{
Shield = shield;
Damage = damage;
CollisionAvg = collisionAvg;
AttackerId = attackerId;
}
public ShieldVsShieldThreadEvent(DefenseShields shield, float damage, Vector3D collisionAvg, long attackerId)
{
Shield = shield;
Damage = damage;
CollisionAvg = collisionAvg;
AttackerId = attackerId;
}
public void Init(MyEntity entity, DefenseShields shield, float damage, Vector3D collisionAvg)
{
Entity = entity;
Shield = shield;
Damage = damage;
CollisionAvg = collisionAvg;
}
public void Clean()
{
Entity = null;
Shield = null;
Damage = 0;
CollisionAvg = Vector3D.Zero;
}
public void Clean()
{
Shield = null;
Damage = 0;
CollisionAvg = Vector3D.Zero;
AttackerId = 0;
}
internal void ComputeEffects(DefenseShields shield, Vector3D impactPos, int prevLod, float shieldPercent, bool activeVisible)
{
Shield = shield;
if (Shield?.ShellActive != null)
{
ComputeSides();
}
else
{
return;
}
_matrix = Shield.ShieldShapeMatrix;
if (Session.Instance.Settings.ClientConfig.ShowHitRings && impactPos != Vector3D.NegativeInfinity && impactPos != Vector3D.PositiveInfinity)
{
CreateImpactRing(shield, impactPos, _lod);
}
_flash = shieldPercent <= 10;
if (_flash && _mainLoop < 30)
{
shieldPercent += 10;
}
var newActiveColor = UtilsStatic.GetShieldColorFromFloat(shieldPercent);
_activeColor = newActiveColor;
ImpactPosState = impactPos;
_active = activeVisible && _activeColor != Session.Instance.Color90;
if (prevLod != _lod)
{
var ib = _backing.IndexBuffer[_lod];
Array.Resize(ref _preCalcNormLclPos, ib.Length / 3);
Array.Resize(ref _triColorBuffer, ib.Length / 3);
}
StepEffects();
/*
* if (refreshAnim && _refresh && ImpactsFinished && prevLod == _lod) RefreshColorAssignments(prevLod);
* if (ImpactsFinished && prevLod == _lod) return;
*
* ImpactColorAssignments(prevLod);
*/
//// vec3 localSpherePositionOfImpact;
// foreach (vec3 triangleCom in triangles) {
// var surfDistance = Math.acos(dot(triangleCom, localSpherePositionOfImpact));
// }
// surfDistance will be the distance, along the surface, between the impact point and the triangle
// Equinox - It won't distort properly for anything that isn't a sphere
// localSpherePositionOfImpact = a direction
// triangleCom is another direction
// Dot product is the cosine of the angle between them
// Acos gives you that angle in radians
// Multiplying by the sphere radius(1 for the unit sphere in question) gives the arc length.
}
public void Init(HashSet <CubeAccel> accelSet, DefenseShields shield, float damage, Vector3D collisionAvg, long attackerId)
{
AccelSet = accelSet;
Shield = shield;
Damage = damage;
CollisionAvg = collisionAvg;
AttackerId = attackerId;
}
public void ProtectDamageReset()
{
IntegrityShield = null;
NotBlockingShield = null;
NotBlockingAttackerId = -1;
IgnoreAttackerId = -1;
OriginBlock = null;
OriginHit = Vector3D.Zero;
NotBlockingMainDamageType = MyStringHash.NullOrEmpty;
}
public void CleanUp()
{
Shields.Clear();
RefreshSlot = 0;
CreationTick = 0;
IntegrityShield = null;
NotBlockingShield = null;
NotBlockingAttackerId = -1;
IgnoreAttackerId = -1;
OriginBlock = null;
OriginHit = Vector3D.Zero;
}
public static Vector3D?MissileIntersect(DefenseShields ds, MyEntity missile, MatrixD detectMatrix, MatrixD detectMatrixInv)
{
var missileVel = missile.Physics.LinearVelocity;
var missileCenter = missile.PositionComp.WorldVolume.Center;
var velStepSize = missileVel * MyEngineConstants.PHYSICS_STEP_SIZE_IN_SECONDS * 2;
var futureCenter = missileCenter + velStepSize;
var testDir = Vector3D.Normalize(missileCenter - futureCenter);
var ellipsoid = IntersectEllipsoid(ds.DetectMatrixOutsideInv, ds.DetectionMatrix, new RayD(futureCenter, -testDir));
if (ellipsoid == null || ellipsoid > 0)
{
return(null);
}
return(futureCenter);
}
public void Init(IMyMeteor meteor, DefenseShields shield)
{
Meteor = meteor;
Shield = shield;
}
public void Clean()
{
Meteor = null;
Shield = null;
}
public void Init(MyCollisionPhysicsData collisionPhysicsData, DefenseShields shield)
{
CollisionData = collisionPhysicsData;
Shield = shield;
}
public void Clean()
{
CollisionData = new MyCollisionPhysicsData();
Shield = null;
}
public ForceDataThreadEvent(MyForceData forceData, DefenseShields shield)
{
ForceData = forceData;
Shield = shield;
}
public MeteorDmgThreadEvent(IMyMeteor meteor, DefenseShields shield)
{
Meteor = meteor;
Shield = shield;
}
public void Clean()
{
Character = null;
Shield = null;
}
public ImpulseDataThreadEvent(MyImpulseData impulseData, DefenseShields shield)
{
ImpulseData = impulseData;
Shield = shield;
}
public VoxelDmgThreadEvent(MyVoxelBase voxelBase, DefenseShields shield)
{
VoxelBase = voxelBase;
Shield = shield;
}
public void Init(IMyCharacter character, DefenseShields shield)
{
Character = character;
Shield = shield;
}
public void Init(MyEntity entity, DefenseShields shield)
{
Entity = entity;
Shield = shield;
}
public void Init(MyForceData forceData, DefenseShields shield)
{
ForceData = forceData;
Shield = shield;
}
public MissileThreadEvent(MyEntity entity, DefenseShields shield)
{
Entity = entity;
Shield = shield;
}
internal void CreateImpactRing(DefenseShields shield, Vector3D impactPosition, int lod)
{
try
{
double shortestSide = Math.Min(shield.DetectMatrixOutside.Scale.X, Math.Min(shield.DetectMatrixOutside.Scale.Y, shield.DetectMatrixOutside.Scale.Z));
double hitPercent = shield.Absorb / shield.ShieldMaxCharge;
double lengthLimit = Math.Max(shortestSide * Math.Min(hitPercent, 1), ImpactRingMinSize);
double divHalfLengthLimit = 1.25 / lengthLimit;
Vector3D impactNormal = Vector3D.Normalize(impactPosition - _matrix.Translation);
Vector3D impactForwardVec = Vector3D.Normalize(Vector3D.Cross(impactNormal, Vector3D.Forward));
MatrixD impactRingPosTransform = MatrixD.Transpose(MatrixD.CreateWorld(Vector3D.Zero, impactForwardVec, impactNormal));
var ring = Session.Instance.RingPool.Get();
ring.LodLevel = lod;
ring.AnimationStartClock = 1;
ring.ImpactPosition = impactPosition;
ring.ImpactMaxDistance = lengthLimit;
ring.RingTriangles.Clear();
var ib = _backing.IndexBuffer[_lod];
for (int i = 0, j = 0; i < ib.Length; i += 3, j++)
{
var i0 = ib[i];
var i1 = ib[i + 1];
var i2 = ib[i + 2];
var v0 = _vertexBuffer[i0];
var v1 = _vertexBuffer[i1];
var v2 = _vertexBuffer[i2];
double dv0 = (v0 - impactPosition).LengthSquared();
double dv1 = (v1 - impactPosition).LengthSquared();
double dv2 = (v2 - impactPosition).LengthSquared();
double checkDistSq = Math.Min(dv0, Math.Min(dv1, dv2));
if (checkDistSq <= lengthLimit * lengthLimit)
{
Vector3D ringV0 = (v0 - impactPosition) * divHalfLengthLimit;
Vector3D ringV1 = (v1 - impactPosition) * divHalfLengthLimit;
Vector3D ringV2 = (v2 - impactPosition) * divHalfLengthLimit;
Vector3D.TransformNormal(ref ringV0, ref impactRingPosTransform, out ringV0);
Vector3D.TransformNormal(ref ringV1, ref impactRingPosTransform, out ringV1);
Vector3D.TransformNormal(ref ringV2, ref impactRingPosTransform, out ringV2);
ring.RingTriangles.Add(new TriangleData()
{
TriangleIndex = j,
UVInfoV0 = new Vector2((float)ringV0.X, (float)ringV0.Z),
UVInfoV1 = new Vector2((float)ringV1.X, (float)ringV1.Z),
UVInfoV2 = new Vector2((float)ringV2.X, (float)ringV2.Z)
});
}
}
if (_impactRings.Count >= Session.Instance.Settings.ClientConfig.MaxHitRings)
{
int indexInside = -1;
double maxInsideSq = double.MaxValue;
int indexOutside = -1;
double maxOutsideSq = double.MaxValue;
for (int i = 0; i < _impactRings.Count; i++)
{
double lengthSq = (_impactRings[i].ImpactPosition - impactPosition).LengthSquared();
if (_impactRings[i].ImpactMaxDistance * _impactRings[i].ImpactMaxDistance >= lengthSq)
{
if (lengthSq < maxInsideSq)
{
maxInsideSq = lengthSq;
indexInside = i;
}
}
else
{
if (lengthSq < maxOutsideSq)
{
maxOutsideSq = lengthSq;
indexOutside = i;
}
}
}
if (indexInside > -1)
{
ring.AnimationStartClock = Math.Min(_impactRings[indexInside].AnimationStartClock, ImpactRingExpandTicks);
_impactRings[indexInside] = ring;
}
else if (indexOutside > -1)
{
ring.AnimationStartClock = Math.Min(_impactRings[indexOutside].AnimationStartClock, ImpactRingExpandTicks);
_impactRings[indexOutside] = ring;
}
else
{
int randomIdex = rnd.Next(0, _impactRings.Count);
ring.AnimationStartClock = Math.Min(_impactRings[randomIdex].AnimationStartClock, ImpactRingExpandTicks);
_impactRings[randomIdex] = ring;
}
}
else
{
_impactRings.Add(ring);
}
}
catch (Exception ex)
{
Log.Line($"Exception in CreateImpactRing {ex}" + ex.StackTrace);
}
}
internal void Draw(uint renderId, DefenseShields shield)
{
try
{
var ib = _backing.IndexBuffer[_lod];
int index = 0;
var damageColor = shield.GetModulatorColor();
damageColor.W = 0.5f;
while (index < _impactRings.Count)
{
bool retain = false;
var impactRingData = _impactRings[index];
float progress;
float ringIntesity;
float ringSize;
float ringSizeCofficient;
if (impactRingData.AnimationStartClock <= ImpactRingExpandTicks)
{
progress = ((float)impactRingData.AnimationStartClock / ImpactRingExpandTicks) * 0.75f + 0.25f;
ringIntesity = (progress * 0.5f) + 0.5f;
ringSize = 1 - ((1 - progress) * (1 - progress));
ringSizeCofficient = 0.5f / ringSize;
}
else
{
progress = 1 - (((float)impactRingData.AnimationStartClock - ImpactRingExpandTicks) / ImpactRingFadeTicks);
ringIntesity = (progress * 0.5f) + 0.5f;
ringSize = 1;
ringSizeCofficient = 0.5f;
}
impactRingData.AnimationStartClock++;
var v4 = new Vector4
{
W = damageColor.W,
X = damageColor.X * 2f * ringIntesity,
Y = damageColor.Y * 2f * ringIntesity,
Z = damageColor.Z * 2f * ringIntesity
};
if (impactRingData.LodLevel == _lod)
{
for (int x = 0; x < impactRingData.RingTriangles.Count; x++)
{
TriangleData triangleData = impactRingData.RingTriangles[x];
int i = triangleData.TriangleIndex * 3;
var i0 = ib[i];
var i1 = ib[i + 1];
var i2 = ib[i + 2];
var v0 = _vertexBuffer[i0];
var v1 = _vertexBuffer[i1];
var v2 = _vertexBuffer[i2];
var n0 = _normalBuffer[i0];
var n1 = _normalBuffer[i1];
var n2 = _normalBuffer[i2];
MyTransparentGeometry.AddTriangleBillboard(v0, v1, v2,
n0, n1, n2,
triangleData.UVInfoV0 * ringSizeCofficient + HalfShift,
triangleData.UVInfoV1 * ringSizeCofficient + HalfShift,
triangleData.UVInfoV2 * ringSizeCofficient + HalfShift,
_impactRingMaterial, renderId, (v0 + v1 + v2) / 3, v4, BlendTypeEnum.PostPP);
}
if (impactRingData.AnimationStartClock <= ImpactRingExpandTicks + ImpactRingFadeTicks)
{
retain = true;
}
}
if (retain)
{
index++;
}
else
{
var last = _impactRings.Count - 1;
var lastData = _impactRings[last];
_impactRings.RemoveAtFast(last);
Session.Instance.RingPool.Return(lastData);
//_impactRings[index] = _impactRings[_impactRings.Count - 1];
//_impactRings.RemoveAt(_impactRings.Count - 1);
}
}
/* Superseded
* if (ImpactsFinished && !_refresh) return;
* var ib = _backing.IndexBuffer[_lod];
* Vector4 color;
* if (!ImpactsFinished)
* {
* color = _waveColor;
* _faceMaterial = _faceWave;
* }
* else
* {
* color = _refreshColor;
* _faceMaterial = _faceCharge;
* }
* for (int i = 0, j = 0; i < ib.Length; i += 3, j++)
* {
* var face = _triColorBuffer[j];
* if (face != 1 && face != 2) continue;
*
* var i0 = ib[i];
* var i1 = ib[i + 1];
* var i2 = ib[i + 2];
*
* var v0 = _vertexBuffer[i0];
* var v1 = _vertexBuffer[i1];
* var v2 = _vertexBuffer[i2];
*
* var n0 = _normalBuffer[i0];
* var n1 = _normalBuffer[i1];
* var n2 = _normalBuffer[i2];
*
* MyTransparentGeometry.AddTriangleBillboard(v0, v1, v2, n0, n1, n2, _v20, _v21, _v22, _faceMaterial, renderId, (v0 + v1 + v2) / 3, color);
* }
*/
}
catch (Exception ex) { Log.Line($"Exception in IcoSphere Draw - renderId {renderId.ToString()}: {ex}"); }
}
public void Clean()
{
ForceData = new MyForceData(null, Vector3D.Zero, null, null, null, false);
Shield = null;
}
public CharacterEffectThreadEvent(IMyCharacter character, DefenseShields shield)
{
Character = character;
Shield = shield;
}
public void Clean()
{
Entity = null;
Shield = null;
}
public VoxelCollisionPhysicsThreadEvent(MyCollisionPhysicsData collisionPhysicsData, DefenseShields shield)
{
CollisionData = collisionPhysicsData;
Shield = shield;
}
