Unity3d 铰链接头中的无损运动-统一

我已经在Unity中创建了一个单摆-带有刚体和铰链关节组件的游戏对象。我已将“阻力”和“角度阻力”都设置为0。当起始位置为90度时，我希望钟摆能从90度到-90度来回摆动。然而，事实并非如此——振幅衰减非常快，但对于小角度，钟摆看起来永远不会停止

我的问题是：我应该如何配置铰链关节，以实现对物理和抵抗运动的力的完全控制？我的目标是让物理模拟尽可能精确，即使以性能为代价

我已经尝试过减少固定步长和增加解算器迭代的时间间隔，但都没有成功

---

为什么我需要它？我计划设计一个控制系统，用于推车上的多重倒立摆。我有一个用Matlab实现的摆锤数学模型，我想用Unity中的一个简单模型来验证它（因为在这种情况下，我调整了所有参数、初始条件等，物理引擎正在为我计算一切）。如果支持Unity的物理引擎不够可靠，你会推荐我其他什么软件？

我的理解是，由于Unity的物理运行方式，如果你只使用铰链关节，这种摆锤运动会随着时间的推移而损失动能。基本上，如果你想要一个精确的钟摆模拟，你必须绕过物理引擎，直接实现它

最初，作者发布了一篇关于如何在Unity中实现更精确的钟摆模拟的文章，我将其粘贴在下面

---

我原以为这是一个相对简单的问题要解决，但我花了几天时间试图弄清楚如何模拟钟摆运动。我不想作弊，只是根据sin（θ）和cos（θ）曲线改变x，y的位置。相反，我想处理现实生活中应用的两种力，重力和张力。我缺少的主要部分是向心力

有一个很好的动画（下图，左侧）解释了钟摆的运动。您可以看到我的结果（右侧）与该图惊人地相似

“bob”是摆动对象，“pivot”是原点/根

我还发现和图表（如下）非常有用：

---

θ等于绳索与重力方向之间的角度

当摆锤位于左侧或右侧时，张力等于：

当摆锤接近平衡点（中间）时，张力更大的原因是：

因此，当摆锤摆动时，覆盖张力公式如下所示：

摆锤系统中有两个力：

• 重力

  • GravityForce=质量*重力.量级

  • GravityDirection=gravity.normalized

• 紧张

  • TensionForce=（质量*重力*Cos（θ））+（（质量*速度变化^2）/缆绳长度）

  • TensionDirection=rope direction=bob到枢轴

就像对普通物体一样，对物体施加重力，然后施加张力。当你施加力时，只需将力乘以方向和增量

下面是脚本（也作为脚本）。它工作得很好，但如果您将其放置一段时间（不会返回到完全相同的位置），则会出现一些舍入误差漂移

脚本在3D中工作，但当然钟摆只在2D平面中摆动。它也可以在任何方向上与重力一起工作。举个例子，如果你把重力倒转，钟摆就会倒转<代码>编辑->项目设置->物理->重力

在更新钟摆时，具有一致的相对较小的deltaTime非常重要，这样您就不会在曲线上反弹。我正在使用本文中的技术来实现这一点。检查下面的

Update（）

函数，了解我是如何实现它的

