OSGEdgeIterator.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 "OSGEdgeIterator.h"

OSG_USING_NAMESPACE


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

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

#endif // only include in dev docs


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

char EdgeIterator::cvsid[] = "@(#)$Id: OSGEdgeIterator.cpp,v 1.1 2005/01/14 11:24:21 a-m-z Exp $";

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

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

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

EdgeIterator::EdgeIterator(void) :  PrimitiveIterator(),
    _edgeIndex(0), _actPrimIndex(), _edgePntIndex()
{
}

EdgeIterator::EdgeIterator(const EdgeIterator &source) :
    PrimitiveIterator(source),
    _edgeIndex(source._edgeIndex),
    _actPrimIndex(source._actPrimIndex),
    _edgePntIndex()
{
    _edgePntIndex[0] = source._edgePntIndex[0];
    _edgePntIndex[1] = source._edgePntIndex[1];
}

EdgeIterator::EdgeIterator(const NodePtr& geo) : PrimitiveIterator(),
    _edgeIndex(0), _actPrimIndex(), _edgePntIndex()
{
    setGeo(geo);
}

EdgeIterator::EdgeIterator(const GeometryPtr& geo) : PrimitiveIterator(),
    _edgeIndex(0), _actPrimIndex(), _edgePntIndex()
{
    setGeo(geo);
}


EdgeIterator::~EdgeIterator(void)
{
}

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

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

    // at end of primitive?
    if(_actPrimIndex >= PrimitiveIterator::getLength() ||
       getType() == GL_LINE_STRIP ||
       getType() == GL_LINE_LOOP    )  // TODO: add GL_POLYLINE here ?!?!
    {
        ++(static_cast<PrimitiveIterator&>(*this));
        
        startPrim();
        
        return;
    }

    switch(getType())
    {
    case GL_LINES:          _edgePntIndex[0] = _actPrimIndex++;
                            _edgePntIndex[1] = _actPrimIndex++;
                            break;
#if 0 // probably to be implemented
                            
    case GL_POLYGON:        TODO
                            break;  
    case GL_TRIANGLES:      TODO
                            break;
    case GL_QUAD_STRIP:     TODO
                            break;
    case GL_TRIANGLE_STRIP: TODO
                            break;
    case GL_TRIANGLE_FAN:   TODO
                            break;
    case GL_QUADS:          TODO
                            break;
#endif // probably to be implemented
    default:                SWARNING << "EdgeIterator::++: encountered " 
                                      << "unknown primitive type " 
                                      << getType()
                                      << ", ignoring!" << std::endl;
                            startPrim();
                            break;
    }           
}


void EdgeIterator::startPrim(void)
{
    // already at end?
    if(isAtEnd())
        return;

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

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

void EdgeIterator::setToBegin(void)
{
    PrimitiveIterator::setToBegin();
    _edgeIndex = 0;
    startPrim();
}

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

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

EdgeIterator& EdgeIterator::operator =(const EdgeIterator &source)
{
    if(this == &source)
        return *this;
    
    *static_cast<Inherited *>(this) = source;

    this->_edgeIndex            = source._edgeIndex;
    this->_actPrimIndex         = source._actPrimIndex;
    this->_edgePntIndex[0]      = source._edgePntIndex[0];
    this->_edgePntIndex[1]      = source._edgePntIndex[1];

    return *this;
}

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

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

bool EdgeIterator::operator ==(const EdgeIterator &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 EdgeIterator::operator !=(const EdgeIterator &other) const
{
    return !(*this == other);
}

---