---

HEFace.cpp

Go to the documentation of this file.

/*
    TEDDY - General graphics application library
    Copyright (C) 1999-2002  Timo Suoranta
    tksuoran@cc.helsinki.fi

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    $Id:  $
*/


#if 0

#include "Teddy/Models/HEFace.h"
#include "Teddy/Models/Vertex.h"
#include "Teddy/PhysicalComponents/Projection.h"
#include "Teddy/SysSupport/Messages.h"
#include <cstdio>
#include <algorithm>
using namespace std;


namespace Teddy  {
namespace Models {


#define FACE_NORMAL_EPSILON (double)(0.0002)


Face::Face()
:
Element(0)
{
}

/*virtual*/ Face::~Face(){
}


void Face::insert( Vertex *v ){
    vertices.push_front( v );
    v->addFace( this );
}


void Face::insert( const float x, const float y, const float z ){
    Vertex *v = new Vertex(x,y,z);
    vertices.push_front( v );
    v->addFace( this );
}


void Face::append( Vertex *v ){
    vertices.push_back( v );
    v->addFace( this );
}


/*virtual*/ void Face::append( const float x, const float y, const float z ){
    Vertex *v = new Vertex(x,y,z);
    vertices.push_back( v );
    v->addFace( this );
}


/*virtual*/ void Face::draw( Projection *p ){
    p->beginPolygon();

    if( isEnabled(EL_USE_ELEMENT_NORMAL|EL_HAS_ELEMENT_NORMAL) ){
        dmsg( M_MAT, "Drawing flat face" );
        p->normal( normal.v[0], normal.v[1], normal.v[2] );
    }else{
        dmsg( M_MAT, "Drawing smoothed face" );
    }

    list<Vertex*>::const_iterator v_it = vertices.begin();
    while( v_it != vertices.end() ){
        (*v_it)->draw( p );
        v_it++;
    }

    p->end();
}


/*virtual*/ void Face::smooth( float max_smoothing_angle ){
    //  Face which has no normal calculated can not be smoothed
    //  Face normal is needed even if face is not smoothed
    if( isDisabled(EL_HAS_ELEMENT_NORMAL) ){
        makeNormal();
    }

    //  If the max smoothing angle is set to less or equal to zero,
    //  smoothing can not be applied.
    if( max_smoothing_angle <= 0 ){
        enable ( EL_USE_ELEMENT_NORMAL );
        disable( EL_USE_VERTEX_NORMALS );
        return;
    }

    int  flat_count   = 0;
    int  share_count  = 0;
    int  smooth_count = 0;
    bool flat         = true;

    //  For each vertex in the Face
    list<Vertex*>::iterator  v_it = vertices.begin();
    while( v_it != vertices.end() ){
        Vertex *old_vertex = *v_it;

        //  Make a new Vertex. We will add each normal of
        //  Faces that participate in the smoothing and
        //  normalize the normal in the end.
        Vertex *new_vertex = new Vertex( old_vertex );

        //  Set the normal of each vertex to the normal of this face in the start
        new_vertex->setNormal( this->getNormal() );

        //  For each other Face that use this Vertex,
        //  test the normal difference. On the way we
        //  also calculate the new normal the the new
        //  Vertex
        share_count  = 1;
        smooth_count = 0;
        flat_count   = 0;
        list<Face*>::iterator f_it = old_vertex->getFaces().begin();
        while( f_it != old_vertex->getFaces().end() ){
            Face *other = *f_it;

            //  Skip if same Face
            if( other == this ){
                f_it++;             
                continue;
            }

            //  Bad Face?
            if( other == NULL ){
                emsg( M_MAT, "NULL face in vertex cross-reference" );
                f_it++;
                continue;
            }

            //  The other face must have a normal as well
            if( other->isDisabled(EL_HAS_ELEMENT_NORMAL) ){
                other->makeNormal();
            }

            //  Calculate Face normal difference.
            //  We have earlier ensured that both Faces do have a normal.
            share_count++;
            Vector n1      = this ->getNormal();
            Vector n2      = other->getNormal();
            float  fn_ang  = (float)(  fabs( n1.angle(n2) )  );
            float  fn_diff = max_smoothing_angle - fn_ang;

            //  Is the enough different and not too much different?
            if( fn_ang > FACE_NORMAL_EPSILON && fn_diff > FLT_MIN ){
                new_vertex->addNormal( n2 );
                smooth_count++;
                //  If the face was considered flat earlier,
                //  we need to set normal to the vertices processed
                //  so far
                if( flat == true ){
                    flat = false;

                    Vector                  normal   = this->getNormal();
                    list<Vertex*>::iterator v_it_fix = vertices.begin();
                    if( v_it_fix != v_it ){
                        Vertex *v = *v_it_fix;
                        v->setNormal( normal );
                        v_it_fix++;
                    }
                }
            }else{  //  Otherwise it is too close or too different
                flat_count++;
            }
            f_it++;
        }

        //  Finalize the new Vertex normal; normalize it
        new_vertex->normNormal();

        //  If the Face is not flat, we will need to store the new Vertex normal
//      if( flat == false ){
            dmsg( M_VERT,
                "Face %ld smoothed vertices %ld flat vertices %ld faces share",
                smooth_count,
                flat_count,
                share_count
            );
            //  If the old Vertex has no normal, we can store the normal information there
            if( old_vertex->isDisabled(VX_HAS_NORMAL) ){
                old_vertex->setNormal( new_vertex->getNormal() );
                dmsg( M_VERT,
                    "Old vertex %ld had no normal, setting it to (%.5f, %.5f, %.5f)",
                    (unsigned long)(old_vertex),
                    new_vertex->getNormal().v[0],
                    new_vertex->getNormal().v[1],
                    new_vertex->getNormal().v[2]
                    );
                delete new_vertex;
            }else{
                //  If the old Vertex normal different, replace the
                //  Vertex in this Faces vertex list with the new Vertex
                //  This will not change the old Vertex, and other Faces'
                //  Vertex lists will not be changed.
                Vector old_normal = old_vertex->getNormal();
                Vector new_normal = new_vertex->getNormal();
                float vn_ang  = (float)(  fabs( old_normal.angle(new_normal) )  );
                if( vn_ang > FACE_NORMAL_EPSILON /*&& vn_diff > FLT_MIN*/ ){
                    dmsg( M_VERT,
                        "Old vertex %ld had different %.5f normal, replacing with copy (%.5f, %.5f, %.5f)",
                        old_vertex,
                        vn_ang,
                        new_vertex->getNormal().v[0],
                        new_vertex->getNormal().v[1],
                        new_vertex->getNormal().v[2]
                    );
                    //new_vertex->debug();
                    *v_it = new_vertex;
                }else{
                    dmsg( M_VERT,
                        "Old vertex %ld had the same normal %.5f",
                        vn_ang,
                        old_vertex
                    );
                    delete new_vertex;

                }
                //  Otherwise, the old vertex has the same normal as the new
                //  vertex and we do nothing
            }
        /*}else{
            delete new_vertex;
        } */
        
        v_it++;
    }


    if( flat == false ){
        disable( EL_USE_ELEMENT_NORMAL );
        enable ( EL_USE_VERTEX_NORMALS );

        list<Vertex*>::iterator  v_it_check = vertices.begin();
        while( v_it_check != vertices.end() ){
            Vertex *check_vertex = *v_it_check;
            if( check_vertex->isDisabled(VX_HAS_NORMAL) ){
                check_vertex->debug();
                dmsg( M_VERT, "This smooth Face has Vertex with no normal!" );
            }
            v_it_check++;
        }
    }else{
        list<Vertex*>::iterator v_it_check = vertices.begin();
        while( v_it_check != vertices.end() ){
            Vertex *check_vertex = *v_it_check;
            check_vertex->setNormal( this->getNormal() );
/*          if( check_vertex->isDisabled(VX_HAS_NORMAL) ){
                check_vertex->debug();
                vert_debug_msg( "This smooth Face has Vertex with no normal!" );
            }*/
            v_it_check++;
        }

//?     v->disable( VX_USE_THIS_NORMAL | VX_USE_PARENT_NORMAL );
        enable( EL_HAS_ELEMENT_NORMAL | EL_USE_ELEMENT_NORMAL );
        //debug_msg( "This face is now FLAT" );
        //debug_msg( "This face is now SMOOTH" );
    }
}


};  //  namespace Models
};  //  namespace Teddy


#endif  //  0