OSGChunkMaterial.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 <OSGGL.h>

#include <OSGAttachmentContainerPtr.h>
#include <OSGState.h>
#include <OSGDrawActionBase.h>
#include <OSGGeometry.h>

#include "OSGChunkMaterial.h"

OSG_USING_NAMESPACE


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

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

/***************************************************************************\
 *                           Class methods                                 *
\***************************************************************************/

/*-------------------------------------------------------------------------*\
 -  private                                                                -
\*-------------------------------------------------------------------------*/

void ChunkMaterial::initMethod(void)
{
}

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

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

ChunkMaterial::ChunkMaterial(void) :
    Inherited()
{
}

ChunkMaterial::ChunkMaterial(const ChunkMaterial &source) :
    Inherited(source)
{
}

ChunkMaterial::~ChunkMaterial(void)
{
    clearChunks();
}

void ChunkMaterial::changed(BitVector whichField, UInt32 origin)
{
    if(origin & ChangedOrigin::Abstract)
    {
        MFStateChunkPtr::iterator matIt  = _mfChunks.begin();
        MFStateChunkPtr::iterator matEnd = _mfChunks.end ();
        
        while(matIt != matEnd)
        {
            addRefCP(*matIt);
           
            ++matIt;
        }
    }

    Inherited::changed(whichField, origin);
}


/*-------------------------- your_category---------------------------------*/

bool ChunkMaterial::addChunk(StateChunkPtr chunk, Int32 slot)
{
    if(slot != State::AutoSlotReplace)
    {
        while(_mfSlots.size() < _mfChunks.size())
            _mfSlots.push_back(State::AutoSlotReplace);
    }
    
    _mfChunks.push_back(chunk);
    
    if(slot != State::AutoSlotReplace)
        _mfSlots.push_back(slot);
        
    addRefCP(chunk);

    return true;
}

bool ChunkMaterial::subChunk(StateChunkPtr chunk, Int32 slot)
{
    UInt32 i;
    
    for(i = 0; i < _mfChunks.size(); ++i)
    {
        if(_mfChunks[i] == chunk &&
           ((i < _mfSlots.size() && _mfSlots[i] == slot) ||
            slot == State::AutoSlotReplace))
        {
            subRefCP(chunk);
            _mfChunks.erase(_mfChunks.begin() + i);
            if(i < _mfSlots.size())
                _mfSlots.erase(_mfSlots.begin() + i);
            return false;
        }
    }

    SWARNING << "ChunkMaterial::subChunk(" << this << ") has no chunk "
             << chunk << " with slot " << slot << std::endl;
             
    return true;
}

Int32 ChunkMaterial::find(StateChunkPtr chunk)
{
    UInt32 i;
    
    for(i = 0; i < _mfChunks.size(); ++i)
    {
        if(_mfChunks[i] == chunk)
            return i;
    }
             
    return -1;
}

StateChunkPtr ChunkMaterial::find(const FieldContainerType &type, 
                                    Int32 slot)
{
    UInt32 index = 0;
    for(UInt32 i = 0; i < _mfChunks.size(); ++i)
    {
        StateChunkPtr p = _mfChunks[i];
        Int32 s = State::AutoSlotReplace;

        if(i < getSlots().size())
            s = getSlots(i);

        if(s == State::AutoSlotReplace)
            s = index;

        if(p->getType() == type)
        {           
            if(slot == State::AutoSlotReplace || slot == s)
                return (p);
            ++index;
        }
    }
    return NullFC;
}

void ChunkMaterial::clearChunks(void)
{
    MFStateChunkPtr::iterator matIt  = _mfChunks.begin();
    MFStateChunkPtr::iterator matEnd = _mfChunks.end ();
    
    while(matIt != matEnd)
    {
        subRefCP(*matIt);
        ++matIt;
    }
    _mfChunks.clear();
}

bool ChunkMaterial::operator==(const Material& other)
{
    Material& thisBase = *this;
    if (!(thisBase == other))
        return false;

    const ChunkMaterial* othercm = dynamic_cast<const ChunkMaterial*>(&other);
    if (!othercm)
        return false;

    // ?
    return false;
}

void ChunkMaterial::draw(Geometry* geo, DrawActionBase * action)
{
    StatePtr state = makeState();

    addRefCP(state);

    state->activate(action);

    geo->drawPrimitives(action);

    state->deactivate(action);

    subRefCP(state); // kill it
}

void ChunkMaterial::draw(DrawFunctor& func, DrawActionBase * action)
{
    StatePtr state = makeState();

    addRefCP(state);

    state->activate(action);

    func.call(action);

    state->deactivate(action);

    subRefCP(state); // kill it
}

void ChunkMaterial::addChunks(StatePtr state)
{
    UInt32 i;
    
    for(i = 0; i < _mfChunks.size(); ++i)
        state->addChunk(_mfChunks[i], 
                        (i < _mfSlots.size()) ? _mfSlots[i]
                                                : State::AutoSlotReplace);
}

StatePtr ChunkMaterial::makeState(void)
{
    StatePtr state = State::create();
    
    addChunks(state);

    return state;
}

void ChunkMaterial::rebuildState(void)
{
    if(_pState != NullFC)
    {
        _pState->clearChunks();
    }
    else
    {
        _pState = State::create();

        addRefCP(_pState);
    }
        
    addChunks(_pState);
}

bool ChunkMaterial::isTransparent(void) const
{
    Int32 tm = getTransparencyMode();
    if(tm != Material::TransparencyAutoDetection)
    {
        return (tm == Material::TransparencyForceTransparent);
    }

    bool returnValue = false;

    MFStateChunkPtr::const_iterator it        = _mfChunks.begin();
    MFStateChunkPtr::const_iterator chunksEnd = _mfChunks.end();

    for(; it != chunksEnd && returnValue == false; ++it)
    {
        returnValue =(*it)->isTransparent();
    }

    return returnValue;
}

/*------------------------------- dump ----------------------------------*/

void ChunkMaterial::dump(      UInt32    OSG_CHECK_ARG(uiIndent),
                         const BitVector OSG_CHECK_ARG(bvFlags )) const
{
    SLOG << "ChunkMaterial at " << this << std::endl;
    SLOG << "Chunks: " << std::endl;

    UInt32 i;
    
    for(i = 0; i < _mfChunks.size(); ++i)
        SLOG << _mfChunks[i] << " "
             << static_cast<Int32>((i < _mfSlots.size()) 
                                   ? _mfSlots[i]
                                   :   State::AutoSlotReplace)
             << std::endl;
}


/*------------------------------------------------------------------------*/
/*                              cvs id's                                  */

#ifdef OSG_SGI_CC
#pragma set woff 1174
#endif

#ifdef OSG_LINUX_ICC
#pragma warning(disable : 177)
#endif

namespace
{
    static Char8 cvsid_cpp       [] = "@(#)$Id: FCTemplate_cpp.h,v 1.13 2002/06/01 10:37:25 vossg Exp $";
    static Char8 cvsid_hpp       [] = OSGCHUNKMATERIAL_HEADER_CVSID;
    static Char8 cvsid_inl       [] = OSGCHUNKMATERIAL_INLINE_CVSID;

    static Char8 cvsid_fields_hpp[] = OSGCHUNKMATERIALFIELDS_HEADER_CVSID;
}

#ifdef __sgi
#pragma reset woff 1174
#endif

---