C++博客 :: 首页 :: 联系 ::  :: 管理
  163 Posts :: 4 Stories :: 350 Comments :: 0 Trackbacks

常用链接

留言簿(48)

我参与的团队

搜索

  •  

积分与排名

  • 积分 - 384182
  • 排名 - 55

最新评论

阅读排行榜

评论排行榜

物理模拟介绍

如果你很熟悉物理规律,并且想实现它,这篇文章很适合你。

在这篇教程里,你会创建一个非常简单的物理引擎,我们将创建以下类:

内容:

位置类
* class Vector3D --->  用来记录物体的三维坐标的类

力和运动
* class Mass --->  表示一个物体的物理属性

模拟类
* class Simulation --->  模拟物理规律

模拟匀速运动
* class ConstantVelocity : public Simulation --->  模拟匀速运动

模拟在力的作用下运动
* class MotionUnderGravitation : public Simulation --->  模拟在引力的作用下运动
* class MassConnectedWithSpring : public Simulation --->  模拟在弹簧的作用下运动

 
  

class Mass
{
public:
    float m;                                    // 质量
    Vector3D pos;                                // 位置
    Vector3D vel;                                // 速度
    Vector3D force;                                // 力

    Mass(float m)                                // 构造函数
    {
        this->m = m;
    }

    ...

  
 下面的代码给物体增加一个力,在初始时这个力为0
 
  

    void applyForce(Vector3D force)
    {
        this->force += force;                        // 增加一个力
    }

    void init()                                // 初始时设为0
    {
        force.x = 0;
        force.y = 0;
        force.z = 0;
    }

    ...

  
 下面的步骤完成一个模拟:

1.设置力
2.应用外力
3.根据力的时间,计算物体的位置和速度
 
  

    void simulate(float dt)
    {
        vel += (force / m) * dt;                    // 更新速度
                               

        pos += vel * dt;                        // 更新位置
                                       
    }

  
 模拟类怎样运作:

在一个物理模拟中,我们按以下规律进行模拟,设置力,更新物体的位置和速度,按时间一次又一次的进行模拟。下面是它的实现代码: 
  

class Simulation
{
public:
    int numOfMasses;                                // 物体的个数
    Mass** masses;                                // 指向物体结构的指针

    Simulation(int numOfMasses, float m)                        // 构造函数
    {
        this->numOfMasses = numOfMasses;

        masses = new Mass*[numOfMasses];               

        for (int a = 0; a < numOfMasses; ++a)               
            masses[a] = new Mass(m);           
    }

    virtual void release()                            // 释放所有的物体
    {
        for (int a = 0; a < numOfMasses; ++a)               
        {
            delete(masses[a]);
            masses[a] = NULL;
        }

        delete(masses);
        masses = NULL;
    }

    Mass* getMass(int index)
    {
        if (index < 0 || index >= numOfMasses)                // 返回第i个物体
            return NULL;                       

        return masses[index];                       
    }

...

    (class Simulation continued)

    virtual void init()                            // 初始化所有的物体
    {
        for (int a = 0; a < numOfMasses; ++a)               
            masses[a]->init();                   
    }

    virtual void solve()                            //虚函数,在具体的应用中设置各个施加给各个物体的力
    {
                                   
    }

    virtual void simulate(float dt)                        //让所有的物体模拟一步
    {
        for (int a = 0; a < numOfMasses; ++a)               
            masses[a]->simulate(dt);               
    }

    ...

  
 整个模拟的部分被封装到下面的函数中 
  

    (class Simulation continued)

