OSGTriangleIterator.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *                                OpenSG                                     *
 *                                                                           *
 *                                                                           *
 *             Copyright(C) 2000-2002 by the OpenSG Forum                    *
 *                                                                           *
 *                            www.opensg.org                                 *
 *                                                                           *
 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                License                                    *
 *                                                                           *
 * This library is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU Library General Public License as published    *
 * by the Free Software Foundation, version 2.                               *
 *                                                                           *
 * 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         *
 * Library General Public License for more details.                          *
 *                                                                           *
 * You should have received a copy of the GNU Library General Public         *
 * License along with this library; if not, write to the Free Software       *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                Changes                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/

//---------------------------------------------------------------------------
 //  Includes
//---------------------------------------------------------------------------

#include <stdlib.h>
#include <stdio.h>

#include "OSGConfig.h"
#include "OSGNodePtr.h"
#include "OSGTriangleIterator.h"

OSG_USING_NAMESPACE


/***************************************************************************\
 *                            Description                                  *
\***************************************************************************/

#if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)

#endif // only include in dev docs


/***************************************************************************\
 *                           Class variables                               *
\***************************************************************************/

char TriangleIterator::cvsid[] = "@(#)$Id: OSGTriangleIterator.cpp,v 1.13 2001/10/15 04:52:16 vossg Exp $";

/***************************************************************************\
 *                           Instance methods                              *
\***************************************************************************/

/*-------------------------------------------------------------------------*\
 -  public                                                                 -
\*-------------------------------------------------------------------------*/

/*------------- constructors & destructors --------------------------------*/

TriangleIterator::TriangleIterator(void) : PrimitiveIterator(),
    _triIndex(0), _actPrimIndex(0), _triPntIndex()
{
}

TriangleIterator::TriangleIterator(const TriangleIterator &source) : 
    PrimitiveIterator(source),
    _triIndex(source._triIndex), _actPrimIndex(source._actPrimIndex),
    _triPntIndex()
{
    _triPntIndex[0] = source._triPntIndex[0];
    _triPntIndex[1] = source._triPntIndex[1];
    _triPntIndex[2] = source._triPntIndex[2];
}


TriangleIterator::TriangleIterator(const GeometryPtr& geo) :
    PrimitiveIterator(),
    _triIndex(0), _actPrimIndex(0), _triPntIndex()
{
    setGeo(geo);
}


TriangleIterator::TriangleIterator(const NodePtr& geo) : 
    PrimitiveIterator(),
    _triIndex(0), _actPrimIndex(0), _triPntIndex()
{
    setGeo(geo);
}


TriangleIterator::~TriangleIterator(void)
{
}

/*--------------------------- Operators ----------------------------------*/

void TriangleIterator::operator++()
{
    // already at end?
    if(isAtEnd())
        return;
    
    ++_triIndex;

    // at end of primitive?
    if(_actPrimIndex >= getLength())
    {
        ++(static_cast<PrimitiveIterator&>(*this));      
        startPrim();
        
        return;
    }

    switch(getType())
    {
    case GL_TRIANGLES:      _triPntIndex[0] = _actPrimIndex++;
                            _triPntIndex[1] = _actPrimIndex++;
                            _triPntIndex[2] = _actPrimIndex++;
                            break;
    case GL_QUAD_STRIP:
    case GL_TRIANGLE_STRIP: if(_actPrimIndex & 1)
                            {
                                _triPntIndex[0] = _triPntIndex[2];
                            }
                            else
                            {
                                _triPntIndex[1] = _triPntIndex[2];
                            }                           
                            _triPntIndex[2] = _actPrimIndex++;
                            
                            if(getPositionIndex(0) == getPositionIndex(1) ||
                               getPositionIndex(0) == getPositionIndex(2) ||
                               getPositionIndex(1) == getPositionIndex(2))
                            {
                                --_triIndex;
                                ++(*this);
                            }
                               
                            break;
    case GL_POLYGON:
    case GL_TRIANGLE_FAN:   _triPntIndex[1] = _triPntIndex[2];
                            _triPntIndex[2] = _actPrimIndex++;
                            break;
    case GL_QUADS:          if(_actPrimIndex & 1)
                            {
                                _triPntIndex[1] = _triPntIndex[2];
                                _triPntIndex[2] = _actPrimIndex++;
                            }
                            else
                            {
                                _triPntIndex[0] = _actPrimIndex++;
                                _triPntIndex[1] = _actPrimIndex++;
                                _triPntIndex[2] = _actPrimIndex++;
                            }                           
                            break;
    default:                SWARNING << "TriangleIterator::++: encountered " 
                                      << "unknown primitive type " 
                                      << getType()
                                      << ", ignoring!" << std::endl;
                            startPrim();
                            break;
    }           
}


void TriangleIterator::startPrim(void)
{
    // already at end?
    if(isAtEnd())
        return;
        
    _triPntIndex[0] = 0;
    _triPntIndex[1] = 1;
    _triPntIndex[2] = 2;
    _actPrimIndex = 3;
    
    // loop until you find a useful primitive or run out
    while(! isAtEnd())
    {
        switch(getType())
        {
        case GL_POINTS:         // non-polygon types: ignored
        case GL_LINES:
        case GL_LINE_STRIP: 
        case GL_LINE_LOOP:  
                                break;
        case GL_TRIANGLES:      // polygon types
        case GL_TRIANGLE_STRIP:
        case GL_TRIANGLE_FAN:
        case GL_QUADS:
        case GL_QUAD_STRIP:
        case GL_POLYGON:        if(getLength() >= 3)
                                    return;
                                break;
        default:                SWARNING << "TriangleIterator::startPrim: "
                                          << "encountered " 
                                          << "unknown primitive type " 
                                          << getType()
                                          << ", ignoring!" << std::endl;
                                break;
        }
        
        ++(static_cast<PrimitiveIterator&>(*this));
    }           
}


void TriangleIterator::seek(Int32 index)
{
    setToBegin();
    
    while(getIndex() != index)
        ++(*this);
}


void TriangleIterator::setToBegin(void)
{
    PrimitiveIterator::setToBegin();
    _triIndex = 0;
    startPrim();
}

void TriangleIterator::setToEnd(void)
{
    PrimitiveIterator::setToEnd();
    _actPrimIndex = 0;
}

/*-------------------------- assignment -----------------------------------*/

TriangleIterator& TriangleIterator::operator =(const TriangleIterator &source)
{
    if(this == &source)
        return *this;

    *static_cast<Inherited *>(this) = source;
    
    this->_triIndex         = source._triIndex;
    this->_actPrimIndex     = source._actPrimIndex;
    this->_triPntIndex[0]   = source._triPntIndex[0];
    this->_triPntIndex[1]   = source._triPntIndex[1];
    this->_triPntIndex[2]   = source._triPntIndex[2];

    return *this;
}

/*-------------------------- comparison -----------------------------------*/

bool TriangleIterator::operator <(const TriangleIterator &other) const
{
    return 
          (*static_cast<const Inherited *>(this) <  other) ||
        ( (*static_cast<const Inherited *>(this) == other)             &&
          _actPrimIndex                          <  other._actPrimIndex);
}

bool TriangleIterator::operator ==(const TriangleIterator &other) const
{
    if(isAtEnd() && other.isAtEnd())
        return true;

    if(isAtEnd() || other.isAtEnd())
        return false;

    return 
        (*static_cast<const Inherited *>(this) == other              ) &&
        _actPrimIndex                          == other._actPrimIndex;
}

bool TriangleIterator::operator !=(const TriangleIterator &other) const
{
    return !(*this == other);
}

---