《物理模拟与渲染集成：固定步长、插值与确定性同步》

模式 A：物理 = 渲染帧（简单但不可取）
  每帧调用一次 Step(frameTime) → 帧率相关，物理不稳定

模式 B：固定步长 + 插值（推荐）
  累加器驱动固定 Step，渲染在两次物理状态间插值

模式 C：异步物理（高级）
  物理在线程/独立频率运行，渲染读最新状态 + 外推

// C++：刚体状态
struct FRigidBody {
    glm::vec3 position;
    glm::quat orientation;
    glm::vec3 linearVelocity;
    glm::vec3 angularVelocity;
    float     mass;
    float     invMass;                 // 0 表示静态
    glm::mat3 inertiaTensor;           // 世界空间惯性张量
    glm::mat3 invInertiaTensor;
    float     restitution;             // 弹性
    float     friction;                // 摩擦
};

// 半隐式欧拉积分（游戏物理最常用）
void Integrate(FRigidBody& b, const glm::vec3& gravity, float dt) {
    b.linearVelocity  += gravity * dt;                 // 先更新速度
    b.position        += b.linearVelocity * dt;        // 再用新速度更新位置
    b.orientation      = IntegrateQuat(b.orientation, b.angularVelocity, dt);
    b.angularVelocity *= exp(-angularDamping * dt);
}

// C++：单次接触点冲量求解（简化）
void SolveContact(FContact& c, float dt) {
    glm::vec3 rv = c.bodyB->linearVelocity - c.bodyA->linearVelocity;
    float velAlongNormal = glm::dot(rv, c.normal);
    if (velAlongNormal > 0) return;                 // 正在分离，跳过

    float e = std::min(c.bodyA->restitution, c.bodyB->restitution);
    float j = -(1.0f + e) * velAlongNormal;
    j /= c.bodyA->invMass + c.bodyB->invMass;       // 除以有效质量

    glm::vec3 impulse = j * c.normal;
    c.bodyA->linearVelocity -= c.bodyA->invMass * impulse;
    c.bodyB->linearVelocity += c.bodyB->invMass * impulse;
    // 摩擦冲量（库仑摩擦，受法向冲量约束）...
}

// C++：固定步长累加器（Gaffer on Games 经典实现）
class FPhysicsLoop {
    double accumulator = 0.0;
    double fixedDt = 1.0 / 60.0;
    double maxFrameTime = 0.25;   // 防止死亡螺旋
public:
    void Update(double frameTime) {
        frameTime = std::min(frameTime, maxFrameTime);
        accumulator += frameTime;
        while (accumulator >= fixedDt) {
            previousState = currentState;    // 保存上一物理状态
            StepPhysics(fixedDt);            // 固定步长推进
            accumulator -= fixedDt;
        }
    }
    // 渲染插值因子：0 = 上一状态，1 = 当前状态
    float GetAlpha() const { return float(accumulator / fixedDt); }
};

// C++：角色移动与滑动（简化）
glm::vec3 MoveCharacter(const FCapsule& capsule, glm::vec3 desiredMove,
                        const FWorld& world, int maxSlideIterations = 4) {
    glm::vec3 position = capsule.center;
    glm::vec3 remaining = desiredMove;

    for (int i = 0; i < maxSlideIterations && glm::length(remaining) > 1e-4; ++i) {
        FSweepResult hit = world.SweepCapsule(capsule, position, remaining);
        if (!hit.hit) { position += remaining; break; }

        // 前进到碰撞点前一点点
        position += remaining * hit.time;
        // 把剩余位移投影到碰撞平面（滑动）
        remaining = remaining - hit.normal * glm::dot(remaining, hit.normal);
        remaining *= (1.0f - 1e-3f);   // 避免贴面抖动
    }
    return position;
}

// C++：质点-弹簧布料的一步（半隐式欧拉 + 弹簧约束）
void SimulateCloth(std::vector<FClothParticle>& ps,
                   const std::vector<FSpring>& springs, float dt) {
    for (auto& p : ps) {                          // 1. 积分受力
        if (p.invMass == 0.0f) continue;          // 固定点
        glm::vec3 f = glm::vec3(0, -9.8f, 0) * (1.0f / p.invMass) + damping * -p.velocity;
        p.velocity += f * p.invMass * dt;
        p.position += p.velocity * dt;
    }
    for (int it = 0; it < solverIterations; ++it) // 2. 约束迭代
        for (const auto& s : springs) {
            glm::vec3 d = ps[s.b].position - ps[s.a].position;
            float len = glm::length(d);
            float w = ps[s.a].invMass + ps[s.b].invMass;
            if (w == 0.0f) continue;
            glm::vec3 corr = d * ((len - s.restLength) / len) * stiffness;
            ps[s.a].position += corr * (ps[s.a].invMass / w);
            ps[s.b].position -= corr * (ps[s.b].invMass / w);
        }
}

// GLSL（compute）：XPBD 距离约束
void SolveDistanceConstraint(inout vec3 p0, inout vec3 p1, float w0, float w1,
                             float restLength, float compliance, float dt) {
    vec3 delta = p1 - p0;
    float len = length(delta);
    if (len < 1e-6) return;
    float C = len - restLength;                       // 约束误差
    float alpha = compliance / (dt * dt);             // 柔度
    float dlambda = -C / (w0 + w1 + alpha);
    vec3 n = delta / len;
    p0 -= w0 * dlambda * n;
    p1 += w1 * dlambda * n;
}

// C++：确定性物理的落地要点（固定步长、固定顺序、确定性随机）
void DeterministicStep(FWorld& world, float fixedDt, uint32 frame) {
    world.SortEntitiesByID();                 // 按 ID 排序，而非内存地址
    SetRandomSeed(Hash(frame));               // 每帧种子固定
    world.Solver.SetDeterministicMode(true);  // 固定归约顺序
    world.Step(fixedDt);
}

输入 → 物理世界（固定步长）
         ↓ 写：TransformComponent（物理侧）
     [双缓冲 / 快照]
         ↓ 读：渲染侧（插值）
     渲染场景图 → 提取 → 绘制

// C++：ECS 中物理系统写 Transform，渲染系统读并插值
struct TransformComponent {
    glm::vec3 prevPosition, position;
    glm::quat prevRotation, rotation;
};

void PhysicsSystem(World& w, float fixedDt) {          // 物理：写权威状态
    for (auto [e, body, tf] : w.Query<RigidBody, TransformComponent>()) {
        tf.prevPosition = tf.position;                 // 保存上一状态
        tf.prevRotation = tf.rotation;
        StepBody(body, fixedDt);
        tf.position = body.position;                   // 写入新状态
        tf.rotation = body.orientation;
    }
}

void RenderExtractSystem(World& w, float alpha) {      // 渲染：插值后提交
    for (auto [e, tf, mesh] : w.Query<TransformComponent, MeshComponent>()) {
        FTransform t;
        t.position = glm::mix(tf.prevPosition, tf.position, alpha);
        t.rotation = glm::slerp(tf.prevRotation, tf.rotation, alpha);
        SubmitMesh(mesh, t);
    }
}