JellyBeam.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 "JellyBeam.h"
#include <OpenCAL/PointMass.h>
#include <OpenCAL/Spring.h>
#include <OpenCAL/System.h>
#include <OpenCAL/Vertex.h>
#include <OpenCAL/Triangle.h>
#include <OpenCAL/Renderer.h>
using namespace OpenCAL;

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

using namespace std;


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

JellyBeam::JellyBeam(System *parent, const Vector3 &from, const Vector3 &to)
: MassSpringSystem(parent)
{
    constructBeam(from, to);
}

JellyBeam::~JellyBeam()
{
}


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


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

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

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

/*
#ifdef USE_OPENGL
void JellyBeam::drawGL()
{
    MassSpringSystem::drawGL();

    //if(!m_draw) return;

    GLboolean culling = glIsEnabled(GL_CULL_FACE);
    if(culling)
        glDisable(GL_CULL_FACE);

    glLineWidth(1.0f);

    m_surface.drawGL();

    if(culling)
        glEnable(GL_CULL_FACE);
}
#endif // USE_OPENGL
*/


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

void JellyBeam::constructBeam(const Vector3 &from, const Vector3 &to)
{
    const float stiffness = 30.0f;
    const float damping = 0.2f;
    const float mass = 1.0f; // Mass of the beam
    const float massEach = mass / 8.0f;

    const float fx = from.getX(), fy = from.getY(), fz = from.getZ();
    const float tx = to.getX(), ty = to.getY(), tz = to.getZ();

    const unsigned int numPoints = 8;
    const unsigned int numSprings = 28;
    PointMass *points[numPoints];
    Spring *springs[numSprings];
    unsigned int i = 0;
    Vertex *v1, *v2, *v3;
    Triangle *triangle;


    /*********
    * Points *
    *********/

    points[0] = new PointMass(this, massEach);
    points[0]->setPosition(from);

    points[1] = new PointMass(this, massEach);
    points[1]->setPosition(Vector3(tx, fy, fz));

    points[2] = new PointMass(this, massEach);
    points[2]->setPosition(Vector3(fx, ty, fz));

    points[3] = new PointMass(this, massEach);
    points[3]->setPosition(Vector3(tx, ty, fz));

    points[4] = new PointMass(this, massEach);
    points[4]->setPosition(Vector3(fx, fy, tz));

    points[5] = new PointMass(this, massEach);
    points[5]->setPosition(Vector3(tx, fy, tz));

    points[6] = new PointMass(this, massEach);
    points[6]->setPosition(Vector3(fx, ty, tz));

    points[7] = new PointMass(this, massEach);
    points[7]->setPosition(to);


    /*******************
    * Straight springs *
    *******************/

    springs[i++] = new Spring(this, points[0], points[1]);
    springs[i++] = new Spring(this, points[2], points[3]);
    springs[i++] = new Spring(this, points[0], points[2]);
    springs[i++] = new Spring(this, points[1], points[3]);
    springs[i++] = new Spring(this, points[0], points[4]);
    springs[i++] = new Spring(this, points[1], points[5]);
    springs[i++] = new Spring(this, points[2], points[6]);
    springs[i++] = new Spring(this, points[3], points[7]);
    springs[i++] = new Spring(this, points[4], points[5]);
    springs[i++] = new Spring(this, points[6], points[7]);
    springs[i++] = new Spring(this, points[4], points[6]);
    springs[i++] = new Spring(this, points[5], points[7]);


    /*******************
    * Diagonal springs *
    *******************/

    springs[i++] = new Spring(this, points[0], points[3]);
    springs[i++] = new Spring(this, points[1], points[2]);
    springs[i++] = new Spring(this, points[4], points[7]);
    springs[i++] = new Spring(this, points[5], points[6]);
    springs[i++] = new Spring(this, points[0], points[6]);
    springs[i++] = new Spring(this, points[4], points[2]);
    springs[i++] = new Spring(this, points[1], points[7]);
    springs[i++] = new Spring(this, points[5], points[3]);
    springs[i++] = new Spring(this, points[0], points[5]);
    springs[i++] = new Spring(this, points[4], points[1]);
    springs[i++] = new Spring(this, points[2], points[7]);
    springs[i++] = new Spring(this, points[6], points[3]);


    /*************************
    * Inner diagonal springs *
    *************************/

    springs[i++] = new Spring(this, points[0], points[7]);
    springs[i++] = new Spring(this, points[1], points[6]);
    springs[i++] = new Spring(this, points[2], points[5]);
    springs[i++] = new Spring(this, points[3], points[4]);


    // Setup the point masses' properties
    for(i = 0; i < numPoints; ++i)
    {
        points[i]->setDraw(false);
    }

    // Setup the spring properties
    for(i = 0; i < numSprings; ++i)
    {
        springs[i]->setStiffness(stiffness);
        springs[i]->setDamping(damping);
        //springs[i]->setDraw(true);
    }


    /******************************
    * The surface (triangle mesh) *
    ******************************/

    // Add some materials
    Material *red = m_surface.addMaterial();
    red->setAmbient(Color::red);
    red->setDiffuse(Color::red);

    Material *green = m_surface.addMaterial();
    green->setAmbient(Color::green);
    green->setDiffuse(Color::green);

    Material *blue = m_surface.addMaterial();
    blue->setAmbient(Color::blue);
    blue->setDiffuse(Color::blue);

    // The vertices (don't copy the positions, link them)
    for(i = 0; i < numPoints; ++i)
        m_surface.addVertex(Vertex(points[i]->getPositionP()));

    // Front face
    v1 = m_surface.getVertex(0);
    v2 = m_surface.getVertex(2);
    v3 = m_surface.getVertex(3);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();
    triangle->setMaterial(red);

    v1 = m_surface.getVertex(3);
    v2 = m_surface.getVertex(1);
    v3 = m_surface.getVertex(0);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    // Back face
    v1 = m_surface.getVertex(5);
    v2 = m_surface.getVertex(7);
    v3 = m_surface.getVertex(6);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    v1 = m_surface.getVertex(6);
    v2 = m_surface.getVertex(4);
    v3 = m_surface.getVertex(5);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    // Upper face
    v1 = m_surface.getVertex(4);
    v2 = m_surface.getVertex(0);
    v3 = m_surface.getVertex(1);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();
    triangle->setMaterial(green);

    v1 = m_surface.getVertex(1);
    v2 = m_surface.getVertex(5);
    v3 = m_surface.getVertex(4);

    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    // Bottom face
    v1 = m_surface.getVertex(2);
    v2 = m_surface.getVertex(6);
    v3 = m_surface.getVertex(7);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    v1 = m_surface.getVertex(7);
    v2 = m_surface.getVertex(3);
    v3 = m_surface.getVertex(2);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    // Left face
    v1 = m_surface.getVertex(4);
    v2 = m_surface.getVertex(6);
    v3 = m_surface.getVertex(2);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();
    triangle->setMaterial(blue);

    v1 = m_surface.getVertex(2);
    v2 = m_surface.getVertex(0);
    v3 = m_surface.getVertex(4);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    // Right face
    v1 = m_surface.getVertex(1);
    v2 = m_surface.getVertex(3);
    v3 = m_surface.getVertex(7);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();

    v1 = m_surface.getVertex(7);
    v2 = m_surface.getVertex(5);
    v3 = m_surface.getVertex(1);
    triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
    triangle->calculateNormal();
}

---