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); } } } }
private new void FixSnapTransformationBase6() { Debug.Assert(CopiedGrids.Count > 0); if (CopiedGrids.Count == 0) { return; } var hitGrid = m_hitEntity as MyCubeGrid; if (hitGrid == null) { return; } // Fix rotation of the first pasted grid Matrix rotationDelta = GetRotationDeltaMatrixToHitGrid(hitGrid); foreach (var grid in PreviewGrids) { Matrix rotation = grid.WorldMatrix.GetOrientation(); rotation = rotation * rotationDelta; Vector3D position = m_pastePosition; MatrixD newWorld = MatrixD.CreateWorld(position, rotation.Forward, rotation.Up); Debug.Assert(newWorld.GetOrientation().IsRotation()); grid.PositionComp.SetWorldMatrix(newWorld); } bool smallOnLargeGrid = hitGrid.GridSizeEnum == MyCubeSize.Large && PreviewGrids[0].GridSizeEnum == MyCubeSize.Small; if (smallOnLargeGrid) { Vector3 pasteOffset = MyCubeBuilder.TransformLargeGridHitCoordToSmallGrid(m_hitPos, hitGrid.PositionComp.WorldMatrixNormalizedInv, hitGrid.GridSize); m_pastePosition = hitGrid.GridIntegerToWorld(pasteOffset); } else { // Find a collision-free position for the first paste grid along the raycast normal Vector3I collisionTestStep = Vector3I.Round(m_hitNormal); Vector3I pasteOffset = hitGrid.WorldToGridInteger(m_pastePosition); Vector3I previewGridMin = PreviewGrids[0].Min; Vector3I previewGridMax = PreviewGrids[0].Max; Vector3I previewGridSize = previewGridMax - previewGridMin + Vector3I.One; Vector3D previewGridSizeInWorld = Vector3D.TransformNormal((Vector3D)previewGridSize, PreviewGrids[0].WorldMatrix); Vector3I previewGridSizeInHitGrid = Vector3I.Abs(Vector3I.Round(Vector3D.TransformNormal(previewGridSizeInWorld, hitGrid.PositionComp.WorldMatrixNormalizedInv))); int attemptsCount = Math.Abs(Vector3I.Dot(ref collisionTestStep, ref previewGridSizeInHitGrid)); Debug.Assert(attemptsCount > 0); int i; for (i = 0; i < attemptsCount; ++i) { if (hitGrid.CanMergeCubes(PreviewGrids[0], pasteOffset)) { break; } pasteOffset += collisionTestStep; } if (i == attemptsCount) { pasteOffset = hitGrid.WorldToGridInteger(m_pastePosition); } m_pastePosition = hitGrid.GridIntegerToWorld(pasteOffset); } // Move all the grids according to the collision-free position of the first one for (int i = 0; i < PreviewGrids.Count; ++i) { var grid = PreviewGrids[i]; MatrixD matrix = grid.WorldMatrix; matrix.Translation = m_pastePosition + Vector3.Transform(m_copiedGridOffsets[i], rotationDelta); grid.PositionComp.SetWorldMatrix(matrix); } if (MyDebugDrawSettings.DEBUG_DRAW_COPY_PASTE) { MyRenderProxy.DebugDrawLine3D(m_hitPos, m_hitPos + m_hitNormal, Color.Red, Color.Green, false); } }
public override void DebugDraw() { MyRenderProxy.DebugDrawLine3D(m_origin, FrontPoint, Color.Red, Color.Blue, false); }
/// <summary> /// Draws a frustum representing the valid scanning range, a line representing the last raycast, /// and a sphere representing the last raycast hit. /// </summary> private void DrawDebug() { MyRenderProxy.DebugDrawLine3D(m_lastRay.Start, m_lastRay.End, Color.Orange, Color.Orange, false); if (m_lastRay.Hit.HasValue) { MyRenderProxy.DebugDrawSphere(m_lastRay.Hit.Value, 1, Color.Orange, 1, false); } double distance = m_lastRay.Distance / Math.Cos(MathHelper.ToRadians(BlockDefinition.RaycastConeLimit)); //calculate the extremes of the scan area and draw the thing manually Vector3D[] corners = new Vector3D[4]; var startPos = this.WorldMatrix.Translation; var forwardDir = this.WorldMatrix.Forward; float pitch = MathHelper.ToRadians(-BlockDefinition.RaycastConeLimit); float yaw = MathHelper.ToRadians(-BlockDefinition.RaycastConeLimit); var pitchMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Right, pitch); var yawMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Down, yaw); Vector3D direction; Vector3D intermediateDirection; Vector3D.RotateAndScale(ref forwardDir, ref pitchMatrix, out intermediateDirection); Vector3D.RotateAndScale(ref intermediateDirection, ref yawMatrix, out direction); corners[0] = startPos + direction * distance; pitch = MathHelper.ToRadians(-BlockDefinition.RaycastConeLimit); yaw = MathHelper.ToRadians(BlockDefinition.RaycastConeLimit); pitchMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Right, pitch); yawMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Down, yaw); Vector3D.RotateAndScale(ref forwardDir, ref pitchMatrix, out intermediateDirection); Vector3D.RotateAndScale(ref intermediateDirection, ref yawMatrix, out direction); corners[1] = startPos + direction * distance; pitch = MathHelper.ToRadians(BlockDefinition.RaycastConeLimit); yaw = MathHelper.ToRadians(BlockDefinition.RaycastConeLimit); pitchMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Right, pitch); yawMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Down, yaw); Vector3D.RotateAndScale(ref forwardDir, ref pitchMatrix, out intermediateDirection); Vector3D.RotateAndScale(ref intermediateDirection, ref yawMatrix, out direction); corners[2] = startPos + direction * distance; pitch = MathHelper.ToRadians(BlockDefinition.RaycastConeLimit); yaw = MathHelper.ToRadians(-BlockDefinition.RaycastConeLimit); pitchMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Right, pitch); yawMatrix = MatrixD.CreateFromAxisAngle(this.WorldMatrix.Down, yaw); Vector3D.RotateAndScale(ref forwardDir, ref pitchMatrix, out intermediateDirection); Vector3D.RotateAndScale(ref intermediateDirection, ref yawMatrix, out direction); corners[3] = startPos + direction * distance; MyRenderProxy.DebugDrawLine3D(startPos, corners[0], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(startPos, corners[1], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(startPos, corners[2], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(startPos, corners[3], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(corners[0], corners[1], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(corners[1], corners[2], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(corners[2], corners[3], Color.Blue, Color.Blue, false); MyRenderProxy.DebugDrawLine3D(corners[3], corners[0], Color.Blue, Color.Blue, false); }
public static void DebugDraw() { if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW && MyDebugDrawSettings.DEBUG_DRAW_ENTITY_COMPONENTS && MySector.MainCamera != null) { double fontSize = 1.5; double lineSize = fontSize * 0.045; double hoffset = 0.5f; Vector3D playerPos = MySector.MainCamera.Position; Vector3D upVector = MySector.MainCamera.WorldMatrix.Up; Vector3D rightVector = MySector.MainCamera.WorldMatrix.Right; Vector3D fwVector = MySector.MainCamera.ForwardVector; BoundingSphereD bSphere = new BoundingSphereD(playerPos, 5.0f); var entities = MyEntities.GetEntitiesInSphere(ref bSphere); Vector3D lastEntityPos = Vector3D.Zero; Vector3D offset = Vector3D.Zero; var mat = MySector.MainCamera.ViewProjectionMatrix; var fullscreenRect = Sandbox.Graphics.MyGuiManager.GetSafeGuiRectangle(); float aspect = (float)fullscreenRect.Height / fullscreenRect.Width; float scaleX = 600; float scaleY = scaleX * aspect; Vector3D worldAxisPos = playerPos + 1.0f * fwVector; // Draw the world-space axis in the middle of the screen /*MyRenderProxy.DebugDrawArrow3D(worldAxisPos, worldAxisPos + Vector3D.Right * 0.1f, Color.Red, Color.Red, false, text: "World X"); * MyRenderProxy.DebugDrawArrow3D(worldAxisPos, worldAxisPos + Vector3D.Up * 0.1f, Color.Green, Color.Green, false, text: "World Y"); * MyRenderProxy.DebugDrawArrow3D(worldAxisPos, worldAxisPos + Vector3D.Backward * 0.1f, Color.Blue, Color.Blue, false, text: "World Z");*/ Vector3D posView = Vector3D.Transform(worldAxisPos, mat); Vector3D rtView = Vector3D.Transform(worldAxisPos + Vector3D.Right * 0.1f, mat); Vector3D upView = Vector3D.Transform(worldAxisPos + Vector3D.Up * 0.1f, mat); Vector3D bwView = Vector3D.Transform(worldAxisPos + Vector3D.Backward * 0.1f, mat); var center2D = new Vector2((float)posView.X * scaleX, (float)posView.Y * -scaleY * aspect); var right2D = new Vector2((float)rtView.X * scaleX, (float)rtView.Y * -scaleY * aspect) - center2D; var up2D = new Vector2((float)upView.X * scaleX, (float)upView.Y * -scaleY * aspect) - center2D; var backward2D = new Vector2((float)bwView.X * scaleX, (float)bwView.Y * -scaleY * aspect) - center2D; var frameSize = 150.0f; var frameBR = Sandbox.Graphics.MyGuiManager.GetScreenCoordinateFromNormalizedCoordinate(new Vector2(1.0f, 1.0f)); var frameBL = frameBR + new Vector2(-frameSize, 0.0f); var frameTR = frameBR + new Vector2(0.0f, -frameSize); var frameTL = frameBR + new Vector2(-frameSize, -frameSize); var frameCenter = (frameBR + frameTL) * 0.5f; // Draw frame around the world-space axis /*MyRenderProxy.DebugDrawLine2D(frameTL, frameTR, Color.White, Color.White); * MyRenderProxy.DebugDrawLine2D(frameTR, frameBR, Color.White, Color.White); * MyRenderProxy.DebugDrawLine2D(frameBR, frameBL, Color.White, Color.White); * MyRenderProxy.DebugDrawLine2D(frameBL, frameTL, Color.White, Color.White);*/ // Draw the world-space axis in the corner MyRenderProxy.DebugDrawLine2D(frameCenter, frameCenter + right2D, Color.Red, Color.Red); MyRenderProxy.DebugDrawLine2D(frameCenter, frameCenter + up2D, Color.Green, Color.Green); MyRenderProxy.DebugDrawLine2D(frameCenter, frameCenter + backward2D, Color.Blue, Color.Blue); MyRenderProxy.DebugDrawText2D(frameCenter + right2D, "World X", Color.Red, 0.5f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER); MyRenderProxy.DebugDrawText2D(frameCenter + up2D, "World Y", Color.Green, 0.5f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER); MyRenderProxy.DebugDrawText2D(frameCenter + backward2D, "World Z", Color.Blue, 0.5f, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER); MyComponentsDebugInputComponent.DetectedEntities.Clear(); foreach (var entity in entities) { if (entity.PositionComp == null) { continue; } Vector3D originalPos = entity.PositionComp.GetPosition(); Vector3D pos2 = originalPos + upVector * 0.1f; Vector3D pos = pos2 - rightVector * hoffset; Vector3D viewVector = Vector3D.Normalize(originalPos - playerPos); double dot = Vector3D.Dot(viewVector, fwVector); if (dot < 0.9995) { Vector3D rightObject = entity.PositionComp.WorldMatrix.Right * 0.3f; Vector3D upObject = entity.PositionComp.WorldMatrix.Up * 0.3f; Vector3D backwardObject = entity.PositionComp.WorldMatrix.Backward * 0.3f; MyRenderProxy.DebugDrawSphere(originalPos, 0.01f, Color.White, 1.0f, false); MyRenderProxy.DebugDrawArrow3D(originalPos, originalPos + rightObject, Color.Red, Color.Red, false, text: "X"); MyRenderProxy.DebugDrawArrow3D(originalPos, originalPos + upObject, Color.Green, Color.Green, false, text: "Y"); MyRenderProxy.DebugDrawArrow3D(originalPos, originalPos + backwardObject, Color.Blue, Color.Blue, false, text: "Z"); continue; } if (Vector3D.Distance(originalPos, lastEntityPos) < 0.01) { offset += rightVector * 0.3f; upVector = -upVector; pos2 = originalPos + upVector * 0.1f; pos = pos2 - rightVector * hoffset; } lastEntityPos = originalPos; double dist = Vector3D.Distance(pos, playerPos); double textSize = Math.Atan(fontSize / Math.Max(dist, 0.001)); float n = 0; { var enumerator = entity.Components.GetEnumerator(); MyComponentBase component = null; while (enumerator.MoveNext()) { component = enumerator.Current; n += GetComponentLines(component); } n += 1; n -= GetComponentLines(component); // The last component should not make the line longer enumerator.Dispose(); } Vector3D topPos = pos + (n + 0.5f) * upVector * lineSize; Vector3D currentPos = pos + (n + 1) * upVector * lineSize + 0.01f * rightVector; MyRenderProxy.DebugDrawLine3D(originalPos, pos2, Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(pos, pos2, Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(pos, topPos, Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(topPos, topPos + rightVector * 1.0f, Color.White, Color.White, false); MyRenderProxy.DebugDrawText3D(currentPos, entity.GetType().ToString() + " - " + entity.DisplayName, Color.Orange, (float)textSize, false, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER); MyComponentsDebugInputComponent.DetectedEntities.Add(entity); foreach (var component in entity.Components) { currentPos = pos + n * upVector * lineSize; DebugDrawComponent(component, currentPos, rightVector, upVector, lineSize, (float)textSize); var entityComponent = component as MyEntityComponentBase; string compType = entityComponent == null ? "" : entityComponent.ComponentTypeDebugString; MyRenderProxy.DebugDrawText3D(currentPos - 0.02f * rightVector, compType, Color.Yellow, (float)textSize, false, MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER); n -= GetComponentLines(component); } } entities.Clear(); } }
public override void DebugDraw(ref Matrix drawMatrix) { if (!MyDebugDrawSettings.ENABLE_DEBUG_DRAW) { return; } base.DebugDraw(ref drawMatrix); if ((MyDebugDrawSettings.DEBUG_DRAW_NAVMESHES & MyWEMDebugDrawMode.EDGES) != 0) { if (m_connectionHelper != null) { foreach (var edge in m_connectionHelper) { Vector3 A = Vector3.Transform(edge.Key.A / 256.0f, drawMatrix); Vector3 B = Vector3.Transform(edge.Key.B / 256.0f, drawMatrix); MyRenderProxy.DebugDrawLine3D(A, B, Color.Red, Color.Yellow, false); } } } if ((MyDebugDrawSettings.DEBUG_DRAW_NAVMESHES & MyWEMDebugDrawMode.NORMALS) != 0) { foreach (var entry in m_smallTriangleRegistry) { var list = entry.Value; foreach (var triIndex in list) { var tri = GetTriangle(triIndex); Vector3 normal = Vector3.Transform(tri.Center + tri.Normal * 0.2f, drawMatrix); Vector3 center = Vector3.Transform(tri.Center, drawMatrix); MyRenderProxy.DebugDrawLine3D(center, normal, Color.Blue, Color.Blue, true); } } } if (MyFakes.DEBUG_DRAW_NAVMESH_HIERARCHY) { if (m_higherLevel != null) { m_higherLevel.DebugDraw(lite: MyFakes.DEBUG_DRAW_NAVMESH_HIERARCHY_LITE); } } /*foreach (var entry in m_smallTriangleRegistry) * { * var list = entry.Value; * foreach (var triIndex in list) * { * var tri = GetTriangle(triIndex); * Vector3 normal = Vector3.Transform(tri.Center + tri.Normal * 0.2f, drawMatrix); * Vector3 center = Vector3.Transform(tri.Center, drawMatrix); * MyRenderProxy.DebugDrawText3D(center, entry.Key.ToString(), Color.Blue, 0.7f, true); * } * }*/ /* * if (m_cubeSet != null) * { * foreach (var entry in m_cubeSet) * { * Vector3 pos = Vector3.Transform(entry, drawMatrix); * MyRenderProxy.DebugDrawSphere(pos, 0.1f, Color.Red, 1.0f, false); * MyRenderProxy.DebugDrawText3D(pos, entry.ToString(), Color.Red, 1.0f, false); * } * }*/ }
public override bool DebugDraw() { var minCorner = m_voxelMap.PositionLeftBottomCorner; if (MyDebugDrawSettings.DEBUG_DRAW_VOXEL_MAP_AABB) { MyRenderProxy.DebugDrawAABB(m_voxelMap.PositionComp.WorldAABB, Color.White, alpha: 0.2f); MyRenderProxy.DebugDrawLine3D(minCorner, minCorner + new Vector3(1f, 0f, 0f), Color.Red, Color.Red, true); MyRenderProxy.DebugDrawLine3D(minCorner, minCorner + new Vector3(0f, 1f, 0f), Color.Green, Color.Green, true); MyRenderProxy.DebugDrawLine3D(minCorner, minCorner + new Vector3(0f, 0f, 1f), Color.Blue, Color.Blue, true); MyRenderProxy.DebugDrawAxis(m_voxelMap.PositionComp.WorldMatrix, 2f, false); MyRenderProxy.DebugDrawSphere(m_voxelMap.PositionComp.GetPosition(), 1, Color.OrangeRed, 1, false); } m_voxelMap.Storage.DebugDraw(m_voxelMap, MyDebugDrawSettings.DEBUG_DRAW_VOXELS_MODE); if (m_voxelMap.Physics != null) { m_voxelMap.Physics.DebugDraw(); } //if (MyDebugDrawSettings.DEBUG_DRAW_VOXEL_GEOMETRY_CELL) //{ // LineD worldLine; // if (false) // { // var entityMatrix = MySession.Static.ControlledEntity.Entity.WorldMatrix; // worldLine = new LineD(entityMatrix.Translation, entityMatrix.Translation + 25f * entityMatrix.Forward); // } // else // { // var camera = MySector.MainCamera; // worldLine = new LineD(camera.Position, camera.Position + 25f * camera.ForwardVector); // } // VRage.Game.Models.MyIntersectionResultLineTriangleEx? result; // bool depthRead = true; // if (m_voxelMap.GetIntersectionWithLine(ref worldLine, out result)) // { // var t = result.Value.Triangle.InputTriangle; // MyRenderProxy.DebugDrawTriangle( // t.Vertex0 + minCorner, // t.Vertex1 + minCorner, // t.Vertex2 + minCorner, // Color.Red, true, false); // Vector3I cellCoord, voxelCoord; // var worldPosition = result.Value.IntersectionPointInWorldSpace; // BoundingBoxD voxelAabb; // MyVoxelCoordSystems.WorldPositionToVoxelCoord(minCorner, ref worldPosition, out voxelCoord); // MyVoxelCoordSystems.VoxelCoordToWorldAABB(minCorner, ref voxelCoord, out voxelAabb); // MyRenderProxy.DebugDrawAABB(voxelAabb, Vector3.UnitY, 1f, 1f, true); // MyVoxelCoordSystems.WorldPositionToGeometryCellCoord(minCorner, ref worldPosition, out cellCoord); // MyVoxelCoordSystems.GeometryCellCoordToWorldAABB(minCorner, ref cellCoord, out voxelAabb); // MyRenderProxy.DebugDrawAABB(voxelAabb, Vector3.UnitZ, 1f, 1f, true); // bool isEmpty; // MyIsoMesh cell; // if (m_voxelMap.Storage.Geometry.TryGetMesh(new MyCellCoord(0, cellCoord), out isEmpty, out cell) && !isEmpty) // { // MyVoxelVertex tmp; // var triangleBatch = MyRenderProxy.PrepareDebugDrawTriangles(); // for (int i = 0; i < cell.VerticesCount; ++i) // { // cell.GetUnpackedVertex(i, out tmp); // triangleBatch.AddVertex(tmp.Position); // tmp.Position += minCorner; // MyRenderProxy.DebugDrawLine3D(tmp.Position, tmp.Position + tmp.Normal * MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF, Color.Gray, Color.White, depthRead); // } // for (int i = 0; i < cell.TrianglesCount; ++i) // { // triangleBatch.AddIndex(cell.Triangles[i].VertexIndex2); // triangleBatch.AddIndex(cell.Triangles[i].VertexIndex1); // triangleBatch.AddIndex(cell.Triangles[i].VertexIndex0); // } // MyRenderProxy.DebugDrawTriangles(triangleBatch, Matrix.CreateTranslation(minCorner), Color.CornflowerBlue, depthRead, false); // } // } //} return(true); }
private static void DrawMountPointsAxisHelpers(MyCubeBlockDefinition def, ref MatrixD drawMatrix, float cubeSize) { Vector3I centerGrid = def.Center; Vector3 centerOffset = def.Size * 0.5f; MatrixD drawTransf = MatrixD.CreateTranslation(centerGrid - centerOffset) * MatrixD.CreateScale(cubeSize) * drawMatrix; // Draw axis helpers for the six mount point walls for (int i = 0; i < 6; ++i) { Base6Directions.Direction dir = (Base6Directions.Direction)i; Vector3D position = Vector3D.Zero; position.Z = -0.2f; Vector3D normal = Vector3.Forward; Vector3D right = Vector3.Right; Vector3D up = Vector3.Up; position = def.MountPointLocalToBlockLocal(position, dir); position = Vector3D.Transform(position, drawTransf); normal = def.MountPointLocalNormalToBlockLocal(normal, dir); normal = Vector3D.TransformNormal(normal, drawTransf); up = def.MountPointLocalNormalToBlockLocal(up, dir); up = Vector3D.TransformNormal(up, drawTransf); right = def.MountPointLocalNormalToBlockLocal(right, dir); right = Vector3D.TransformNormal(right, drawTransf); MatrixD rightMat = MatrixD.CreateWorld(position + right * 0.25f, normal, right); MatrixD upMat = MatrixD.CreateWorld(position + up * 0.25f, normal, up); Vector4 rc = Color.Red.ToVector4(); Vector4 uc = Color.Green.ToVector4(); MyRenderProxy.DebugDrawSphere(position, 0.03f * cubeSize, Color.Red.ToVector3(), 1.0f, true); MySimpleObjectDraw.DrawTransparentCylinder(ref rightMat, 0.0f, 0.03f * cubeSize, 0.5f * cubeSize, ref rc, false, 16, 0.01f * cubeSize); MySimpleObjectDraw.DrawTransparentCylinder(ref upMat, 0.0f, 0.03f * cubeSize, 0.5f * cubeSize, ref uc, false, 16, 0.01f * cubeSize); MyRenderProxy.DebugDrawLine3D(position, position - normal * 0.2f, Color.Red, Color.Red, true); float textSizeX = 0.5f * cubeSize; float textSizeY = 0.5f * cubeSize; float textSizeDesc = 0.5f * cubeSize; if (MySector.MainCamera != null) { float distX = (float)(position + right * 0.55f - MySector.MainCamera.Position).Length(); float distY = (float)(position + up * 0.55f - MySector.MainCamera.Position).Length(); float distDesc = (float)(position + normal * 0.1f - MySector.MainCamera.Position).Length(); textSizeX = textSizeX * 6 / distX; textSizeY = textSizeY * 6 / distY; textSizeDesc = textSizeDesc * 6 / distDesc; } MyRenderProxy.DebugDrawText3D(position + right * 0.55f, "X", Color.Red, textSizeX, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER); MyRenderProxy.DebugDrawText3D(position + up * 0.55f, "Y", Color.Green, textSizeY, false, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER); MyRenderProxy.DebugDrawText3D(position + normal * 0.1f, m_mountPointSideNames[i], Color.White, textSizeDesc, true, MyGuiDrawAlignEnum.HORISONTAL_CENTER_AND_VERTICAL_CENTER); } // If close enough, draw a black grid spaced by tenths of a mount point unit float dist = (float)(drawTransf.Translation - MySector.MainCamera.Position).Length(); BoundingBoxD bb = new BoundingBoxD(-def.Size * cubeSize * 0.5f, def.Size * cubeSize * 0.5f); dist -= (float)bb.Size.Max() * 0.866f; // sqrt(3) * 0.5 - half of the solid diagonal of a cube Color black = Color.Black; if (dist < cubeSize * 3.0f) { MySimpleObjectDraw.DrawTransparentBox(ref drawMatrix, ref bb, ref black, MySimpleObjectRasterizer.Wireframe, def.Size * 10, 0.005f / (float)bb.Size.Max() * cubeSize, onlyFrontFaces: true); } }
private void Probe(Vector3D pos) { var ray = m_probedLine; ray.From += pos; ray.To += pos; var entities = new List <MyLineSegmentOverlapResult <MyEntity> >(); MyGamePruningStructure.GetTopmostEntitiesOverlappingRay(ref ray, entities, MyEntityQueryType.Static); double closest = double.PositiveInfinity; foreach (var e in entities) { var voxel = e.Element as MyVoxelBase; if (voxel != null && e.Distance < closest) { m_probedVoxel = voxel; } } if (m_probedVoxel is MyVoxelPhysics) { m_probedVoxel = ((MyVoxelPhysics)m_probedVoxel).Parent; } if (m_probedVoxel != null && m_probedVoxel.Storage.DataProvider != null) { MyRenderProxy.DebugDrawLine3D(ray.From, ray.To, Color.Green, Color.Green, true); Vector3D start = Vector3D.Transform(ray.From, m_probedVoxel.PositionComp.WorldMatrixInvScaled); start += m_probedVoxel.SizeInMetresHalf; var end = Vector3D.Transform(ray.To, m_probedVoxel.PositionComp.WorldMatrixInvScaled); end += m_probedVoxel.SizeInMetresHalf; var voxRay = new LineD(start, end); double startOffset; double endOffset; // Intersect provider for nau var cont = m_probedVoxel.Storage.DataProvider.Intersect(ref voxRay, out startOffset, out endOffset); var from = voxRay.From; voxRay.From = from + voxRay.Direction * voxRay.Length * startOffset; voxRay.To = from + voxRay.Direction * voxRay.Length * endOffset; if (m_probeCount == 1) { Text(Color.Yellow, 1.5f, "Probing voxel map {0}:{1}", m_probedVoxel.StorageName, m_probedVoxel.EntityId); Text("Local Pos: {0}", start); Text("Intersects: {0}", cont); } if (cont) { start = voxRay.From - m_probedVoxel.SizeInMetresHalf; start = Vector3D.Transform(start, m_probedVoxel.PositionComp.WorldMatrix); end = voxRay.To - m_probedVoxel.SizeInMetresHalf; end = Vector3D.Transform(end, m_probedVoxel.PositionComp.WorldMatrix); MyRenderProxy.DebugDrawLine3D(start, end, Color.Red, Color.Red, true); } } else { if (m_probeCount == 1) { Text(Color.Yellow, 1.5f, "No voxel found"); } MyRenderProxy.DebugDrawLine3D(ray.From, ray.To, Color.Yellow, Color.Yellow, true); } }
public void DebugDraw() { if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW == false) { return; } m_aiming.DebugDraw(m_aimingPositionAndOrientation); if (MyDebugDrawSettings.DEBUG_DRAW_BOT_STEERING) { foreach (var steering in m_steerings) { steering.DebugDraw(); } } if (MyDebugDrawSettings.DEBUG_DRAW_BOT_NAVIGATION) { Vector3 pos = PositionAndOrientation.Translation;// + /*PositionAndOrientation.Up * 1.5f + */ForwardVector; Vector3 rightVector = Vector3.Cross(m_forwardVector, UpVector); if (Stuck) { MyRenderProxy.DebugDrawSphere(pos, 1.0f, Color.Red.ToVector3(), 1.0f, false); } //MyRenderProxy.DebugDrawLine3D(pos, pos + ForwardVector, Color.Blue, Color.Blue, false); //var normalizedCorrection = Vector3D.Normalize(m_correction); //var normalizedCorrectedDirXZ = normalizedCorrection + m_forwardVector; //normalizedCorrectedDirXZ = Vector3D.Normalize(Vector3D.Reject(normalizedCorrectedDirXZ, Vector3D.Up)); //MyRenderProxy.DebugDrawLine3D(pos, pos + normalizedCorrectedDirXZ * 3, Color.Lime, Color.Lime, false); MyRenderProxy.DebugDrawArrow3D(pos, pos + ForwardVector, Color.Blue, Color.Blue, false, text: "Nav. FW"); MyRenderProxy.DebugDrawArrow3D(pos + ForwardVector, pos + ForwardVector + m_correction, Color.LightBlue, Color.LightBlue, false, text: "Correction"); //MyRenderProxy.DebugDrawLine3D(pos + ForwardVector, pos + ForwardVector + m_correction, Color.Yellow, Color.Yellow, false); //MyRenderProxy.DebugDrawSphere(pos + ForwardVector + m_correction, 0.05f, Color.Yellow.ToVector3(), 1.0f, true); if (m_destinationSphere != null) { m_destinationSphere.DebugDraw(); } var character = this.BotEntity as MyCharacter; if (character != null) { var viewMatrix = character.GetViewMatrix(); var worldMatrix = MatrixD.Invert(viewMatrix); var headMatrix = character.GetHeadMatrix(true, true); MyRenderProxy.DebugDrawLine3D(worldMatrix.Translation, Vector3D.Transform(Vector3D.Forward * 50, worldMatrix), Color.Yellow, Color.White, false); MyRenderProxy.DebugDrawLine3D(headMatrix.Translation, Vector3D.Transform(Vector3D.Forward * 50, headMatrix), Color.Red, Color.Red, false); if (character.CurrentWeapon != null) { var direction = character.CurrentWeapon.DirectionToTarget(character.AimedPoint); var spos = (character.CurrentWeapon as MyEntity).WorldMatrix.Translation; MyRenderProxy.DebugDrawSphere(character.AimedPoint, 1.0f, Color.Yellow, 1.0f, false); MyRenderProxy.DebugDrawLine3D(spos, spos + direction * 20, Color.Purple, Color.Purple, false); } } } }
// ------------------------------------------------------------------------------------ /// <summary> /// Solve IK for chain of two bones + change rotation of end bone. /// </summary> /// <param name="characterBones">bone storage</param> /// <param name="ikChain">description of bone chain</param> /// <param name="finalPosition">desired position of end bone</param> /// <param name="finalNormal">desired normal of end bone - would be projected on plane first bone-second bone-third bone</param> /// <param name="fromBindPose">solve this starting from the bind pose</param> /// <returns>true on success</returns> public static bool SolveIkTwoBones(MyCharacterBone[] characterBones, MyAnimationIkChainExt ikChain, ref Vector3 finalPosition, ref Vector3 finalNormal, bool fromBindPose) { int boneIndex = ikChain.BoneIndex; float finalMinRot = MathHelper.ToRadians(ikChain.MinEndPointRotation); float finalMaxRot = MathHelper.ToRadians(ikChain.MaxEndPointRotation); Vector3 lastPoleVector = ikChain.LastPoleVector; int chainLength = ikChain.ChainLength; bool alignBoneWithTerrain = ikChain.AlignBoneWithTerrain; MyCharacterBone thirdBone = characterBones[boneIndex]; if (thirdBone == null) { return(false); } MyCharacterBone secondBone = thirdBone.Parent; for (int i = 2; i < chainLength; i++) { secondBone = secondBone.Parent; } if (secondBone == null) { return(false); } MyCharacterBone firstBone = secondBone.Parent; if (firstBone == null) { return(false); } if (fromBindPose) { firstBone.SetCompleteBindTransform(); secondBone.SetCompleteBindTransform(); thirdBone.SetCompleteBindTransform(); firstBone.ComputeAbsoluteTransform(true); } Matrix thirdBoneTransformBackup = thirdBone.AbsoluteTransform; //Vector3 firstBoneTransformRightDir = firstBone.AbsoluteTransform.Right; Vector3 firstBoneOrigin = firstBone.AbsoluteTransform.Translation; Vector3 secondBoneOrigin = secondBone.AbsoluteTransform.Translation; Vector3 thirdBoneOrigin = thirdBone.AbsoluteTransform.Translation; // Vector3D finalPosition comes from parameter Vector3 secondMinusFirst = secondBoneOrigin - firstBoneOrigin; Vector3 finalMinusFirst = finalPosition - firstBoneOrigin; //Vector3 finalMinusSecond = finalPosition - secondBoneOrigin; Vector3 poleVectorNormalized; Vector3 thirdMinusFirst = thirdBoneOrigin - firstBoneOrigin; Vector3.Cross(ref secondMinusFirst, ref thirdMinusFirst, out poleVectorNormalized); // project to 2D (only vectors) poleVectorNormalized.Normalize(); poleVectorNormalized = Vector3.Normalize(Vector3.Lerp(poleVectorNormalized, lastPoleVector, m_poleVectorChangeSmoothness)); Vector3 planeDirY = Vector3.Normalize(finalMinusFirst); // finalMinusFirst? thirdMinusFirst? Vector3 planeDirX = Vector3.Normalize(Vector3.Cross(planeDirY, poleVectorNormalized)); //Vector2 firstBoneOrigin2D = new Vector2(0, 0); Vector2 secondBoneOrigin2D = new Vector2(planeDirX.Dot(ref secondMinusFirst), planeDirY.Dot(ref secondMinusFirst)); Vector2 thirdBoneOrigin2D = new Vector2(planeDirX.Dot(ref thirdMinusFirst), planeDirY.Dot(ref thirdMinusFirst)); Vector2 finalPosition2D = new Vector2(planeDirX.Dot(ref finalMinusFirst), planeDirY.Dot(ref finalMinusFirst)); Vector2 terrainNormal2D = new Vector2(planeDirX.Dot(ref finalNormal), planeDirY.Dot(ref finalNormal)); float firstBoneLength = (secondBoneOrigin2D /* - 0*/).Length(); float secondBoneLength = (thirdBoneOrigin2D - secondBoneOrigin2D).Length(); float finalDistance = finalPosition2D.Length(); if (firstBoneLength + secondBoneLength <= finalDistance) { finalPosition2D = (firstBoneLength + secondBoneLength) * finalPosition2D / finalDistance; // too far //return false; } // mid-joint -> wanted position in 2D Vector2 newSecondBoneOrigin2D; { newSecondBoneOrigin2D.Y = (finalPosition2D.Y * finalPosition2D.Y - secondBoneLength * secondBoneLength + firstBoneLength * firstBoneLength) / (2.0f * finalPosition2D.Y); float srqtArg = firstBoneLength * firstBoneLength - newSecondBoneOrigin2D.Y * newSecondBoneOrigin2D.Y; newSecondBoneOrigin2D.X = (float)Math.Sqrt(srqtArg > 0 ? srqtArg : 0); } // project back Vector3 newSecondBoneOrigin = firstBoneOrigin + planeDirX * newSecondBoneOrigin2D.X + planeDirY * newSecondBoneOrigin2D.Y; Vector3 newSecondMinusFirst = newSecondBoneOrigin - firstBoneOrigin; Vector3 newThirdMinusSecond = finalPosition - newSecondBoneOrigin; Vector3 newTerrainNormal = planeDirX * terrainNormal2D.X + planeDirY * terrainNormal2D.Y; newTerrainNormal.Normalize(); // set the rotations in the bones // first bone --------------------------------- Matrix firstBoneAbsoluteFinal = firstBone.AbsoluteTransform; Quaternion rotFirstDelta = Quaternion.CreateFromTwoVectors(secondMinusFirst, newSecondMinusFirst); firstBoneAbsoluteFinal.Right = Vector3.Transform(firstBoneAbsoluteFinal.Right, rotFirstDelta); firstBoneAbsoluteFinal.Up = Vector3.Transform(firstBoneAbsoluteFinal.Up, rotFirstDelta); firstBoneAbsoluteFinal.Forward = Vector3.Transform(firstBoneAbsoluteFinal.Forward, rotFirstDelta); firstBone.SetCompleteTransformFromAbsoluteMatrix(ref firstBoneAbsoluteFinal, true); firstBone.ComputeAbsoluteTransform(); // second bone --------------------------------- Matrix secondBoneAbsoluteFinal = secondBone.AbsoluteTransform; Quaternion rotSecondDelta = Quaternion.CreateFromTwoVectors(thirdBone.AbsoluteTransform.Translation - secondBone.AbsoluteTransform.Translation, newThirdMinusSecond); secondBoneAbsoluteFinal.Right = Vector3.Transform(secondBoneAbsoluteFinal.Right, rotSecondDelta); secondBoneAbsoluteFinal.Up = Vector3.Transform(secondBoneAbsoluteFinal.Up, rotSecondDelta); secondBoneAbsoluteFinal.Forward = Vector3.Transform(secondBoneAbsoluteFinal.Forward, rotSecondDelta); secondBone.SetCompleteTransformFromAbsoluteMatrix(ref secondBoneAbsoluteFinal, true); secondBone.ComputeAbsoluteTransform(); //// third bone ---------------------------------- if (ikChain.EndBoneTransform.HasValue) { MatrixD localTransformRelated = ikChain.EndBoneTransform.Value * MatrixD.Invert((MatrixD)thirdBone.BindTransform * thirdBone.Parent.AbsoluteTransform); thirdBone.Rotation = Quaternion.CreateFromRotationMatrix(Matrix.Normalize((Matrix)localTransformRelated.GetOrientation())); thirdBone.Translation = (Vector3)localTransformRelated.Translation; thirdBone.ComputeAbsoluteTransform(); } else if (alignBoneWithTerrain) { Matrix footRotation; Vector3 finalRotPoleVec; Vector3.Cross(ref newTerrainNormal, ref Vector3.Up, out finalRotPoleVec); float deltaAngle = MyUtils.GetAngleBetweenVectors(newTerrainNormal, Vector3.Up); if (finalRotPoleVec.Dot(poleVectorNormalized) > 0) { deltaAngle = -deltaAngle; } deltaAngle = MathHelper.Clamp(deltaAngle, finalMinRot, finalMaxRot); Matrix.CreateFromAxisAngle(ref poleVectorNormalized, deltaAngle, out footRotation); ikChain.LastAligningRotationMatrix = Matrix.Lerp(ikChain.LastAligningRotationMatrix, footRotation, ikChain.AligningSmoothness); Matrix thirdBoneAbsoluteFinal = thirdBoneTransformBackup.GetOrientation() * ikChain.LastAligningRotationMatrix; thirdBoneAbsoluteFinal.Translation = thirdBone.AbsoluteTransform.Translation; thirdBone.SetCompleteTransformFromAbsoluteMatrix(ref thirdBoneAbsoluteFinal, true); thirdBone.ComputeAbsoluteTransform(); } // Debugging of the solver. if (m_showDebugDrawings) { MyRenderProxy.DebugDrawLine3D(Vector3D.Transform(firstBoneOrigin, ref DebugTransform), Vector3D.Transform(secondBoneOrigin, ref DebugTransform), Color.Yellow, Color.Red, false); MyRenderProxy.DebugDrawLine3D(Vector3D.Transform(secondBoneOrigin, ref DebugTransform), Vector3D.Transform(thirdBoneOrigin, ref DebugTransform), Color.Yellow, Color.Red, false); MyRenderProxy.DebugDrawSphere(Vector3D.Transform(finalPosition, ref DebugTransform), 0.05f, Color.Cyan, 1.0f, false); MyRenderProxy.DebugDrawLine3D(Vector3D.Transform(secondBoneOrigin, ref DebugTransform), Vector3D.Transform(secondBoneOrigin + poleVectorNormalized, ref DebugTransform), Color.PaleGreen, Color.PaleGreen, false); MyRenderProxy.DebugDrawLine3D(Vector3D.Transform(firstBoneOrigin, ref DebugTransform), Vector3D.Transform(firstBoneOrigin + planeDirX, ref DebugTransform), Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(Vector3D.Transform(firstBoneOrigin, ref DebugTransform), Vector3D.Transform(firstBoneOrigin + planeDirY, ref DebugTransform), Color.White, Color.White, false); MyRenderProxy.DebugDrawSphere(Vector3D.Transform(newSecondBoneOrigin, ref DebugTransform), 0.05f, Color.Green, 1.0f, false); MyRenderProxy.DebugDrawAxis(firstBone.AbsoluteTransform * DebugTransform, 0.5f, false); MyRenderProxy.DebugDrawLine3D(Vector3D.Transform(finalPosition, ref DebugTransform), Vector3D.Transform(finalPosition + newTerrainNormal, ref DebugTransform), Color.Black, Color.LightBlue, false); MyRenderProxy.DebugDrawArrow3D(Vector3D.Transform(secondBoneOrigin, ref DebugTransform), Vector3D.Transform(newSecondBoneOrigin, ref DebugTransform), Color.Green, Color.White, false); } ikChain.LastPoleVector = poleVectorNormalized; return(true); }
public void DebugDraw() { var matrix = Sandbox.Game.World.MySector.MainCamera.ViewMatrix; Vector3D?prevPosition = null; foreach (var node in m_pathNodes) { Vector3D down = Sandbox.Game.GameSystems.MyGravityProviderSystem.CalculateTotalGravityInPoint(node.WorldPosition); if (Vector3D.IsZero(down, 0.001)) { down = Vector3D.Down; } down.Normalize(); Vector3D position = node.WorldPosition + down * -10.0; MyRenderProxy.DebugDrawSphere(position, 1.0f, Color.IndianRed, 1.0f, false); MyRenderProxy.DebugDrawLine3D(node.WorldPosition, position, Color.IndianRed, Color.IndianRed, false); if (prevPosition.HasValue) { MyRenderProxy.DebugDrawLine3D(position, prevPosition.Value, Color.IndianRed, Color.IndianRed, false); } prevPosition = position; } /*if (m_hlEnd != null) * { * Vector3D position = m_hlEnd.WorldPosition + new Vector3D(0.0f, 10.0f, 0.0f); * MyRenderProxy.DebugDrawSphere(position, 1.0f, Color.Crimson, 1.0f, false); * MyRenderProxy.DebugDrawLine3D(m_hlEnd.WorldPosition, position, Color.Crimson, Color.Crimson, false); * }*/ MyRenderProxy.DebugDrawSphere(m_startPoint, 0.5f, Color.HotPink, 1.0f, false); /*MyRenderProxy.DebugDrawSphere(m_endPoint, 0.5f, Color.HotPink, 1.0f, false); * MyRenderProxy.DebugDrawLine3D(m_startPoint, m_endPoint, Color.HotPink, Color.HotPink, false);*/ if (m_goal != null) { m_goal.DebugDraw(); } if (MyFakes.DEBUG_DRAW_FOUND_PATH) { Vector3D?prevPoint = null; for (int i = 0; i < m_expandedPath.Count; ++i) { Vector3D point = new Vector3D(m_expandedPath[i]); float radius = (float)m_expandedPath[i].W; Color col = i == m_expandedPath.Count - 1 ? Color.OrangeRed : Color.Orange; //VRageRender.MyRenderProxy.DebugDrawSphere(point, radius, col, 1.0f, false); VRageRender.MyRenderProxy.DebugDrawPoint(point, col, false); VRageRender.MyRenderProxy.DebugDrawText3D(point + matrix.Right * 0.1f, radius.ToString(), col, 0.7f, false); if (prevPoint.HasValue) { VRageRender.MyRenderProxy.DebugDrawLine3D(prevPoint.Value, point, Color.Pink, Color.Pink, false); } prevPoint = point; } } }
public static void DebugDraw() { if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW && MyDebugDrawSettings.DEBUG_DRAW_ENTITY_COMPONENTS && MySector.MainCamera != null) { double fontSize = 1.5; double lineSize = fontSize * 0.045; double hoffset = 0.5f; Vector3D playerPos = MySector.MainCamera.Position; Vector3D upVector = MySector.MainCamera.WorldMatrix.Up; Vector3D rightVector = MySector.MainCamera.WorldMatrix.Right; Vector3D fwVector = MySector.MainCamera.ForwardVector; BoundingSphereD bSphere = new BoundingSphereD(playerPos, 5.0f); var entities = MyEntities.GetEntitiesInSphere(ref bSphere); foreach (var entity in entities) { if (entity.PositionComp == null) { continue; } Vector3D originalPos = entity.PositionComp.GetPosition(); Vector3D pos2 = originalPos + upVector * 0.1f; Vector3D pos = pos2 - rightVector * hoffset; Vector3D viewVector = Vector3D.Normalize(originalPos - playerPos); double dot = Vector3D.Dot(viewVector, fwVector); if (dot < 0.9995) { MyRenderProxy.DebugDrawSphere(originalPos, 0.01f, Color.White, 1.0f, false); continue; } double dist = Vector3D.Distance(pos, playerPos); double textSize = Math.Atan(fontSize / Math.Max(dist, 0.001)); float n = 0; { var enumerator = entity.Components.GetEnumerator(); MyComponentBase component = null; while (enumerator.MoveNext()) { component = enumerator.Current; n += GetComponentLines(component); } n += 1; n -= GetComponentLines(component); // The last component should not make the line longer enumerator.Dispose(); } Vector3D topPos = pos + (n + 0.5f) * upVector * lineSize; Vector3D currentPos = pos + (n + 1) * upVector * lineSize + 0.01f * rightVector; MyRenderProxy.DebugDrawLine3D(originalPos, pos2, Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(pos, pos2, Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(pos, topPos, Color.White, Color.White, false); MyRenderProxy.DebugDrawLine3D(topPos, topPos + rightVector * 1.0f, Color.White, Color.White, false); MyRenderProxy.DebugDrawText3D(currentPos, entity.GetType().ToString() + " - " + entity.DisplayName, Color.Orange, (float)textSize, false, MyGuiDrawAlignEnum.HORISONTAL_LEFT_AND_VERTICAL_CENTER); foreach (var component in entity.Components) { currentPos = pos + n * upVector * lineSize; DebugDrawComponent(component, currentPos, rightVector, upVector, lineSize, (float)textSize); var entityComponent = component as MyEntityComponentBase; string compType = entityComponent == null ? "" : entityComponent.ComponentTypeDebugString; MyRenderProxy.DebugDrawText3D(currentPos - 0.02f * rightVector, compType, Color.Yellow, (float)textSize, false, MyGuiDrawAlignEnum.HORISONTAL_RIGHT_AND_VERTICAL_CENTER); n -= GetComponentLines(component); } } entities.Clear(); } }
public virtual void DebugDraw(ref Matrix drawMatrix) { if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW) { if (MyDebugDrawSettings.DEBUG_DRAW_NAVMESHES != MyWEMDebugDrawMode.NONE) { this.m_mesh.DebugDraw(ref drawMatrix, MyDebugDrawSettings.DEBUG_DRAW_NAVMESHES); this.m_mesh.CustomDebugDrawFaces(ref drawMatrix, MyDebugDrawSettings.DEBUG_DRAW_NAVMESHES, obj => (obj as MyNavigationTriangle).Index.ToString()); } if (MyFakes.DEBUG_DRAW_FUNNEL) { List <Vector3> .Enumerator enumerator; MyRenderProxy.DebugDrawSphere(Vector3.Transform(this.m_vertex, (Matrix)drawMatrix), 0.05f, Color.Yellow.ToVector3(), 1f, false, false, true, false); MyRenderProxy.DebugDrawSphere(Vector3.Transform(this.m_vertex + this.m_normal, (Matrix)drawMatrix), 0.05f, Color.Orange.ToVector3(), 1f, false, false, true, false); MyRenderProxy.DebugDrawSphere(Vector3.Transform(this.m_left, (Matrix)drawMatrix), 0.05f, Color.Red.ToVector3(), 1f, false, false, true, false); Color green = Color.Green; MyRenderProxy.DebugDrawSphere(Vector3.Transform(this.m_right, (Matrix)drawMatrix), 0.05f, green.ToVector3(), 1f, false, false, true, false); using (enumerator = m_debugPointsLeft.GetEnumerator()) { while (enumerator.MoveNext()) { green = Color.Red; MyRenderProxy.DebugDrawSphere(Vector3.Transform(enumerator.Current, (Matrix)drawMatrix), 0.03f, green.ToVector3(), 1f, false, false, true, false); } } using (enumerator = m_debugPointsRight.GetEnumerator()) { while (enumerator.MoveNext()) { green = Color.Green; MyRenderProxy.DebugDrawSphere(Vector3.Transform(enumerator.Current, (Matrix)drawMatrix), 0.04f, green.ToVector3(), 1f, false, false, true, false); } } Vector3?nullable = null; if (m_path != null) { using (enumerator = m_path.GetEnumerator()) { while (enumerator.MoveNext()) { Vector3 vector = Vector3.Transform(enumerator.Current, (Matrix)drawMatrix); MyRenderProxy.DebugDrawSphere(vector + (Vector3.Up * 0.2f), 0.02f, Color.Orange.ToVector3(), 1f, false, false, true, false); if (nullable != null) { MyRenderProxy.DebugDrawLine3D(nullable.Value + (Vector3.Up * 0.2f), vector + (Vector3.Up * 0.2f), Color.Orange, Color.Orange, true, false); } nullable = new Vector3?(vector); } } } nullable = null; if (m_path2 != null) { using (enumerator = m_path2.GetEnumerator()) { while (enumerator.MoveNext()) { Vector3 vector2 = Vector3.Transform(enumerator.Current, (Matrix)drawMatrix); if (nullable != null) { MyRenderProxy.DebugDrawLine3D(nullable.Value + (Vector3.Up * 0.1f), vector2 + (Vector3.Up * 0.1f), Color.Violet, Color.Violet, true, false); } nullable = new Vector3?(vector2); } } } if (m_debugFunnel.Count > 0) { FunnelState local2 = m_debugFunnel[m_debugFunnelIdx % m_debugFunnel.Count]; Vector3 vector3 = Vector3.Transform(local2.Apex, (Matrix)drawMatrix); Vector3 vector4 = vector3 + ((Vector3.Transform(local2.Left, (Matrix)drawMatrix) - vector3) * 10f); Vector3 vector5 = vector3 + ((Vector3.Transform(local2.Right, (Matrix)drawMatrix) - vector3) * 10f); Color cyan = Color.Cyan; MyRenderProxy.DebugDrawLine3D(vector3 + (Vector3.Up * 0.1f), vector4 + (Vector3.Up * 0.1f), cyan, cyan, true, false); MyRenderProxy.DebugDrawLine3D(vector3 + (Vector3.Up * 0.1f), vector5 + (Vector3.Up * 0.1f), cyan, cyan, true, false); } } } }