CatmullClark.cpp

Go to the documentation of this file.

#include "CatmullClark.h"

#include <math.h>
#include <gmVec3.h>

#include "Implicit.h"  // M_PI

#include "meshBase.h"


void CatmullClarkSubdivision::divideFace(indexFace *face)
{
        gmVector3 average (0.0, 0.0, 0.0);

        U32 total_vertices = face->getVertexCount ();

        // part of tangent term
        double A_N = 1.0 + cos (2.0 * M_PI / total_vertices) +
                                           cos (          M_PI / total_vertices) * 
                                           sqrt (2.0 * (9.0 + cos (2.0 * M_PI / total_vertices)));

        gmVector3 tan0,
                          tan1;

        for (U32 i = 0; i < total_vertices; i++)
        {
                average += face->getVertex (i);
        }

        average /= double (total_vertices);

        face->setArbitraryIndex (m_mesh.addVertex (average));
}

void CatmullClarkSubdivision::divideEdge(indexEdge  *edge, 
                                                                                 indexFace  *face)
{
        gmVector3 average;

        indexFace adj_face;

        // check for boundary vertices
        if (edge->getNumberOfAdjFaces () == 2)
        {
                adj_face = edge->getFace (0);
                average = m_mesh.getVertex (adj_face.getArbitraryIndex ());
                
                adj_face = edge->getFace (1);
                average += m_mesh.getVertex (adj_face.getArbitraryIndex ());

                average += edge->getVertexA ();
                average += edge->getVertexB ();

                average /= 4.0;
        }
        else
        {
                average = 0.5 * edge->getVertexA () +
                                  0.5 * edge->getVertexB ();
        }

        edge->setArbitraryIndex (m_mesh.addVertex (average));
}

void CatmullClarkSubdivision::buildVertex (indexVertex *vertex)
{
        gmVector3 avg_face (0.0, 0.0, 0.0),
                          avg_edge (0.0, 0.0, 0.0),
                          avg_vert,
                          average;

        U32 total = vertex->getValence ();

        indexEdge adj_edge;

        // test for boundary and corner vertices
        if (total > 2)
        {
                double inv_total2 = 1.0 / (double) (total * total);

                for (U32 i = 0; i < total; i++)
                {
                        indexFace adj_face;
        
                        adj_face = vertex->getAdjacentFace (i);

                        avg_face += m_mesh.getVertex (adj_face.getArbitraryIndex ());
                }
                avg_face *= inv_total2; 
        
                for (U32 i = 0; i < total; i++)
                {
                        adj_edge = vertex->getEdge (i);

                        if (vertex->getVertexIndex () != adj_edge.getVertexIndexA ())
                        {
                                avg_edge += adj_edge.getVertexA ();
                        }
                        else 
                        {
                                avg_edge += adj_edge.getVertexB ();
                        }
                }
                avg_edge *= inv_total2;

                avg_vert = (((double) total - 2.0) / (double) total) * 
                                          m_mesh.getVertex (vertex->getVertexIndex ());

                average = avg_vert + avg_edge + avg_face;
        }
        else
        {
                // assuming no dangling edges
                adj_edge = vertex->getEdge (0);         
                if (vertex->getVertexIndex () != adj_edge.getVertexIndexA ())
                {
                        avg_edge += adj_edge.getVertexA ();
                }
                else 
                {
                        avg_edge += adj_edge.getVertexB ();
                }

                adj_edge = vertex->getEdge (1);
                if (vertex->getVertexIndex () != adj_edge.getVertexIndexA ())
                {
                        avg_edge += adj_edge.getVertexA ();
                }
                else 
                {
                        avg_edge += adj_edge.getVertexB ();
                }
                avg_edge *= 0.125;

                average = avg_edge + 0.75 * m_mesh.getVertex (vertex->getVertexIndex ());
        }

        vertex->setArbitraryIndex (m_mesh.addVertex (average));
}

