1695 lines
116 KiB
Plaintext
1695 lines
116 KiB
Plaintext
|
|
Esto es .NET 9.0.
|
|
---------------------
|
|
Versión del SDK: 9.0.203
|
|
|
|
Telemetría
|
|
---------
|
|
Las herramientas de .NET recopilan datos de uso para ayudarnos a mejorar su experiencia. Microsoft los recopila y los comparte con la comunidad. Puede optar por no participar en la telemetría si establece la variable de entorno DOTNET_CLI_TELEMETRY_OPTOUT en "1" o "true" mediante su shell favorito.
|
|
|
|
Lea más sobre la telemetría de las herramientas de la CLI de .NET: https://aka.ms/dotnet-cli-telemetry
|
|
|
|
----------------
|
|
Instalar un certificado de desarrollo HTTPS de ASP.NET Core.
|
|
Para confiar en el certificado, ejecute "dotnet dev-certs https --trust"
|
|
Obtenga información sobre HTTPS: https://aka.ms/dotnet-https
|
|
|
|
----------------
|
|
Escribir su primera aplicación: https://aka.ms/dotnet-hello-world
|
|
Descubra las novedades: https://aka.ms/dotnet-whats-new
|
|
Explore la documentación: https://aka.ms/dotnet-docs
|
|
Notificar problemas y encontrar el código fuente en GitHub: https://github.com/dotnet/core
|
|
Use "dotnet --help" para ver los comandos disponibles o visite: https://aka.ms/dotnet-cli
|
|
--------------------------------------------------------------------------------------
|
|
[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName=".NET 8.0")]
|
|
namespace nkast.Aether.Physics2D.Collision
|
|
{
|
|
public struct AABB
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Vector2 LowerBound;
|
|
public nkast.Aether.Physics2D.Common.Vector2 UpperBound;
|
|
public AABB(nkast.Aether.Physics2D.Common.Vector2 min, nkast.Aether.Physics2D.Common.Vector2 max) { }
|
|
public AABB(ref nkast.Aether.Physics2D.Common.Vector2 min, ref nkast.Aether.Physics2D.Common.Vector2 max) { }
|
|
public AABB(nkast.Aether.Physics2D.Common.Vector2 center, float width, float height) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Center { get; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Extents { get; }
|
|
public float Height { get; }
|
|
public float Perimeter { get; }
|
|
public nkast.Aether.Physics2D.Collision.AABB Q1 { get; }
|
|
public nkast.Aether.Physics2D.Collision.AABB Q2 { get; }
|
|
public nkast.Aether.Physics2D.Collision.AABB Q3 { get; }
|
|
public nkast.Aether.Physics2D.Collision.AABB Q4 { get; }
|
|
public nkast.Aether.Physics2D.Common.Vertices Vertices { get; }
|
|
public float Width { get; }
|
|
public void Combine(ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public void Combine(ref nkast.Aether.Physics2D.Collision.AABB aabb1, ref nkast.Aether.Physics2D.Collision.AABB aabb2) { }
|
|
public bool Contains(ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public bool Contains(ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public bool IsValid() { }
|
|
public bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, bool doInteriorCheck = true) { }
|
|
public static bool TestOverlap(ref nkast.Aether.Physics2D.Collision.AABB a, ref nkast.Aether.Physics2D.Collision.AABB b) { }
|
|
}
|
|
public delegate bool BroadPhaseQueryCallback(int proxyId);
|
|
public delegate float BroadPhaseRayCastCallback(ref nkast.Aether.Physics2D.Collision.RayCastInput input, int proxyId);
|
|
public delegate void BroadphaseDelegate(int proxyIdA, int proxyIdB);
|
|
public struct ClipVertex
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.ContactID ID;
|
|
public nkast.Aether.Physics2D.Common.Vector2 V;
|
|
}
|
|
public static class Collision
|
|
{
|
|
public static void CollideCircles(ref nkast.Aether.Physics2D.Collision.Manifold manifold, nkast.Aether.Physics2D.Collision.Shapes.CircleShape circleA, ref nkast.Aether.Physics2D.Common.Transform xfA, nkast.Aether.Physics2D.Collision.Shapes.CircleShape circleB, ref nkast.Aether.Physics2D.Common.Transform xfB) { }
|
|
public static void CollideEdgeAndCircle(ref nkast.Aether.Physics2D.Collision.Manifold manifold, nkast.Aether.Physics2D.Collision.Shapes.EdgeShape edgeA, ref nkast.Aether.Physics2D.Common.Transform transformA, nkast.Aether.Physics2D.Collision.Shapes.CircleShape circleB, ref nkast.Aether.Physics2D.Common.Transform transformB) { }
|
|
public static void CollideEdgeAndPolygon(ref nkast.Aether.Physics2D.Collision.Manifold manifold, nkast.Aether.Physics2D.Collision.Shapes.EdgeShape edgeA, ref nkast.Aether.Physics2D.Common.Transform xfA, nkast.Aether.Physics2D.Collision.Shapes.PolygonShape polygonB, ref nkast.Aether.Physics2D.Common.Transform xfB) { }
|
|
public static void CollidePolygonAndCircle(ref nkast.Aether.Physics2D.Collision.Manifold manifold, nkast.Aether.Physics2D.Collision.Shapes.PolygonShape polygonA, ref nkast.Aether.Physics2D.Common.Transform xfA, nkast.Aether.Physics2D.Collision.Shapes.CircleShape circleB, ref nkast.Aether.Physics2D.Common.Transform xfB) { }
|
|
public static void CollidePolygons(ref nkast.Aether.Physics2D.Collision.Manifold manifold, nkast.Aether.Physics2D.Collision.Shapes.PolygonShape polyA, ref nkast.Aether.Physics2D.Common.Transform transformA, nkast.Aether.Physics2D.Collision.Shapes.PolygonShape polyB, ref nkast.Aether.Physics2D.Common.Transform transformB) { }
|
|
public static void GetPointStates(out nkast.Aether.Physics2D.Common.FixedArray2<nkast.Aether.Physics2D.Collision.PointState> state1, out nkast.Aether.Physics2D.Common.FixedArray2<nkast.Aether.Physics2D.Collision.PointState> state2, ref nkast.Aether.Physics2D.Collision.Manifold manifold1, ref nkast.Aether.Physics2D.Collision.Manifold manifold2) { }
|
|
public static bool TestOverlap(nkast.Aether.Physics2D.Collision.Shapes.Shape shapeA, int indexA, nkast.Aether.Physics2D.Collision.Shapes.Shape shapeB, int indexB, ref nkast.Aether.Physics2D.Common.Transform xfA, ref nkast.Aether.Physics2D.Common.Transform xfB) { }
|
|
}
|
|
public struct ContactFeature
|
|
{
|
|
public byte IndexA;
|
|
public byte IndexB;
|
|
public byte TypeA;
|
|
public byte TypeB;
|
|
}
|
|
public struct ContactID
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.ContactFeature Features;
|
|
public uint Key;
|
|
}
|
|
public static class Distance
|
|
{
|
|
[System.ThreadStatic]
|
|
public static int GJKCalls;
|
|
[System.ThreadStatic]
|
|
public static int GJKIters;
|
|
[System.ThreadStatic]
|
|
public static int GJKMaxIters;
|
|
public static void ComputeDistance(out nkast.Aether.Physics2D.Collision.DistanceOutput output, out nkast.Aether.Physics2D.Collision.SimplexCache cache, nkast.Aether.Physics2D.Collision.DistanceInput input) { }
|
|
}
|
|
public struct DistanceInput
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.DistanceProxy ProxyA;
|
|
public nkast.Aether.Physics2D.Collision.DistanceProxy ProxyB;
|
|
public nkast.Aether.Physics2D.Common.Transform TransformA;
|
|
public nkast.Aether.Physics2D.Common.Transform TransformB;
|
|
public bool UseRadii;
|
|
}
|
|
public struct DistanceOutput
|
|
{
|
|
public float Distance;
|
|
public int Iterations;
|
|
public nkast.Aether.Physics2D.Common.Vector2 PointA;
|
|
public nkast.Aether.Physics2D.Common.Vector2 PointB;
|
|
}
|
|
public struct DistanceProxy
|
|
{
|
|
public DistanceProxy(nkast.Aether.Physics2D.Collision.Shapes.Shape shape, int index) { }
|
|
public int GetSupport(nkast.Aether.Physics2D.Common.Vector2 direction) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetSupportVertex(nkast.Aether.Physics2D.Common.Vector2 direction) { }
|
|
}
|
|
public class DynamicTreeBroadPhase : nkast.Aether.Physics2D.Collision.DynamicTreeBroadPhase<nkast.Aether.Physics2D.Dynamics.FixtureProxy>, nkast.Aether.Physics2D.Collision.IBroadPhase, nkast.Aether.Physics2D.Collision.IBroadPhase<nkast.Aether.Physics2D.Dynamics.FixtureProxy>
|
|
{
|
|
public DynamicTreeBroadPhase() { }
|
|
}
|
|
public class DynamicTreeBroadPhase<TNode> : nkast.Aether.Physics2D.Collision.IBroadPhase<TNode>
|
|
where TNode : struct
|
|
{
|
|
public DynamicTreeBroadPhase() { }
|
|
public int ProxyCount { get; }
|
|
public int TreeBalance { get; }
|
|
public int TreeHeight { get; }
|
|
public float TreeQuality { get; }
|
|
public int AddProxy(ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public void GetFatAABB(int proxyId, out nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public TNode GetProxy(int proxyId) { }
|
|
public void MoveProxy(int proxyId, ref nkast.Aether.Physics2D.Collision.AABB aabb, nkast.Aether.Physics2D.Common.Vector2 displacement) { }
|
|
public void Query(nkast.Aether.Physics2D.Collision.BroadPhaseQueryCallback callback, ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public void RayCast(nkast.Aether.Physics2D.Collision.BroadPhaseRayCastCallback callback, ref nkast.Aether.Physics2D.Collision.RayCastInput input) { }
|
|
public void RemoveProxy(int proxyId) { }
|
|
public void SetProxy(int proxyId, ref TNode proxy) { }
|
|
public void ShiftOrigin(nkast.Aether.Physics2D.Common.Vector2 newOrigin) { }
|
|
public bool TestOverlap(int proxyIdA, int proxyIdB) { }
|
|
public void TouchProxy(int proxyId) { }
|
|
public void UpdatePairs(nkast.Aether.Physics2D.Collision.BroadphaseDelegate callback) { }
|
|
}
|
|
public class DynamicTree<TNode>
|
|
{
|
|
public DynamicTree() { }
|
|
public float AreaRatio { get; }
|
|
public int Height { get; }
|
|
public int MaxBalance { get; }
|
|
public int AddProxy(ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public int ComputeHeight() { }
|
|
public int ComputeHeight(int nodeId) { }
|
|
public nkast.Aether.Physics2D.Collision.AABB GetFatAABB(int proxyId) { }
|
|
public void GetFatAABB(int proxyId, out nkast.Aether.Physics2D.Collision.AABB fatAABB) { }
|
|
public TNode GetUserData(int proxyId) { }
|
|
public bool MoveProxy(int proxyId, ref nkast.Aether.Physics2D.Collision.AABB aabb, nkast.Aether.Physics2D.Common.Vector2 displacement) { }
|
|
public void Query(nkast.Aether.Physics2D.Collision.BroadPhaseQueryCallback callback, ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public void RayCast(nkast.Aether.Physics2D.Collision.BroadPhaseRayCastCallback callback, ref nkast.Aether.Physics2D.Collision.RayCastInput input) { }
|
|
public void RebuildBottomUp() { }
|
|
public void RemoveProxy(int proxyId) { }
|
|
public void SetUserData(int proxyId, TNode userData) { }
|
|
public void ShiftOrigin(nkast.Aether.Physics2D.Common.Vector2 newOrigin) { }
|
|
public bool TestFatAABBOverlap(int proxyIdA, int proxyIdB) { }
|
|
public void Validate() { }
|
|
public void ValidateMetrics(int index) { }
|
|
public void ValidateStructure(int index) { }
|
|
}
|
|
public struct EPAxis
|
|
{
|
|
public int Index;
|
|
public float Separation;
|
|
public nkast.Aether.Physics2D.Collision.EPAxisType Type;
|
|
}
|
|
public enum EPAxisType
|
|
{
|
|
Unknown = 0,
|
|
EdgeA = 1,
|
|
EdgeB = 2,
|
|
}
|
|
public interface IBroadPhase : nkast.Aether.Physics2D.Collision.IBroadPhase<nkast.Aether.Physics2D.Dynamics.FixtureProxy> { }
|
|
public interface IBroadPhase<TNode>
|
|
where TNode : struct
|
|
{
|
|
int ProxyCount { get; }
|
|
int AddProxy(ref nkast.Aether.Physics2D.Collision.AABB aabb);
|
|
void GetFatAABB(int proxyId, out nkast.Aether.Physics2D.Collision.AABB aabb);
|
|
TNode GetProxy(int proxyId);
|
|
void MoveProxy(int proxyId, ref nkast.Aether.Physics2D.Collision.AABB aabb, nkast.Aether.Physics2D.Common.Vector2 displacement);
|
|
void Query(nkast.Aether.Physics2D.Collision.BroadPhaseQueryCallback callback, ref nkast.Aether.Physics2D.Collision.AABB aabb);
|
|
void RayCast(nkast.Aether.Physics2D.Collision.BroadPhaseRayCastCallback callback, ref nkast.Aether.Physics2D.Collision.RayCastInput input);
|
|
void RemoveProxy(int proxyId);
|
|
void SetProxy(int proxyId, ref TNode proxy);
|
|
void ShiftOrigin(nkast.Aether.Physics2D.Common.Vector2 newOrigin);
|
|
bool TestOverlap(int proxyIdA, int proxyIdB);
|
|
void TouchProxy(int proxyId);
|
|
void UpdatePairs(nkast.Aether.Physics2D.Collision.BroadphaseDelegate callback);
|
|
}
|
|
public struct Manifold
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalNormal;
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalPoint;
|
|
public int PointCount;
|
|
public nkast.Aether.Physics2D.Common.FixedArray2<nkast.Aether.Physics2D.Collision.ManifoldPoint> Points;
|
|
public nkast.Aether.Physics2D.Collision.ManifoldType Type;
|
|
}
|
|
public struct ManifoldPoint
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.ContactID Id;
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalPoint;
|
|
public float NormalImpulse;
|
|
public float TangentImpulse;
|
|
}
|
|
public enum ManifoldType
|
|
{
|
|
Circles = 0,
|
|
FaceA = 1,
|
|
FaceB = 2,
|
|
}
|
|
public enum PointState
|
|
{
|
|
Null = 0,
|
|
Add = 1,
|
|
Persist = 2,
|
|
Remove = 3,
|
|
}
|
|
public struct RayCastInput
|
|
{
|
|
public float MaxFraction;
|
|
public nkast.Aether.Physics2D.Common.Vector2 Point1;
|
|
public nkast.Aether.Physics2D.Common.Vector2 Point2;
|
|
}
|
|
public struct RayCastOutput
|
|
{
|
|
public float Fraction;
|
|
public nkast.Aether.Physics2D.Common.Vector2 Normal;
|
|
}
|
|
public struct ReferenceFace
|
|
{
|
|
public int i1;
|
|
public int i2;
|
|
public nkast.Aether.Physics2D.Common.Vector2 normal;
|
|
public nkast.Aether.Physics2D.Common.Vector2 sideNormal1;
|
|
public nkast.Aether.Physics2D.Common.Vector2 sideNormal2;
|
|
public float sideOffset1;
|
|
public float sideOffset2;
|
|
public nkast.Aether.Physics2D.Common.Vector2 v1;
|
|
public nkast.Aether.Physics2D.Common.Vector2 v2;
|
|
}
|
|
public static class SeparationFunction
|
|
{
|
|
public static float Evaluate(int indexA, int indexB, float t) { }
|
|
public static float FindMinSeparation(out int indexA, out int indexB, float t) { }
|
|
public static void Set(ref nkast.Aether.Physics2D.Collision.SimplexCache cache, ref nkast.Aether.Physics2D.Collision.DistanceProxy proxyA, ref nkast.Aether.Physics2D.Common.Sweep sweepA, ref nkast.Aether.Physics2D.Collision.DistanceProxy proxyB, ref nkast.Aether.Physics2D.Common.Sweep sweepB, float t1) { }
|
|
}
|
|
public enum SeparationFunctionType
|
|
{
|
|
Points = 0,
|
|
FaceA = 1,
|
|
FaceB = 2,
|
|
}
|
|
public struct SimplexCache
|
|
{
|
|
public ushort Count;
|
|
public nkast.Aether.Physics2D.Common.FixedArray3<byte> IndexA;
|
|
public nkast.Aether.Physics2D.Common.FixedArray3<byte> IndexB;
|
|
public float Metric;
|
|
}
|
|
public class TOIInput
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.DistanceProxy ProxyA;
|
|
public nkast.Aether.Physics2D.Collision.DistanceProxy ProxyB;
|
|
public nkast.Aether.Physics2D.Common.Sweep SweepA;
|
|
public nkast.Aether.Physics2D.Common.Sweep SweepB;
|
|
public float TMax;
|
|
public TOIInput() { }
|
|
}
|
|
public struct TOIOutput
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.TOIOutputState State;
|
|
public float T;
|
|
}
|
|
public enum TOIOutputState
|
|
{
|
|
Unknown = 0,
|
|
Failed = 1,
|
|
Overlapped = 2,
|
|
Touching = 3,
|
|
Seperated = 4,
|
|
}
|
|
public static class TimeOfImpact
|
|
{
|
|
[System.ThreadStatic]
|
|
public static int TOICalls;
|
|
[System.ThreadStatic]
|
|
public static int TOIIters;
|
|
[System.ThreadStatic]
|
|
public static int TOIMaxIters;
|
|
[System.ThreadStatic]
|
|
public static int TOIMaxRootIters;
|
|
[System.ThreadStatic]
|
|
public static int TOIRootIters;
|
|
public static void CalculateTimeOfImpact(out nkast.Aether.Physics2D.Collision.TOIOutput output, ref nkast.Aether.Physics2D.Collision.TOIInput input) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Collision.Shapes
|
|
{
|
|
public class ChainShape : nkast.Aether.Physics2D.Collision.Shapes.Shape
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Vertices Vertices;
|
|
public ChainShape() { }
|
|
public ChainShape(nkast.Aether.Physics2D.Common.Vertices vertices, bool createLoop = false) { }
|
|
public override int ChildCount { get; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 NextVertex { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 PrevVertex { get; set; }
|
|
public override nkast.Aether.Physics2D.Collision.Shapes.Shape Clone() { }
|
|
public bool CompareTo(nkast.Aether.Physics2D.Collision.Shapes.ChainShape shape) { }
|
|
public override void ComputeAABB(out nkast.Aether.Physics2D.Collision.AABB aabb, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
protected override void ComputeProperties() { }
|
|
public override float ComputeSubmergedArea(ref nkast.Aether.Physics2D.Common.Vector2 normal, float offset, ref nkast.Aether.Physics2D.Common.Transform xf, out nkast.Aether.Physics2D.Common.Vector2 sc) { }
|
|
public nkast.Aether.Physics2D.Collision.Shapes.EdgeShape GetChildEdge(int index) { }
|
|
public override bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
public override bool TestPoint(ref nkast.Aether.Physics2D.Common.Transform transform, ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
}
|
|
public class CircleShape : nkast.Aether.Physics2D.Collision.Shapes.Shape
|
|
{
|
|
public CircleShape(float radius, float density) { }
|
|
public override int ChildCount { get; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Position { get; set; }
|
|
public override nkast.Aether.Physics2D.Collision.Shapes.Shape Clone() { }
|
|
public bool CompareTo(nkast.Aether.Physics2D.Collision.Shapes.CircleShape shape) { }
|
|
public override void ComputeAABB(out nkast.Aether.Physics2D.Collision.AABB aabb, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
protected override sealed void ComputeProperties() { }
|
|
public override float ComputeSubmergedArea(ref nkast.Aether.Physics2D.Common.Vector2 normal, float offset, ref nkast.Aether.Physics2D.Common.Transform xf, out nkast.Aether.Physics2D.Common.Vector2 sc) { }
|
|
public override bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
public override bool TestPoint(ref nkast.Aether.Physics2D.Common.Transform transform, ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
}
|
|
public class EdgeShape : nkast.Aether.Physics2D.Collision.Shapes.Shape
|
|
{
|
|
public EdgeShape(nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public override int ChildCount { get; }
|
|
public bool HasVertex0 { get; set; }
|
|
public bool HasVertex3 { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Vertex0 { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Vertex1 { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Vertex2 { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Vertex3 { get; set; }
|
|
public override nkast.Aether.Physics2D.Collision.Shapes.Shape Clone() { }
|
|
public bool CompareTo(nkast.Aether.Physics2D.Collision.Shapes.EdgeShape shape) { }
|
|
public override void ComputeAABB(out nkast.Aether.Physics2D.Collision.AABB aabb, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
protected override void ComputeProperties() { }
|
|
public override float ComputeSubmergedArea(ref nkast.Aether.Physics2D.Common.Vector2 normal, float offset, ref nkast.Aether.Physics2D.Common.Transform xf, out nkast.Aether.Physics2D.Common.Vector2 sc) { }
|
|
public override bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
public void Set(nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public override bool TestPoint(ref nkast.Aether.Physics2D.Common.Transform transform, ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
}
|
|
public struct MassData : System.IEquatable<nkast.Aether.Physics2D.Collision.Shapes.MassData>
|
|
{
|
|
public float Area { get; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Centroid { get; }
|
|
public float Inertia { get; }
|
|
public float Mass { get; }
|
|
public bool Equals(nkast.Aether.Physics2D.Collision.Shapes.MassData other) { }
|
|
public override bool Equals(object obj) { }
|
|
public override int GetHashCode() { }
|
|
public static bool operator !=(nkast.Aether.Physics2D.Collision.Shapes.MassData left, nkast.Aether.Physics2D.Collision.Shapes.MassData right) { }
|
|
public static bool operator ==(nkast.Aether.Physics2D.Collision.Shapes.MassData left, nkast.Aether.Physics2D.Collision.Shapes.MassData right) { }
|
|
}
|
|
public class PolygonShape : nkast.Aether.Physics2D.Collision.Shapes.Shape
|
|
{
|
|
public PolygonShape(float density) { }
|
|
public PolygonShape(nkast.Aether.Physics2D.Common.Vertices vertices, float density) { }
|
|
public override int ChildCount { get; }
|
|
public nkast.Aether.Physics2D.Common.Vertices Normals { get; }
|
|
public nkast.Aether.Physics2D.Common.Vertices Vertices { get; set; }
|
|
public override nkast.Aether.Physics2D.Collision.Shapes.Shape Clone() { }
|
|
public bool CompareTo(nkast.Aether.Physics2D.Collision.Shapes.PolygonShape shape) { }
|
|
public override void ComputeAABB(out nkast.Aether.Physics2D.Collision.AABB aabb, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
protected override void ComputeProperties() { }
|
|
public override float ComputeSubmergedArea(ref nkast.Aether.Physics2D.Common.Vector2 normal, float offset, ref nkast.Aether.Physics2D.Common.Transform xf, out nkast.Aether.Physics2D.Common.Vector2 sc) { }
|
|
public override bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex) { }
|
|
public override bool TestPoint(ref nkast.Aether.Physics2D.Common.Transform transform, ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
}
|
|
public abstract class Shape
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.Shapes.MassData MassData;
|
|
protected Shape(float density) { }
|
|
public abstract int ChildCount { get; }
|
|
public float Density { get; set; }
|
|
public float Radius { get; set; }
|
|
public nkast.Aether.Physics2D.Collision.Shapes.ShapeType ShapeType { get; }
|
|
public abstract nkast.Aether.Physics2D.Collision.Shapes.Shape Clone();
|
|
public abstract void ComputeAABB(out nkast.Aether.Physics2D.Collision.AABB aabb, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex);
|
|
protected abstract void ComputeProperties();
|
|
public abstract float ComputeSubmergedArea(ref nkast.Aether.Physics2D.Common.Vector2 normal, float offset, ref nkast.Aether.Physics2D.Common.Transform xf, out nkast.Aether.Physics2D.Common.Vector2 sc);
|
|
public abstract bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, ref nkast.Aether.Physics2D.Common.Transform transform, int childIndex);
|
|
public abstract bool TestPoint(ref nkast.Aether.Physics2D.Common.Transform transform, ref nkast.Aether.Physics2D.Common.Vector2 point);
|
|
}
|
|
public enum ShapeType
|
|
{
|
|
Unknown = -1,
|
|
Circle = 0,
|
|
Edge = 1,
|
|
Polygon = 2,
|
|
Chain = 3,
|
|
TypeCount = 4,
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Common
|
|
{
|
|
public struct Complex
|
|
{
|
|
public float R;
|
|
public float i;
|
|
public Complex(float real, float imaginary) { }
|
|
public float Magnitude { get; }
|
|
public float Phase { get; set; }
|
|
public static nkast.Aether.Physics2D.Common.Complex ImaginaryOne { get; }
|
|
public static nkast.Aether.Physics2D.Common.Complex One { get; }
|
|
public void Conjugate() { }
|
|
public float MagnitudeSquared() { }
|
|
public void Negate() { }
|
|
public void Normalize() { }
|
|
public override string ToString() { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 ToVector2() { }
|
|
public static nkast.Aether.Physics2D.Common.Complex Conjugate(ref nkast.Aether.Physics2D.Common.Complex value) { }
|
|
public static nkast.Aether.Physics2D.Common.Complex Divide(ref nkast.Aether.Physics2D.Common.Complex left, ref nkast.Aether.Physics2D.Common.Complex right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Divide(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Complex right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Divide(nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Complex right) { }
|
|
public static void Divide(ref nkast.Aether.Physics2D.Common.Complex left, ref nkast.Aether.Physics2D.Common.Complex right, out nkast.Aether.Physics2D.Common.Complex result) { }
|
|
public static void Divide(nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Complex right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static nkast.Aether.Physics2D.Common.Complex FromAngle(float angle) { }
|
|
public static nkast.Aether.Physics2D.Common.Complex Multiply(ref nkast.Aether.Physics2D.Common.Complex left, ref nkast.Aether.Physics2D.Common.Complex right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Multiply(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Complex right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Multiply(nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Complex right) { }
|
|
public static void Multiply(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Complex right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static nkast.Aether.Physics2D.Common.Complex Negate(ref nkast.Aether.Physics2D.Common.Complex value) { }
|
|
public static nkast.Aether.Physics2D.Common.Complex Normalize(ref nkast.Aether.Physics2D.Common.Complex value) { }
|
|
}
|
|
public struct FixedArray2<T>
|
|
{
|
|
public T this[int index] { get; set; }
|
|
}
|
|
public struct FixedArray3<T>
|
|
{
|
|
public T this[int index] { get; set; }
|
|
}
|
|
public struct FixedArray4<T>
|
|
{
|
|
public T this[int index] { get; set; }
|
|
}
|
|
public struct FixedArray8<T>
|
|
{
|
|
public T this[int index] { get; set; }
|
|
}
|
|
public static class LineTools
|
|
{
|
|
public static float DistanceBetweenPointAndLineSegment(ref nkast.Aether.Physics2D.Common.Vector2 point, ref nkast.Aether.Physics2D.Common.Vector2 start, ref nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 LineIntersect(nkast.Aether.Physics2D.Common.Vector2 p1, nkast.Aether.Physics2D.Common.Vector2 p2, nkast.Aether.Physics2D.Common.Vector2 q1, nkast.Aether.Physics2D.Common.Vector2 q2) { }
|
|
public static bool LineIntersect(ref nkast.Aether.Physics2D.Common.Vector2 point1, ref nkast.Aether.Physics2D.Common.Vector2 point2, ref nkast.Aether.Physics2D.Common.Vector2 point3, ref nkast.Aether.Physics2D.Common.Vector2 point4, out nkast.Aether.Physics2D.Common.Vector2 intersectionPoint) { }
|
|
public static bool LineIntersect(nkast.Aether.Physics2D.Common.Vector2 point1, nkast.Aether.Physics2D.Common.Vector2 point2, nkast.Aether.Physics2D.Common.Vector2 point3, nkast.Aether.Physics2D.Common.Vector2 point4, out nkast.Aether.Physics2D.Common.Vector2 intersectionPoint) { }
|
|
public static bool LineIntersect(nkast.Aether.Physics2D.Common.Vector2 point1, nkast.Aether.Physics2D.Common.Vector2 point2, nkast.Aether.Physics2D.Common.Vector2 point3, nkast.Aether.Physics2D.Common.Vector2 point4, bool firstIsSegment, bool secondIsSegment, out nkast.Aether.Physics2D.Common.Vector2 intersectionPoint) { }
|
|
public static bool LineIntersect(ref nkast.Aether.Physics2D.Common.Vector2 point1, ref nkast.Aether.Physics2D.Common.Vector2 point2, ref nkast.Aether.Physics2D.Common.Vector2 point3, ref nkast.Aether.Physics2D.Common.Vector2 point4, bool firstIsSegment, bool secondIsSegment, out nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public static bool LineIntersect2(ref nkast.Aether.Physics2D.Common.Vector2 a0, ref nkast.Aether.Physics2D.Common.Vector2 a1, ref nkast.Aether.Physics2D.Common.Vector2 b0, ref nkast.Aether.Physics2D.Common.Vector2 b1, out nkast.Aether.Physics2D.Common.Vector2 intersectionPoint) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices LineSegmentAABBIntersect(ref nkast.Aether.Physics2D.Common.Vector2 point1, ref nkast.Aether.Physics2D.Common.Vector2 point2, nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices LineSegmentVerticesIntersect(ref nkast.Aether.Physics2D.Common.Vector2 point1, ref nkast.Aether.Physics2D.Common.Vector2 point2, nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
}
|
|
public struct Mat22
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Vector2 ex;
|
|
public nkast.Aether.Physics2D.Common.Vector2 ey;
|
|
public Mat22(nkast.Aether.Physics2D.Common.Vector2 c1, nkast.Aether.Physics2D.Common.Vector2 c2) { }
|
|
public Mat22(float a11, float a12, float a21, float a22) { }
|
|
public nkast.Aether.Physics2D.Common.Mat22 Inverse { get; }
|
|
public void Set(nkast.Aether.Physics2D.Common.Vector2 c1, nkast.Aether.Physics2D.Common.Vector2 c2) { }
|
|
public void SetIdentity() { }
|
|
public void SetZero() { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Solve(nkast.Aether.Physics2D.Common.Vector2 b) { }
|
|
public static void Add(ref nkast.Aether.Physics2D.Common.Mat22 A, ref nkast.Aether.Physics2D.Common.Mat22 B, out nkast.Aether.Physics2D.Common.Mat22 R) { }
|
|
}
|
|
public struct Mat33
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Vector3 ex;
|
|
public nkast.Aether.Physics2D.Common.Vector3 ey;
|
|
public nkast.Aether.Physics2D.Common.Vector3 ez;
|
|
public Mat33(nkast.Aether.Physics2D.Common.Vector3 c1, nkast.Aether.Physics2D.Common.Vector3 c2, nkast.Aether.Physics2D.Common.Vector3 c3) { }
|
|
public void GetInverse22(ref nkast.Aether.Physics2D.Common.Mat33 M) { }
|
|
public void GetSymInverse33(ref nkast.Aether.Physics2D.Common.Mat33 M) { }
|
|
public void SetZero() { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Solve22(nkast.Aether.Physics2D.Common.Vector2 b) { }
|
|
public nkast.Aether.Physics2D.Common.Vector3 Solve33(nkast.Aether.Physics2D.Common.Vector3 b) { }
|
|
}
|
|
public static class MathUtils
|
|
{
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Abs(nkast.Aether.Physics2D.Common.Vector2 v) { }
|
|
public static float Area(nkast.Aether.Physics2D.Common.Vector2 a, nkast.Aether.Physics2D.Common.Vector2 b, nkast.Aether.Physics2D.Common.Vector2 c) { }
|
|
public static float Area(ref nkast.Aether.Physics2D.Common.Vector2 a, ref nkast.Aether.Physics2D.Common.Vector2 b, ref nkast.Aether.Physics2D.Common.Vector2 c) { }
|
|
public static float Clamp(float a, float low, float high) { }
|
|
public static int Clamp(int a, int low, int high) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Clamp(nkast.Aether.Physics2D.Common.Vector2 a, nkast.Aether.Physics2D.Common.Vector2 low, nkast.Aether.Physics2D.Common.Vector2 high) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Cross(float s, ref nkast.Aether.Physics2D.Common.Vector2 a) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Cross(nkast.Aether.Physics2D.Common.Vector2 a, float s) { }
|
|
public static float Cross(ref nkast.Aether.Physics2D.Common.Vector2 a, ref nkast.Aether.Physics2D.Common.Vector2 b) { }
|
|
public static float Cross(nkast.Aether.Physics2D.Common.Vector2 a, nkast.Aether.Physics2D.Common.Vector2 b) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 Cross(ref nkast.Aether.Physics2D.Common.Vector3 a, ref nkast.Aether.Physics2D.Common.Vector3 b) { }
|
|
public static void Cross(float s, ref nkast.Aether.Physics2D.Common.Vector2 a, out nkast.Aether.Physics2D.Common.Vector2 b) { }
|
|
public static void Cross(ref nkast.Aether.Physics2D.Common.Vector2 a, ref nkast.Aether.Physics2D.Common.Vector2 b, out float c) { }
|
|
public static float Dot(nkast.Aether.Physics2D.Common.Vector2 a, ref nkast.Aether.Physics2D.Common.Vector2 b) { }
|
|
public static float Dot(nkast.Aether.Physics2D.Common.Vector3 a, nkast.Aether.Physics2D.Common.Vector3 b) { }
|
|
public static bool FloatEquals(float value1, float value2) { }
|
|
public static bool FloatEquals(float value1, float value2, float delta) { }
|
|
public static bool FloatInRange(float value, float min, float max) { }
|
|
public static bool IsCollinear(ref nkast.Aether.Physics2D.Common.Vector2 a, ref nkast.Aether.Physics2D.Common.Vector2 b, ref nkast.Aether.Physics2D.Common.Vector2 c, float tolerance = 0) { }
|
|
public static bool IsValid(float x) { }
|
|
public static bool IsValid(this nkast.Aether.Physics2D.Common.Vector2 x) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Mul(ref nkast.Aether.Physics2D.Common.Mat22 A, nkast.Aether.Physics2D.Common.Vector2 v) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Mul(ref nkast.Aether.Physics2D.Common.Mat22 A, ref nkast.Aether.Physics2D.Common.Vector2 v) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 Mul(nkast.Aether.Physics2D.Common.Mat33 A, nkast.Aether.Physics2D.Common.Vector3 v) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Mul22(nkast.Aether.Physics2D.Common.Mat33 A, nkast.Aether.Physics2D.Common.Vector2 v) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 MulT(ref nkast.Aether.Physics2D.Common.Mat22 A, nkast.Aether.Physics2D.Common.Vector2 v) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 MulT(ref nkast.Aether.Physics2D.Common.Mat22 A, ref nkast.Aether.Physics2D.Common.Vector2 v) { }
|
|
public static void MulT(ref nkast.Aether.Physics2D.Common.Mat22 A, ref nkast.Aether.Physics2D.Common.Mat22 B, out nkast.Aether.Physics2D.Common.Mat22 C) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Rot270(ref nkast.Aether.Physics2D.Common.Vector2 a) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Rot90(ref nkast.Aether.Physics2D.Common.Vector2 a) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Skew(nkast.Aether.Physics2D.Common.Vector2 input) { }
|
|
public static void Swap<T>(ref T a, ref T b) { }
|
|
public static double VectorAngle(ref nkast.Aether.Physics2D.Common.Vector2 p1, ref nkast.Aether.Physics2D.Common.Vector2 p2) { }
|
|
public static double VectorAngle(nkast.Aether.Physics2D.Common.Vector2 p1, nkast.Aether.Physics2D.Common.Vector2 p2) { }
|
|
}
|
|
public class Path
|
|
{
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vector2> ControlPoints;
|
|
public Path() { }
|
|
public Path(System.Collections.Generic.IList<nkast.Aether.Physics2D.Common.Vector2> vertices) { }
|
|
public Path(nkast.Aether.Physics2D.Common.Vector2[] vertices) { }
|
|
public bool Closed { get; set; }
|
|
public void Add(nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public float GetLength() { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetPosition(float time) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetPositionNormal(float time) { }
|
|
public nkast.Aether.Physics2D.Common.Vertices GetVertices(int divisions) { }
|
|
public int NextIndex(int index) { }
|
|
public int PreviousIndex(int index) { }
|
|
public void Remove(nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public void RemoveAt(int index) { }
|
|
public void Rotate(float value) { }
|
|
public void Scale(ref nkast.Aether.Physics2D.Common.Vector2 value) { }
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vector3> SubdivideEvenly(int divisions) { }
|
|
public override string ToString() { }
|
|
public void Translate(ref nkast.Aether.Physics2D.Common.Vector2 vector) { }
|
|
}
|
|
public static class PathManager
|
|
{
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Joints.RevoluteJoint> AttachBodiesWithRevoluteJoint(nkast.Aether.Physics2D.Dynamics.World world, System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Body> bodies, nkast.Aether.Physics2D.Common.Vector2 localAnchorA, nkast.Aether.Physics2D.Common.Vector2 localAnchorB, bool connectFirstAndLast, bool collideConnected) { }
|
|
public static void ConvertPathToEdges(nkast.Aether.Physics2D.Common.Path path, nkast.Aether.Physics2D.Dynamics.Body body, int subdivisions) { }
|
|
public static void ConvertPathToPolygon(nkast.Aether.Physics2D.Common.Path path, nkast.Aether.Physics2D.Dynamics.Body body, float density, int subdivisions) { }
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Body> EvenlyDistributeShapesAlongPath(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Common.Path path, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Collision.Shapes.Shape> shapes, nkast.Aether.Physics2D.Dynamics.BodyType type, int copies, object userData = null) { }
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Body> EvenlyDistributeShapesAlongPath(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Common.Path path, nkast.Aether.Physics2D.Collision.Shapes.Shape shape, nkast.Aether.Physics2D.Dynamics.BodyType type, int copies, object userData = null) { }
|
|
public static void MoveBodyOnPath(nkast.Aether.Physics2D.Common.Path path, nkast.Aether.Physics2D.Dynamics.Body body, float time, float strength, float timeStep) { }
|
|
public enum LinkType
|
|
{
|
|
Revolute = 0,
|
|
Slider = 1,
|
|
}
|
|
}
|
|
public enum PolygonError
|
|
{
|
|
NoError = 0,
|
|
InvalidAmountOfVertices = 1,
|
|
NotSimple = 2,
|
|
NotCounterClockWise = 3,
|
|
NotConvex = 4,
|
|
AreaTooSmall = 5,
|
|
SideTooSmall = 6,
|
|
}
|
|
public static class PolygonTools
|
|
{
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateArc(float radians, int sides, float radius) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateCapsule(float height, float endRadius, int edges) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateCapsule(float height, float topRadius, int topEdges, float bottomRadius, int bottomEdges) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateCircle(float radius, int numberOfEdges) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateEllipse(float xRadius, float yRadius, int numberOfEdges) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateGear(float radius, int numberOfTeeth, float tipPercentage, float toothHeight) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateLine(nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateRectangle(float hx, float hy) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateRectangle(float hx, float hy, nkast.Aether.Physics2D.Common.Vector2 center, float angle) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices CreateRoundedRectangle(float width, float height, float xRadius, float yRadius, int segments) { }
|
|
}
|
|
public struct Sweep
|
|
{
|
|
public float A;
|
|
public float A0;
|
|
public float Alpha0;
|
|
public nkast.Aether.Physics2D.Common.Vector2 C;
|
|
public nkast.Aether.Physics2D.Common.Vector2 C0;
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalCenter;
|
|
public void Advance(float alpha) { }
|
|
public void GetTransform(out nkast.Aether.Physics2D.Common.Transform xfb, float beta) { }
|
|
public void Normalize() { }
|
|
}
|
|
public struct Transform
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Vector2 p;
|
|
public nkast.Aether.Physics2D.Common.Complex q;
|
|
public Transform(nkast.Aether.Physics2D.Common.Vector2 position, float angle) { }
|
|
public Transform(nkast.Aether.Physics2D.Common.Vector2 position, nkast.Aether.Physics2D.Common.Complex rotation) { }
|
|
public static nkast.Aether.Physics2D.Common.Transform Identity { get; }
|
|
public static nkast.Aether.Physics2D.Common.Transform Divide(ref nkast.Aether.Physics2D.Common.Transform left, ref nkast.Aether.Physics2D.Common.Transform right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Divide(nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Transform right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Divide(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Transform right) { }
|
|
public static void Divide(ref nkast.Aether.Physics2D.Common.Transform left, nkast.Aether.Physics2D.Common.Complex right, out nkast.Aether.Physics2D.Common.Transform result) { }
|
|
public static void Divide(ref nkast.Aether.Physics2D.Common.Transform left, ref nkast.Aether.Physics2D.Common.Transform right, out nkast.Aether.Physics2D.Common.Transform result) { }
|
|
public static void Divide(nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Transform right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static nkast.Aether.Physics2D.Common.Transform Multiply(ref nkast.Aether.Physics2D.Common.Transform left, ref nkast.Aether.Physics2D.Common.Transform right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Multiply(nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Transform right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Multiply(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Transform right) { }
|
|
public static void Multiply(ref nkast.Aether.Physics2D.Common.Transform left, nkast.Aether.Physics2D.Common.Complex right, out nkast.Aether.Physics2D.Common.Transform result) { }
|
|
}
|
|
public struct Vector2 : System.IEquatable<nkast.Aether.Physics2D.Common.Vector2>
|
|
{
|
|
public float X;
|
|
public float Y;
|
|
public Vector2(float xy) { }
|
|
public Vector2(float x, float y) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 One { get; }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 Zero { get; }
|
|
public bool Equals(nkast.Aether.Physics2D.Common.Vector2 other) { }
|
|
public override bool Equals(object obj) { }
|
|
public override int GetHashCode() { }
|
|
public float Length() { }
|
|
public float LengthSquared() { }
|
|
public void Normalize() { }
|
|
public override string ToString() { }
|
|
public static void Add(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Vector2 right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static void Distance(ref nkast.Aether.Physics2D.Common.Vector2 v1, ref nkast.Aether.Physics2D.Common.Vector2 v2, out float result) { }
|
|
public static void DistanceSquared(ref nkast.Aether.Physics2D.Common.Vector2 v1, ref nkast.Aether.Physics2D.Common.Vector2 v2, out float result) { }
|
|
public static void Divide(ref nkast.Aether.Physics2D.Common.Vector2 left, float right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static void Dot(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Vector2 right, out float result) { }
|
|
public static void Max(ref nkast.Aether.Physics2D.Common.Vector2 v1, ref nkast.Aether.Physics2D.Common.Vector2 v2, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static void Min(ref nkast.Aether.Physics2D.Common.Vector2 v1, ref nkast.Aether.Physics2D.Common.Vector2 v2, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static void Multiply(ref nkast.Aether.Physics2D.Common.Vector2 left, float right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static void Multiply(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Vector2 right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static void Subtract(ref nkast.Aether.Physics2D.Common.Vector2 left, ref nkast.Aether.Physics2D.Common.Vector2 right, out nkast.Aether.Physics2D.Common.Vector2 result) { }
|
|
public static bool operator !=(nkast.Aether.Physics2D.Common.Vector2 left, nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator *(float left, nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator *(nkast.Aether.Physics2D.Common.Vector2 left, float right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator *(nkast.Aether.Physics2D.Common.Vector2 left, nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator +(nkast.Aether.Physics2D.Common.Vector2 left, nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator -(nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator -(nkast.Aether.Physics2D.Common.Vector2 left, nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector2 operator /(nkast.Aether.Physics2D.Common.Vector2 left, float right) { }
|
|
public static bool operator ==(nkast.Aether.Physics2D.Common.Vector2 left, nkast.Aether.Physics2D.Common.Vector2 right) { }
|
|
}
|
|
public struct Vector3 : System.IEquatable<nkast.Aether.Physics2D.Common.Vector3>
|
|
{
|
|
public float X;
|
|
public float Y;
|
|
public float Z;
|
|
public Vector3(float xyz) { }
|
|
public Vector3(float x, float y, float z) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 One { get; }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 Zero { get; }
|
|
public bool Equals(nkast.Aether.Physics2D.Common.Vector3 other) { }
|
|
public override bool Equals(object obj) { }
|
|
public override int GetHashCode() { }
|
|
public override string ToString() { }
|
|
public static bool operator !=(nkast.Aether.Physics2D.Common.Vector3 left, nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator *(float left, nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator *(nkast.Aether.Physics2D.Common.Vector3 left, float right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator *(nkast.Aether.Physics2D.Common.Vector3 left, nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator +(nkast.Aether.Physics2D.Common.Vector3 left, nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator -(nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator -(nkast.Aether.Physics2D.Common.Vector3 left, nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
public static nkast.Aether.Physics2D.Common.Vector3 operator /(nkast.Aether.Physics2D.Common.Vector3 left, float right) { }
|
|
public static bool operator ==(nkast.Aether.Physics2D.Common.Vector3 left, nkast.Aether.Physics2D.Common.Vector3 right) { }
|
|
}
|
|
[System.Diagnostics.DebuggerDisplay("Count = {Count} Vertices = {ToString()}")]
|
|
public class Vertices : System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vector2>
|
|
{
|
|
public Vertices() { }
|
|
public Vertices(System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Common.Vector2> vertices) { }
|
|
public Vertices(int capacity) { }
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> Holes { get; set; }
|
|
public nkast.Aether.Physics2D.Common.PolygonError CheckPolygon() { }
|
|
public void ForceCounterClockWise() { }
|
|
public nkast.Aether.Physics2D.Collision.AABB GetAABB() { }
|
|
public float GetArea() { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetCentroid() { }
|
|
public float GetSignedArea() { }
|
|
public bool IsConvex() { }
|
|
public bool IsCounterClockWise() { }
|
|
public bool IsSimple() { }
|
|
public int NextIndex(int index) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 NextVertex(int index) { }
|
|
public int PointInPolygon(ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public bool PointInPolygonAngle(ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public int PreviousIndex(int index) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 PreviousVertex(int index) { }
|
|
public void ProjectToAxis(ref nkast.Aether.Physics2D.Common.Vector2 axis, out float min, out float max) { }
|
|
public void Rotate(float value) { }
|
|
public void Scale(nkast.Aether.Physics2D.Common.Vector2 value) { }
|
|
public void Scale(ref nkast.Aether.Physics2D.Common.Vector2 value) { }
|
|
public override string ToString() { }
|
|
public void Translate(nkast.Aether.Physics2D.Common.Vector2 value) { }
|
|
public void Translate(ref nkast.Aether.Physics2D.Common.Vector2 value) { }
|
|
}
|
|
public static class WorldSerializer
|
|
{
|
|
public static nkast.Aether.Physics2D.Dynamics.World Deserialize(System.IO.Stream stream) { }
|
|
public static void Serialize(nkast.Aether.Physics2D.Dynamics.World world, System.IO.Stream stream) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Common.ConvexHull
|
|
{
|
|
public static class ChainHull
|
|
{
|
|
public static nkast.Aether.Physics2D.Common.Vertices GetConvexHull(nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
}
|
|
public static class GiftWrap
|
|
{
|
|
public static nkast.Aether.Physics2D.Common.Vertices GetConvexHull(nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
}
|
|
public static class Melkman
|
|
{
|
|
public static nkast.Aether.Physics2D.Common.Vertices GetConvexHull(nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Common.Decomposition
|
|
{
|
|
public static class Triangulate
|
|
{
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> ConvexPartition(nkast.Aether.Physics2D.Common.Vertices vertices, nkast.Aether.Physics2D.Common.Decomposition.TriangulationAlgorithm algorithm, bool discardAndFixInvalid = true, float tolerance = 0.001, bool skipSanityChecks = false) { }
|
|
}
|
|
public enum TriangulationAlgorithm
|
|
{
|
|
Earclip = 0,
|
|
Bayazit = 1,
|
|
Flipcode = 2,
|
|
Seidel = 3,
|
|
SeidelTrapezoids = 4,
|
|
Delauny = 5,
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Common.PhysicsLogic
|
|
{
|
|
public class BreakableBody
|
|
{
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Fixture> Parts;
|
|
public float Strength;
|
|
public BreakableBody(nkast.Aether.Physics2D.Dynamics.World world, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Collision.Shapes.Shape> shapes, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0) { }
|
|
public BreakableBody(nkast.Aether.Physics2D.Dynamics.World world, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Common.Vertices> vertices, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0) { }
|
|
public BreakableBody(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Common.Vertices vertices, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body MainBody { get; }
|
|
public nkast.Aether.Physics2D.Common.PhysicsLogic.BreakableBody.BreakableBodyState State { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.World World { get; }
|
|
public void Update() { }
|
|
public enum BreakableBodyState
|
|
{
|
|
Unbroken = 0,
|
|
ShouldBreak = 1,
|
|
Broken = 2,
|
|
}
|
|
}
|
|
[System.Flags]
|
|
public enum ControllerCategory
|
|
{
|
|
None = 0,
|
|
Cat01 = 1,
|
|
Cat02 = 2,
|
|
Cat03 = 4,
|
|
Cat04 = 8,
|
|
Cat05 = 16,
|
|
Cat06 = 32,
|
|
Cat07 = 64,
|
|
Cat08 = 128,
|
|
Cat09 = 256,
|
|
Cat10 = 512,
|
|
Cat11 = 1024,
|
|
Cat12 = 2048,
|
|
Cat13 = 4096,
|
|
Cat14 = 8192,
|
|
Cat15 = 16384,
|
|
Cat16 = 32768,
|
|
Cat17 = 65536,
|
|
Cat18 = 131072,
|
|
Cat19 = 262144,
|
|
Cat20 = 524288,
|
|
Cat21 = 1048576,
|
|
Cat22 = 2097152,
|
|
Cat23 = 4194304,
|
|
Cat24 = 8388608,
|
|
Cat25 = 16777216,
|
|
Cat26 = 33554432,
|
|
Cat27 = 67108864,
|
|
Cat28 = 134217728,
|
|
Cat29 = 268435456,
|
|
Cat30 = 536870912,
|
|
Cat31 = 1073741824,
|
|
All = 2147483647,
|
|
}
|
|
public struct ControllerFilter
|
|
{
|
|
public nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory ControllerCategories;
|
|
public ControllerFilter(nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory controllerCategory) { }
|
|
public void IgnoreController(nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory category) { }
|
|
public bool IsControllerIgnored(nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory category) { }
|
|
public void RestoreController(nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory category) { }
|
|
}
|
|
public abstract class FilterData
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.Category DisabledOnCategories;
|
|
public int DisabledOnGroup;
|
|
public nkast.Aether.Physics2D.Dynamics.Category EnabledOnCategories;
|
|
public int EnabledOnGroup;
|
|
protected FilterData() { }
|
|
public void AddDisabledCategory(nkast.Aether.Physics2D.Dynamics.Category category) { }
|
|
public void AddEnabledCategory(nkast.Aether.Physics2D.Dynamics.Category category) { }
|
|
public virtual bool IsActiveOn(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public bool IsInDisabledCategory(nkast.Aether.Physics2D.Dynamics.Category category) { }
|
|
public bool IsInEnabledInCategory(nkast.Aether.Physics2D.Dynamics.Category category) { }
|
|
public void RemoveDisabledCategory(nkast.Aether.Physics2D.Dynamics.Category category) { }
|
|
public void RemoveEnabledCategory(nkast.Aether.Physics2D.Dynamics.Category category) { }
|
|
}
|
|
public abstract class PhysicsLogic : nkast.Aether.Physics2D.Common.PhysicsLogic.FilterData
|
|
{
|
|
public nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory ControllerCategory;
|
|
public PhysicsLogic(nkast.Aether.Physics2D.Dynamics.World world) { }
|
|
public nkast.Aether.Physics2D.Dynamics.World World { get; }
|
|
public override bool IsActiveOn(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
}
|
|
public sealed class RealExplosion : nkast.Aether.Physics2D.Common.PhysicsLogic.PhysicsLogic
|
|
{
|
|
public float EdgeRatio;
|
|
public bool IgnoreWhenInsideShape;
|
|
public float MaxAngle;
|
|
public int MaxShapes;
|
|
public int MinRays;
|
|
public RealExplosion(nkast.Aether.Physics2D.Dynamics.World world) { }
|
|
public System.Collections.Generic.Dictionary<nkast.Aether.Physics2D.Dynamics.Fixture, nkast.Aether.Physics2D.Common.Vector2> Activate(nkast.Aether.Physics2D.Common.Vector2 pos, float radius, float maxForce) { }
|
|
}
|
|
public sealed class SimpleExplosion : nkast.Aether.Physics2D.Common.PhysicsLogic.PhysicsLogic
|
|
{
|
|
public SimpleExplosion(nkast.Aether.Physics2D.Dynamics.World world) { }
|
|
public float Power { get; set; }
|
|
public System.Collections.Generic.Dictionary<nkast.Aether.Physics2D.Dynamics.Body, nkast.Aether.Physics2D.Common.Vector2> Activate(nkast.Aether.Physics2D.Common.Vector2 pos, float radius, float force, float maxForce = 3.4028235E+38) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Common.PolygonManipulation
|
|
{
|
|
public static class CuttingTools
|
|
{
|
|
public static bool Cut(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public static void SplitShape(nkast.Aether.Physics2D.Dynamics.Fixture fixture, nkast.Aether.Physics2D.Common.Vector2 entryPoint, nkast.Aether.Physics2D.Common.Vector2 exitPoint, out nkast.Aether.Physics2D.Common.Vertices first, out nkast.Aether.Physics2D.Common.Vertices second) { }
|
|
}
|
|
public enum PolyClipError
|
|
{
|
|
None = 0,
|
|
DegeneratedOutput = 1,
|
|
NonSimpleInput = 2,
|
|
BrokenResult = 3,
|
|
}
|
|
public static class SimpleCombiner
|
|
{
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> PolygonizeTriangles(System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> triangles, int maxPolys = 2147483647, float tolerance = 0.001) { }
|
|
}
|
|
public static class SimplifyTools
|
|
{
|
|
public static nkast.Aether.Physics2D.Common.Vertices CollinearSimplify(nkast.Aether.Physics2D.Common.Vertices vertices, float collinearityTolerance = 0) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices DouglasPeuckerSimplify(nkast.Aether.Physics2D.Common.Vertices vertices, float distanceTolerance) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices MergeIdenticalPoints(nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices MergeParallelEdges(nkast.Aether.Physics2D.Common.Vertices vertices, float tolerance) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices ReduceByArea(nkast.Aether.Physics2D.Common.Vertices vertices, float areaTolerance) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices ReduceByDistance(nkast.Aether.Physics2D.Common.Vertices vertices, float distance) { }
|
|
public static nkast.Aether.Physics2D.Common.Vertices ReduceByNth(nkast.Aether.Physics2D.Common.Vertices vertices, int nth) { }
|
|
}
|
|
public static class YuPengClipper
|
|
{
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> Difference(nkast.Aether.Physics2D.Common.Vertices polygon1, nkast.Aether.Physics2D.Common.Vertices polygon2, out nkast.Aether.Physics2D.Common.PolygonManipulation.PolyClipError error) { }
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> Intersect(nkast.Aether.Physics2D.Common.Vertices polygon1, nkast.Aether.Physics2D.Common.Vertices polygon2, out nkast.Aether.Physics2D.Common.PolygonManipulation.PolyClipError error) { }
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> Union(nkast.Aether.Physics2D.Common.Vertices polygon1, nkast.Aether.Physics2D.Common.Vertices polygon2, out nkast.Aether.Physics2D.Common.PolygonManipulation.PolyClipError error) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Common.TextureTools
|
|
{
|
|
public static class MarchingSquares
|
|
{
|
|
public static System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> DetectSquares(nkast.Aether.Physics2D.Collision.AABB domain, float cellWidth, float cellHeight, sbyte[] f, int lerpCount, bool combine) { }
|
|
}
|
|
public class Terrain
|
|
{
|
|
public int CellSize;
|
|
public nkast.Aether.Physics2D.Common.Vector2 Center;
|
|
public nkast.Aether.Physics2D.Common.Decomposition.TriangulationAlgorithm Decomposer;
|
|
public float Height;
|
|
public int Iterations;
|
|
public int PointsPerUnit;
|
|
public int SubCellSize;
|
|
public float Width;
|
|
public nkast.Aether.Physics2D.Dynamics.World World;
|
|
public Terrain(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Collision.AABB area) { }
|
|
public Terrain(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Common.Vector2 position, float width, float height) { }
|
|
public void ApplyData(sbyte[] data, nkast.Aether.Physics2D.Common.Vector2 offset = default) { }
|
|
public void Initialize() { }
|
|
public void ModifyTerrain(nkast.Aether.Physics2D.Common.Vector2 location, sbyte value) { }
|
|
public void RegenerateTerrain() { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Controllers
|
|
{
|
|
public sealed class BuoyancyController : nkast.Aether.Physics2D.Controllers.Controller
|
|
{
|
|
public float AngularDragCoefficient;
|
|
public float Density;
|
|
public float LinearDragCoefficient;
|
|
public nkast.Aether.Physics2D.Common.Vector2 Velocity;
|
|
public BuoyancyController(nkast.Aether.Physics2D.Collision.AABB container, float density, float linearDragCoefficient, float rotationalDragCoefficient, nkast.Aether.Physics2D.Common.Vector2 gravity) { }
|
|
public nkast.Aether.Physics2D.Collision.AABB Container { get; set; }
|
|
public override void Update(float dt) { }
|
|
}
|
|
public abstract class Controller : nkast.Aether.Physics2D.Common.PhysicsLogic.FilterData
|
|
{
|
|
public nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerCategory ControllerCategory;
|
|
public bool Enabled;
|
|
public Controller() { }
|
|
public nkast.Aether.Physics2D.Dynamics.World World { get; }
|
|
public override bool IsActiveOn(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public abstract void Update(float dt);
|
|
}
|
|
public class GravityController : nkast.Aether.Physics2D.Controllers.Controller
|
|
{
|
|
public GravityController(float strength) { }
|
|
public GravityController(float strength, float maxRadius, float minRadius) { }
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Body> Bodies { get; set; }
|
|
public nkast.Aether.Physics2D.Controllers.GravityType GravityType { get; set; }
|
|
public float MaxRadius { get; set; }
|
|
public float MinRadius { get; set; }
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vector2> Points { get; set; }
|
|
public float Strength { get; set; }
|
|
public void AddBody(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public void AddPoint(nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public override void Update(float dt) { }
|
|
}
|
|
public enum GravityType
|
|
{
|
|
Linear = 0,
|
|
DistanceSquared = 1,
|
|
}
|
|
public class VelocityLimitController : nkast.Aether.Physics2D.Controllers.Controller
|
|
{
|
|
public bool LimitAngularVelocity;
|
|
public bool LimitLinearVelocity;
|
|
public VelocityLimitController() { }
|
|
public VelocityLimitController(float maxLinearVelocity, float maxAngularVelocity) { }
|
|
public float MaxAngularVelocity { get; set; }
|
|
public float MaxLinearVelocity { get; set; }
|
|
public void AddBody(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public void RemoveBody(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public override void Update(float dt) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Dynamics
|
|
{
|
|
public delegate void AfterCollisionEventHandler(nkast.Aether.Physics2D.Dynamics.Fixture sender, nkast.Aether.Physics2D.Dynamics.Fixture other, nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact, nkast.Aether.Physics2D.Dynamics.Contacts.ContactVelocityConstraint impulse);
|
|
public delegate bool BeforeCollisionEventHandler(nkast.Aether.Physics2D.Dynamics.Fixture sender, nkast.Aether.Physics2D.Dynamics.Fixture other);
|
|
public delegate bool BeginContactDelegate(nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact);
|
|
public class Body
|
|
{
|
|
public nkast.Aether.Physics2D.Common.PhysicsLogic.ControllerFilter ControllerFilter;
|
|
public readonly nkast.Aether.Physics2D.Dynamics.FixtureCollection FixtureList;
|
|
public object Tag;
|
|
public Body() { }
|
|
public float AngularDamping { get; set; }
|
|
public float AngularVelocity { get; set; }
|
|
public bool Awake { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.BodyType BodyType { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.ContactEdge ContactList { get; }
|
|
public bool Enabled { get; set; }
|
|
public bool FixedRotation { get; set; }
|
|
public bool IgnoreCCD { get; set; }
|
|
public bool IgnoreGravity { get; set; }
|
|
public float Inertia { get; set; }
|
|
public bool IsBullet { get; set; }
|
|
[System.Obsolete]
|
|
public int IslandIndex { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.JointEdge JointList { get; }
|
|
public float LinearDamping { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LinearVelocity { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalCenter { get; set; }
|
|
public float Mass { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Position { get; set; }
|
|
public float Revolutions { get; }
|
|
public float Rotation { get; set; }
|
|
public bool SleepingAllowed { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.World World { get; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 WorldCenter { get; }
|
|
public event nkast.Aether.Physics2D.Dynamics.OnCollisionEventHandler OnCollision;
|
|
public event nkast.Aether.Physics2D.Dynamics.OnSeparationEventHandler OnSeparation;
|
|
public void Add(nkast.Aether.Physics2D.Dynamics.Fixture fixture) { }
|
|
public void ApplyAngularImpulse(float impulse) { }
|
|
public void ApplyForce(ref nkast.Aether.Physics2D.Common.Vector2 force) { }
|
|
public void ApplyForce(nkast.Aether.Physics2D.Common.Vector2 force) { }
|
|
public void ApplyForce(nkast.Aether.Physics2D.Common.Vector2 force, nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public void ApplyForce(ref nkast.Aether.Physics2D.Common.Vector2 force, ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public void ApplyLinearImpulse(nkast.Aether.Physics2D.Common.Vector2 impulse) { }
|
|
public void ApplyLinearImpulse(ref nkast.Aether.Physics2D.Common.Vector2 impulse) { }
|
|
public void ApplyLinearImpulse(nkast.Aether.Physics2D.Common.Vector2 impulse, nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public void ApplyLinearImpulse(ref nkast.Aether.Physics2D.Common.Vector2 impulse, ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
public void ApplyTorque(float torque) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body Clone(nkast.Aether.Physics2D.Dynamics.World world = null) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateChainShape(nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateCircle(float radius, float density) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateCircle(float radius, float density, nkast.Aether.Physics2D.Common.Vector2 offset) { }
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Fixture> CreateCompoundPolygon(System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> list, float density) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateEdge(nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateEllipse(float xRadius, float yRadius, int edges, float density) { }
|
|
public virtual nkast.Aether.Physics2D.Dynamics.Fixture CreateFixture(nkast.Aether.Physics2D.Collision.Shapes.Shape shape) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateLineArc(float radians, int sides, float radius, bool closed) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateLoopShape(nkast.Aether.Physics2D.Common.Vertices vertices) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreatePolygon(nkast.Aether.Physics2D.Common.Vertices vertices, float density) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CreateRectangle(float width, float height, float density, nkast.Aether.Physics2D.Common.Vector2 offset) { }
|
|
public System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Fixture> CreateSolidArc(float density, float radians, int sides, float radius) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body DeepClone(nkast.Aether.Physics2D.Dynamics.World world = null) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLinearVelocityFromLocalPoint(nkast.Aether.Physics2D.Common.Vector2 localPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLinearVelocityFromLocalPoint(ref nkast.Aether.Physics2D.Common.Vector2 localPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLinearVelocityFromWorldPoint(nkast.Aether.Physics2D.Common.Vector2 worldPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLinearVelocityFromWorldPoint(ref nkast.Aether.Physics2D.Common.Vector2 worldPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLocalPoint(ref nkast.Aether.Physics2D.Common.Vector2 worldPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLocalPoint(nkast.Aether.Physics2D.Common.Vector2 worldPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLocalVector(ref nkast.Aether.Physics2D.Common.Vector2 worldVector) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetLocalVector(nkast.Aether.Physics2D.Common.Vector2 worldVector) { }
|
|
public nkast.Aether.Physics2D.Common.Transform GetTransform() { }
|
|
public void GetTransform(out nkast.Aether.Physics2D.Common.Transform transform) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetWorldPoint(ref nkast.Aether.Physics2D.Common.Vector2 localPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetWorldPoint(nkast.Aether.Physics2D.Common.Vector2 localPoint) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetWorldVector(ref nkast.Aether.Physics2D.Common.Vector2 localVector) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 GetWorldVector(nkast.Aether.Physics2D.Common.Vector2 localVector) { }
|
|
public virtual void Remove(nkast.Aether.Physics2D.Dynamics.Fixture fixture) { }
|
|
public void ResetDynamics() { }
|
|
public void ResetMassData() { }
|
|
public void SetTransform(ref nkast.Aether.Physics2D.Common.Vector2 position, float rotation) { }
|
|
public void SetTransform(nkast.Aether.Physics2D.Common.Vector2 position, float rotation) { }
|
|
public void SetTransformIgnoreContacts(ref nkast.Aether.Physics2D.Common.Vector2 position, float angle) { }
|
|
}
|
|
public class BodyCollection : System.Collections.Generic.ICollection<nkast.Aether.Physics2D.Dynamics.Body>, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Dynamics.Body>, System.Collections.Generic.IList<nkast.Aether.Physics2D.Dynamics.Body>, System.Collections.IEnumerable
|
|
{
|
|
public BodyCollection(nkast.Aether.Physics2D.Dynamics.World world) { }
|
|
public int Count { get; }
|
|
public bool IsReadOnly { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Body this[int index] { get; set; }
|
|
public bool Contains(nkast.Aether.Physics2D.Dynamics.Body item) { }
|
|
public void CopyTo(nkast.Aether.Physics2D.Dynamics.Body[] array, int arrayIndex) { }
|
|
public nkast.Aether.Physics2D.Dynamics.BodyCollection.BodyEnumerator GetEnumerator() { }
|
|
public int IndexOf(nkast.Aether.Physics2D.Dynamics.Body item) { }
|
|
public struct BodyEnumerator : System.Collections.Generic.IEnumerator<nkast.Aether.Physics2D.Dynamics.Body>, System.Collections.IEnumerator, System.IDisposable
|
|
{
|
|
public BodyEnumerator(nkast.Aether.Physics2D.Dynamics.BodyCollection collection, System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Body> list) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body Current { get; }
|
|
public bool MoveNext() { }
|
|
}
|
|
}
|
|
public delegate void BodyDelegate(nkast.Aether.Physics2D.Dynamics.World sender, nkast.Aether.Physics2D.Dynamics.Body body);
|
|
public enum BodyType
|
|
{
|
|
Static = 0,
|
|
Kinematic = 1,
|
|
Dynamic = 2,
|
|
}
|
|
[System.Flags]
|
|
public enum Category
|
|
{
|
|
None = 0,
|
|
Cat1 = 1,
|
|
Cat2 = 2,
|
|
Cat3 = 4,
|
|
Cat4 = 8,
|
|
Cat5 = 16,
|
|
Cat6 = 32,
|
|
Cat7 = 64,
|
|
Cat8 = 128,
|
|
Cat9 = 256,
|
|
Cat10 = 512,
|
|
Cat11 = 1024,
|
|
Cat12 = 2048,
|
|
Cat13 = 4096,
|
|
Cat14 = 8192,
|
|
Cat15 = 16384,
|
|
Cat16 = 32768,
|
|
Cat17 = 65536,
|
|
Cat18 = 131072,
|
|
Cat19 = 262144,
|
|
Cat20 = 524288,
|
|
Cat21 = 1048576,
|
|
Cat22 = 2097152,
|
|
Cat23 = 4194304,
|
|
Cat24 = 8388608,
|
|
Cat25 = 16777216,
|
|
Cat26 = 33554432,
|
|
Cat27 = 67108864,
|
|
Cat28 = 134217728,
|
|
Cat29 = 268435456,
|
|
Cat30 = 536870912,
|
|
Cat31 = 1073741824,
|
|
All = 2147483647,
|
|
}
|
|
public delegate bool CollisionFilterDelegate(nkast.Aether.Physics2D.Dynamics.Fixture fixtureA, nkast.Aether.Physics2D.Dynamics.Fixture fixtureB);
|
|
public class ContactManager
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.BeginContactDelegate BeginContact;
|
|
public readonly nkast.Aether.Physics2D.Collision.IBroadPhase BroadPhase;
|
|
public int CollideMultithreadThreshold;
|
|
public nkast.Aether.Physics2D.Dynamics.CollisionFilterDelegate ContactFilter;
|
|
public readonly nkast.Aether.Physics2D.Dynamics.Contacts.ContactListHead ContactList;
|
|
public nkast.Aether.Physics2D.Dynamics.EndContactDelegate EndContact;
|
|
public nkast.Aether.Physics2D.Collision.BroadphaseDelegate OnBroadphaseCollision;
|
|
public int PositionConstraintsMultithreadThreshold;
|
|
public nkast.Aether.Physics2D.Dynamics.PostSolveDelegate PostSolve;
|
|
public nkast.Aether.Physics2D.Dynamics.PreSolveDelegate PreSolve;
|
|
public int VelocityConstraintsMultithreadThreshold;
|
|
public int ContactCount { get; }
|
|
}
|
|
public class ControllerCollection : System.Collections.Generic.ICollection<nkast.Aether.Physics2D.Controllers.Controller>, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Controllers.Controller>, System.Collections.Generic.IList<nkast.Aether.Physics2D.Controllers.Controller>, System.Collections.IEnumerable
|
|
{
|
|
public ControllerCollection(nkast.Aether.Physics2D.Dynamics.World world) { }
|
|
public int Count { get; }
|
|
public bool IsReadOnly { get; }
|
|
public nkast.Aether.Physics2D.Controllers.Controller this[int index] { get; set; }
|
|
public bool Contains(nkast.Aether.Physics2D.Controllers.Controller item) { }
|
|
public void CopyTo(nkast.Aether.Physics2D.Controllers.Controller[] array, int arrayIndex) { }
|
|
public nkast.Aether.Physics2D.Dynamics.ControllerCollection.ControllerEnumerator GetEnumerator() { }
|
|
public int IndexOf(nkast.Aether.Physics2D.Controllers.Controller item) { }
|
|
public struct ControllerEnumerator : System.Collections.Generic.IEnumerator<nkast.Aether.Physics2D.Controllers.Controller>, System.Collections.IEnumerator, System.IDisposable
|
|
{
|
|
public ControllerEnumerator(nkast.Aether.Physics2D.Dynamics.ControllerCollection collection, System.Collections.Generic.List<nkast.Aether.Physics2D.Controllers.Controller> list) { }
|
|
public nkast.Aether.Physics2D.Controllers.Controller Current { get; }
|
|
public bool MoveNext() { }
|
|
}
|
|
}
|
|
public delegate void ControllerDelegate(nkast.Aether.Physics2D.Dynamics.World sender, nkast.Aether.Physics2D.Controllers.Controller controller);
|
|
public delegate void EndContactDelegate(nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact);
|
|
public class Fixture
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.AfterCollisionEventHandler AfterCollision;
|
|
public nkast.Aether.Physics2D.Dynamics.BeforeCollisionEventHandler BeforeCollision;
|
|
public nkast.Aether.Physics2D.Dynamics.OnCollisionEventHandler OnCollision;
|
|
public nkast.Aether.Physics2D.Dynamics.OnSeparationEventHandler OnSeparation;
|
|
public object Tag;
|
|
public Fixture(nkast.Aether.Physics2D.Collision.Shapes.Shape shape) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body Body { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Category CollidesWith { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.Category CollisionCategories { get; set; }
|
|
public short CollisionGroup { get; set; }
|
|
public float Friction { get; set; }
|
|
public bool IsSensor { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.FixtureProxy[] Proxies { get; }
|
|
public int ProxyCount { get; }
|
|
public float Restitution { get; set; }
|
|
public nkast.Aether.Physics2D.Collision.Shapes.Shape Shape { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture CloneOnto(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public void GetAABB(out nkast.Aether.Physics2D.Collision.AABB aabb, int childIndex) { }
|
|
public bool RayCast(out nkast.Aether.Physics2D.Collision.RayCastOutput output, ref nkast.Aether.Physics2D.Collision.RayCastInput input, int childIndex) { }
|
|
public bool TestPoint(ref nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
}
|
|
public class FixtureCollection : System.Collections.Generic.ICollection<nkast.Aether.Physics2D.Dynamics.Fixture>, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Dynamics.Fixture>, System.Collections.Generic.IList<nkast.Aether.Physics2D.Dynamics.Fixture>, System.Collections.IEnumerable
|
|
{
|
|
public FixtureCollection(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public int Count { get; }
|
|
public bool IsReadOnly { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture this[int index] { get; set; }
|
|
public bool Contains(nkast.Aether.Physics2D.Dynamics.Fixture item) { }
|
|
public void CopyTo(nkast.Aether.Physics2D.Dynamics.Fixture[] array, int arrayIndex) { }
|
|
public nkast.Aether.Physics2D.Dynamics.FixtureCollection.FixtureEnumerator GetEnumerator() { }
|
|
public int IndexOf(nkast.Aether.Physics2D.Dynamics.Fixture item) { }
|
|
public struct FixtureEnumerator : System.Collections.Generic.IEnumerator<nkast.Aether.Physics2D.Dynamics.Fixture>, System.Collections.IEnumerator, System.IDisposable
|
|
{
|
|
public FixtureEnumerator(nkast.Aether.Physics2D.Dynamics.FixtureCollection collection, System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Fixture> list) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture Current { get; }
|
|
public bool MoveNext() { }
|
|
}
|
|
}
|
|
public delegate void FixtureDelegate(nkast.Aether.Physics2D.Dynamics.World sender, nkast.Aether.Physics2D.Dynamics.Body body, nkast.Aether.Physics2D.Dynamics.Fixture fixture);
|
|
public struct FixtureProxy
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.AABB AABB;
|
|
public int ChildIndex;
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture Fixture;
|
|
public int ProxyId;
|
|
}
|
|
public class Island
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.Body[] Bodies;
|
|
public int BodyCapacity;
|
|
public int BodyCount;
|
|
public int ContactCapacity;
|
|
public int ContactCount;
|
|
public int JointCapacity;
|
|
public int JointCount;
|
|
public System.TimeSpan JointUpdateTime;
|
|
public Island() { }
|
|
public void Add(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public void Add(nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact) { }
|
|
public void Add(nkast.Aether.Physics2D.Dynamics.Joints.Joint joint) { }
|
|
public void Clear() { }
|
|
public void Reset(int bodyCapacity, int contactCapacity, int jointCapacity, nkast.Aether.Physics2D.Dynamics.ContactManager contactManager) { }
|
|
}
|
|
public class JointCollection : System.Collections.Generic.ICollection<nkast.Aether.Physics2D.Dynamics.Joints.Joint>, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Dynamics.Joints.Joint>, System.Collections.Generic.IList<nkast.Aether.Physics2D.Dynamics.Joints.Joint>, System.Collections.IEnumerable
|
|
{
|
|
public JointCollection(nkast.Aether.Physics2D.Dynamics.World world) { }
|
|
public int Count { get; }
|
|
public bool IsReadOnly { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.Joint this[int index] { get; set; }
|
|
public bool Contains(nkast.Aether.Physics2D.Dynamics.Joints.Joint item) { }
|
|
public void CopyTo(nkast.Aether.Physics2D.Dynamics.Joints.Joint[] array, int arrayIndex) { }
|
|
public nkast.Aether.Physics2D.Dynamics.JointCollection.JointEnumerator GetEnumerator() { }
|
|
public int IndexOf(nkast.Aether.Physics2D.Dynamics.Joints.Joint item) { }
|
|
public struct JointEnumerator : System.Collections.Generic.IEnumerator<nkast.Aether.Physics2D.Dynamics.Joints.Joint>, System.Collections.IEnumerator, System.IDisposable
|
|
{
|
|
public JointEnumerator(nkast.Aether.Physics2D.Dynamics.JointCollection collection, System.Collections.Generic.List<nkast.Aether.Physics2D.Dynamics.Joints.Joint> list) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.Joint Current { get; }
|
|
public bool MoveNext() { }
|
|
}
|
|
}
|
|
public delegate void JointDelegate(nkast.Aether.Physics2D.Dynamics.World sender, nkast.Aether.Physics2D.Dynamics.Joints.Joint joint);
|
|
public delegate bool OnCollisionEventHandler(nkast.Aether.Physics2D.Dynamics.Fixture sender, nkast.Aether.Physics2D.Dynamics.Fixture other, nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact);
|
|
public delegate void OnSeparationEventHandler(nkast.Aether.Physics2D.Dynamics.Fixture sender, nkast.Aether.Physics2D.Dynamics.Fixture other, nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact);
|
|
public delegate void PostSolveDelegate(nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact, nkast.Aether.Physics2D.Dynamics.Contacts.ContactVelocityConstraint impulse);
|
|
public delegate void PreSolveDelegate(nkast.Aether.Physics2D.Dynamics.Contacts.Contact contact, ref nkast.Aether.Physics2D.Collision.Manifold oldManifold);
|
|
public delegate bool QueryReportFixtureDelegate(nkast.Aether.Physics2D.Dynamics.Fixture fixture);
|
|
public delegate float RayCastReportFixtureDelegate(nkast.Aether.Physics2D.Dynamics.Fixture fixture, nkast.Aether.Physics2D.Common.Vector2 point, nkast.Aether.Physics2D.Common.Vector2 normal, float fraction);
|
|
public struct SolverIterations
|
|
{
|
|
public bool AutoClearForces;
|
|
public int PositionIterations;
|
|
public int TOIPositionIterations;
|
|
public int TOIVelocityIterations;
|
|
public int VelocityIterations;
|
|
}
|
|
public class World
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.BodyDelegate BodyAdded;
|
|
public readonly nkast.Aether.Physics2D.Dynamics.BodyCollection BodyList;
|
|
public nkast.Aether.Physics2D.Dynamics.BodyDelegate BodyRemoved;
|
|
public readonly nkast.Aether.Physics2D.Dynamics.ContactManager ContactManager;
|
|
public nkast.Aether.Physics2D.Dynamics.ControllerDelegate ControllerAdded;
|
|
public readonly nkast.Aether.Physics2D.Dynamics.ControllerCollection ControllerList;
|
|
public nkast.Aether.Physics2D.Dynamics.ControllerDelegate ControllerRemoved;
|
|
public nkast.Aether.Physics2D.Dynamics.FixtureDelegate FixtureAdded;
|
|
public nkast.Aether.Physics2D.Dynamics.FixtureDelegate FixtureRemoved;
|
|
public nkast.Aether.Physics2D.Dynamics.JointDelegate JointAdded;
|
|
public readonly nkast.Aether.Physics2D.Dynamics.JointCollection JointList;
|
|
public nkast.Aether.Physics2D.Dynamics.JointDelegate JointRemoved;
|
|
public object Tag;
|
|
public World() { }
|
|
public World(nkast.Aether.Physics2D.Collision.IBroadPhase broadPhase) { }
|
|
public World(nkast.Aether.Physics2D.Common.Vector2 gravity) { }
|
|
public System.TimeSpan AddRemoveTime { get; }
|
|
public int ContactCount { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.ContactListHead ContactList { get; }
|
|
public System.TimeSpan ContactsUpdateTime { get; }
|
|
public System.TimeSpan ContinuousPhysicsTime { get; }
|
|
public System.TimeSpan ControllersUpdateTime { get; }
|
|
public bool Enabled { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Gravity { get; set; }
|
|
public bool IsLocked { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Island Island { get; }
|
|
public System.TimeSpan NewContactsTime { get; }
|
|
public int ProxyCount { get; }
|
|
public System.TimeSpan SolveUpdateTime { get; }
|
|
public System.TimeSpan UpdateTime { get; }
|
|
public void Add(nkast.Aether.Physics2D.Controllers.Controller controller) { }
|
|
public virtual void Add(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public void Add(nkast.Aether.Physics2D.Dynamics.Joints.Joint joint) { }
|
|
public void Clear() { }
|
|
public void ClearForces() { }
|
|
public virtual nkast.Aether.Physics2D.Dynamics.Body CreateBody(nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateCapsule(float height, float endRadius, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateCapsule(float height, float topRadius, int topEdges, float bottomRadius, int bottomEdges, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Common.Path CreateChain(nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end, float linkWidth, float linkHeight, int numberOfLinks, float linkDensity, bool attachRopeJoint) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateChainShape(nkast.Aether.Physics2D.Common.Vertices vertices, nkast.Aether.Physics2D.Common.Vector2 position = default) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateCircle(float radius, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateCompoundPolygon(System.Collections.Generic.List<nkast.Aether.Physics2D.Common.Vertices> list, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateEdge(nkast.Aether.Physics2D.Common.Vector2 start, nkast.Aether.Physics2D.Common.Vector2 end) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateEllipse(float xRadius, float yRadius, int edges, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateGear(float radius, int numberOfTeeth, float tipPercentage, float toothHeight, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateLineArc(float radians, int sides, float radius, bool closed = false, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateLoopShape(nkast.Aether.Physics2D.Common.Vertices vertices, nkast.Aether.Physics2D.Common.Vector2 position = default) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreatePolygon(nkast.Aether.Physics2D.Common.Vertices vertices, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateRectangle(float width, float height, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateRoundedRectangle(float width, float height, float xRadius, float yRadius, int segments, float density, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body CreateSolidArc(float density, float radians, int sides, float radius, nkast.Aether.Physics2D.Common.Vector2 position = default, float rotation = 0, nkast.Aether.Physics2D.Dynamics.BodyType bodyType = 0) { }
|
|
public void QueryAABB(nkast.Aether.Physics2D.Dynamics.QueryReportFixtureDelegate callback, nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public void QueryAABB(nkast.Aether.Physics2D.Dynamics.QueryReportFixtureDelegate callback, ref nkast.Aether.Physics2D.Collision.AABB aabb) { }
|
|
public void RayCast(nkast.Aether.Physics2D.Dynamics.RayCastReportFixtureDelegate callback, nkast.Aether.Physics2D.Common.Vector2 point1, nkast.Aether.Physics2D.Common.Vector2 point2) { }
|
|
public void Remove(nkast.Aether.Physics2D.Controllers.Controller controller) { }
|
|
public virtual void Remove(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
public void Remove(nkast.Aether.Physics2D.Dynamics.Joints.Joint joint) { }
|
|
public void ShiftOrigin(nkast.Aether.Physics2D.Common.Vector2 newOrigin) { }
|
|
public void Step(System.TimeSpan dt) { }
|
|
public void Step(float dt) { }
|
|
public void Step(System.TimeSpan dt, ref nkast.Aether.Physics2D.Dynamics.SolverIterations iterations) { }
|
|
public void Step(float dt, ref nkast.Aether.Physics2D.Dynamics.SolverIterations iterations) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture TestPoint(nkast.Aether.Physics2D.Common.Vector2 point) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Dynamics.Contacts
|
|
{
|
|
public class Contact
|
|
{
|
|
public nkast.Aether.Physics2D.Collision.Manifold Manifold;
|
|
protected Contact(nkast.Aether.Physics2D.Dynamics.Fixture fA, int indexA, nkast.Aether.Physics2D.Dynamics.Fixture fB, int indexB) { }
|
|
public int ChildIndexA { get; }
|
|
public int ChildIndexB { get; }
|
|
public bool Enabled { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture FixtureA { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Fixture FixtureB { get; }
|
|
public float Friction { get; set; }
|
|
public bool IsTouching { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.Contact Next { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.Contact Prev { get; }
|
|
public float Restitution { get; set; }
|
|
public float TangentSpeed { get; set; }
|
|
public void GetWorldManifold(out nkast.Aether.Physics2D.Common.Vector2 normal, out nkast.Aether.Physics2D.Common.FixedArray2<nkast.Aether.Physics2D.Common.Vector2> points) { }
|
|
public void ResetFriction() { }
|
|
public void ResetRestitution() { }
|
|
}
|
|
public sealed class ContactEdge
|
|
{
|
|
public ContactEdge() { }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.Contact Contact { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.ContactEdge Next { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Body Other { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.ContactEdge Prev { get; }
|
|
}
|
|
public class ContactListHead : nkast.Aether.Physics2D.Dynamics.Contacts.Contact, System.Collections.Generic.IEnumerable<nkast.Aether.Physics2D.Dynamics.Contacts.Contact>, System.Collections.IEnumerable { }
|
|
public sealed class ContactPositionConstraint
|
|
{
|
|
public int indexA;
|
|
public int indexB;
|
|
public float invIA;
|
|
public float invIB;
|
|
public float invMassA;
|
|
public float invMassB;
|
|
public nkast.Aether.Physics2D.Common.Vector2 localCenterA;
|
|
public nkast.Aether.Physics2D.Common.Vector2 localCenterB;
|
|
public nkast.Aether.Physics2D.Common.Vector2 localNormal;
|
|
public nkast.Aether.Physics2D.Common.Vector2 localPoint;
|
|
public nkast.Aether.Physics2D.Common.Vector2[] localPoints;
|
|
public int pointCount;
|
|
public float radiusA;
|
|
public float radiusB;
|
|
public nkast.Aether.Physics2D.Collision.ManifoldType type;
|
|
public ContactPositionConstraint() { }
|
|
}
|
|
public class ContactSolver
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.Contact[] _contacts;
|
|
public int _count;
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.ContactPositionConstraint[] _positionConstraints;
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.ContactVelocityConstraint[] _velocityConstraints;
|
|
public ContactSolver() { }
|
|
public void InitializeVelocityConstraints() { }
|
|
public bool SolvePositionConstraints() { }
|
|
public bool SolveTOIPositionConstraints(int toiIndexA, int toiIndexB) { }
|
|
public void SolveVelocityConstraints() { }
|
|
public void StoreImpulses() { }
|
|
public void WarmStart() { }
|
|
public static class WorldManifold
|
|
{
|
|
public static void Initialize(ref nkast.Aether.Physics2D.Collision.Manifold manifold, ref nkast.Aether.Physics2D.Common.Transform xfA, float radiusA, ref nkast.Aether.Physics2D.Common.Transform xfB, float radiusB, out nkast.Aether.Physics2D.Common.Vector2 normal, out nkast.Aether.Physics2D.Common.FixedArray2<nkast.Aether.Physics2D.Common.Vector2> points) { }
|
|
}
|
|
}
|
|
public sealed class ContactVelocityConstraint
|
|
{
|
|
public nkast.Aether.Physics2D.Common.Mat22 K;
|
|
public int contactIndex;
|
|
public float friction;
|
|
public int indexA;
|
|
public int indexB;
|
|
public float invIA;
|
|
public float invIB;
|
|
public float invMassA;
|
|
public float invMassB;
|
|
public nkast.Aether.Physics2D.Common.Vector2 normal;
|
|
public nkast.Aether.Physics2D.Common.Mat22 normalMass;
|
|
public int pointCount;
|
|
public nkast.Aether.Physics2D.Dynamics.Contacts.VelocityConstraintPoint[] points;
|
|
public float restitution;
|
|
public float tangentSpeed;
|
|
public ContactVelocityConstraint() { }
|
|
}
|
|
public sealed class VelocityConstraintPoint
|
|
{
|
|
public float normalImpulse;
|
|
public float normalMass;
|
|
public nkast.Aether.Physics2D.Common.Vector2 rA;
|
|
public nkast.Aether.Physics2D.Common.Vector2 rB;
|
|
public float tangentImpulse;
|
|
public float tangentMass;
|
|
public float velocityBias;
|
|
public VelocityConstraintPoint() { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D.Dynamics.Joints
|
|
{
|
|
public class AngleJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public AngleJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB) { }
|
|
public float BiasFactor { get; set; }
|
|
public float MaxImpulse { get; set; }
|
|
public float Softness { get; set; }
|
|
public float TargetAngle { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class DistanceJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public DistanceJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public float DampingRatio { get; set; }
|
|
public float Frequency { get; set; }
|
|
public float Length { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public override sealed nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override sealed nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class FixedMouseJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public FixedMouseJoint(nkast.Aether.Physics2D.Dynamics.Body body, nkast.Aether.Physics2D.Common.Vector2 worldAnchor) { }
|
|
public float DampingRatio { get; set; }
|
|
public float Frequency { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public float MaxForce { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class FrictionJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public FrictionJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, bool useWorldCoordinates = false) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public float MaxForce { get; set; }
|
|
public float MaxTorque { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class GearJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public GearJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Dynamics.Joints.Joint jointA, nkast.Aether.Physics2D.Dynamics.Joints.Joint jointB, float ratio = 1) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.Joint JointA { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.Joint JointB { get; }
|
|
public float Ratio { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public abstract class Joint
|
|
{
|
|
public bool Enabled;
|
|
public object Tag;
|
|
protected Joint() { }
|
|
protected Joint(nkast.Aether.Physics2D.Dynamics.Body body) { }
|
|
protected Joint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB) { }
|
|
public nkast.Aether.Physics2D.Dynamics.Body BodyA { get; }
|
|
public nkast.Aether.Physics2D.Dynamics.Body BodyB { get; }
|
|
public float Breakpoint { get; set; }
|
|
public bool CollideConnected { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.JointType JointType { get; protected set; }
|
|
public nkast.Aether.Physics2D.Dynamics.World World { get; }
|
|
public abstract nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public abstract nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public event System.Action<nkast.Aether.Physics2D.Dynamics.Joints.Joint, float> Broke;
|
|
public abstract nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt);
|
|
public abstract float GetReactionTorque(float invDt);
|
|
public bool IsFixedType() { }
|
|
protected void WakeBodies() { }
|
|
}
|
|
public sealed class JointEdge
|
|
{
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.Joint Joint;
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.JointEdge Next;
|
|
public nkast.Aether.Physics2D.Dynamics.Body Other;
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.JointEdge Prev;
|
|
public JointEdge() { }
|
|
}
|
|
public static class JointFactory
|
|
{
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.AngleJoint CreateAngleJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.DistanceJoint CreateDistanceJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.DistanceJoint CreateDistanceJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.FixedMouseJoint CreateFixedMouseJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body body, nkast.Aether.Physics2D.Common.Vector2 worldAnchor) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.FrictionJoint CreateFrictionJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.FrictionJoint CreateFrictionJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.GearJoint CreateGearJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Dynamics.Joints.Joint jointA, nkast.Aether.Physics2D.Dynamics.Joints.Joint jointB, float ratio) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.MotorJoint CreateMotorJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.PrismaticJoint CreatePrismaticJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, nkast.Aether.Physics2D.Common.Vector2 axis, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.PulleyJoint CreatePulleyJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, nkast.Aether.Physics2D.Common.Vector2 worldAnchorA, nkast.Aether.Physics2D.Common.Vector2 worldAnchorB, float ratio, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.RevoluteJoint CreateRevoluteJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.RevoluteJoint CreateRevoluteJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.RopeJoint CreateRopeJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.WeldJoint CreateWeldJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.WheelJoint CreateWheelJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 axis) { }
|
|
public static nkast.Aether.Physics2D.Dynamics.Joints.WheelJoint CreateWheelJoint(nkast.Aether.Physics2D.Dynamics.World world, nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, nkast.Aether.Physics2D.Common.Vector2 axis, bool useWorldCoordinates = false) { }
|
|
}
|
|
public enum JointType
|
|
{
|
|
Unknown = 0,
|
|
Revolute = 1,
|
|
Prismatic = 2,
|
|
Distance = 3,
|
|
Pulley = 4,
|
|
Gear = 5,
|
|
Wheel = 6,
|
|
Weld = 7,
|
|
Friction = 8,
|
|
Rope = 9,
|
|
Motor = 10,
|
|
Angle = 11,
|
|
FixedMouse = 12,
|
|
FixedRevolute = 13,
|
|
FixedDistance = 14,
|
|
FixedLine = 15,
|
|
FixedPrismatic = 16,
|
|
FixedAngle = 17,
|
|
FixedFriction = 18,
|
|
}
|
|
public enum LimitState
|
|
{
|
|
Inactive = 0,
|
|
AtLower = 1,
|
|
AtUpper = 2,
|
|
Equal = 3,
|
|
}
|
|
public class MotorJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public MotorJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, bool useWorldCoordinates = false) { }
|
|
public float AngularOffset { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LinearOffset { get; set; }
|
|
public float MaxForce { get; set; }
|
|
public float MaxTorque { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class PrismaticJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public PrismaticJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, nkast.Aether.Physics2D.Common.Vector2 axis, bool useWorldCoordinates = false) { }
|
|
public PrismaticJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, nkast.Aether.Physics2D.Common.Vector2 axis, bool useWorldCoordinates = false) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Axis { get; set; }
|
|
public float JointSpeed { get; }
|
|
public float JointTranslation { get; }
|
|
public bool LimitEnabled { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalXAxis { get; }
|
|
public float LowerLimit { get; set; }
|
|
public float MaxMotorForce { get; set; }
|
|
public bool MotorEnabled { get; set; }
|
|
public float MotorImpulse { get; set; }
|
|
public float MotorSpeed { get; set; }
|
|
public float ReferenceAngle { get; set; }
|
|
public float UpperLimit { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public float GetMotorForce(float invDt) { }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
public void SetLimits(float lower, float upper) { }
|
|
}
|
|
public class PulleyJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public PulleyJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, nkast.Aether.Physics2D.Common.Vector2 worldAnchorA, nkast.Aether.Physics2D.Common.Vector2 worldAnchorB, float ratio, bool useWorldCoordinates = false) { }
|
|
public float CurrentLengthA { get; }
|
|
public float CurrentLengthB { get; }
|
|
public float LengthA { get; set; }
|
|
public float LengthB { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public float Ratio { get; set; }
|
|
public override sealed nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override sealed nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class RevoluteJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public RevoluteJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, bool useWorldCoordinates = false) { }
|
|
public RevoluteJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public float JointAngle { get; }
|
|
public float JointSpeed { get; }
|
|
public bool LimitEnabled { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public float LowerLimit { get; set; }
|
|
public float MaxMotorTorque { get; set; }
|
|
public bool MotorEnabled { get; set; }
|
|
public float MotorImpulse { get; set; }
|
|
public float MotorSpeed { get; set; }
|
|
public float ReferenceAngle { get; set; }
|
|
public float UpperLimit { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public float GetMotorTorque(float invDt) { }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
public void SetLimits(float lower, float upper) { }
|
|
}
|
|
public class RopeJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public RopeJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public float MaxLength { get; set; }
|
|
public nkast.Aether.Physics2D.Dynamics.Joints.LimitState State { get; }
|
|
public override sealed nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override sealed nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class WeldJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public WeldJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchorA, nkast.Aether.Physics2D.Common.Vector2 anchorB, bool useWorldCoordinates = false) { }
|
|
public float DampingRatio { get; set; }
|
|
public float FrequencyHz { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public float ReferenceAngle { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
public class WheelJoint : nkast.Aether.Physics2D.Dynamics.Joints.Joint
|
|
{
|
|
public WheelJoint(nkast.Aether.Physics2D.Dynamics.Body bodyA, nkast.Aether.Physics2D.Dynamics.Body bodyB, nkast.Aether.Physics2D.Common.Vector2 anchor, nkast.Aether.Physics2D.Common.Vector2 axis, bool useWorldCoordinates = false) { }
|
|
public nkast.Aether.Physics2D.Common.Vector2 Axis { get; set; }
|
|
public float DampingRatio { get; set; }
|
|
public float Frequency { get; set; }
|
|
public float JointSpeed { get; }
|
|
public float JointTranslation { get; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorA { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalAnchorB { get; set; }
|
|
public nkast.Aether.Physics2D.Common.Vector2 LocalXAxis { get; }
|
|
public float MaxMotorTorque { get; set; }
|
|
public bool MotorEnabled { get; set; }
|
|
public float MotorSpeed { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorA { get; set; }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 WorldAnchorB { get; set; }
|
|
public float GetMotorTorque(float invDt) { }
|
|
public override nkast.Aether.Physics2D.Common.Vector2 GetReactionForce(float invDt) { }
|
|
public override float GetReactionTorque(float invDt) { }
|
|
}
|
|
}
|
|
namespace nkast.Aether.Physics2D
|
|
{
|
|
public static class Settings
|
|
{
|
|
public const float AABBExtension = 0.1F;
|
|
public const float AABBMultiplier = 2F;
|
|
public const float AngularSleepTolerance = 0.03490659F;
|
|
public const float AngularSlop = 0.03490659F;
|
|
public const bool AutoClearForces = true;
|
|
public const float Baumgarte = 0.2F;
|
|
public const bool EnableDiagnostics = true;
|
|
public const float Epsilon = 1.1920929E-07F;
|
|
public const float LinearSleepTolerance = 0.01F;
|
|
public const float LinearSlop = 0.005F;
|
|
public const float MaxAngularCorrection = 0.13962635F;
|
|
public const float MaxFloat = 3.4028235E+38F;
|
|
public const int MaxGJKIterations = 20;
|
|
public const float MaxLinearCorrection = 0.2F;
|
|
public const int MaxManifoldPoints = 2;
|
|
public const float MaxRotation = 1.5707964F;
|
|
public const float MaxRotationSquared = 2.4674013F;
|
|
public const int MaxSubSteps = 8;
|
|
public const int MaxTOIContacts = 32;
|
|
public const float MaxTranslation = 2F;
|
|
public const float MaxTranslationSquared = 4F;
|
|
public const float PolygonRadius = 0.01F;
|
|
public const float TimeToSleep = 0.5F;
|
|
public const float VelocityThreshold = 1F;
|
|
public static bool AllowSleep;
|
|
public static bool ContinuousPhysics;
|
|
public static int MaxPolygonVertices;
|
|
public static int PositionIterations;
|
|
public static int TOIPositionIterations;
|
|
public static int TOIVelocityIterations;
|
|
public static bool UseConvexHullPolygons;
|
|
public static int VelocityIterations;
|
|
public static float MixFriction(float friction1, float friction2) { }
|
|
public static float MixRestitution(float restitution1, float restitution2) { }
|
|
}
|
|
}
|