MassSpringSystem.cpp

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

// Includes
#include "MassSpringSystem.h"
#include <OpenCAL/PointMass.h>
#include <OpenCAL/Spring.h>
#include <OpenCAL/Renderer.h>
#include <OpenCAL/Picker.h>
using namespace OpenCAL;

#include <OpenCAL/Vector3.h>
using namespace OpenCAL::Utils;

#include <map>
using namespace std;


/******************************
* Constructors and destructor *
******************************/

MassSpringSystem::MassSpringSystem(System *parent)
: PhysicsSystem(parent)
{
    m_maxStepSize = 0.005f;
}


MassSpringSystem::~MassSpringSystem()
{
}


/************************
* Get and set functions *
************************/

void MassSpringSystem::setMass(float mass)
{
    if(m_objects.empty()) return;

    float massEach = mass / m_objects.size();
    for(unsigned int i = 0; i < m_objects.size(); ++i)
        ((PointMass *) m_objects[i])->setMass(massEach);
}

void MassSpringSystem::setMassEach(float mass)
{
    for(unsigned int i = 0; i < m_objects.size(); ++i)
        ((PointMass *) m_objects[i])->setMass(mass);
}

void MassSpringSystem::setStiffness(float stiffness)
{
    for(unsigned int i = 0; i < m_actors.size(); ++i)
        ((Spring *) m_actors[i])->setStiffness(stiffness);
}

void MassSpringSystem::setDamping(float damping)
{
    for(unsigned int i = 0; i < m_actors.size(); ++i)
        ((Spring *) m_actors[i])->setDamping(damping);
}


/******************
* Other functions *
******************/

void MassSpringSystem::step(float deltaSeconds)
{
    //if(!m_enabled) return;

    // Don't use PhysicsSystem::step, cause we use a special integrator here.
    //PhysicsSystem::step(deltaSeconds);

    unsigned int steps = (unsigned int) (deltaSeconds / m_maxStepSize) + 1;
    deltaSeconds /= steps;

    for(unsigned int i = 0; i < steps; ++i)
    {
        System::step(deltaSeconds);
        integrate(deltaSeconds);
    }
}

void MassSpringSystem::render()
{
    Renderer *renderer = m_parent->getRenderer();
    if(!renderer) return;

    m_surface.invalidateTriangleNormals();
    m_surface.calculateVertexNormals();
    renderer->renderMesh(&m_surface);
}

void MassSpringSystem::renderPicking()
{
    Renderer *renderer = m_parent->getRenderer();
    if(!renderer) return;

    Picker *picker = m_parent->getPicker();
    if(!picker) return;

    picker->pushName(0);

    PointMass *point;
    for(unsigned int i = 0; i < m_objects.size(); ++i)
    {
        point = getPoint(i);
        picker->loadName(i);
        renderer->renderPoint(point->getPosition(), 3.0f);
    }

    picker->popName();
}

/*
#ifdef USE_OPENGL
void MassSpringSystem::drawPickGL()
{
    map<PointMass *, bool> drawMap;

    PointMass *point;
    for(unsigned int i = 0; i < m_objects.size(); ++i)
    {
        point = getPoint(i);
        drawMap[point] = point->getDraw();
        point->enableDraw();
    }

    PhysicsSystem::drawPickGL();

    map<PointMass *, bool>::iterator it;
    for(it = drawMap.begin(); it != drawMap.end(); ++it)
        it->first->setDraw(it->second);
}
#endif // USE_OPENGL
*/

void MassSpringSystem::initialize()
{
    PhysicsSystem::initialize();

    Renderer *renderer = m_parent->getRenderer();
    if(!renderer) return;

    renderer->initializeMesh(&m_surface);
}


/**********************
* Protected functions *
**********************/

void MassSpringSystem::integrate(float deltaSeconds)
{
    for(unsigned int i = 0; i < m_objects.size(); ++i)
    {
        PointMass *point = getPoint(i);
        Vector3 &pos = *(point->getPositionP());
        Vector3 &vel = *(point->getVelocityP());
        Vector3 acc = point->getAccelleration();

        if(!point->isFixed())
        {
            vel += deltaSeconds * acc;
            pos += deltaSeconds * vel;
        }
        point->resetForce();
    }
}

---