C和OpenGL中的运动粒子

我希望能够在3D环境中沿直线移动粒子，但我想不出如何根据3D空间中的两点计算出下一个位置

我创建了一个结构，它表示一个粒子，它有一个位置和一个下一个位置？这是否也适合确定下一个移动位置？我知道如何使用以下方法初始设置下一个位置：

// Set particle's direction to a random direction
void setDirection(struct particle *p)
{
    float xnm = (p->location.x * -1) - p->velocity;
    float xnp = p->location.x + p->velocity;
    float ynm = (p->location.y * -1) - p->velocity;
    float ynp = p->location.y + p->velocity;
    float znm = (p->location.z * -1) - p->velocity;
    float znp = p->location.z + p->velocity;

    struct point3f nextLocation = { randFloat(xnm, xnp), randFloat(ynm, ynp), randFloat(znm, znp) };
    p->nextLocation = nextLocation;
}

我使用的结构是：

// Represents a 3D point
struct point3f
{
    float x;
    float y;
    float z;
};

// Represents a particle
struct particle
{
    enum TYPES type;
    float radius;
    float velocity;
    struct point3f location;
    struct point3f nextLocation;
    struct point3f colour;
};

我是不是走错了路

---

这是我所有的代码

你想要实现向量数学

X{i+1}=X{i}+Vt

。对于分别表示位置和速度的

X

s和

V

矢量，以及表示时间的

t

。我已经用时间参数化了轨道上的距离，因为我是物理学家，但这是很自然的事情。如果要给出轨迹距离（即缩放

V

，使

V.x*V.x+V.y*V.y+V.z*V.z=1

），则对速度矢量进行规格化

使用上面的

struct

可以很自然地访问元素，但进行添加并不方便：数组更适合这样做。像这样：

double X[3];
double V[3];

// initialize

for (int i=0; i<3 ++1){
  X[i] = X[i] + V[i]*t;
}

---

如果要将粒子的位置和速度与粒子相关联（这是非常合理的做法），则需要构造一个支持两个向量的结构

typedef
struct particle_s {
  vector position;
  vector velocity;
  //...
} particle_t;

然后运行一个更新例程，大致如下所示：

void update(particle *p, double dt){
  for (int i=0; i<3 ++i){
    p->position.a[i] += p->velocity.a[i]*dt;
  }
}

void更新（粒子*p，双dt）{
对于（inti=0；iposition.a[i]+=p->velocity.a[i]*dt；
}
}

您想要实现向量数学

X_{i+1}=X_{i}+Vt

。对于分别表示位置和速度的

X

s和

V

矢量，以及表示时间的

t

矢量。我已经按时间参数化了轨迹上的距离，因为我是物理学家，但这确实是很自然的事情。如果你想给出轨迹距离，请规范化速度矢量（即缩放

V

，使

V.x*V.x+V.y*V.y+V.z*V.z=1

）

使用上面的

struct

可以很自然地访问元素，但添加起来并不方便：数组更适合这样做。如下所示：

double X[3];
double V[3];

// initialize

for (int i=0; i<3 ++1){
  X[i] = X[i] + V[i]*t;
}

---

如果要将粒子的位置和速度与粒子相关联（这是非常合理的做法），则需要构造一个支持两个向量的结构

typedef
struct particle_s {
  vector position;
  vector velocity;
  //...
} particle_t;

然后运行一个更新例程，大致如下所示：

void update(particle *p, double dt){
  for (int i=0; i<3 ++i){
    p->position.a[i] += p->velocity.a[i]*dt;
  }
}

void更新（粒子*p，双dt）{
对于（inti=0；iposition.a[i]+=p->velocity.a[i]*dt；
}
}

想想物理学。一个物体有一个位置（x，y，z）和一个运动矢量（a，b，c）。你的物体应该存在于它的位置；它有一个与之相关联的运动矢量来描述它的动量。在物体上没有任何附加力的情况下，假设你的运动矢量描述了一段时间t内的运动，那么你的物体在时间x的位置将是（x+（at），y+（bt），z+（c*t））

---

简而言之，不要存储当前位置和下一个位置。存储当前位置和对象的动量。只需将动量添加到位置，就可以很容易地“计时”并更新对象的位置。

想想物理。对象有一个位置（x，y，z）和一个运动向量（a，b，c）。你的物体应该存在于它的位置；它有一个与之相关联的运动矢量来描述它的动量。在物体上没有任何附加力的情况下，假设你的运动矢量描述了一段时间t内的运动，那么你的物体在时间x的位置将是（x+（at），y+（bt），z+（c*t））

---

简而言之，不要存储当前位置和下一个位置。存储当前位置和对象的动量。只需将动量添加到位置，就可以很容易地“计时”并更新对象的位置。

将速度存储为结构点3f，然后您就可以得到如下结果：

void move(struct particle * p)
{
  p->position.x += p->velocity.x;
  p->position.y += p->velocity.y;
  p->position.z += p->velocity.z;
}

---

从本质上讲，速度是指你希望位置每秒钟改变多少/滴答声/随便什么。

将速度存储为结构点3f，然后你会得到如下结果：

void move(struct particle * p)
{
  p->position.x += p->velocity.x;
  p->position.y += p->velocity.y;
  p->position.z += p->velocity.z;
}

---

基本上，速度是你希望位置每秒改变多少/滴答声/无论什么。

我建议一个粒子应该只有一个位置成员——当前位置。此外，理想情况下，速度本身应该是三个分量的向量。创建一个函数（称之为

移动
，
置换
无论什么）这需要一个
粒子
和一个持续时间
t
。这将在经过
t
时间单位后计算最终位置：

struct point3f move(struct *particle, int time) {
    particle->location->x = particle->velocity->x * t;
    /* and so on for the other 2 dimensions */
    return particle->location;
}

我建议一个粒子应该只有一个位置成员——当前位置。此外，理想情况下，速度应该是一个由3个分量组成的向量。创建一个函数（称之为
move
，
displace
随便什么）这需要一个
粒子
和一个持续时间
t
。这将在经过
t
时间单位后计算最终位置：

struct point3f move(struct *particle, int time) {
    particle->location->x = particle->velocity->x * t;
    /* and so on for the other 2 dimensions */
    return particle->location;
}

另一个答案有点数学化，其实很简单

你需要一个移动的“速度”，它还有x，y和z坐标

在一个时间段内，若要移动，只需将x速度添加到x位置以获得新的x位置，重复y和z

最重要的是，你可以有一个“加速度”（也就是x，y，z），例如，你的z加速度可以是重力，一个常数

每次你的速度都应该以同样的方式重新计算，称速度x为“vx”，所以vx应该变成vx+ax，重复y和z（再次）

数学已经有一段时间了，但我就是这么记得的，非常直截了当，除非你需要跟踪单位，然后它会变得更有趣（但仍然不错）
另一个答案是有点数学化，它实际上非常直截了当

你需要一个你正在移动的“速度”