public void ConstructorException2()
{
MatrixD m = new MatrixD(new double[,] {{ 1, 2 },
{ 3, 4 },
{ 5, 6 }});
new EigenvalueDecompositionD(m);
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
m_cameraDummy = Matrix.Identity;
m_characterDummy = Matrix.Identity;
base.Init(objectBuilder, cubeGrid);
var chamberOb = objectBuilder as MyObjectBuilder_CryoChamber;
if (chamberOb.SteamId != null && chamberOb.SerialId != null)
{
m_currentPlayerId = new MyPlayer.PlayerId(chamberOb.SteamId.Value, chamberOb.SerialId.Value);
}
else
{
m_currentPlayerId = null;
}
var overlayTexture = BlockDefinition.OverlayTexture;
if (!string.IsNullOrEmpty(overlayTexture))
{
m_overlayTextureName = overlayTexture;
}
PowerReceiver = new MyPowerReceiver(
MyConsumerGroupEnum.Utility,
false,
BlockDefinition.IdlePowerConsumption,
this.CalculateRequiredPowerInput);
PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged;
NeedsUpdate |= Common.MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
public void Test1()
{
MatrixD a = new MatrixD(new double[,] { { 2, -1, 0},
{ -1, 2, -1},
{ 0, -1, 2} });
CholeskyDecompositionD d = new CholeskyDecompositionD(a);
Assert.AreEqual(true, d.IsSymmetricPositiveDefinite);
MatrixD l = d.L;
Assert.AreEqual(0, l[0, 1]);
Assert.AreEqual(0, l[0, 2]);
Assert.AreEqual(0, l[1, 2]);
Assert.IsTrue(MatrixD.AreNumericallyEqual(a, l * l.Transposed));
Assert.IsTrue(MatrixD.AreNumericallyEqual(a, l * l.Transposed));
// Check solving of linear equations.
MatrixD x = new MatrixD(new double[,] { { 1, 2},
{ 3, 4},
{ 5, 6} });
MatrixD b = a * x;
Assert.IsTrue(MatrixD.AreNumericallyEqual(x, d.SolveLinearEquations(b)));
}
public void TestMatricesWithoutFullRank()
{
MatrixD a = new MatrixD(3, 3);
SingularValueDecompositionD svd = new SingularValueDecompositionD(a);
Assert.AreEqual(0, svd.NumericalRank);
Assert.AreEqual(svd.SingularValues[0], svd.Norm2);
double condNumber = svd.ConditionNumber;
a = new MatrixD(new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 4, 5, 6 } });
svd = new SingularValueDecompositionD(a);
Assert.AreEqual(2, svd.NumericalRank);
Assert.AreEqual(svd.SingularValues[0], svd.Norm2);
Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed));
svd = new SingularValueDecompositionD(a.Transposed);
Assert.AreEqual(2, svd.NumericalRank);
Assert.IsTrue(MatrixD.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed));
Assert.IsTrue(MatrixD.AreNumericallyEqual(a.Transposed, svd.U * svd.S * svd.V.Transposed)); // Repeat to test with cached values.
Assert.AreEqual(svd.SingularValues[0], svd.Norm2);
condNumber = svd.ConditionNumber;
a = new MatrixD(new double[,] { { 1, 2 }, { 1, 2 }, { 1, 2 } });
svd = new SingularValueDecompositionD(a);
Assert.AreEqual(1, svd.NumericalRank);
Assert.IsTrue(MatrixD.AreNumericallyEqual(a, svd.U * svd.S * svd.V.Transposed));
Assert.AreEqual(svd.SingularValues[0], svd.Norm2);
condNumber = svd.ConditionNumber;
}
public void DeterminantException()
{
MatrixD a = new MatrixD(new double[,] { { 1, 2 }, { 5, 6 }, { 0, 1 } });
LUDecompositionD d = new LUDecompositionD(a);
double det = d.Determinant;
}
public void TestRandomA()
{
RandomHelper.Random = new Random(1);
for (int i = 0; i < 100; i++)
{
// Create A.
MatrixD a = new MatrixD(3, 3);
RandomHelper.Random.NextMatrixD(a, 0, 1);
LUDecompositionD d = new LUDecompositionD(a);
if (d.IsNumericallySingular == false)
{
// Check solving of linear equations.
MatrixD b = new MatrixD(3, 2);
RandomHelper.Random.NextMatrixD(b, 0, 1);
MatrixD x = d.SolveLinearEquations(b);
MatrixD b2 = a * x;
Assert.IsTrue(MatrixD.AreNumericallyEqual(b, b2, 0.01));
MatrixD aPermuted = d.L * d.U;
Assert.IsTrue(MatrixD.AreNumericallyEqual(aPermuted, a.GetSubmatrix(d.PivotPermutationVector, 0, 2)));
}
}
}
//--------------------------------------------------------------
/// <summary>
/// Creates the principal component analysis for the given list of points.
/// </summary>
/// <param name="points">
/// The list of data points. All points must have the same
/// <see cref="VectorD.NumberOfElements"/>.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="points"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="points"/> is empty.
/// </exception>
public PrincipalComponentAnalysisD(IList<VectorD> points)
{
if (points == null)
throw new ArgumentNullException("points");
if (points.Count == 0)
throw new ArgumentException("The list of points is empty.");
// Compute covariance matrix.
MatrixD covarianceMatrix = StatisticsHelper.ComputeCovarianceMatrix(points);
// Perform Eigenvalue decomposition.
EigenvalueDecompositionD evd = new EigenvalueDecompositionD(covarianceMatrix);
int numberOfElements = evd.RealEigenvalues.NumberOfElements;
Variances = new VectorD(numberOfElements);
V = new MatrixD(numberOfElements, numberOfElements);
// Sort eigenvalues by decreasing value.
// Since covarianceMatrix is symmetric, we have no imaginary eigenvalues.
for (int i = 0; i < Variances.NumberOfElements; i++)
{
int index = evd.RealEigenvalues.IndexOfLargestElement;
Variances[i] = evd.RealEigenvalues[index];
V.SetColumn(i, evd.V.GetColumn(index));
evd.RealEigenvalues[index] = double.NegativeInfinity;
}
}
public MyEntity Spawn(MyFixedPoint amount, MatrixD worldMatrix, MyEntity owner = null)
{
if (Content is MyObjectBuilder_BlockItem)
{
Debug.Assert(MyFixedPoint.IsIntegral(amount), "Spawning fractional number of grids!");
var blockItem = Content as MyObjectBuilder_BlockItem;
var builder = MyObjectBuilderSerializer.CreateNewObject(typeof(MyObjectBuilder_CubeGrid)) as MyObjectBuilder_CubeGrid;
builder.GridSizeEnum = MyCubeSize.Small;
builder.IsStatic = false;
builder.PersistentFlags |= MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.Enabled;
builder.PositionAndOrientation = new MyPositionAndOrientation(worldMatrix);
var block = MyObjectBuilderSerializer.CreateNewObject(blockItem.BlockDefId) as MyObjectBuilder_CubeBlock;
builder.CubeBlocks.Add(block);
MyCubeGrid firstGrid = null;
for (int i = 0; i < amount; ++i)
{
builder.EntityId = MyEntityIdentifier.AllocateId();
block.EntityId = MyEntityIdentifier.AllocateId();
MyCubeGrid newGrid = MyEntities.CreateFromObjectBuilder(builder) as MyCubeGrid;
firstGrid = firstGrid ?? newGrid;
MyEntities.Add(newGrid);
Sandbox.Game.Multiplayer.MySyncCreate.SendEntityCreated(builder);
}
return firstGrid;
}
else
return MyFloatingObjects.Spawn(new MyPhysicalInventoryItem(amount, Content),worldMatrix, owner != null ? owner.Physics : null);
}
public MyRenderBatch(uint id, string debugName, MatrixD worldMatrix, RenderFlags renderFlags, List<MyRenderBatchPart> batchParts)
: base(id, debugName, worldMatrix, renderFlags)
{
m_localAABB = BoundingBoxD.CreateInvalid();
m_batchParts.Clear();
m_batchParts.AddList(batchParts);
}
void IMyClipmapCell.UpdateWorldMatrix(ref VRageMath.MatrixD worldMatrix, bool sortIntoCullObjects)
{
m_worldMatrix = worldMatrix;
Matrix m = m_worldMatrix * Matrix.CreateScale(m_scale) * Matrix.CreateTranslation(m_translation);
m_actor.SetMatrix(ref m);
}
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
{
m_cameraDummy = Matrix.Identity;
m_characterDummy = Matrix.Identity;
base.Init(objectBuilder, cubeGrid);
var chamberOb = objectBuilder as MyObjectBuilder_CryoChamber;
if (chamberOb.SteamId != null && chamberOb.SerialId != null)
{
m_currentPlayerId = new MyPlayer.PlayerId(chamberOb.SteamId.Value, chamberOb.SerialId.Value);
}
else
{
m_currentPlayerId = null;
}
var overlayTexture = BlockDefinition.OverlayTexture;
if (!string.IsNullOrEmpty(overlayTexture))
{
m_overlayTextureName = overlayTexture;
}
var sinkComp = new MyResourceSinkComponent();
sinkComp.Init(
MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup),
BlockDefinition.IdlePowerConsumption,
this.CalculateRequiredPowerInput);
sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged;
ResourceSink = sinkComp;
NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
}
public MyRenderAtmosphere(uint id, string debugName, string model, MatrixD worldMatrix, MyMeshDrawTechnique drawTechnique, RenderFlags renderFlags, float atmosphereRadius, float planetRadius, Vector3 atmosphereWavelengths)
: base(id, debugName,model, worldMatrix,drawTechnique, renderFlags)
{
m_atmosphereWavelengths = atmosphereWavelengths;
m_atmosphereRadius = atmosphereRadius;
m_planetRadius = planetRadius;
}
public IMyClipmapCell CreateCell(MyClipmapScaleEnum scaleGroup, MyCellCoord cellCoord, ref MatrixD worldMatrix)
{
var cell = new MyClipmapCellProxy(cellCoord, ref worldMatrix, m_massiveCenter, m_massiveRadius, m_renderFlags);
cell.SetVisibility(false);
cell.ScaleGroup = scaleGroup;
return cell;
}
public override void OnWorldPositionChanged(ref MatrixD worldMatrix)
{
var forward = worldMatrix.Forward;
m_origin = worldMatrix.Translation + forward * m_originOffset;
FrontPoint = m_origin + m_rayLength * forward;
Center = (m_origin + FrontPoint) * 0.5f;
}
public void TestToVector()
{
var m1 = new MatrixD(new double[] { 1, 2, 3, 4 }, 2, 2);
var v1 = m1.ToVector();
Assert.AreEqual<VectorD>(new VectorD(1, 2, 3, 4), v1);
}
internal MyLodMeshMerge(MyClipmap parentClipmap, int lod, int lodDivisions, ref MatrixD worldMatrix, ref Vector3D massiveCenter, float massiveRadius, RenderFlags renderFlags)
{
Debug.Assert(parentClipmap != null, "Parent clipmap cannot be null");
Debug.Assert(lod >= 0, "Lod level must be non-negative");
Debug.Assert(lodDivisions >= 0, "Invalid number of lod divisions");
m_parentClipmap = parentClipmap;
m_lod = lod;
m_lodDivisions = lodDivisions;
if (m_lodDivisions <= 0)
return;
m_dirtyProxyIndices = new HashSet<int>();
m_cellProxyToAabbProxy = new Dictionary<MyClipmapCellProxy, int>();
m_boundingBoxes = new MyDynamicAABBTreeD(Vector3D.Zero);
int cellCount = lodDivisions*lodDivisions*lodDivisions;
m_mergeJobs = new MergeJobInfo[cellCount];
m_mergedLodMeshProxies = new MyClipmapCellProxy[cellCount];
m_trackedActors = new HashSet<MyActor>[cellCount];
for (int divideIndex = 0; divideIndex < cellCount; ++divideIndex)
{
m_mergedLodMeshProxies[divideIndex] = new MyClipmapCellProxy(new MyCellCoord(Lod, GetCellFromDivideIndex(divideIndex)), ref worldMatrix, massiveCenter, massiveRadius, renderFlags, true);
m_mergeJobs[divideIndex] = new MergeJobInfo { CurrentWorkId = 0, LodMeshesBeingMerged = new List<LodMeshId>(), NextPossibleMergeStartTime = MyCommon.FrameCounter };
m_trackedActors[divideIndex] = new HashSet<MyActor>();
m_dirtyProxyIndices.Add(divideIndex);
}
}
internal MyClipmapHandler(uint id, MyClipmapScaleEnum scaleGroup, MatrixD worldMatrix, Vector3I sizeLod0, RenderFlags additionalFlags)
{
m_clipmapBase = new MyClipmap(id, scaleGroup, worldMatrix, sizeLod0, this);
m_renderFlags = additionalFlags;
MyClipmap.AddToUpdate(MyEnvironment.CameraPosition, m_clipmapBase);
}
public Sandbox.Common.MyIntersectionResultLineTriangleEx? GetIntersectionWithLine(IMyEntity physObject, ref LineD line, ref MatrixD customInvMatrix, IntersectionFlags flags)
{
LineD lineInModelSpace = new LineD(Vector3D.Transform(line.From, ref customInvMatrix), Vector3D.Transform(line.To, ref customInvMatrix));
MyIntersectionResultLineTriangleEx? ret = m_rootNode.GetIntersectionWithLine(physObject, m_model, ref lineInModelSpace, null, flags);
return ret;
}
public void UpdateWorldMatrix(ref MatrixD worldMatrix, bool sortCellsIntoCullObjects)
{
m_worldMatrix = worldMatrix;
MatrixD.Invert(ref m_worldMatrix, out m_invWorldMatrix);
foreach (var lodLevel in m_lodLevels)
lodLevel.UpdateWorldMatrices(sortCellsIntoCullObjects);
m_updateClipping = true;
}
void IMyClipmapCell.UpdateWorldMatrix(ref VRageMath.MatrixD worldMatrix, bool sortIntoCullObjects)
{
m_worldMatrix = worldMatrix;
MatrixD m = MatrixD.CreateScale(m_scale) * MatrixD.CreateTranslation(m_translation) * m_worldMatrix;
m_actor.SetMatrix(ref m);
m_actor.SetAabb((BoundingBoxD)m_localAabb.Transform(m_worldMatrix));
}
public MyRenderVoxelCell(MyClipmapScaleEnum scaleGroup, MyCellCoord coord, ref MatrixD worldMatrix)
: base(0, "MyRenderVoxelCell", RenderFlags.Visible | RenderFlags.CastShadows, CullingOptions.VoxelMap)
{
m_scaleGroup = scaleGroup;
m_coord = coord;
m_worldMatrix = worldMatrix;
m_fakeVoxelMaterial.DrawTechnique = MyMeshDrawTechnique.VOXEL_MAP;
}
public void SolveLinearEquationsException1()
{
// Create A.
MatrixD a = new MatrixD(new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, -9 } });
QRDecompositionD decomp = new QRDecompositionD(a);
decomp.SolveLinearEquations(null);
}
public void SetViewMatrix(ref MatrixD viewMatrix)
{
MyUtils.AssertIsValid(viewMatrix);
this.m_viewMatrix = viewMatrix;
MatrixD.Invert(ref viewMatrix, out m_worldMatrix);
MyUtils.AssertIsValid(m_worldMatrix);
Update();
}
public void AddMatrix()
{
MatrixD m1 = new MatrixD(3, 4, rowMajor, MatrixOrder.RowMajor);
MatrixD m2 = new MatrixD(3, 4, rowMajor, MatrixOrder.RowMajor) * (-3);
MatrixD result = MatrixD.Add(m1, m2);
for (int i = 0; i < 12; i++)
Assert.AreEqual(-rowMajor[i] * 2, result[i]);
}
public void Test1()
{
MatrixD a = new MatrixD(new double[,] {{ 1, -1, 4 },
{ 3, 2, -1 },
{ 2, 1, -1 }});
EigenvalueDecompositionD d = new EigenvalueDecompositionD(a);
Assert.IsTrue(MatrixD.AreNumericallyEqual(a * d.V, d.V * d.D));
}
public void Test2()
{
MatrixD a = new MatrixD(new double[,] {{ 0, 1, 2 },
{ 1, 4, 3 },
{ 2, 3, 5 }});
EigenvalueDecompositionD d = new EigenvalueDecompositionD(a);
Assert.IsTrue(MatrixD.AreNumericallyEqual(a, d.V * d.D * d.V.Transposed));
}
public MyRenderVoxelCellBackground(MyCellCoord coord, ref MatrixD worldMatrix, Vector3D position, float atmoshpereRadius, float planetRadius, bool hasAtmosphere) :
base(MyClipmapScaleEnum.Massive, coord, ref worldMatrix)
{
m_atmosphereRadius = atmoshpereRadius;
m_planetRadius = planetRadius;
m_hasAtmosphere = hasAtmosphere;
m_position = position;
m_leftCornerPositionOffset = worldMatrix.Translation -position;
}
public void SolveLinearEquationsException3()
{
// Create A.
MatrixD a = new MatrixD(new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 1, 2, 3 } });
MatrixD b = new MatrixD(new double[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, -9 } });
CholeskyDecompositionD decomp = new CholeskyDecompositionD(a);
decomp.SolveLinearEquations(b);
}
void PhysicsStateGroup_OnMoved(ref MatrixD oldTransform, ref MatrixD newTransform)
{
Quaternion q1, q2;
Quaternion.CreateFromRotationMatrix(ref oldTransform, out q1);
Quaternion.CreateFromRotationMatrix(ref newTransform, out q2);
if (!NearEqual(ref q1, ref q2))
m_lastMovementFrame = MyMultiplayer.Static.FrameCounter;
}
public MyRenderVoxelDebris(uint id, string debugName, string model, MatrixD worldMatrix, float textureCoordOffset, float textureCoordScale, float textureColorMultiplier, byte voxelMaterialIndex)
: base(id, debugName, model, worldMatrix, MyMeshDrawTechnique.VOXELS_DEBRIS, RenderFlags.Visible)
{
System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(model));
TextureCoordOffset = textureCoordOffset;
TextureCoordScale = textureCoordScale;
TextureColorMultiplier = textureColorMultiplier;
VoxelMaterialIndex = voxelMaterialIndex;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserEvd"/> class. This object will compute the
/// the eigenvalue decomposition when the constructor is called and cache it's decomposition.
/// </summary>
/// <param name="matrix">The matrix to factor.</param>
/// <exception cref="ArgumentNullException">If <paramref name="matrix"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">If EVD algorithm failed to converge with matrix <paramref name="matrix"/>.</exception>
public UserEvd(Matrix <float> matrix)
{
if (matrix == null)
{
throw new ArgumentNullException("matrix");
}
if (matrix.RowCount != matrix.ColumnCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSquare);
}
var order = matrix.RowCount;
// Initialize matricies for eigenvalues and eigenvectors
MatrixEv = matrix.CreateMatrix(order, order);
MatrixD = matrix.CreateMatrix(order, order);
VectorEv = new LinearAlgebra.Complex.DenseVector(order);
IsSymmetric = true;
for (var i = 0; i < order & IsSymmetric; i++)
{
for (var j = 0; j < order & IsSymmetric; j++)
{
IsSymmetric &= matrix.At(i, j) == matrix.At(j, i);
}
}
var d = new float[order];
var e = new float[order];
if (IsSymmetric)
{
matrix.CopyTo(MatrixEv);
d = MatrixEv.Row(order - 1).ToArray();
SymmetricTridiagonalize(d, e, order);
SymmetricDiagonalize(d, e, order);
}
else
{
var matrixH = matrix.ToArray();
NonsymmetricReduceToHessenberg(matrixH, order);
NonsymmetricReduceHessenberToRealSchur(matrixH, d, e, order);
}
for (var i = 0; i < order; i++)
{
MatrixD.At(i, i, d[i]);
if (e[i] > 0)
{
MatrixD.At(i, i + 1, e[i]);
}
else if (e[i] < 0)
{
MatrixD.At(i, i - 1, e[i]);
}
}
for (var i = 0; i < order; i++)
{
VectorEv[i] = new Complex(d[i], e[i]);
}
}
public static void DebugDrawClusters()
{
if (Clusters == null)
{
return;
}
double previewScale = 2000;
MatrixD previewMatrix = MatrixD.CreateWorld(DebugDrawClustersMatrix.Translation + previewScale * DebugDrawClustersMatrix.Forward, Vector3D.Forward, Vector3D.Up);
m_resultWorlds.Clear();
Clusters.GetAll(m_resultWorlds);
BoundingBoxD totalBox = BoundingBoxD.CreateInvalid();
foreach (var res in m_resultWorlds)
{
totalBox = totalBox.Include(res.AABB);
}
double maxAxis = totalBox.Size.AbsMax();
//double scaleAxis = 0.057142857142857141;
double scaleAxis = previewScale / maxAxis;
//Vector3D scale = new Vector3D(totalBox.Size.X * scaleAxis, totalBox.Size.Y * scaleAxis, totalBox.Size.Z * scaleAxis);
Vector3D center = totalBox.Center;
totalBox.Min -= center;
totalBox.Max -= center;
{
BoundingBoxD scaledBox = new BoundingBoxD(totalBox.Min * scaleAxis * 1.02f, totalBox.Max * scaleAxis * 1.02f);
MyOrientedBoundingBoxD oriented = new MyOrientedBoundingBoxD(scaledBox, previewMatrix);
MyRenderProxy.DebugDrawOBB(oriented, Vector3.Up, 1, false, false);
MyRenderProxy.DebugDrawAxis(previewMatrix, 50, false);
if (MySession.Static != null)
{
foreach (var player in Sandbox.Game.Multiplayer.Sync.Players.GetOnlinePlayers())
{
if (player.Character != null)
{
var playerPos = Vector3D.Transform((player.Character.PositionComp.GetPosition() - center) * scaleAxis, previewMatrix);
MyRenderProxy.DebugDrawSphere(playerPos, 10, Vector3.One, 1, false);
}
}
}
}
Clusters.GetAllStaticObjects(m_clusterStaticObjects);
foreach (var staticBB in m_clusterStaticObjects)
{
BoundingBoxD scaledBox = new BoundingBoxD((staticBB.Min - center) * scaleAxis, (staticBB.Max - center) * scaleAxis);
MyOrientedBoundingBoxD oriented = new MyOrientedBoundingBoxD(scaledBox, previewMatrix);
MyRenderProxy.DebugDrawOBB(oriented, Color.Blue, 1, false, false);
}
foreach (var res in m_resultWorlds)
{
BoundingBoxD scaledBox = new BoundingBoxD((res.AABB.Min - center) * scaleAxis, (res.AABB.Max - center) * scaleAxis);
MyOrientedBoundingBoxD oriented = new MyOrientedBoundingBoxD(scaledBox, previewMatrix);
MyRenderProxy.DebugDrawOBB(oriented, Vector3.One, 1, false, false);
foreach (var rb in ((HkWorld)res.UserData).CharacterRigidBodies)
{
Vector3D rbCenter = res.AABB.Center + rb.Position;
rbCenter = (rbCenter - center) * scaleAxis;
rbCenter = Vector3D.Transform(rbCenter, previewMatrix);
Vector3D velocity = rb.LinearVelocity;
velocity = Vector3D.TransformNormal(velocity, previewMatrix) * 10;
MyRenderProxy.DebugDrawLine3D(rbCenter, rbCenter + velocity, Color.Blue, Color.White, false);
}
foreach (var rb in ((HkWorld)res.UserData).RigidBodies)
{
MyOrientedBoundingBoxD rbbb = new MyOrientedBoundingBoxD((BoundingBoxD)rb.GetEntity().LocalAABB, rb.GetEntity().WorldMatrix);
rbbb.Center = (rbbb.Center - center) * scaleAxis;
rbbb.HalfExtent *= scaleAxis;
rbbb.Transform(previewMatrix);
MyRenderProxy.DebugDrawOBB(rbbb, Color.Yellow, 1, false, false);
//BoundingBoxD rbaa = rb.GetEntity().WorldAABB;
//rbaa.Min = (rbaa.Min - center) * scaleAxis;
//rbaa.Max = (rbaa.Max - center) * scaleAxis;
//MyRenderProxy.DebugDrawAABB(rbaa, new Vector3(0.8f, 0.8f, 0.8f), 1, 1, false);
Vector3D velocity = rb.LinearVelocity;
velocity = Vector3D.TransformNormal(velocity, previewMatrix) * 10;
MyRenderProxy.DebugDrawLine3D(rbbb.Center, rbbb.Center + velocity, Color.Red, Color.White, false);
if (velocity.Length() > 1)
{
BoundingBoxD ideal = new BoundingBoxD(rb.GetEntity().WorldAABB.Center - MyHavokCluster.IdealClusterSize / 2, rb.GetEntity().WorldAABB.Center + MyHavokCluster.IdealClusterSize / 2);
MyOrientedBoundingBoxD idealObb = new MyOrientedBoundingBoxD(ideal, MatrixD.Identity);
idealObb.Center = (ideal.Center - center) * scaleAxis;
idealObb.HalfExtent *= scaleAxis;
idealObb.Transform(previewMatrix);
MyRenderProxy.DebugDrawOBB(idealObb, new Vector3(0, 0, 1), 1, false, false);
}
}
}
}
public static HkContactBodyData?CastShapeReturnContactBodyData(Vector3D to, HkShape shape, ref MatrixD transform, uint collisionFilter, float extraPenetration, bool ignoreConvexShape = true)
{
m_resultWorlds.Clear();
Clusters.Intersects(to, m_resultWorlds);
if (m_resultWorlds.Count == 0)
{
return(null);
}
var world = m_resultWorlds[0];
Matrix transformF = transform;
transformF.Translation = (Vector3)(transform.Translation - world.AABB.Center);
Vector3 toF = (Vector3)(to - world.AABB.Center);
HkContactBodyData?result = ((HkWorld)world.UserData).CastShapeReturnContactBodyData(toF, shape, ref transformF, collisionFilter, extraPenetration);
if (result == null)
{
return(null);
}
HkContactBodyData cpd = result.Value;
cpd.HitPosition += world.AABB.Center;
return(cpd);
}
// Moves and rotates player by specified vector and angles
public virtual void MoveAndRotate(Vector3 moveIndicator, Vector2 rotationIndicator, float rollIndicator)
{
// this method is overriden by MySpecatorCameraController, content of MySpectator::MoveAndRotate is not run
var oldPosition = Position;
moveIndicator *= m_speedModeLinear;
float amountOfMovement = 0.1f;
float amountOfRotation = 0.0025f * m_speedModeAngular;
Vector3D moveVector = (Vector3D)moveIndicator * amountOfMovement;
switch (SpectatorCameraMovement)
{
case MySpectatorCameraMovementEnum.UserControlled:
{
if (rollIndicator != 0)
{
Vector3D r, u;
float rollAmount = rollIndicator * m_speedModeLinear * 0.1f;
rollAmount = MathHelper.Clamp(rollAmount, -0.02f, 0.02f);
MyUtils.VectorPlaneRotation(m_orientation.Up, m_orientation.Right, out u, out r, rollAmount);
m_orientation.Right = r;
m_orientation.Up = u;
}
if (rotationIndicator.X != 0)
{
Vector3D u, f;
MyUtils.VectorPlaneRotation(m_orientation.Up, m_orientation.Forward, out u, out f, rotationIndicator.X * amountOfRotation);
m_orientation.Up = u;
m_orientation.Forward = f;
}
if (rotationIndicator.Y != 0)
{
Vector3D r, f;
MyUtils.VectorPlaneRotation(m_orientation.Right, m_orientation.Forward, out r, out f, -rotationIndicator.Y * amountOfRotation);
m_orientation.Right = r;
m_orientation.Forward = f;
}
Position += Vector3D.Transform(moveVector, m_orientation);
}
break;
case MySpectatorCameraMovementEnum.Orbit:
{
m_orbitY += rotationIndicator.Y * 0.01f;
m_orbitX += rotationIndicator.X * 0.01f;
var delta = Position - Target;
MatrixD invRot = Matrix.Invert(m_orientation);
var deltaInv = Vector3D.Transform(delta, invRot);
rotationIndicator *= 0.01f;
MatrixD rotationMatrix = MatrixD.CreateRotationX(m_orbitX) * MatrixD.CreateRotationY(m_orbitY) * MatrixD.CreateRotationZ(rollIndicator);
delta = Vector3D.Transform(deltaInv, rotationMatrix);
Position = Target + delta;
var strafe = (m_orientation.Right * moveVector.X) + (m_orientation.Up * moveVector.Y);
Target += strafe;
Position += strafe;
var forwardDelta = m_orientation.Forward * -moveVector.Z;
Position += forwardDelta;
m_orientation = rotationMatrix;
}
break;
}
}
public override void UpdateOnceBeforeFrame()
{
base.UpdateOnceBeforeFrame();
if (!Sync.IsServer)
{
if (this.m_entitiesToTake.Count > 0)
{
this.m_entitiesToTake.Clear();
}
}
else
{
if ((this.m_phantomConstraint == null) && this.ShouldHavePhantom)
{
this.CreatePhantomConstraint();
}
if (base.Enabled && base.IsWorking)
{
bool flag = false;
this.m_isCollecting = true;
foreach (MyFloatingObject obj2 in this.m_entitiesToTake)
{
this.GetInventory(0).TakeFloatingObject(obj2);
flag = true;
}
this.m_isCollecting = false;
if (flag)
{
MyParticleEffect effect;
Vector3D position = this.m_entitiesToTake.ElementAt <MyFloatingObject>(0).PositionComp.GetPosition();
MyParticlesManager.TryCreateParticleEffect("Smoke_Collector", MatrixD.CreateWorld(position, base.WorldMatrix.Down, base.WorldMatrix.Forward), out effect);
if (base.m_soundEmitter != null)
{
bool?nullable = null;
base.m_soundEmitter.PlaySound(base.m_actionSound, false, false, false, false, false, nullable);
}
EndpointId targetEndpoint = new EndpointId();
Sandbox.Engine.Multiplayer.MyMultiplayer.RaiseEvent <MyCollector, Vector3D>(this, x => new Action <Vector3D>(x.PlayActionSoundAndParticle), position, targetEndpoint);
}
}
}
}
MatrixD GetBlock2WorldTransform(IMyCubeBlock blk)
{
Matrix blk2grid; blk.Orientation.GetMatrix(out blk2grid); return(blk2grid * MatrixD.CreateTranslation(((Vector3D) new Vector3D(blk.Min + blk.Max)) / 2.0) * GetGrid2WorldTransform(blk.CubeGrid));
}
public void MoveLeftArm()
{
try
{
var subpart = npcCrewBlock.GetSubpart("NPC_Engineer_LeftArm");
var initialMatrix = subpart.PositionComp.LocalMatrix;
double rotationX = 0.001f;
double rotationY = 0.001f;
if (AnimationLoopLeftArm == 200)
{
AnimationLoopLeftArm = 0;
}
if (AnimationLoopLeftArm == 0)
{
TranslationTimeLeftArm = -1;
}
if (AnimationLoopLeftArm == 100)
{
TranslationTimeLeftArm = 1;
}
var rotationMatrix = MatrixD.CreateRotationX(rotationX * TranslationTimeLeftArm) * MatrixD.CreateRotationY(rotationY * TranslationTimeLeftArm);
var matrix = rotationMatrix * initialMatrix;
subpart.PositionComp.LocalMatrix = matrix;
AnimationLoopLeftArm++;
}
catch (Exception e)
{
MyVisualScriptLogicProvider.ShowNotificationToAll("Update Error" + e, 2500, "Red");
}
}
public IMyClipmapCell CreateCell(MyClipmapScaleEnum scaleGroup, MyCellCoord cellCoord, ref MatrixD worldMatrix)
{
var cell = new MyClipmapCellProxy(cellCoord, ref worldMatrix, m_massiveCenter, m_massiveRadius, m_renderFlags);
cell.SetVisibility(false);
cell.ScaleGroup = scaleGroup;
return(cell);
}
internal void UpdateWorldMatrix(ref MatrixD worldMatrix)
{
Base.UpdateWorldMatrix(ref worldMatrix, true);
}
public void DebugDraw(ref MatrixD worldMatrix)
{
}
public static ContainmentType ContainsRelativeBox(ref Vector3D hA, ref Vector3D hB, ref MatrixD mB)
{
Vector3D translation = mB.Translation;
double x = Math.Abs(translation.X);
double y = Math.Abs(translation.Y);
Vector3D vectord2 = new Vector3D(x, y, Math.Abs(translation.Z));
Vector3D right = mB.Right;
Vector3D up = mB.Up;
Vector3D backward = mB.Backward;
Vector3D vectord6 = (Vector3D)(right * hB.X);
Vector3D vectord7 = (Vector3D)(up * hB.Y);
Vector3D vectord8 = (Vector3D)(backward * hB.Z);
double num = (Math.Abs(vectord6.X) + Math.Abs(vectord7.X)) + Math.Abs(vectord8.X);
double num2 = (Math.Abs(vectord6.Y) + Math.Abs(vectord7.Y)) + Math.Abs(vectord8.Y);
double num3 = (Math.Abs(vectord6.Z) + Math.Abs(vectord7.Z)) + Math.Abs(vectord8.Z);
if ((((vectord2.X + num) <= hA.X) && ((vectord2.Y + num2) <= hA.Y)) && ((vectord2.Z + num3) <= hA.Z))
{
return(ContainmentType.Contains);
}
if (vectord2.X > (((hA.X + Math.Abs(vectord6.X)) + Math.Abs(vectord7.X)) + Math.Abs(vectord8.X)))
{
return(ContainmentType.Disjoint);
}
if (vectord2.Y > (((hA.Y + Math.Abs(vectord6.Y)) + Math.Abs(vectord7.Y)) + Math.Abs(vectord8.Y)))
{
return(ContainmentType.Disjoint);
}
if (vectord2.Z > (((hA.Z + Math.Abs(vectord6.Z)) + Math.Abs(vectord7.Z)) + Math.Abs(vectord8.Z)))
{
return(ContainmentType.Disjoint);
}
if (Math.Abs(Vector3.Dot((Vector3)translation, (Vector3)right)) > (((Math.Abs((double)(hA.X * right.X)) + Math.Abs((double)(hA.Y * right.Y))) + Math.Abs((double)(hA.Z * right.Z))) + hB.X))
{
return(ContainmentType.Disjoint);
}
if (Math.Abs(Vector3.Dot((Vector3)translation, (Vector3)up)) > (((Math.Abs((double)(hA.X * up.X)) + Math.Abs((double)(hA.Y * up.Y))) + Math.Abs((double)(hA.Z * up.Z))) + hB.Y))
{
return(ContainmentType.Disjoint);
}
if (Math.Abs(Vector3.Dot((Vector3)translation, (Vector3)backward)) > (((Math.Abs((double)(hA.X * backward.X)) + Math.Abs((double)(hA.Y * backward.Y))) + Math.Abs((double)(hA.Z * backward.Z))) + hB.Z))
{
return(ContainmentType.Disjoint);
}
Vector3 vector = (Vector3) new Vector3D(0.0, -right.Z, right.Y);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.Y * vector.Y)) + Math.Abs((double)(hA.Z * vector.Z))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord7))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord8))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(0.0, -up.Z, up.Y);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.Y * vector.Y)) + Math.Abs((double)(hA.Z * vector.Z))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord8))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord6))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(0.0, -backward.Z, backward.Y);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.Y * vector.Y)) + Math.Abs((double)(hA.Z * vector.Z))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord6))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord7))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(right.Z, 0.0, -right.X);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.Z * vector.Z)) + Math.Abs((double)(hA.X * vector.X))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord7))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord8))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(up.Z, 0.0, -up.X);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.Z * vector.Z)) + Math.Abs((double)(hA.X * vector.X))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord8))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord6))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(backward.Z, 0.0, -backward.X);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.Z * vector.Z)) + Math.Abs((double)(hA.X * vector.X))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord6))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord7))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(-right.Y, right.X, 0.0);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.X * vector.X)) + Math.Abs((double)(hA.Y * vector.Y))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord7))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord8))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(-up.Y, up.X, 0.0);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.X * vector.X)) + Math.Abs((double)(hA.Y * vector.Y))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord8))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord6))))
{
return(ContainmentType.Disjoint);
}
vector = (Vector3) new Vector3D(-backward.Y, backward.X, 0.0);
if (Math.Abs(Vector3.Dot((Vector3)translation, vector)) > (((Math.Abs((double)(hA.X * vector.X)) + Math.Abs((double)(hA.Y * vector.Y))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord6))) + Math.Abs(Vector3.Dot(vector, (Vector3)vectord7))))
{
return(ContainmentType.Disjoint);
}
return(ContainmentType.Intersects);
}
public double?Intersects(ref RayD ray)
{
MatrixD xd = Matrix.CreateFromQuaternion(this.Orientation);
Vector3D vectord = this.Center - ray.Position;
double minValue = double.MinValue;
double maxValue = double.MaxValue;
double num3 = Vector3D.Dot(xd.Right, vectord);
double num4 = Vector3D.Dot(xd.Right, ray.Direction);
if ((num4 >= -9.9999996826552254E-21) && (num4 <= 9.9999996826552254E-21))
{
if (((-num3 - this.HalfExtent.X) > 0.0) || ((-num3 + this.HalfExtent.X) < 0.0))
{
return(null);
}
}
else
{
double num5 = (num3 - this.HalfExtent.X) / num4;
double num6 = (num3 + this.HalfExtent.X) / num4;
if (num5 > num6)
{
double num7 = num5;
num5 = num6;
num6 = num7;
}
if (num5 > minValue)
{
minValue = num5;
}
if (num6 < maxValue)
{
maxValue = num6;
}
if ((maxValue < 0.0) || (minValue > maxValue))
{
return(null);
}
}
num3 = Vector3.Dot((Vector3)xd.Up, (Vector3)vectord);
num4 = Vector3.Dot((Vector3)xd.Up, (Vector3)ray.Direction);
if ((num4 >= -9.9999996826552254E-21) && (num4 <= 9.9999996826552254E-21))
{
if (((-num3 - this.HalfExtent.Y) > 0.0) || ((-num3 + this.HalfExtent.Y) < 0.0))
{
return(null);
}
}
else
{
double num8 = (num3 - this.HalfExtent.Y) / num4;
double num9 = (num3 + this.HalfExtent.Y) / num4;
if (num8 > num9)
{
double num10 = num8;
num8 = num9;
num9 = num10;
}
if (num8 > minValue)
{
minValue = num8;
}
if (num9 < maxValue)
{
maxValue = num9;
}
if ((maxValue < 0.0) || (minValue > maxValue))
{
return(null);
}
}
num3 = Vector3.Dot((Vector3)xd.Forward, (Vector3)vectord);
num4 = Vector3.Dot((Vector3)xd.Forward, (Vector3)ray.Direction);
if ((num4 >= -9.9999996826552254E-21) && (num4 <= 9.9999996826552254E-21))
{
if (((-num3 - this.HalfExtent.Z) > 0.0) || ((-num3 + this.HalfExtent.Z) < 0.0))
{
return(null);
}
}
else
{
double num11 = (num3 - this.HalfExtent.Z) / num4;
double num12 = (num3 + this.HalfExtent.Z) / num4;
if (num11 > num12)
{
double num13 = num11;
num11 = num12;
num12 = num13;
}
if (num11 > minValue)
{
minValue = num11;
}
if (num12 < maxValue)
{
maxValue = num12;
}
if ((maxValue < 0.0) || (minValue > maxValue))
{
return(null);
}
}
return(new double?(minValue));
}
public void AbsorbEmp()
{
if (Vector3D.DistanceSquared(DetectionCenter, Session.Instance.EmpWork.EpiCenter) <= Session.Instance.EmpWork.RangeCapSqr)
{
var empResistenceRatio = 1f;
const long AttackerId = 0L;
var energyResistenceRatio = DsState.State.ModulateKinetic;
var epiCenter = Session.Instance.EmpWork.EpiCenter;
var rangeCap = Session.Instance.EmpWork.RangeCap;
var empDirYield = Session.Instance.EmpWork.DirYield;
if (DsState.State.EmpProtection)
{
if (energyResistenceRatio < 0.4)
{
energyResistenceRatio = 0.4f;
}
empResistenceRatio = 0.1f;
}
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - Start] ShieldOwner:{MyGrid.DebugName} - Yield:{warHeadYield} - StackCount:{stackCount} - ProtectionRatio:{energyResistenceRatio * empResistenceRatio} - epiCenter:{epiCenter}");
var line = new LineD(epiCenter, SOriBBoxD.Center);
var testDir = Vector3D.Normalize(line.From - line.To);
var ray = new RayD(line.From, -testDir);
var ellipsoid = CustomCollision.IntersectEllipsoid(DetectMatrixOutsideInv, DetectionMatrix, ray);
if (!ellipsoid.HasValue)
{
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - Ellipsoid null hit] ShieldOwner:{MyGrid.DebugName} - Yield:{warHeadYield} - StackCount:{stackCount} - ProtectionRatio:{energyResistenceRatio * empResistenceRatio} - epiCenter:{epiCenter}");
return;
}
var impactPos = line.From + (testDir * -ellipsoid.Value);
IHitInfo hitInfo;
MyAPIGateway.Physics.CastRay(epiCenter, impactPos, out hitInfo, CollisionLayers.DefaultCollisionLayer);
if (hitInfo != null)
{
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - occluded] ShieldOwner:{MyGrid.DebugName} - by {((MyEntity)hitInfo.HitEntity).DebugName}");
return;
}
var gridLocalMatrix = MyGrid.PositionComp.LocalMatrix;
var worldDirection = impactPos - gridLocalMatrix.Translation;
var localPosition = Vector3D.TransformNormal(worldDirection, MatrixD.Transpose(gridLocalMatrix));
var hitFaceSurfaceArea = UtilsStatic.GetIntersectingSurfaceArea(ShieldShapeMatrix, localPosition);
var invSqrDist = UtilsStatic.InverseSqrDist(epiCenter, impactPos, rangeCap);
var damageScaler = invSqrDist * hitFaceSurfaceArea;
if (invSqrDist <= 0)
{
//if (Session.Enforced.Debug >= 2) Log.Line($"[EmpBlastShield - Range] ShieldOwner:{MyGrid.DebugName} - insqrDist was 0");
return;
}
var targetDamage = (float)(((empDirYield * damageScaler) * energyResistenceRatio) * empResistenceRatio);
if (targetDamage >= DsState.State.Charge * ConvToHp)
{
_empOverLoad = true;
}
//if (Session.Enforced.Debug >= 2) Log.Line($"-----------------------] epiDist:{Vector3D.Distance(epiCenter, impactPos)} - iSqrDist:{invSqrDist} - RangeCap:{rangeCap} - SurfaceA:{hitFaceSurfaceArea}({_ellipsoidSurfaceArea * 0.5}) - dirYield:{empDirYield} - damageScaler:{damageScaler} - Damage:{targetDamage}(toOver:{(targetDamage / (DsState.State.Charge * ConvToHp))})");
if (_isServer && _mpActive)
{
AddEmpBlastHit(AttackerId, targetDamage, Session.Instance.MPEMP, impactPos);
}
EnergyHit = HitType.Energy;
WorldImpactPosition = epiCenter;
Absorb += targetDamage;
}
}
// from http://forums.keenswh.com/threads/library-grid-to-world-coordinates.7284828/
MatrixD GetGrid2WorldTransform(IMyCubeGrid grid)
{
Vector3D origin = grid.GridIntegerToWorld(new Vector3I(0, 0, 0)); Vector3D plusY = grid.GridIntegerToWorld(new Vector3I(0, 1, 0)) - origin; Vector3D plusZ = grid.GridIntegerToWorld(new Vector3I(0, 0, 1)) - origin; return(MatrixD.CreateScale(grid.GridSize) * MatrixD.CreateWorld(origin, -plusZ, plusY));
}
public bool AreAllAabbCornersInside(ref MatrixD aabbWorldTransform, BoundingBoxD aabb)
{
return(CountCornersInside(ref aabbWorldTransform, ref aabb) == 8);
}
public abstract void OnWorldPositionChanged(ref MatrixD worldMatrix);
/// <summary>
/// Updates the world matrix (change caused by parent)
/// </summary>
public virtual void UpdateWorldMatrix(ref MatrixD parentWorldMatrix, object source = null)
{
PositionComp.UpdateWorldMatrix(ref parentWorldMatrix, source);
}
public void MoveAndRotate(ref Vector3 moveIndicator, ref Vector2 rotationIndicator, float roll, bool canRotate)
{
var characterPhysics = Character.Physics;
var characterProxy = characterPhysics.CharacterProxy;
ThrustComp.ControlThrust = Vector3.Zero;
const MyCharacterMovementEnum newMovementState = MyCharacterMovementEnum.Flying;
Character.SwitchAnimation(newMovementState);
Character.SetCurrentMovementState(newMovementState);
bool wantsFlyDown = (Character.MovementFlags & MyCharacterMovementFlags.FlyDown) == MyCharacterMovementFlags.FlyDown;
bool wantsFlyUp = (Character.MovementFlags & MyCharacterMovementFlags.FlyUp) == MyCharacterMovementFlags.FlyUp;
IsFlying = moveIndicator.LengthSquared() != 0;
var proxyState = characterProxy != null?characterProxy.GetState() : 0;
if ((proxyState == HkCharacterStateType.HK_CHARACTER_IN_AIR || (int)proxyState == MyCharacter.HK_CHARACTER_FLYING))
{
Character.PlayCharacterAnimation("Jetpack", MyBlendOption.Immediate, MyFrameOption.Loop, 0.2f);
Character.CanJump = true;
}
MatrixD WorldMatrix = Character.WorldMatrix;
if (canRotate)
{
MatrixD rotationXMatrix = MatrixD.Identity;
MatrixD rotationYMatrix = MatrixD.Identity;
MatrixD rotationZMatrix = MatrixD.Identity;
if (Math.Abs(rotationIndicator.X) > float.Epsilon)
{
if (Character.Definition.VerticalPositionFlyingOnly)
{
Character.SetHeadLocalXAngle(Character.HeadLocalXAngle - rotationIndicator.X * Character.RotationSpeed);
}
else
{
rotationXMatrix = MatrixD.CreateFromAxisAngle(WorldMatrix.Right, -rotationIndicator.X * Character.RotationSpeed * ROTATION_FACTOR);
}
}
if (Math.Abs(rotationIndicator.Y) > float.Epsilon)
{
rotationYMatrix = MatrixD.CreateFromAxisAngle(WorldMatrix.Up, -rotationIndicator.Y * Character.RotationSpeed * ROTATION_FACTOR);
}
if (!Character.Definition.VerticalPositionFlyingOnly)
{
if (Math.Abs(roll) > float.Epsilon)
{
rotationZMatrix = MatrixD.CreateFromAxisAngle(WorldMatrix.Forward, roll * ROTATION_FACTOR);
}
}
// Rotation center is at the middle of the character, who is 2 meters high.
float rotationHeight = Character.ModelCollision.BoundingBoxSizeHalf.Y;
MatrixD physicsMatrix = Character.Physics.GetWorldMatrix();
Vector3D translation = physicsMatrix.Translation + (Vector3D)(WorldMatrix.Up * rotationHeight);
// Compute rotation
MatrixD fullRotation = rotationXMatrix * rotationYMatrix * rotationZMatrix;
MatrixD rotatedMatrix = WorldMatrix.GetOrientation();
rotatedMatrix = rotatedMatrix * fullRotation;
rotatedMatrix.Translation = translation - (Vector3D)(rotatedMatrix.Up * rotationHeight);
// Update game character
Character.WorldMatrix = rotatedMatrix;
// Update physics character
/*rotatedMatrix.Translation = physicsMatrix.Translation;
* Character.PositionComp.SetWorldMatrix(rotatedMatrix, Character.Physics);*/
Character.ClearShapeContactPoints();
}
Vector3 moveDirection = moveIndicator;
if (Character.Definition.VerticalPositionFlyingOnly)
{
float angleSign = Math.Sign(Character.HeadLocalXAngle);
double headAngle = Math.Abs(MathHelper.ToRadians(Character.HeadLocalXAngle));
double exponent = 1.95;
double smoothedAngle = Math.Pow(headAngle, exponent);
smoothedAngle *= headAngle / Math.Pow(MathHelper.ToRadians(MyCharacter.MAX_HEAD_LOCAL_X_ANGLE), exponent);
MatrixD rotationMatrix = MatrixD.CreateFromAxisAngle(Vector3D.Right, angleSign * smoothedAngle);
moveDirection = Vector3D.Transform(moveDirection, rotationMatrix);
}
if (!Vector3.IsZero(moveDirection))
{
moveDirection.Normalize();
}
ThrustComp.ControlThrust += moveDirection * ForceMagnitude;
}
public bool TryFindClearArea(GridOrientation orientation)
{
Vector3D?result = MyAPIGateway.Entities.FindFreePlace(worldVolume.Center, (float)worldVolume.Radius);
if (!result.HasValue || Vector3D.DistanceSquared(worldVolume.Center, result.Value) > Constants.maxNewDist2)
{
return(false);
}
MatrixD mRef = reference.WorldMatrix;
Vector3D newPosRel = Vector3D.TransformNormal(result.Value - mRef.Translation, MatrixD.Transpose(mRef));
orientation.Translate(newPosRel - relativeCenter);
return(true);
}
public override bool Draw()
{
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyGuiScreenGamePlay::Draw");
//VRageRender.MyRenderProxy.DebugDrawSphere(
// new Vector3D(-60.7171351205786, 34.002275028352, 78.131769977211),
// 0.02f,
// Vector3.One,
// 1, true, true);
//VRageRender.MyRenderProxy.DebugDrawSphere(
// new Vector3(-13.36391f, -1.974166f, -35.97278f),
// 0.2f,
// Vector3.One,
// 1, true, true);
//Vector3 target = new Vector3(-83.87779f, -62.17611f, -127.3294f);
//Vector3 pos = new Vector3(-87.42791f, -57.17604f, -139.3147f);
//VRageRender.MyRenderProxy.DebugDrawLine3D(
// target, pos, Color.Green, Color.Yellow, false);
//if (MyCubeBuilder.Static.CurrentGrid != null)
//{
// Matrix m = MyCubeBuilder.Static.CurrentGrid.WorldMatrix;
// m.Translation = MySession.ControlledObject.WorldMatrix.Translation;
// VRageRender.MyRenderProxy.DebugDrawAxis(m, 1, false);
//}
MatrixD viewMatrix = MySession.Static.CameraController.GetViewMatrix();
if (viewMatrix.IsValid() && viewMatrix != MatrixD.Zero)
{
MySector.MainCamera.SetViewMatrix(viewMatrix);
}
else
{
Debug.Fail("Camera matrix is invalid or zero!");
}
VRageRender.MyRenderProxy.UpdateGodRaysSettings(
MySector.GodRaysProperties.Enabled,
MySector.GodRaysProperties.Density,
MySector.GodRaysProperties.Weight,
MySector.GodRaysProperties.Decay,
MySector.GodRaysProperties.Exposition,
false
);
VRageRender.MyRenderProxy.UpdateAntiAliasSettings(
MyPostProcessAntiAlias.Enabled
);
VRageRender.MyRenderProxy.UpdateVignettingSettings(
MyPostProcessVignetting.Enabled,
MyPostProcessVignetting.VignettingPower
);
VRageRender.MyRenderProxy.UpdateColorMappingSettings(
MyPostProcessColorMapping.Enabled
);
VRageRender.MyRenderProxy.UpdateChromaticAberrationSettings(
MyPostProcessChromaticAberration.Enabled,
MyPostProcessChromaticAberration.DistortionLens,
MyPostProcessChromaticAberration.DistortionCubic,
new Vector3(MyPostProcessChromaticAberration.DistortionWeightRed,
MyPostProcessChromaticAberration.DistortionWeightGreen,
MyPostProcessChromaticAberration.DistortionWeightBlue)
);
VRageRender.MyRenderProxy.UpdateContrastSettings(
MyPostProcessContrast.Enabled,
MyPostProcessContrast.Contrast,
MyPostProcessContrast.Hue,
MyPostProcessContrast.Saturation
);
VRageRender.MyRenderFogSettings fogSettings = new VRageRender.MyRenderFogSettings()
{
Enabled = MySector.FogProperties.EnableFog,
FogNear = MySector.FogProperties.FogNear,
FogFar = MySector.FogProperties.FogFar,
FogMultiplier = MySector.FogProperties.FogMultiplier,
FogBacklightMultiplier = MySector.FogProperties.FogBacklightMultiplier,
FogColor = MySector.FogProperties.FogColor,
FogDensity = MySector.FogProperties.FogDensity / 100.0f
};
VRageRender.MyRenderProxy.UpdateFogSettings(ref fogSettings);
VRageRender.MyRenderProxy.UpdateHDRSettings(
MyPostProcessHDR.DebugHDRChecked,
MyPostProcessHDR.Exposure,
MyPostProcessHDR.Threshold,
MyPostProcessHDR.BloomIntensity,
MyPostProcessHDR.BloomIntensityBackground,
MyPostProcessHDR.VerticalBlurAmount,
MyPostProcessHDR.HorizontalBlurAmount,
(int)MyPostProcessHDR.NumberOfBlurPasses
);
VRageRender.MyRenderProxy.UpdateSSAOSettings(
MyPostProcessVolumetricSSAO2.Enabled,
MyPostProcessVolumetricSSAO2.ShowOnlySSAO,
MyPostProcessVolumetricSSAO2.UseBlur,
MyPostProcessVolumetricSSAO2.MinRadius,
MyPostProcessVolumetricSSAO2.MaxRadius,
MyPostProcessVolumetricSSAO2.RadiusGrowZScale,
MyPostProcessVolumetricSSAO2.CameraZFarScale * MySector.MainCamera.FarPlaneDistance,
MyPostProcessVolumetricSSAO2.Bias,
MyPostProcessVolumetricSSAO2.Falloff,
MyPostProcessVolumetricSSAO2.NormValue,
MyPostProcessVolumetricSSAO2.Contrast
);
Vector3 sunDirection = -MySector.SunProperties.SunDirectionNormalized;
if (MySession.Static.Settings.EnableSunRotation && !MyFakes.DEVELOPMENT_PRESET)
{
sunDirection = -MySector.SunProperties.BaseSunDirectionNormalized;
float angle = 2.0f * MathHelper.Pi * (float)(MySession.Static.ElapsedGameTime.TotalMinutes / MySession.Static.Settings.SunRotationIntervalMinutes);
float originalSunCosAngle = Math.Abs(Vector3.Dot(sunDirection, Vector3.Up));
Vector3 sunRotationAxis;
if (originalSunCosAngle > 0.95f)
{
// original sun is too close to the poles
sunRotationAxis = Vector3.Cross(Vector3.Cross(sunDirection, Vector3.Left), sunDirection);
}
else
{
sunRotationAxis = Vector3.Cross(Vector3.Cross(sunDirection, Vector3.Up), sunDirection);
}
sunDirection = Vector3.Transform(sunDirection, Matrix.CreateFromAxisAngle(sunRotationAxis, angle));
sunDirection.Normalize();
MySector.SunProperties.SunDirectionNormalized = -sunDirection;
}
MyRenderProxy.Settings.FarShadowDistanceOverride = -1.0f;
Vector3D cameraPos = MySector.MainCamera.WorldMatrix.Translation;
VRageRender.MyRenderProxy.UpdateRenderEnvironment(
sunDirection,
MySector.SunProperties.SunDiffuse,
MySector.SunProperties.BackSunDiffuse,
MySector.SunProperties.SunSpecular,
MySector.SunProperties.SunIntensity,
MySector.SunProperties.BackSunIntensity,
true,
MySector.SunProperties.AmbientColor,
MySector.SunProperties.AmbientMultiplier,
MySector.SunProperties.EnvironmentAmbientIntensity,
MySector.SunProperties.BackgroundColor,
MySector.BackgroundTexture,
MySector.BackgroundOrientation,
MySector.SunProperties.SunSizeMultiplier,
MySector.DistanceToSun,
MySector.SunProperties.SunMaterial,
MySector.DayTime,
MySector.ResetEyeAdaptation,
MyFakes.ENABLE_SUN_BILLBOARD
);
MySector.ResetEyeAdaptation = false;
VRageRender.MyRenderProxy.UpdateEnvironmentMap();
VRageRender.MyRenderProxy.SwitchProsprocessSettings(VRageRender.MyPostprocessSettings.LerpExposure(ref MyPostprocessSettingsWrapper.Settings, ref MyPostprocessSettingsWrapper.Settings, 0));
VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("Main render");
VRageRender.MyRenderProxy.Draw3DScene();
using (Stats.Generic.Measure("GamePrepareDraw"))
{
if (MySession.Static != null)
{
MySession.Static.Draw();
}
}
VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("Draw HUD");
if (MySession.ControlledEntity != null && MySession.Static.CameraController != null)
{
MySession.ControlledEntity.DrawHud(MySession.Static.CameraController, MySession.LocalPlayerId);
}
VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("FillDebugScreen");
//FillDebugScreen();
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
if (MySandboxGame.IsPaused && !MyHud.MinimalHud)
{
DrawPauseIndicator();
}
return(true);
}
public unsafe BoundingBoxD Transform(MatrixD worldMatrix)
{
return(Transform(ref worldMatrix));
}
public void Update(TimeSpan timestamp, UpdateFrequency updateFlags)
{
if (runs % 240 == 0)
{
statusBuilder.Clear();
foreach (var tube in LandpedoTubes)
{
tube.CheckLandpedo();
// statusBuilder.AppendLine(tube.GetStatus());
}
}
if (runs % 10 == 0)
{
statusBuilder.Clear();
var targets = IntelProvider.GetFleetIntelligences(timestamp);
var canonicalTime = IntelProvider.CanonicalTimeDiff + timestamp;
DeadLandpedos.Clear();
foreach (var landpedo in Landpedos)
{
statusBuilder.AppendLine("LANDPEDO===");
if (landpedo.Fired)
{
landpedo.DeadCount--;
}
if (!landpedo.IsOK())
{
DeadLandpedos.Add(landpedo);
continue;
}
landpedo.runs++;
var landpedoPosition = landpedo.Controller.WorldMatrix.Translation;
var landpedoVelocity = landpedo.Controller.GetShipVelocities().LinearVelocity;
var gravDir = landpedo.Controller.GetNaturalGravity();
var gravStr = gravDir.Normalize();
var planarVelocity = landpedoVelocity - VectorHelpers.VectorProjection(landpedoVelocity, gravDir);
if (landpedo.TargetID != -1)
{
var key = MyTuple.Create(IntelItemType.Enemy, landpedo.TargetID);
if (targets.ContainsKey(key))
{
var target = targets[key];
landpedo.TargetPosition = target.GetPositionFromCanonicalTime(canonicalTime);
landpedo.TargetVelocity = target.GetVelocity();
}
}
statusBuilder.AppendLine(landpedo.TargetPosition.ToString());
if (landpedo.TargetPosition != Vector3D.Zero)
{
var relativeVector = landpedo.TargetPosition - landpedoPosition;
var planarVector = relativeVector - VectorHelpers.VectorProjection(relativeVector, gravDir);
var targetPoint = AttackHelpers.GetAttackPoint(landpedo.TargetVelocity, landpedo.TargetPosition - landpedoPosition, landpedo.lastSpeed);
if (targetPoint == Vector3D.Zero)
{
targetPoint = landpedo.TargetPosition - landpedoPosition;
}
var targetPointDist = targetPoint.Length();
var planarDist = planarVector.Length();
var velocity = landpedo.Controller.GetShipVelocities().LinearVelocity;
var verticalVelocity = VectorHelpers.VectorProjection(velocity, gravDir);
var planarLeft = landpedo.Controller.WorldMatrix.Left - VectorHelpers.VectorProjection(landpedo.Controller.WorldMatrix.Left, gravDir);
planarLeft.Normalize();
var planarForward = landpedo.Controller.WorldMatrix.Forward - VectorHelpers.VectorProjection(landpedo.Controller.WorldMatrix.Forward, gravDir);
planarForward.Normalize();
double altitude;
landpedo.Controller.TryGetPlanetElevation(MyPlanetElevation.Surface, out altitude);
if (targetPointDist > 350 || landpedo.Launchers.Count == 0)
{
landpedo.desiredAltitude = planarVector.Length() > 200 ? 10 : 50;
planarVector.Normalize();
MatrixD orientationMatrix = MatrixD.Identity;
orientationMatrix.Translation = landpedo.Controller.WorldMatrix.Translation;
orientationMatrix.Up = -gravDir;
orientationMatrix.Left = planarLeft;
orientationMatrix.Forward = planarForward;
var spinAngle = VectorHelpers.VectorAngleBetween(planarForward, planarVector) * Math.Sign(-planarLeft.Dot(planarVector));
// var planarVelocity = velocity - verticalVelocity;
// var velocityAdjust = planarVelocity - VectorHelpers.VectorProjection(velocity, planarVector);
// velocityAdjust.Normalize();
// planarVector -= velocityAdjust;
// var MoveIndicator = Vector3D.TransformNormal(planarVector, MatrixD.Transpose(orientationMatrix));
var rangeVector = planarVector;
var waypointVector = rangeVector;
var distTargetSq = rangeVector.LengthSquared();
var targetPlanarVelocity = landpedo.TargetVelocity - VectorHelpers.VectorProjection(landpedo.TargetVelocity, gravDir);
Vector3D velocityVector = targetPlanarVelocity - planarVelocity;
var speed = planarVelocity.Length();
Vector3D AccelerationVector;
double alignment = planarVelocity.Dot(ref waypointVector);
if (alignment > 0)
{
Vector3D rangeDivSqVector = waypointVector / waypointVector.LengthSquared();
Vector3D compensateVector = velocityVector - (velocityVector.Dot(ref waypointVector) * rangeDivSqVector);
Vector3D targetANVector;
var targetAccel = (landpedo.lastTargetVelocity - targetPlanarVelocity) * 0.16667;
targetANVector = targetAccel - (targetAccel.Dot(ref waypointVector) * rangeDivSqVector);
bool accelerating = speed > landpedo.lastSpeed + 1;
if (accelerating)
{
AccelerationVector = planarVelocity + (10 * 1.5 * (compensateVector + (0.5 * targetANVector)));
}
else
{
AccelerationVector = planarVelocity + (10 * (compensateVector + (0.5 * targetANVector)));
}
}
// going backwards or perpendicular
else
{
AccelerationVector = (waypointVector * 0.1) + velocityVector;
}
landpedo.lastTargetVelocity = landpedo.TargetVelocity;
landpedo.lastSpeed = speed;
var MoveIndicator = Vector3D.TransformNormal(AccelerationVector, MatrixD.Transpose(orientationMatrix));
MoveIndicator.Y = 0;
MoveIndicator.Normalize();
statusBuilder.AppendLine(MoveIndicator.ToString());
landpedo.Drive.MoveIndicators = MoveIndicator;
landpedo.Drive.RotationIndicators = new Vector3(0, spinAngle, 0);
landpedo.Drive.Drive();
if (verticalVelocity.Length() > 10 && verticalVelocity.Dot(gravDir) > 0)
{
landpedo.Drive.maxFlightPitch = 20;
landpedo.Drive.maxFlightRoll = 20;
}
else
{
landpedo.Drive.maxFlightPitch = 60;
landpedo.Drive.maxFlightRoll = 60;
}
if (targetPointDist < 1000)
{
landpedo.Drive.maxFlightPitch = 20;
}
}
else if (landpedo.TargetID != -1)
{
var key = MyTuple.Create(IntelItemType.Enemy, landpedo.TargetID);
if (!targets.ContainsKey(key))
{
return;
}
var target = targets[key];
var posDiff = target.GetPositionFromCanonicalTime(canonicalTime) - landpedoPosition;
var avgVel = 400 * Math.Sqrt(posDiff.Length() / 400);
var relativeAttackPoint = AttackHelpers.GetAttackPoint(landpedo.TargetVelocity - velocity, posDiff, avgVel);
targetPointDist = relativeAttackPoint.Length();
double yawAngle, pitchAngle;
TrigHelpers.GetRotationAngles(relativeAttackPoint, landpedo.Controller.WorldMatrix.Forward, landpedo.Controller.WorldMatrix.Left, landpedo.Controller.WorldMatrix.Up, out yawAngle, out pitchAngle);
TrigHelpers.ApplyGyroOverride(landpedo.PitchPID.Control(pitchAngle), landpedo.YawPID.Control(yawAngle), 0, landpedo.Gyros, landpedo.Controller.WorldMatrix);
if ((targetPointDist < 125 || landpedo.minDist < planarDist))
{
foreach (var weapon in landpedo.Launchers)
{
weapon.Enabled = true;
}
landpedo.Fired = true;
}
landpedo.minDist = Math.Min(landpedo.minDist, planarDist);
}
var verticalThrustRatio = TrigHelpers.FastCos(VectorHelpers.VectorAngleBetween(landpedo.Controller.WorldMatrix.Down, gravDir));
var desiredThrust = ((landpedo.desiredAltitude - altitude) + verticalVelocity.LengthSquared() * 0.1 + gravStr) * landpedo.Controller.CalculateShipMass().PhysicalMass / verticalThrustRatio;
var individualThrust = desiredThrust / landpedo.Thrusters.Count();
if (individualThrust <= 0)
{
individualThrust = 0.001;
}
foreach (var thruster in landpedo.Thrusters)
{
thruster.Enabled = ((verticalVelocity.Length() > 20 && verticalVelocity.Dot(gravDir) < 0) || ((verticalVelocity.Length() > 2 && verticalVelocity.Dot(gravDir) < 0) && targetPointDist < 1000)) ? false : true;
thruster.ThrustOverride = (float)individualThrust;
}
statusBuilder.AppendLine($"{landpedo.Drive.thrustController.CalculateThrustToHover()}");
statusBuilder.AppendLine($"{landpedo.Drive.thrustController.upThrusters.Count} : {landpedo.Drive.thrustController.downThrusters.Count}");
}
}
foreach (var landpedo in DeadLandpedos)
{
Landpedos.Remove(landpedo);
}
}
runs++;
}
public MatrixD GetViewMatrix()
{
return(MatrixD.Invert(MatrixD.CreateWorld(Position, m_orientation.Forward, m_orientation.Up)));
}
private Vector3D LocalNavmeshPositionToWorldPosition(MyOrientedBoundingBoxD obb, Vector3D position, Vector3D center, Vector3D heightIncrease)
{
MatrixD matrix = this.LocalNavmeshPositionToWorldPositionTransform(obb, center);
return((Vector3D.Transform(position, matrix) + this.Center) + heightIncrease);
}
private void CompileTurret(WeaponComponent comp, bool reset = false)
{
var c = 0;
foreach (var m in Structure.WeaponSystems)
{
MyEntity muzzlePart = null;
if (Parts.NameToEntity.TryGetValue(m.Key.String, out muzzlePart) || m.Value.DesignatorWeapon)
{
var azimuthPartName = comp.BaseType == Turret?string.IsNullOrEmpty(m.Value.AzimuthPartName.String) ? "MissileTurretBase1" : m.Value.AzimuthPartName.String : m.Value.AzimuthPartName.String;
var elevationPartName = comp.BaseType == Turret?string.IsNullOrEmpty(m.Value.ElevationPartName.String) ? "MissileTurretBarrels" : m.Value.ElevationPartName.String : m.Value.ElevationPartName.String;
var weapon = Weapons[c];
var muzzlePartName = m.Key.String;
if (m.Value.DesignatorWeapon)
{
muzzlePart = weapon.ElevationPart.Entity;
muzzlePartName = elevationPartName;
}
weapon.MuzzlePart.Entity = muzzlePart;
weapon.HeatingParts = new List <MyEntity> {
weapon.MuzzlePart.Entity
};
if (muzzlePartName != "None")
{
var muzzlePartLocation = comp.Session.GetPartLocation("subpart_" + muzzlePartName, muzzlePart.Parent.Model);
var muzzlePartPosTo = MatrixD.CreateTranslation(-muzzlePartLocation);
var muzzlePartPosFrom = MatrixD.CreateTranslation(muzzlePartLocation);
weapon.MuzzlePart.ToTransformation = muzzlePartPosTo;
weapon.MuzzlePart.FromTransformation = muzzlePartPosFrom;
weapon.MuzzlePart.PartLocalLocation = muzzlePartLocation;
weapon.MuzzlePart.Entity.NeedsWorldMatrix = true;
}
if (weapon.AiOnlyWeapon)
{
var azimuthPart = weapon.AzimuthPart.Entity;
var elevationPart = weapon.ElevationPart.Entity;
if (azimuthPart != null && azimuthPartName != "None" && weapon.System.TurretMovement != WeaponSystem.TurretType.ElevationOnly)
{
var azimuthPartLocation = comp.Session.GetPartLocation("subpart_" + azimuthPartName, azimuthPart.Parent.Model);
var partDummy = comp.Session.GetPartDummy("subpart_" + azimuthPartName, azimuthPart.Parent.Model);
if (partDummy == null)
{
PlatformCrash(comp, true, true, $"partDummy null: name:{azimuthPartName} - azimuthPartParentNull:{azimuthPart.Parent == null}, I am crashing now Dave.");
return;
}
var azPartPosTo = MatrixD.CreateTranslation(-azimuthPartLocation);
var azPrtPosFrom = MatrixD.CreateTranslation(azimuthPartLocation);
var fullStepAzRotation = azPartPosTo * MatrixD.CreateFromAxisAngle(partDummy.Matrix.Up, -m.Value.AzStep) * azPrtPosFrom;
var rFullStepAzRotation = MatrixD.Invert(fullStepAzRotation);
weapon.AzimuthPart.RotationAxis = partDummy.Matrix.Up;
weapon.AzimuthPart.ToTransformation = azPartPosTo;
weapon.AzimuthPart.FromTransformation = azPrtPosFrom;
weapon.AzimuthPart.FullRotationStep = fullStepAzRotation;
weapon.AzimuthPart.RevFullRotationStep = rFullStepAzRotation;
weapon.AzimuthPart.PartLocalLocation = azimuthPartLocation;
weapon.AzimuthPart.OriginalPosition = azimuthPart.PositionComp.LocalMatrixRef;
//weapon.AzimuthPart.Entity.NeedsWorldMatrix = true;
}
else
{
weapon.AzimuthPart.RotationAxis = Vector3.Zero;
weapon.AzimuthPart.ToTransformation = MatrixD.Zero;
weapon.AzimuthPart.FromTransformation = MatrixD.Zero;
weapon.AzimuthPart.FullRotationStep = MatrixD.Zero;
weapon.AzimuthPart.RevFullRotationStep = MatrixD.Zero;
weapon.AzimuthPart.PartLocalLocation = Vector3.Zero;
weapon.AzimuthPart.OriginalPosition = MatrixD.Zero;
//weapon.AzimuthPart.Entity.NeedsWorldMatrix = true;
}
if (elevationPart != null && elevationPartName != "None" && weapon.System.TurretMovement != WeaponSystem.TurretType.AzimuthOnly)
{
var elevationPartLocation = comp.Session.GetPartLocation("subpart_" + elevationPartName, elevationPart.Parent.Model);
var partDummy = comp.Session.GetPartDummy("subpart_" + elevationPartName, elevationPart.Parent.Model);
if (partDummy == null)
{
PlatformCrash(comp, true, true, $"partDummy null: name:{elevationPartName} - azimuthPartParentNull:{elevationPart.Parent == null}, I am crashing now Dave.");
return;
}
var elPartPosTo = MatrixD.CreateTranslation(-elevationPartLocation);
var elPartPosFrom = MatrixD.CreateTranslation(elevationPartLocation);
var fullStepElRotation = elPartPosTo * MatrixD.CreateFromAxisAngle(partDummy.Matrix.Left, m.Value.ElStep) * elPartPosFrom;
var rFullStepElRotation = MatrixD.Invert(fullStepElRotation);
weapon.ElevationPart.RotationAxis = partDummy.Matrix.Left;
weapon.ElevationPart.ToTransformation = elPartPosTo;
weapon.ElevationPart.FromTransformation = elPartPosFrom;
weapon.ElevationPart.FullRotationStep = fullStepElRotation;
weapon.ElevationPart.RevFullRotationStep = rFullStepElRotation;
weapon.ElevationPart.PartLocalLocation = elevationPartLocation;
weapon.ElevationPart.OriginalPosition = elevationPart.PositionComp.LocalMatrix;
//weapon.ElevationPart.Entity.NeedsWorldMatrix = true;
}
else if (elevationPartName == "None")
{
weapon.ElevationPart.RotationAxis = Vector3.Zero;
weapon.ElevationPart.ToTransformation = MatrixD.Zero;
weapon.ElevationPart.FromTransformation = MatrixD.Zero;
weapon.ElevationPart.FullRotationStep = MatrixD.Zero;
weapon.ElevationPart.RevFullRotationStep = MatrixD.Zero;
weapon.ElevationPart.PartLocalLocation = Vector3.Zero;
weapon.ElevationPart.OriginalPosition = MatrixD.Zero;
//weapon.ElevationPart.Entity.NeedsWorldMatrix = true;
}
}
var barrelCount = m.Value.Barrels.Length;
if (m.Key.String != "Designator")
{
weapon.MuzzlePart.Entity.PositionComp.OnPositionChanged += weapon.PositionChanged;
weapon.MuzzlePart.Entity.OnMarkForClose += weapon.EntPartClose;
}
else
{
if (weapon.ElevationPart.Entity != null)
{
weapon.ElevationPart.Entity.PositionComp.OnPositionChanged += weapon.PositionChanged;
weapon.ElevationPart.Entity.OnMarkForClose += weapon.EntPartClose;
}
else
{
weapon.AzimuthPart.Entity.PositionComp.OnPositionChanged += weapon.PositionChanged;
weapon.AzimuthPart.Entity.OnMarkForClose += weapon.EntPartClose;
}
}
for (int i = 0; i < barrelCount; i++)
{
var barrel = m.Value.Barrels[i];
weapon.MuzzleIdToName.Add(i, barrel);
if (weapon.Muzzles[i] == null)
{
weapon.Dummies[i] = new Dummy(weapon.MuzzlePart.Entity, weapon, barrel);
weapon.Muzzles[i] = new Muzzle(weapon, i, comp.Session);
}
else
{
weapon.Dummies[i].Entity = weapon.MuzzlePart.Entity;
}
}
for (int i = 0; i < m.Value.HeatingSubparts.Length; i++)
{
var partName = m.Value.HeatingSubparts[i];
MyEntity ent;
if (Parts.NameToEntity.TryGetValue(partName, out ent))
{
weapon.HeatingParts.Add(ent);
try
{
ent.SetEmissiveParts("Heating", Color.Transparent, 0);
}
catch (Exception ex) { Log.Line($"Exception no emmissive Found: {ex}"); }
}
}
//was run only on weapon first build, needs to run every reset as well
try
{
foreach (var emissive in weapon.System.WeaponEmissiveSet)
{
if (emissive.Value.EmissiveParts == null)
{
continue;
}
foreach (var part in emissive.Value.EmissiveParts)
{
Parts.SetEmissiveParts(part, Color.Transparent, 0);
}
}
}
catch (Exception e)
{
//cant check for emissives so may be null ref
}
if (weapon.Comp.FunctionalBlock.Enabled)
{
if (weapon.AnimationsSet.ContainsKey(EventTriggers.TurnOn))
{
weapon.Comp.Session.FutureEvents.Schedule(weapon.TurnOnAV, null, 4);
}
else
if (weapon.AnimationsSet.ContainsKey(EventTriggers.TurnOff))
{
weapon.Comp.Session.FutureEvents.Schedule(weapon.TurnOffAv, null, 4);
}
}
c++;
}
}
}
private MatrixD LocalNavmeshPositionToWorldPositionTransform(MyOrientedBoundingBoxD obb, Vector3D center)
{
Vector3D v = -Vector3D.Normalize(MyGravityProviderSystem.CalculateTotalGravityInPoint(center));
return(MatrixD.CreateFromQuaternion(Quaternion.CreateFromForwardUp((Vector3)Vector3D.CalculatePerpendicularVector(v), (Vector3)v)));
}
public static HkContactPoint?CastShapeReturnContact(Vector3D to, HkShape shape, ref MatrixD transform, int filterLayer, float extraPenetration, out Vector3 worldTranslation)
{
m_resultWorlds.Clear();
Clusters.Intersects(to, m_resultWorlds);
worldTranslation = Vector3.Zero;
if (m_resultWorlds.Count == 0)
{
return(null);
}
var world = m_resultWorlds[0];
worldTranslation = world.AABB.Center;
Matrix transformF = transform;
transformF.Translation = (Vector3)(transform.Translation - world.AABB.Center);
Vector3 toF = (Vector3)(to - world.AABB.Center);
HkContactPoint?result = ((HkWorld)world.UserData).CastShapeReturnContact(toF, shape, ref transformF, filterLayer, extraPenetration);
if (result == null)
{
return(null);
}
return(result);
}
public override void ActiveUpdate()
{
if (MyAPIGateway.Session.Player == null)
{
return;
}
//if (Vector3D.Distance(MyAPIGateway.Session.Camera.Position, m_source.PositionComp.GetPosition()) > 50f)
if (Vector3D.Distance(MyAPIGateway.Session.Player.GetPosition(), m_source.PositionComp.GetPosition()) > 50f)
{
return;
}
for (int s = m_activeBolts.Count - 1; s >= 0; s--)
{
var activeItem = m_activeBolts[s];
activeItem.Position++;
if (activeItem.Position >= activeItem.MaxPosition)
{
m_activeBolts.Remove(activeItem);
m_globalBolts--;
continue;
}
}
if (m_activeBolts.Count < m_maxBolts && m_globalBolts < m_globalMaxBolts && m_boltPathPool.Count > 0)
{
int numAdd = Math.Min(2, m_maxBolts - m_activeBolts.Count);
for (int r = 0; r < numAdd; r++)
{
var bolt = m_boltPool[MyUtils.GetRandomInt(0, m_boltPool.Count)];
var boltPath = m_boltPathPool[MyUtils.GetRandomInt(0, m_boltPathPool.Count)];
var boltItem = new LightningBoltInstance(bolt, boltPath, 60 + MyUtils.GetRandomInt(-10, 15));
m_activeBolts.Add(boltItem);
m_globalBolts++;
}
}
for (int s = 0; s < m_activeBolts.Count; s++)
{
var activeItem = m_activeBolts[s];
Vector3D sourceBolt = new Vector3D(0f, 2f, 0f);
Vector3D startBoltPoint = activeItem.Path.Start - new Vector3D(0f, 1.5f, 0f);
Vector3D endBoltPoint = activeItem.Path.End - new Vector3D(0f, 1.5f, 0f);
Vector3D endDiff = endBoltPoint - startBoltPoint;
Vector3D endBoltPosition = startBoltPoint + Vector3D.Normalize(endDiff) * (endDiff.Length() * ((float)activeItem.Position / (float)activeItem.MaxPosition));
Quaternion rot = sourceBolt.CreateQuaternionFromVector(endBoltPosition);
int startPos = 0;
int maxPos = activeItem.Bolt.Points.Count;
var previousPoint = activeItem.Bolt.Points[startPos];
var color = activeItem.Path.Color;
for (int r = startPos + 1; r < maxPos; r++)
{
var currentPoint = activeItem.Bolt.Points[startPos + r];
if (previousPoint.Length() > endBoltPosition.Length())
{
break;
}
// Spin the bolt on the Y axis
var startPoint = Vector3D.Transform(currentPoint, MatrixD.CreateRotationY(MathHelper.ToRadians((float)activeItem.Position * 5)));
// Rotate the bolt towards the endpoint
startPoint = Vector3D.Transform(startPoint, rot);
// Move the bolt up to the center of the sphere
startPoint += new Vector3D(0f, 1.5f, 0f);
// Place it in the world properly
startPoint = Vector3D.Transform(startPoint, m_source.WorldMatrix);
var endPoint = Vector3D.Transform(previousPoint, MatrixD.CreateRotationY(MathHelper.ToRadians((float)activeItem.Position * 5)));
endPoint = Vector3D.Transform(endPoint, rot);
endPoint += new Vector3(0f, 1.5f, 0f);
endPoint = Vector3D.Transform(endPoint, m_source.WorldMatrix);
var dir = Vector3D.Normalize(endPoint - startPoint);
var length = (endPoint - startPoint).Length() * 2f;
float pulse = MathExtensions.TrianglePulse((float)activeItem.Position, 1f, activeItem.MaxPosition / 2f) + 0.2f;
if (activeItem.Position < 10)
{
pulse = MathExtensions.TrianglePulse((float)activeItem.Position, 1f, 2.5f);
}
Vector4 diff = color * pulse;
float thickness = (0.0125f);
MyTransparentGeometry.AddLineBillboard(MyStringId.GetOrCompute("Testfly"), diff, startPoint, dir, (float)length, (float)thickness);
previousPoint = currentPoint;
}
}
}
public void Transform(MatrixD matrix)
{
this.Center = Vector3D.Transform(this.Center, matrix);
this.Orientation = Quaternion.CreateFromRotationMatrix(MatrixD.CreateFromQuaternion(this.Orientation) * matrix);
}
public void MoveLCD()
{
try
{
var subpart = npcCrewBlock.GetSubpart("NPC_Engineer_LCDRotation");
subpart.SetEmissiveParts("CleanEmissive", Color.OrangeRed, 0.4f);
var initialMatrix = subpart.PositionComp.LocalMatrix;
double rotationX = 0.01f;
double rotationY = 0.01f;
double rotationZ = 0.01;
if (AnimationLoopLCD == 200)
{
AnimationLoopLCD = 0;
}
if (AnimationLoopLCD == 0)
{
RotationTimeLCD = -1;
}
if (AnimationLoopLCD == 100)
{
RotationTimeLCD = 1;
}
var rotationMatrix = MatrixD.CreateRotationX(rotationX) * MatrixD.CreateRotationY(rotationY) * MatrixD.CreateRotationZ(rotationZ);
var matrix = rotationMatrix * initialMatrix;
subpart.PositionComp.LocalMatrix = matrix;
AnimationLoopLCD++;
}
catch (Exception e)
{
MyVisualScriptLogicProvider.ShowNotificationToAll("Update Error" + e, 2500, "Red");
}
}
