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"); } }