    virtual void operate(float dt)                        //  完整的模拟过程
    {
        init();                                // 设置力为0
        solve();                                // 应用力
        simulate(dt);                            // 模拟
    }
};

  
 现在我们已经有了一个简单的物理模拟引擎了,它包含有物体和模拟两个类,下面我们基于它们创建三个具体的模拟对象:

1. 具有恒定速度的物体
2. 具有恒定加速度的物体
3. 具有与距离成反比的力的物体

在程序中控制一个模拟对象:

在我们写一个具体的模拟类之前,让我们看看如何在程序中模拟一个对象,在这个教程里,模拟引擎和操作模拟的程序在两个文件里,在程序中我们使用如下的函数,操作模拟:

 
  

void Update (DWORD milliseconds)                        // 执行模拟

  
 这个函数在每一帧的开始更新,参数为相隔的时间。 
  

void Update (DWORD milliseconds)
{
    ...
    ...
    ...

    float dt = milliseconds / 1000.0f;                    // 转化为秒

    dt /= slowMotionRatio;                        // 除以模拟系数

    timeElapsed += dt;                            // 更新流失的时间

    ...

  
 在下面的代码中,我们定义一个处理间隔,没隔这么长时间,让物理引擎模拟一次。 
  

    ...

    float maxPossible_dt = 0.1f;                    // 设置模拟间隔
                                   

      int numOfIterations = (int)(dt / maxPossible_dt) + 1;            //计算在流失的时间里模拟的次数
    if (numOfIterations != 0)                   
        dt = dt / numOfIterations;                   

    for (int a = 0; a < numOfIterations; ++a)                // 模拟它们   
    {
        constantVelocity->operate(dt);                   
        motionUnderGravitation->operate(dt);               
        massConnectedWithSpring->operate(dt);               
    }
}

  
 下面让我们来写着两个具体的模拟类:

1. 具有恒定速度的物体
* class ConstantVelocity : public Simulation ---> 模拟一个匀速运动的物体

 
  

class ConstantVelocity : public Simulation
{
public:
    ConstantVelocity() : Simulation(1, 1.0f)                 
    {
        masses[0]->pos = Vector3D(0.0f, 0.0f, 0.0f);            // 初始位置为0
        masses[0]->vel = Vector3D(1.0f, 0.0f, 0.0f);            // 向右运动
    }
};

  
 下面我们来创建一个具有恒定加速的物体:

 
  

class MotionUnderGravitation : public Simulation
{
    Vector3D gravitation;                            // 加速度

    MotionUnderGravitation(Vector3D gravitation) : Simulation(1, 1.0f)        //  构造函数
    {                                   
        this->gravitation = gravitation;                    // 设置加速度
        masses[0]->pos = Vector3D(-10.0f, 0.0f, 0.0f);            // 设置位置为左边-10处
        masses[0]->vel = Vector3D(10.0f, 15.0f, 0.0f);            // 设置速度为右上
    }

    ...

  
 下面的函数设置施加给物体的力 
  

    virtual void solve()                            // 设置当前的力
    {
        for (int a = 0; a < numOfMasses; ++a)               
            masses[a]->applyForce(gravitation * masses[a]->m);   
    }

  
 下面的类创建一个受到与距离成正比的力的物体: 
  

class MassConnectedWithSpring : public Simulation
{
public:
    float springConstant;                            // 弹性系数
    Vector3D connectionPos;                            // 连接方向

    MassConnectedWithSpring(float springConstant) : Simulation(1, 1.0f)        // 构造函数
    {
        this->springConstant = springConstant;               

        connectionPos = Vector3D(0.0f, -5.0f, 0.0f);       

        masses[0]->pos = connectionPos + Vector3D(10.0f, 0.0f, 0.0f);   
        masses[0]->vel = Vector3D(0.0f, 0.0f, 0.0f);       
    }

    ...

  
 下面的函数设置当前物体所受到的力: 
  

virtual void solve()                                // 设置当前的力
{
    for (int a = 0; a < numOfMasses; ++a)                   
    {
        Vector3D springVector = masses[a]->pos - connectionPos;       
        masses[a]->applyForce(-springVector * springConstant);       
    }
}

  
 好了上面就是一个简单的物理模拟,希望你能喜欢:)

 
 
posted on 2007-12-30 15:32 sdfasdf 阅读(726) 评论(0)  编辑 收藏 引用 所属分类: OPENGL

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理