Cloth.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 "Cloth.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 *
******************************/

Cloth::Cloth(System *parent, const Vector3 &position, float width, float height)
: MassSpringSystem(parent)
{
    constructCloth(position, width, height);
}

/*
Cloth::Cloth(System *parent, const Vector3 &from, const Vector3 &to)
: MassSpringSystem(parent)
{
    constructCloth(from, to);
}
*/

Cloth::~Cloth()
{
}


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


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

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

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

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

    //if(!m_draw) return;

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

    glLineWidth(1.0f);

    //m_surface.invalidateTriangleNormals();
    //m_surface.calculateVertexNormals();
    m_surface.drawGL();

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


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

void Cloth::constructCloth(const Vector3 &position, float width, float height)
{
    const int precision = 20; // Particles per unit length
    const float mass = 1.0f; // Mass per unit area

    // Structural spring properties
    const float stiffness1 = 20.0f;
    const float damping1 = 0.04f;
    const float snapFactor = 0.0f; // No tearing for now

    // Shear spring properties
    const float stiffness2 = 15.0f;
    const float damping2 = 0.04f;

    // Bend spring properties
    const float stiffness3 = 1.0f;
    const float damping3 = 0.04f;


    float area = width * height;
    m_columns = (unsigned int) (width * precision);
    m_rows = (unsigned int) (height * precision);
    unsigned int points = m_columns * m_rows;
    float massEach = area * mass / (float) points;

    unsigned int i, j;
    float x, y, z;
    PointMass *point1, *point2;
    Spring *spring;


    // Create the points
    for(j = 0; j < m_rows; ++j)
        for(i = 0; i < m_columns; ++i)
        {
            point1 = new PointMass(this, massEach);
            x = width * (i / (float) (m_columns - 1) - 0.5f);
            y = 0.0f;
            z = height * (j / (float) (m_rows - 1) - 0.5f);
            point1->setPosition(Vector3(x, y, z) + position);
            point1->disableDraw();
        }

    // Create the structural springs
    for(j = 0; j < m_rows - 1; ++j)
        for(i = 0; i < m_columns - 1; ++i)
        {
            point1 = getPoint(j, i);
            point2 = getPoint(j, i + 1);
            spring = new Spring(this, point1, point2);
            spring->setStiffness(stiffness1);
            spring->setDamping(damping1);
            spring->setSnapFactor(snapFactor);

            point2 = getPoint(j + 1, i);
            spring = new Spring(this, point1, point2);
            spring->setStiffness(stiffness1);
            spring->setDamping(damping1);
            spring->setSnapFactor(snapFactor);

            if(i == m_columns - 2)
            {
                point1 = getPoint(j, i + 1);
                point2 = getPoint(j + 1, i + 1);
                spring = new Spring(this, point1, point2);
                spring->setStiffness(stiffness1);
                spring->setDamping(damping1);
                spring->setSnapFactor(snapFactor);
            }
            if(j == m_rows - 2)
            {
                point1 = getPoint(j + 1, i);
                point2 = getPoint(j + 1, i + 1);
                spring = new Spring(this, point1, point2);
                spring->setStiffness(stiffness1);
                spring->setDamping(damping1);
                spring->setSnapFactor(snapFactor);
            }
        }
    m_structuralSprings = numActors();

    // Create the shear springs
    for(j = 0; j < m_rows - 1; ++j)
        for(i = 0; i < m_columns - 1; ++i)
        {
            point1 = getPoint(j, i);
            point2 = getPoint(j + 1, i + 1);
            spring = new Spring(this, point1, point2);
            spring->setStiffness(stiffness2);
            spring->setDamping(damping2);
            spring->setSnapFactor(snapFactor);

            point1 = getPoint(j, i + 1);
            point2 = getPoint(j + 1, i);
            spring = new Spring(this, point1, point2);
            spring->setStiffness(stiffness2);
            spring->setDamping(damping2);
            spring->setSnapFactor(snapFactor);
        }
    m_shearSprings = numActors() - m_structuralSprings;

    // Create the bend springs
    for(j = 0; j < m_rows - 2; ++j)
        for(i = 0; i < m_columns - 2; ++i)
        {
            point1 = getPoint(j, i);
            point2 = getPoint(j, i + 2);
            spring = new Spring(this, point1, point2);
            spring->setStiffness(stiffness3);
            spring->setDamping(damping3);
            spring->setSnapFactor(snapFactor);

            point2 = getPoint(j + 2, i);
            spring = new Spring(this, point1, point2);
            spring->setStiffness(stiffness3);
            spring->setDamping(damping3);
            spring->setSnapFactor(snapFactor);

            if(i == m_columns - 3)
            {
                point1 = getPoint(j, i + 1);
                point2 = getPoint(j + 2, i + 1);
                spring = new Spring(this, point1, point2);
                spring->setStiffness(stiffness3);
                spring->setDamping(damping3);
                spring->setSnapFactor(snapFactor);

                point1 = getPoint(j, i + 2);
                point2 = getPoint(j + 2, i + 2);
                spring = new Spring(this, point1, point2);
                spring->setStiffness(stiffness3);
                spring->setDamping(damping3);
                spring->setSnapFactor(snapFactor);
            }
            if(j == m_rows - 3)
            {
                point1 = getPoint(j + 1, i);
                point2 = getPoint(j + 1, i + 2);
                spring = new Spring(this, point1, point2);
                spring->setStiffness(stiffness3);
                spring->setDamping(damping3);
                spring->setSnapFactor(snapFactor);

                point1 = getPoint(j + 2, i);
                point2 = getPoint(j + 2, i + 2);
                spring = new Spring(this, point1, point2);
                spring->setStiffness(stiffness3);
                spring->setDamping(damping3);
                spring->setSnapFactor(snapFactor);
            }
        }
    m_bendSprings = numActors() - m_structuralSprings - m_shearSprings;


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

    Vertex *v1, *v2, *v3;
    Triangle *triangle;
    float u, v;

    // Add some materials
/*
    Material *blue = m_surface.addMaterial();
    blue->setAmbient(Color(0.1f, 0.08f, 0.6f));
    blue->setDiffuse(Color(0.08f, 0.1f, 0.65f));
    blue->setSpecular(Color(0.04f, 0.05f, 0.3f));
    blue->setShininess(30.0f);
*/

    // Set the texture
    //m_surface.setTexture(new Texture("cloth.tga"));

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

    for(j = 0; j < m_rows - 1; ++j)
        for(i = 0; i < m_columns - 1; ++i)
        {
            v1 = m_surface.getVertex(i + 1 + j * m_columns);
            u = (i + 1) / (float) (m_columns - 1);
            v = j / (float) (m_rows - 1);
            v1->setTexturePos(u, v);
            //cout << "v1 texture (" << u << "," << v << ")" << endl;

            v2 = m_surface.getVertex(i + j * m_columns);
            u = i / (float) (m_columns - 1);
            v = j / (float) (m_rows - 1);
            v2->setTexturePos(u, v);
            //cout << "v2 texture (" << u << "," << v << ")" << endl;

            v3 = m_surface.getVertex(i + (j + 1) * m_columns);
            u = i / (float) (m_columns - 1);
            v = (j + 1) / (float) (m_rows - 1);
            v3->setTexturePos(u, v);
            //cout << "v3 texture (" << u << "," << v << ")" << endl;

            triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
            triangle->calculateNormal();
            //triangle->setMaterial(blue);
            //triangle->setTexture(texture);

            v1 = m_surface.getVertex(i + 1 + j * m_columns);
            u = (i + 1) / (float) (m_columns - 1);
            v = j / (float) (m_rows - 1);
            v1->setTexturePos(u, v);
            //cout << "v1 texture (" << u << "," << v << ")" << endl;

            v2 = m_surface.getVertex(i + (j + 1) * m_columns);
            u = i / (float) (m_columns - 1);
            v = (j + 1) / (float) (m_rows - 1);
            v2->setTexturePos(u, v);
            //cout << "v2 texture (" << u << "," << v << ")" << endl;

            v3 = m_surface.getVertex(i + 1 + (j + 1) * m_columns);
            u = (i + 1) / (float) (m_columns - 1);
            v = (j + 1) / (float) (m_rows - 1);
            v3->setTexturePos(u, v);
            //cout << "v3 texture (" << u << "," << v << ")" << endl;

            triangle = m_surface.addTriangle(Triangle(v1, v2, v3));
            triangle->calculateNormal();
            //triangle->setMaterial(blue);
            //triangle->setTexture(texture);
        }
}

---