如何在两点之间强制执行约束

Question

我想在两点之间应用约束，同时应用重力。下图是我画的点2的开始和结束位置，不包括中间的时间步长位置，假设点1有一个固定的位置：

我有一个点class定义如下：

class Point{
  glm::vec3 position;
  glm::vec3 op; // original position
  glm::vec3 velocity;
  float mass;
};

我可以定义两个点并使用以下方法找到两点之间的原始长度：

Point p1;
p1.position = glm::vec3(0, 10, 0);
p1.op = p1.position;
p1.velocity = glm::vec3(0, 0, 0);
p1.mass = 1.0f;

Point p2;
p2.position = glm::vec3(10, 10, 0);
p2.op = p2.position;
p2.velocity = glm::vec3(0, 0, 0);
p2.mass = 1.0f;

float original_length_p1_p2 = glm::length(p2.op- p1.op);

我在 class 点内部有一个更新函数，它在某个时间步内运行应该通过应用重力更新点位置：

glm::vec3 gravity(0,-9.8,0);
...
void update(float dt){
  velocity += gravity * dt;
  position += velocity * dt;
}

点存储在向量中，更新函数调用如下：

std::vector<Point> myPoints;
...
for(int n = 0; n < myPoints.size(); n++){
  myPoints[n].update(dt);
}

现在我希望能够在这两个点之间应用一些类似于 spring 的约束，这将像一个简单的类似于 spring 的钟摆一样摆动。我尝试将以下内容添加到上面的 for 循环中：

void applyConstraint(Point &p1, Point &p2, float dt){
    float change = (glm::length(p1.position-p2.position) - glm::length(p1.op-p2.op)) / glm::length(p1.position-p2.position);
    p1.position -= 0.5 * (p1.position-p2.position) * change * dt;
    p2.position += 0.5 * (p1.position-p2.position) * change * dt;
}

但是当尝试这个时，p2 没有任何限制地下降。我怎样才能确保 p2 与图像相似？

已更新 applyConstraint:

void Scene::applyConstraint(Point &p1, Point &p2, float dt) {
    float change = (glm::length(p1.position - p2.position) - glm::length(p1.op - p2.op)) / glm::length(p1.position - p2.position);
    glm::vec3 force = 0.5f * (p1.position - p2.position) * change * dt;
    glm::vec3 accel1 = (-force / p1.mass) * dt;
    glm::vec3 accel2 = (force / p2.mass) * dt;
    p1.velocity += accel1 * dt;
    p2.velocity += accel2 * dt;
    p1.position += p1.velocity * dt;
    p2.position += p2.velocity * dt;
}

Answer 1

您没有正确计算加速度。力 = m * a。乘以 dt 可以让您通过欧拉积分获得速度。更好的集成方法将有助于提高准确性。我想你只是想要一个 spring。钟摆通常意味着你想要一个固定的距离约束，但你认为你的意思只是一个重复的摆动位置。

警告：我没有通过编译器进行编译，所以我的加速可能会倒退。

另外我会考虑有一个双缓冲位置。您不想像那样计算循环中的所有位置，否则您可以根据不同时间步长中的位置计算力。

void Scene::applyConstraint(Point &p1, Point &p2, float dt) {

    //Our spring constant
    const float k = 0.5f;

    //Hooke's Law is F = -k*dX
    glm::vec3 dir = p1.position - p2.position;
    glm::vec3 force =  -k*dir;   

    glm::vec3 accel1 = (force / p1.mass);
    glm::vec3 accel2 = (-force / p2.mass);

    p1.velocity += accel1 * dt;
    p2.velocity += accel2 * dt;

    p1.position += p1.velocity * dt;
    p2.position += p2.velocity * dt;
}

Answer 2

您的代码中存在三个问题。首先，您对每个约束应用欧拉积分，但它应该只在每次迭代结束时应用一次。第二，点p1应该是固定的。第三，你在计算力的时候没有考虑质量。

要修复它，请在 Point 结构中添加一个 force 向量并使用此代码：

// Reset forces
p1.force = glm::vec3(0, 0, 0);
p2.force = glm::vec3(0, 0, 0);

// Add gravity
p1.force += gravity / p1.mass ;
p2.force += gravity / p2.mass ;

// Add spring forces
// To be put in applyConstraint, without dependency on dt
float k = 1 ;
glm::vec3 difference = p1.position - p2.position;
float current_length = glm::length(difference);
float original_length = glm::length(p2.op- p1.op);
float displacement = (current_length - original_length) / current_length;
p1.force -= k * displacement * difference ;
p2.force += k * displacement * difference ;

// Euler integration
p1.velocity += p1.force / p1.mass * dt ;
p2.velocity += p2.force / p2.mass * dt ;
//p1.position += p1.velocity * dt ; // This point is an anchor
p2.position += p2.velocity * dt ;

更改k以调整spring的弹性。如果您知道您想要的行为，请使用 this website.

上给出的公式计算它

您还可以使用 p2.force -= c * p2.velocity 向系统添加阻尼，其中 c 是 damping ratio。

如何在两点之间强制执行约束

How to enforce a constraint between two points

c++

simulation

game-physics

glm-math