void CatmullClarkSubdivision::subdivide(U32 base_group)
{
        // create a new mesh group and acquire its id number
        U32 group;
        group = m_mesh.addGroup ();

        // acquire the mesh group to be subdivided
        MeshGroup &base_mesh = m_mesh.getGroup (base_group);

        // cycle through the faces, building a new
        // face vertex for each
        base_mesh.rewindFaceList ();
        while (indexFace *p_face = base_mesh.facePostIncrement ())
        {       
                divideFace (p_face);
        }
        
        // cycle through the faces, building new 
        // vertices for each edge
        base_mesh.rewindFaceList ();
        while (indexFace *p_face = base_mesh.facePostIncrement ())
        {
                U32 edge_count = p_face->getEdgeCount ();
                for (U32 i = 0; i < edge_count; i++)
                {
                        indexEdge &p_edge = p_face->getEdge (i);

                        // build new edge point if necessary
                        if (!p_edge.hasArbitraryIndex ())
                        {
                                divideEdge(&p_edge, p_face);
                        }
                }
        }

        // cycle through the faces, offsetting all
        // original vertices
        base_mesh.rewindFaceList ();
        while (indexFace *p_face = base_mesh.facePostIncrement ())
        {
                U32 vertex_count = p_face->getVertexCount ();

                for (U32 i = 0; i < vertex_count; i++)
                {
                        U32 base_vertex = p_face->getVertexIndex (i);

                        indexVertex &curr_vertex = m_mesh.getIndexVertex (base_vertex);

                        if (!curr_vertex.hasArbitraryIndex ())
                        {
                                buildVertex (&curr_vertex);
                        }
                }
        }

        // build new faces from the new vertices
        base_mesh.rewindFaceList ();
        while (U32 *p_face_index = base_mesh.faceIndexPostIncrement ())
        {
                indexFace *p_face = &m_mesh.getFace (*p_face_index);

                U32 vertex_count = p_face->getVertexCount ();

                U32 *new_vert           = new U32[vertex_count], 
                        *new_edge               = new U32[vertex_count],
                        *new_vert_norm  = new U32[vertex_count],
                        *new_edge_norm  = new U32[vertex_count];

                // acquire the offset and new edge vertices
                for (U32 i = 0; i < vertex_count; i++)
                {
                        U32 base = p_face->getVertexIndex (i);

                        indexVertex &p_vertex = m_mesh.getIndexVertex (base);
                        indexEdge &p_edge = p_face->getEdge (i);

                        new_vert[i] = p_vertex.getArbitraryIndex ();
                        new_edge[i] = p_edge.getArbitraryIndex ();

                        new_vert_norm[i] = m_mesh.getIndexVertex 
                                                                (new_vert[i]).getNormalIndex (); 
                        new_edge_norm[i] = m_mesh.getIndexVertex 
                                                                (new_edge[i]).getNormalIndex (); 
                }

                U32 new_face_vert = p_face->getArbitraryIndex ();
                U32 new_face_norm = m_mesh.getIndexVertex 
                                                                (new_face_vert).getNormalIndex (); 

                // enumerate the new faces (number of
                // new faces equal to number of prior
                // vertices)
                indexFace *new_face;

                for (U32 i = 0; i < (vertex_count - 1); i++)
                {
                        new_face = new indexFace;

                        new_face->addVertex (new_face_vert, new_face_norm);
                        new_face->addVertex (new_edge[i],   new_edge_norm[i]);
                        new_face->addVertex (new_vert[i+1], new_vert_norm[i+1]);
                        new_face->addVertex (new_edge[i],   new_edge_norm[i]);

                        m_mesh.addFace (*new_face);

                        delete new_face;
                }
                // enumerate final new face (wrap around indices)
                new_face = new indexFace;

                new_face->addVertex (new_face_vert, new_face_norm);
                new_face->addVertex (new_edge    [vertex_count - 1],   
                                                         new_edge_norm[vertex_count - 1]);
                new_face->addVertex (new_vert[0], new_vert_norm[0]);
                new_face->addVertex (new_edge[0], new_edge_norm[0]);

                m_mesh.addFace (*new_face);

                delete new_face;

                delete [] new_vert;
                delete [] new_edge;
                delete [] new_vert_norm;
                delete [] new_edge_norm;
        }
}

void CatmullClarkSubdivision::compute(int n)
{
        U32 base = 0;

        // Step through the levels currently in the mesh
        m_mesh.rewindGroupList();
        while (m_mesh.groupPostIncrement()) 
                base++;

        // Subdivide until desired level is reached
        for(U32 i = base; i < U32 (n); i++) 
        {
                // Subdivide the mesh using level i as the base for one step
                subdivide (i);
        }

}

int CatmullClarkSubdivision::matrix(int *n, double *s)
{       
        return 0; 
}

---