使用UnityEngine；
使用系统集合；
//作者：埃里克·伊斯特伍德（ericestwood.com）
//
//说明：
//针对本gd.se问题编写：http://gamedev.stackexchange.com/a/75748/16587
//在代码中模拟/仿真摆锤运动
//在任何3D方向和任何重力/方向下工作
//
//演示：https://i.imgur.com/vOQgFMe.gif
//
//用法：https://i.imgur.com/BM52dbT.png
公共类钟摆：单一行为{
公共游戏对象轴心；
公共游戏对象Bob；
公共浮子质量=1f；
浮绳长度=2f；
矢量3开始位置；
bool bobStartingPositionSet=false；
//您可以在'PendulumUpdate（）'循环中定义这些
//但是我们希望它们在类范围内，这样我们就可以绘制gizmo`OnDrawGizmos（）`
私人矢量3引力方向；
专用矢量3张紧方向；
专用矢量3切向；
私人矢量3摆动方向；
专用浮子拉力=0f；
专用浮子重力力=0f；
//跟踪流速
Vector3 currentVelocity=新Vector3（）；
//在“Update（）”循环中的某些帧速率情况下，我们使用这些参数在值之间平滑
矢量3当前状态位置；
向量3先前状态位置；
//用于初始化
无效开始（）{
//设置起始位置，以便以后在上下文菜单重置方法中使用
this.bobStartingPosition=this.Bob.transform.position；
this.bobStartingPositionSet=true；
这个。摆（）；
}
浮动t=0f；
浮子dt=0.01f；
浮动电流时间=0f；
浮子蓄能器=0f；
无效更新（）
{
/* */
//修复了使用平滑在任意速度下进行deltaTime渲染的问题
//技术：http://gafferongames.com/game-physics/fix-your-timestep/
using UnityEngine;
using System.Collections;

// Author: Eric Eastwood (ericeastwood.com)
//
// Description:
//      Written for this gd.se question: http://gamedev.stackexchange.com/a/75748/16587
//      Simulates/Emulates pendulum motion in code
//      Works in any 3D direction and with any force/direciton of gravity
//
// Demonstration: https://i.imgur.com/vOQgFMe.gif
//
// Usage: https://i.imgur.com/BM52dbT.png
public class Pendulum : MonoBehaviour {

    public GameObject Pivot;
    public GameObject Bob;


    public float mass = 1f;

    float ropeLength = 2f;

    Vector3 bobStartingPosition;
    bool bobStartingPositionSet = false;

    // You could define these in the `PendulumUpdate()` loop 
    // But we want them in the class scope so we can draw gizmos `OnDrawGizmos()`
    private Vector3 gravityDirection;
    private Vector3 tensionDirection;

    private Vector3 tangentDirection;
    private Vector3 pendulumSideDirection;

    private float tensionForce = 0f;
    private float gravityForce = 0f;


    // Keep track of the current velocity
    Vector3 currentVelocity = new Vector3();

    // We use these to smooth between values in certain framerate situations in the `Update()` loop
    Vector3 currentStatePosition;
    Vector3 previousStatePosition;

    // Use this for initialization
    void Start () {
        // Set the starting position for later use in the context menu reset methods
        this.bobStartingPosition = this.Bob.transform.position;
        this.bobStartingPositionSet = true;

        this.PendulumInit();
    }


    float t = 0f;
    float dt = 0.01f;
    float currentTime = 0f;
    float accumulator = 0f;

    void Update()
    {
        /* */
        // Fixed deltaTime rendering at any speed with smoothing
        // Technique: http://gafferongames.com/game-physics/fix-your-timestep/
        float frameTime = Time.time - currentTime;
        this.currentTime = Time.time;

        this.accumulator += frameTime;

        while (this.accumulator >= this.dt)
        {
            this.previousStatePosition = this.currentStatePosition;
            this.currentStatePosition = this.PendulumUpdate(this.currentStatePosition, this.dt);
            //integrate(state, this.t, this.dt);
            accumulator -= this.dt;
            this.t += this.dt;
        }

        float alpha = this.accumulator/this.dt;

        Vector3 newPosition = this.currentStatePosition*alpha + this.previousStatePosition*(1f-alpha);

        this.Bob.transform.position = newPosition; //this.currentStatePosition;
        /* */

        //this.Bob.transform.position = this.PendulumUpdate(this.Bob.transform.position, Time.deltaTime);
    }


    // Use this to reset forces and go back to the starting position
    [ContextMenu("Reset Pendulum Position")]
    void ResetPendulumPosition()
    {
        if(this.bobStartingPositionSet)
            this.MoveBob(this.bobStartingPosition);
        else
            this.PendulumInit();
    }

    // Use this to reset any built up forces
    [ContextMenu("Reset Pendulum Forces")]
    void ResetPendulumForces()
    {
        this.currentVelocity = Vector3.zero;

        // Set the transition state
        this.currentStatePosition = this.Bob.transform.position;
    }

    void PendulumInit()
    {
        // Get the initial rope length from how far away the bob is now
        this.ropeLength = Vector3.Distance(Pivot.transform.position, Bob.transform.position);
        this.ResetPendulumForces();
    }

    void MoveBob(Vector3 resetBobPosition)
    {
        // Put the bob back in the place we first saw it at in `Start()`
        this.Bob.transform.position = resetBobPosition;

        // Set the transition state
        this.currentStatePosition = resetBobPosition;
    }


    Vector3 PendulumUpdate(Vector3 currentStatePosition, float deltaTime)
    {
        // Add gravity free fall
        this.gravityForce = this.mass * Physics.gravity.magnitude;
        this.gravityDirection = Physics.gravity.normalized;
        this.currentVelocity += this.gravityDirection * this.gravityForce * deltaTime;

        Vector3 pivot_p = this.Pivot.transform.position;
        Vector3 bob_p = this.currentStatePosition;


        Vector3 auxiliaryMovementDelta = this.currentVelocity * deltaTime;
        float distanceAfterGravity = Vector3.Distance(pivot_p, bob_p + auxiliaryMovementDelta);

        // If at the end of the rope
        if(distanceAfterGravity > this.ropeLength || Mathf.Approximately(distanceAfterGravity, this.ropeLength))
        {

            this.tensionDirection = (pivot_p - bob_p).normalized;

            this.pendulumSideDirection = (Quaternion.Euler(0f, 90f, 0f) * this.tensionDirection);
            this.pendulumSideDirection.Scale(new Vector3(1f, 0f, 1f));
            this.pendulumSideDirection.Normalize();

            this.tangentDirection = (-1f * Vector3.Cross(this.tensionDirection, this.pendulumSideDirection)).normalized;


            float inclinationAngle = Vector3.Angle(bob_p-pivot_p, this.gravityDirection);

            this.tensionForce = this.mass * Physics.gravity.magnitude * Mathf.Cos(Mathf.Deg2Rad * inclinationAngle);
            float centripetalForce = ((this.mass * Mathf.Pow(this.currentVelocity.magnitude, 2))/this.ropeLength);
            this.tensionForce += centripetalForce;

            this.currentVelocity += this.tensionDirection * this.tensionForce * deltaTime;
        }

        // Get the movement delta
        Vector3 movementDelta = Vector3.zero;
        movementDelta += this.currentVelocity * deltaTime;


        //return currentStatePosition + movementDelta;

        float distance = Vector3.Distance(pivot_p, currentStatePosition + movementDelta);
        return this.GetPointOnLine(pivot_p, currentStatePosition + movementDelta, distance <= this.ropeLength ? distance : this.ropeLength);
    }

    Vector3 GetPointOnLine(Vector3 start, Vector3 end, float distanceFromStart)
    {
        return start + (distanceFromStart * Vector3.Normalize(end - start));
    }

    void OnDrawGizmos()
    {
        // purple
        Gizmos.color = new Color(.5f, 0f, .5f);
        Gizmos.DrawWireSphere(this.Pivot.transform.position, this.ropeLength);

        Gizmos.DrawWireCube(this.bobStartingPosition, new Vector3(.5f, .5f, .5f));


        // Blue: Auxilary
        Gizmos.color = new Color(.3f, .3f, 1f); // blue
        Vector3 auxVel = .3f * this.currentVelocity;
        Gizmos.DrawRay(this.Bob.transform.position, auxVel);
        Gizmos.DrawSphere(this.Bob.transform.position + auxVel, .2f);

        // Yellow: Gravity
        Gizmos.color = new Color(1f, 1f, .2f);
        Vector3 gravity = .3f * this.gravityForce*this.gravityDirection;
        Gizmos.DrawRay(this.Bob.transform.position, gravity);
        Gizmos.DrawSphere(this.Bob.transform.position + gravity, .2f);

        // Orange: Tension
        Gizmos.color = new Color(1f, .5f, .2f); // Orange
        Vector3 tension = .3f * this.tensionForce*this.tensionDirection;
        Gizmos.DrawRay(this.Bob.transform.position, tension);
        Gizmos.DrawSphere(this.Bob.transform.position + tension, .2f);

        // Red: Resultant
        Gizmos.color = new Color(1f, .3f, .3f); // red
        Vector3 resultant = gravity + tension;
        Gizmos.DrawRay(this.Bob.transform.position, resultant);
        Gizmos.DrawSphere(this.Bob.transform.position + resultant, .2f);


        /* * /
        // Green: Pendulum side direction
        Gizmos.color = new Color(.3f, 1f, .3f);
        Gizmos.DrawRay(this.Bob.transform.position, 3f*this.pendulumSideDirection);
        Gizmos.DrawSphere(this.Bob.transform.position + 3f*this.pendulumSideDirection, .2f);
        /* */

        /* * /
        // Cyan: tangent direction
        Gizmos.color = new Color(.2f, 1f, 1f); // cyan
        Gizmos.DrawRay(this.Bob.transform.position, 3f*this.tangentDirection);
        Gizmos.DrawSphere(this.Bob.transform.position + 3f*this.tangentDirection, .2f);
        /* */
    }
}