---

Vertex.h

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:  $
*/


#ifndef TEDDY__MODELS__VERTEX__H
#define TEDDY__MODELS__VERTEX__H


#if defined(_MSC_VER)
#pragma warning(disable:4521)  //  multiple copy constructors defined (!)
#endif


#include "Teddy/Graphics/Color.h"
#include "Teddy/Maths/Vector.h"
#include "Teddy/Maths/Matrix.h"
#include "Teddy/MixIn/Options.h"
#include "Teddy/Models/Element.h"
#include "Teddy/SysSupport/StdList.h"
using namespace Teddy::Graphics;
using namespace Teddy::Maths;
using namespace Teddy::MixIn;


namespace Teddy  {
namespace Models {


class Face;


class Vertex : public Element {
public:
    Vertex();
    Vertex( Vertex *v );
    Vertex( Vertex &v );
    Vertex( const Vertex &v );
    Vertex( const Vector &v );
    Vertex( const float x, const float y, const float z );
    virtual ~Vertex();

    virtual double getMaxVector() const;

public:
    virtual void  debug       ();
    virtual void  draw        ( Projection *p );
    virtual void  applyColor  ( Projection *p );
    virtual void  applyNormal ( Projection *p );
    virtual void  applyTexture( Projection *p );
    virtual void  applyVertex ( Projection *p );

    void          neg         ();
    void          transform   ( const Matrix &m, const Matrix &normal_matrix );
    void          setParent   ( const Vertex &vert    );
    void          setVertex   ( const Vector &vert    );
    void          setVertex   ( const float x, const float y, const float z );
    void          setColor    ( const Color  &color   );
    void          setNormal   ( const Vector &normal  );
    void          setNormal   ( const float x, const float y, const float z  );
    void          setTexture  ( const Vector &texture );
    void          setTexture  ( const float s, const float t, const float u = 0.0f );
    void          addNormal   ( const Vector &add     );
    void          normNormal  ();
    void          removeNormal();
    Vertex       *getRoot     ();
    Vertex       *getParent   ();
    Vector       &getVertex   ();
    Color        &getColor    ();
    Vector       &getNormal   ();
    Vector       &getTexture  ();
    list<Face*>  &getFaces    ();
    void          addFace     ( Face *face );

    //  Basic operations on vertex
    Vertex &operator+=( Vertex &v ){ vert += v.getVertex(); return *this; };
    Vertex &operator-=( Vertex &v ){ vert -= v.getVertex(); return *this; };
    Vertex &operator*=( float   k ){ vert *= k; return *this; };
    Vertex &operator/=( float   k ){ vert /= k; return *this; };

    Vertex &operator+=( const Vertex &v ){ vert += v.vert; return *this; };
    Vertex &operator-=( const Vertex &v ){ vert -= v.vert; return *this; };
//  Vertex &operator*=( const float   k ){ vert *= k; return *this; };
//  Vertex &operator/=( const float   k ){ vert /= k; return *this; };

    Vertex  operator+( Vertex &v ){ return new Vertex(vert+v.vert); };
    Vertex  operator-( Vertex &v ){ return new Vertex(vert-v.vert); };
    Vertex  operator*( float   k ){ return new Vertex(vert*k     ); };
    Vertex  operator/( float   k ){ return new Vertex(vert/k     ); };

    Vertex  operator+( const Vertex &v ){ return new Vertex(vert+v.vert); };
    Vertex  operator-( const Vertex &v ){ return new Vertex(vert-v.vert); };
//  Vertex  operator*( const float   k ){ return new Vertex(vert*k            ); };
//  Vertex  operator/( const float   k ){ return new Vertex(vert/k            ); };

    //  Flip code; FIX if parent vertex is being used, copy it and only change the copy
    void flipX    (){ getVertex().v[0] *= -1; };
    void flipY    (){ getVertex().v[1] *= -1; };
    void flipZ    (){ getVertex().v[2] *= -1; };

    //  Length code; FIX if parent vertex is being used, copy it and only change the copy
    void  normalize(){ getVertex().normalize();        };
    float magnitude(){ return getVertex().magnitude(); };

public:
    list<Face*>  faces;    

protected:
    Vertex *parent;        
    Vector  vert;          
    Vector  normal;        
    Color   color;         
    Vector  texturecoord;  
};


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


#endif  //  TEDDY__MODELS__VERTEX__H