PhysSystem.cpp

Go to the documentation of this file.

#include "PhysSystem.h"

PhysSystem::PhysSystem()
{
    gravity.SetVector(glVector(0,-9.8,0));
    wind.SetVector(glVector(0,0,0));
}
        
bool PhysSystem::AddObjects(vector<Object3d*> &new_obj_list)
{
    Object3d *new_obj;
    for(int i = 0; i < new_obj_list.size(); i++)
    {
        new_obj = new_obj_list[i];
        obj_list.push_back(new_obj);
        obj_list.back().qrot_velocity = Quaternion(0, 0, 0);
    }
}

void PhysSystem::UpdateAll()
{
    physics_timer.GetElapsedSeconds();
    for(int a = 0; a < obj_list.size(); a++)
    {
        WorldEffect(obj_list[a]);
        for(int b = a+1; b < obj_list.size(); b++)
        {
            float center_distance = ((obj_list[a].bsphere_list[0].offset + *obj_list[a].center) - 
                                     (obj_list[b].bsphere_list[0].offset + *obj_list[b].center)).length();
            float radius_total = obj_list[a].bsphere_list[0].radius + obj_list[b].bsphere_list[0].radius;
                
            if(center_distance - radius_total < 0)
                CollideObjects(obj_list[a], obj_list[b]);
        }
        Update(obj_list[a]);
    }
}

void PhysSystem::CollideObjects(PhysObject &Object1, PhysObject &Object2)
{
    glVector p1_offset;
    glVector p2_offset;
    
    for(int c = 1; c < Object1.bsphere_list.size(); c++)
    {
        for(int d = 1; d < Object2.bsphere_list.size(); d++)
        {
            Quaternion q1(Object1.center->rot);
            Quaternion q2(Object2.center->rot);
            p1_offset = q1.RotateV(Object1.bsphere_list[c].offset);
            p2_offset = q2.RotateV(Object2.bsphere_list[d].offset);
            
            float center_distance = ((p1_offset + *Object1.center) - (p2_offset + *Object2.center)).length();
            float radius_total = Object1.bsphere_list[c].radius + Object2.bsphere_list[d].radius;
            if(center_distance - radius_total < 0)
            {
                float radius1 = p1_offset.length();
                float radius2 = p2_offset.length();
                glVector v1;
                glVector v2;
                glVector v1_lin;
                glVector v2_lin;
                glVector v1_ang;
                glVector v2_ang;

                v1 = Object1.velocity;
                v2 = Object2.velocity;
                
                Quaternion qin_1(Object1.qrot_velocity);
                Quaternion qin_2(Object2.qrot_velocity);
                
                float angspeed_1 = qin_1.GetAngle();
                float angspeed_2 = qin_2.GetAngle();
                
                glVector angvector_1 = !((q1 * qin_1 * ~q1).v % p1_offset);
                glVector angvector_2 = !((q2 * qin_2 * ~q2).v % p2_offset);
                
                v1 += (angvector_1 * radius1 * angspeed_1);
                v2 += (angvector_2 * radius2 * angspeed_2);
                
                float m1 = Object1.mass + Object1.inertial_moment;
                float m2 = Object2.mass + Object2.inertial_moment;

                if(!CollidePoints(p1_offset + *Object1.center, v1, m1, Object1.elasticity,
                                  p2_offset + *Object2.center, v2, m2, Object2.elasticity))
                    return;
                    
                if(radius1 != 0) v1_lin = v1.ProjectOnto(p1_offset);
                    else v1_lin = v1;
                if(radius2 != 0) v2_lin = v2.ProjectOnto(p2_offset);
                    else v2_lin = v2;
                
                v1_ang = v1 - v1_lin;
                v2_ang = v2 - v2_lin;
            
                if(radius1 != 0)
                {
                    Quaternion qout_1(v1_ang.length() / radius1, !(p1_offset % v1_ang));
                    Object1.qrot_velocity = Object1.qrot_velocity * (~q1 * qout_1 * q1);
                }
                if(radius2 != 0)
                {
                    Quaternion qout_2(v2_ang.length() / radius2, !(p2_offset % v2_ang));
                    Object2.qrot_velocity = Object2.qrot_velocity * (~q2 * qout_2 * q2);
                }
                
                Object1.velocity  += (v1_lin);
                Object2.velocity  += (v2_lin);
            }
        }
    }
}

bool PhysSystem::CollidePoints(glVector point1, glVector &momentum1, float m1, float cor1,
                               glVector point2, glVector &momentum2, float m2, float cor2)
{
    glVector col_vector = !(point2 - point1);
    glVector rel_momentum = momentum1 - momentum2;
    glVector proj_momentum = rel_momentum.ProjectOnto(col_vector);
    
    if((proj_momentum * col_vector) > 0)
    {
         momentum1 = proj_momentum * -(m2/(m1+m2))*(1+cor1);
         momentum2 = proj_momentum *  (m1/(m1+m2))*(1+cor2);
         return true;
    }
    return false;
}

void PhysSystem::WorldEffect(PhysObject &cur_obj)
{
    cur_obj.velocity = cur_obj.velocity + (!(glVector(*cur_obj.center) - glVector(*obj_list[0].center)) * -98.0/2.0 * cur_obj.gravity_effect) * physics_timer.difference_time;
//    cur_obj.velocity = cur_obj.velocity + (wind * cur_obj.wind_effect) * physics_timer.difference_time;
}

void PhysSystem::Update(PhysObject &cur_obj)
{
    cur_obj.center->Move(cur_obj.velocity * physics_timer.difference_time);
    
    Quaternion rot_step(cur_obj.qrot_velocity.GetAngle() * physics_timer.difference_time, cur_obj.qrot_velocity.GetAxis());
    cur_obj.center->rot = cur_obj.center->rot * rot_step;
}

---