OSGVRMLNodeDescs.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                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/

#define OSG_COMPILEVRMLNODEDESCINST

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

#include "OSGConfig.h"

#include <iostream>
#include <fstream>

#include "OSGVRMLNodeDescs.h"
#include <OSGLog.h>

#include <OSGNode.h>
#include <OSGNodeCore.h>
#include <OSGGroup.h>
#include <OSGComponentTransform.h>
#include <OSGGeometry.h>
#include <OSGMaterialGroup.h>
#include <OSGSimpleGeometry.h>
#include <OSGExtrusionGeometry.h>
#include <OSGTextureChunk.h>
#include <OSGTextureTransformChunk.h>
#include <OSGGeoFunctions.h>
#include <OSGDistanceLOD.h>
#include <OSGSwitch.h>
#include <OSGInline.h>
#include <OSGImage.h>
#include <OSGSceneFileHandler.h>
#include <OSGImageFileHandler.h>
#include <OSGZStream.h>

#include <OSGVRMLFile.h>

#ifndef OSG_LOG_MODULE
#define OSG_LOG_MODULE "VRMLLoader"
#endif

//#define OSG_DEBUG_VRML

#ifndef OSG_DO_DOC
#    ifdef OSG_DEBUG_VRML
#        define OSG_VRML_ARG(ARG) ARG
#    else
#        define OSG_VRML_ARG(ARG)
#    endif
#else
#    define OSG_VRML_ARG(ARG) ARG
#endif

OSG_USING_NAMESPACE



#ifdef WIN32
OSG_FC_ST_TYPE_FUNCTIONS_INL_TMPL_DEF(GenericAttDesc,
                                      DynFieldAttachment)
#endif

OSG_DYNFIELD_FC_DLLEXPORT_DEF(DynFieldAttachment,
                              GenericAttDesc,
                              OSG_SYSTEMLIB_DLLTMPLMAPPING);

#if defined(OSG_WIN32_ICL) && !defined(OSG_CHECK_FIELDSETARG)
#pragma warning (disable : 383)
#endif

//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

UInt32 VRMLNodeDesc::_uiIndent = 0;

/*-------------------------------------------------------------------------*/
/*                            Static Get                                   */

UInt32 VRMLNodeDesc::getIndent(void)
{
    return _uiIndent;
}

void VRMLNodeDesc::incIndent(void)
{
    _uiIndent += 4;
}

void VRMLNodeDesc::decIndent(void)
{
    if(_uiIndent < 4)
    {
        PWARNING << "Indent smaller 4 decremented" << std::endl;

        _uiIndent = 4;
    }

    _uiIndent -= 4;
}

void VRMLNodeDesc::resetIndent(void)
{
    _uiIndent = 0;
}

/*-------------------------------------------------------------------------*/
/*                            Constructors                                 */

VRMLNodeDesc::VRMLNodeDesc(void) :
    _mFieldTypes   (),

    _pGenAtt       (NullFC),

    _pNodeProto    (NullFC),
    _pNodeCoreProto(NullFC),

    _pCurrField    (NULL),

    _szCurrentName (),
    _bSaveOnEnd    (false)
{
}

/*-------------------------------------------------------------------------*/
/*                             Destructor                                  */

VRMLNodeDesc::~VRMLNodeDesc(void)
{
}

/*-------------------------------------------------------------------------*/
/*                              Helper                                     */

void VRMLNodeDesc::init(const Char8 *szName)
{
    if(szName == NULL)
    {
        _pNodeCoreProto = Group::create();
    }
    else if(stringcasecmp(szName, "Transform") == 0)
    {
        _pNodeCoreProto = ComponentTransform::create();
    }
    else
    {
        _pNodeCoreProto = Group::create();
    }

    _pNodeProto = Node::create();

    _pGenAtt    = GenericAtt::create();
    _pGenAtt->setInternal(true);
}


void VRMLNodeDesc::reset(void)
{
}

void VRMLNodeDesc::setOnEndSave(const Char8 *szName)
{
    _szCurrentName = szName; // does that make a copy? I expect it to...
    _bSaveOnEnd = true;
}

void VRMLNodeDesc::clearOnEndSave(void)
{
    _bSaveOnEnd = false;
}

bool VRMLNodeDesc::getOnEndSave(void)
{
    return _bSaveOnEnd;
}

const Char8 *VRMLNodeDesc::getSavename(void)
{
    return _szCurrentName.c_str();
}

FieldContainerPtr VRMLNodeDesc::getSaveFieldContainer(void)
{
    return NullFC;
}

/*-------------------------------------------------------------------------*/
/*                                Field                                    */

Field *VRMLNodeDesc::getField(const Char8 *szFieldname)
{
    return getField(_pNodeProto, _pNodeCoreProto, _pGenAtt, szFieldname);
}

void VRMLNodeDesc::getFieldAndDesc(
    FieldContainerPtr        pFC,
    const Char8            * szFieldname,
    Field                  *&pField,
    const FieldDescription *&pDesc)
{
    FieldContainerPtr pTmpFC    = NullFC;
    NodePtr           pNode     = NullFC;
    NodeCorePtr       pNodeCore = NullFC;

    pField = NULL;
    pDesc  = NULL;

    if(pFC == NullFC)
        return;

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "VRMLNodeDesc::getFieldAndDesc : looking for "
          << szFieldname
          << std::endl;

    incIndent();
#endif

    pField = pFC->getField(szFieldname);

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "Got this from fieldcontainer : " << pField << std::endl;
#endif

    if(pField != NULL)
    {
        pDesc = pFC->getType().findFieldDescription(szFieldname);

#ifdef OSG_DEBUG_VRML
        decIndent();
#endif

        return;
    }

    if(pFC->getType().isNode() == true)
    {
        pNode     = NodePtr::dcast(pFC);

        pNodeCore = pNode->getCore();

        if(pNodeCore != NullFC)
        {
            pField    = pNodeCore->getField(szFieldname);

#ifdef OSG_DEBUG_VRML
            indentLog(getIndent(), PINFO);
            PINFO << "Got this from nodecore : " << pField << std::endl;
#endif
        }

        if(pField != NULL)
        {
            pDesc = pNodeCore->getType().findFieldDescription(szFieldname);
        }
        else
        {
            pTmpFC = pNode->findAttachment(
                GenericAtt::getClassType().getGroupId());

            if(pTmpFC != NullFC)
            {
                pField = pTmpFC->getField(szFieldname);
            }

#ifdef OSG_DEBUG_VRML
            indentLog(getIndent(), PINFO);
            PINFO << "Got this from node attachment : " << pField << std::endl;
#endif
            if(pField == NULL)
            {
                pTmpFC =
                    pNodeCore->findAttachment(
                        GenericAtt::getClassType().getGroupId());

                if(pTmpFC != NullFC)
                {
                    pField = pTmpFC->getField(szFieldname);
                }

#ifdef OSG_DEBUG_VRML
                indentLog(getIndent(), PINFO);
                PINFO << "Got this from nodecore attachment : "
                      << pField << std::endl;
#endif
            }

            if(pField != NULL)
            {
                pDesc = pTmpFC->getType().findFieldDescription(szFieldname);
            }
        }
    }
    else if(pFC->getType().isNodeCore() == true)
    {
        pNodeCore = NodeCorePtr::dcast(pFC);

        pTmpFC = pNodeCore->findAttachment(
            GenericAtt::getClassType().getGroupId());

        if(pTmpFC != NullFC)
        {
            pField = pTmpFC->getField(szFieldname);
        }

        if(pField != NULL)
        {
            pDesc = pTmpFC->getType().findFieldDescription(szFieldname);
        }

#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "Got this from nodecore attachment : "
              << pField << std::endl;
#endif
    }

#ifdef OSG_DEBUG_VRML
    decIndent();
#endif
}

/*-------------------------------------------------------------------------*/
/*                              Prototypes                                 */

bool VRMLNodeDesc::prototypeAddField(const Char8  *OSG_VRML_ARG(szFieldType),
                                     const UInt32  uiFieldTypeId,
                                     const Char8  *szFieldName)
{
    FieldDescription *pDesc = NULL;
    FieldType        *pType = NULL;

    Field *pField = getField(_pNodeProto,
                             _pNodeCoreProto,
                             _pGenAtt,
                              szFieldName);


#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "VRMLNodeDesc::prototypeAddField | getField "
          << szFieldName
          << "  returned : "
          << pField
          << std::endl;
#endif

    if(pField == NULL)
    {
        pType = FieldFactory::the().getFieldType(uiFieldTypeId);

        if(pType == NULL)
        {
            PWARNING << "VRMLNodeDesc::prototypeAddField "
                     << "Could not get fieldtype "
                     << uiFieldTypeId << " "
                     << szFieldName << " "
                     << std::endl;

            return false;
        }

#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "VRMLNodeDesc::prototypeAddField | got fieldtype : "
              << uiFieldTypeId
              << " "
              << pType->getName()
              << " "
              << pType->getId()
              << std::endl;
#endif

        pDesc = new FieldDescription(*pType,
                                     szFieldName,
                                     0, 0,
                                     false,
                                     (FieldIndexAccessMethod)
                                     &GenericAtt::getDynamicField);

        _pGenAtt->addField(*pDesc);

        _pCurrField = getField(_pNodeProto,
                               _pNodeCoreProto,
                               _pGenAtt,
                                szFieldName);

        delete pDesc;

#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "VRMLNodeDesc::prototypeAddField | field added : "
              << szFieldType
              << " "
              << uiFieldTypeId
              << " "
              << szFieldName
              << " "
              << _pCurrField
              << std::endl;
#endif

        if(_pCurrField != NULL)
            return true;
        else
            return false;
    }
    else
    {
        if((_pGenAtt != NullFC                     ) &&
           (_pGenAtt->getField(szFieldName) != NULL))
        {
            PWARNING << "VRMLNodeDesc::prototypeAddField | "
                     << "Could not add field "
                     << szFieldName
                     << " a second time"
                     << std::endl;
        }

        return false;
    }
}

void VRMLNodeDesc::prototypeAddFieldValue(const Char8 *szFieldVal)
{
    if(_pCurrField       != NULL)
    {
        _pCurrField->pushValueByStr(szFieldVal);
    }
}

void VRMLNodeDesc::endProtoInterface(void)
{
}

/*-------------------------------------------------------------------------*/
/*                                Node                                     */

FieldContainerPtr VRMLNodeDesc::beginNode(const Char8      *,
                                          const Char8      *,
                                          FieldContainerPtr)
{
    FieldContainerPtr returnValue = NullFC;
    NodePtr           pNode       = NullFC;
    NodeCorePtr       pCore       = NullFC;
    GenericAttPtr     pAtt        = NullFC;

    if(_pNodeProto != NullFC)
    {
        returnValue = _pNodeProto->shallowCopy();

        if(_pNodeCoreProto != NullFC)
        {
            FieldContainerPtr pCoreClone = _pNodeCoreProto->shallowCopy();

            pNode = NodePtr    ::dcast(returnValue);
            pCore = NodeCorePtr::dcast(pCoreClone );

            beginEditCP(pNode, Node::CoreFieldMask);
            {
                pNode->setCore(pCore);
            }
            endEditCP  (pNode, Node::CoreFieldMask);
        }

        if(_pGenAtt != NullFC)
        {
            FieldContainerPtr pAttClone = _pGenAtt->emptyCopy();

            pAtt = GenericAttPtr::dcast(pAttClone);

            if(pAtt != NullFC)
            {
                pAtt->setInternal(true);
            }

            if(pCore != NullFC)
            {
                pCore->addAttachment(pAtt);
            }
            else
            {
                pNode->addAttachment(pAtt);
            }
        }
    }

    return returnValue;
}

void VRMLNodeDesc::endNode(FieldContainerPtr)
{
}

/*-------------------------------------------------------------------------*/
/*                             Field Value                                 */

void VRMLNodeDesc::addFieldValue(      Field *pField,
                                    const Char8   *szFieldVal)
{
    if(pField != NULL)
    {
        pField->pushValueByStr(szFieldVal);
    }
}

bool VRMLNodeDesc::use(FieldContainerPtr)
{
    return false;
}


/*-------------------------------------------------------------------------*/
/*                                Dump                                     */

void VRMLNodeDesc::dump(const Char8 *szNodeName)
{
    fprintf(stderr, "\tDefault %s\n", szNodeName);

    fprintf(stderr, "\t\tGenAtt        %p\n", &(*_pGenAtt));
    fprintf(stderr, "\t\tNodeProto     %p\n", &(*_pNodeProto));
    fprintf(stderr, "\t\tNodeCoreProto %p\n", &(*_pNodeCoreProto));

    std::string stringVal;

    if(_pGenAtt != NullFC)
    {
        fprintf(stderr, "\t\t%u Desc\n",
                _pGenAtt->getType().getNumFieldDescs());

        for(UInt32 i = 2; i <= _pGenAtt->getType().getNumFieldDescs(); i++)
        {
            FieldDescription *pFieldDesc =
                _pGenAtt->getType().getFieldDescription(i);
            Field            *pField     =
                _pGenAtt->getDynamicField(i);

            stringVal.erase(stringVal.begin(),
                            stringVal.end());

            pField->getValueByStr(stringVal);

            fprintf(stderr, "\t\t%s %s %s\n",
                    pFieldDesc->getCName(),
                    pFieldDesc->getFieldType().getCName(),
                    stringVal.c_str());
        }
    }
}

/*-------------------------------------------------------------------------*/
/*                                Get                                      */

Field *VRMLNodeDesc::getField(      FieldContainerPtr  pFC1,
                                    FieldContainerPtr  pFC2,
                                    GenericAttPtr      pGenAtt,
                              const Char8             *szFieldname)
{
    Field *returnValue = NULL;

    if(szFieldname == NULL)
    {
        return returnValue;
    }

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "VRMLNodeDesc::getField " << std::endl;

    incIndent();

    indentLog(getIndent(), PINFO);
    PINFO << "Trying to find field : " << szFieldname << std::endl;
#endif

    if(pFC1 != NullFC)
    {
        returnValue = pFC1->getField(szFieldname);
    }

#ifdef OSG_DEBUG_VRML
    incIndent();

    indentLog(getIndent(), PINFO);
    PINFO << "Got this from node : " << returnValue << std::endl;
#endif

    if(returnValue != NULL)
        return returnValue;

    if(pFC2 != NullFC)
    {
        returnValue = pFC2->getField(szFieldname);

#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "Got this from nodecore : " << returnValue << std::endl;
#endif
    }
    else
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "No core to check" << std::endl;
#endif
    }


    if(returnValue != NULL)
        return returnValue;

    if(pGenAtt != NullFC)
    {
        returnValue = pGenAtt->getField(szFieldname);
    }

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "Got this from attachment : " << returnValue << std::endl;

    decIndent();
    decIndent();
#endif

    return returnValue;
}




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

/*-------------------------------------------------------------------------*/
/*                            Constructors                                 */

VRMLShapeDesc::VRMLShapeDesc(void) :
    Inherited     (),

    _pMaterialDesc(NULL)
{
}

/*-------------------------------------------------------------------------*/
/*                             Destructor                                  */

VRMLShapeDesc::~VRMLShapeDesc(void)
{
}

/*-------------------------------------------------------------------------*/
/*                               Helper                                    */

void VRMLShapeDesc::init(const Char8 *OSG_VRML_ARG(szName))
{
#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "ShapeDesc::init : " << szName << std::endl;
#endif

    _pNodeProto     = Node::create();
    _pNodeCoreProto = MaterialGroup::create();

    _pGenAtt        = GenericAtt::create();
    _pGenAtt->setInternal(true);
}

void VRMLShapeDesc::setMaterialDesc(VRMLMaterialDesc *pMaterialDesc)
{
    _pMaterialDesc = pMaterialDesc;
}

/*-------------------------------------------------------------------------*/
/*                                Get                                      */

bool VRMLShapeDesc::prototypeAddField(const Char8  *szFieldType,
                                      const UInt32  uiFieldTypeId,
                                      const Char8  *szFieldname)
{
    bool returnValue = false;

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "VRMLShapeDesc::prototypeAddField | add request : "
          << szFieldname
          << std::endl;
#endif

    _pCurrField = NULL;

    if(szFieldname == NULL)
        return false;

    incIndent();

    if(stringcasecmp("geometry", szFieldname) == 0)
    {
        _pCurrField = _pNodeProto->getField("children");
        returnValue = true;

#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "VRMLShapeDesc::prototypeAddField | request internal : "
              << szFieldname
              << " "
              << _pCurrField
              << std::endl;
#endif
    }

    if(stringcasecmp("appearance", szFieldname) == 0)
    {
        _pCurrField = _pNodeCoreProto->getField("material");
        returnValue = true;

#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);

        PINFO << "VRMLShapeDesc::prototypeAddField | request internal : "
              << szFieldname
              << " "
              << _pCurrField
              << std::endl;
#endif
    }

    if(_pCurrField == NULL)
    {
        returnValue =  Inherited::prototypeAddField(szFieldType,
                                                    uiFieldTypeId,
                                                    szFieldname);
    }

#ifdef OSG_DEBUG_VRML
    decIndent();
#endif

    return returnValue;
}

void VRMLShapeDesc::getFieldAndDesc(
          FieldContainerPtr   pFC,
    const Char8             * szFieldname,
          Field             *&pField,
    const FieldDescription  *&pDesc)
{
    if(szFieldname == NULL)
        return;

    if(pFC == NullFC)
        return;

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "VRMLShapeDesc::getFieldAndDesc : looking for "
          << szFieldname
          << std::endl;

    incIndent();
#endif

    if(stringcasecmp("geometry", szFieldname) == 0)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "VRMLShapeDesc::getFieldAndDesc : request internal "
              << szFieldname
              << std::endl;
#endif

        pField = pFC->getField("children");

        if(pField != NULL)
            pDesc = pFC->getType().findFieldDescription("children");
    }
    else if(stringcasecmp("appearance", szFieldname) == 0)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "VRMLShapeDesc::getFieldAndDesc : request internal "
              << szFieldname
              << std::endl;
#endif

        NodePtr pNode = NodePtr::dcast(pFC);

        if(pNode != NullFC)
        {
            if(pNode->getCore() != NullFC)
            {
                pField = pNode->getCore()->getField("material");

                if(pField != NULL)
                {
                    pDesc =
                        pNode->getCore()->getType().findFieldDescription(
                            "material");
                }
            }
        }
        else
        {
            VRMLNodeDesc::getFieldAndDesc(pFC,
                                          szFieldname,
                                          pField,
                                          pDesc);
        }
    }
    else
    {
        VRMLNodeDesc::getFieldAndDesc(pFC,
                                      szFieldname,
                                      pField,
                                      pDesc);
    }

#ifdef OSG_DEBUG_VRML
    decIndent();
#endif
}

/*-------------------------------------------------------------------------*/
/*                                Node                                     */

FieldContainerPtr VRMLShapeDesc::beginNode(const Char8            *,
                                           const Char8            *,
                                                 FieldContainerPtr)
{
    NodePtr           pNode     = NullFC;
    NodeCorePtr       pNodeCore = NullFC;

    if(_pNodeProto != NullFC)
    {
        pNode = NodePtr::dcast(_pNodeProto->shallowCopy());

        if(_pNodeCoreProto != NullFC)
        {
            pNodeCore = NodeCorePtr::dcast(_pNodeCoreProto->shallowCopy());

            beginEditCP(pNode, Node::CoreFieldMask);
            {
                pNode->setCore(pNodeCore);
            }
            endEditCP  (pNode, Node::CoreFieldMask);
        }
    }

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "Begin Shape " << &(*pNode) << std::endl;

    incIndent();
#endif

    return pNode;
}

void VRMLShapeDesc::endNode(FieldContainerPtr pFC)
{
    if(pFC != NullFC)
    {
        NodePtr pNode = NodePtr::dcast(pFC);

        if(pNode != NullFC && pNode->getCore() == NullFC)
        {
            PWARNING << "warning empty material, using default\n" << std::endl;

            MaterialGroupPtr pMatGroup = MaterialGroup::create();

            beginEditCP(pMatGroup);
            {
                pMatGroup->setMaterial(_pMaterialDesc->getDefaultMaterial());
            }
            endEditCP(pMatGroup);

            beginEditCP(pNode, Node::CoreFieldMask);
            {
                pNode->setCore(pMatGroup);
            }
            endEditCP  (pNode, Node::CoreFieldMask);
        }
        else
        {
            MaterialGroupPtr pMatGroup;

            pMatGroup = MaterialGroupPtr::dcast(pNode->getCore());

            if(pMatGroup != NullFC)
            {
                if(pMatGroup->getMaterial() == NullFC)
                {
                    pMatGroup->setMaterial(
                        _pMaterialDesc->getDefaultMaterial());
                }
            }
        }
    }

#ifdef OSG_DEBUG_VRML
    decIndent();

    indentLog(getIndent(), PINFO);
    PINFO << "End Shape " << &(*pFC) << std::endl;
#endif
}

/*-------------------------------------------------------------------------*/
/*                                Dump                                     */

void VRMLShapeDesc::dump(const Char8 *)
{
}




//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

/*-------------------------------------------------------------------------*/
/*                            Constructors                                 */

VRMLGeometryDesc::VRMLGeometryDesc(bool bIsFaceSet) :
    Inherited     (),

    _bIsFaceSet   (bIsFaceSet),

    _bInIndex     (false),
    _uiNumVertices(0),

    _pTypeField   (NullFC    ),
    _pLengthField (NullFC    )
{
}

/*-------------------------------------------------------------------------*/
/*                             Destructor                                  */

VRMLGeometryDesc::~VRMLGeometryDesc(void)
{
}

/*-------------------------------------------------------------------------*/
/*                               Helper                                    */

void VRMLGeometryDesc::init(const Char8 *OSG_VRML_ARG(szName))
{
#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "GeoDesc::init : " << szName << std::endl;
#endif

    _pNodeProto     = Node::create();
    _pNodeCoreProto = Geometry::create();

    _pGenAtt = GenericAtt::create();
    _pGenAtt->setInternal(true);
}

/*-------------------------------------------------------------------------*/
/*                                Get                                      */

bool VRMLGeometryDesc::prototypeAddField(const Char8  *szFieldType,
                                         const UInt32  uiFieldTypeId,
                                         const Char8  *szFieldname)
{
    bool bFound = false;

    _pCurrField = NULL;

    if(szFieldname == NULL)
        return false;

    if(stringcasecmp("coord", szFieldname) == 0)
    {
        bFound = true;
    }
    else if(stringcasecmp("normal", szFieldname) == 0)
    {
        bFound = true;
    }
    else if(stringcasecmp("color", szFieldname) == 0)
    {
        bFound = true;
    }
    else if(stringcasecmp("texCoord", szFieldname) == 0)
    {
        bFound = true;
    }

    if(bFound == true)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "GeoDesc::prototypeAddField : internal "
              << szFieldname << std::endl;
#endif

        return true;
    }
    else
    {
        return Inherited::prototypeAddField(szFieldType,
                                            uiFieldTypeId,
                                            szFieldname);
    }
}


void VRMLGeometryDesc::getFieldAndDesc(
          FieldContainerPtr   pFC,
    const Char8             * szFieldname,
          Field             *&pField,
    const FieldDescription  *&pDesc)
{
#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "GeoDesc::getFieldAndDesc : request "
          << szFieldname
          << std::endl;
#endif

    if(szFieldname == NULL)
        return;

    if(pFC == NullFC)
        return;

    NodePtr pNode = NodePtr::dcast(pFC);

    if(pNode == NullFC)
    {
        PWARNING << "GeoDesc::getFieldAndDesc : No Node" << std::endl;
        return;
    }

    NodeCorePtr pNodeCore = pNode->getCore();

    GeometryPtr pGeo      = GeometryPtr::dcast(pNodeCore);

    if(pGeo == NullFC)
    {
        PWARNING << "GeoDesc::getFieldAndDesc : No Geo" << std::endl;
        return;
    }

    _bInIndex = false;

    if(stringcasecmp("coord", szFieldname) == 0)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "GeoDesc::getFieldAndDesc : internal "
              << szFieldname << std::endl;
#endif
        pField = pGeo->getField("positions");

        if(pField != NULL)
            pDesc = pGeo->getType().findFieldDescription("positions");
    }
    else if(stringcasecmp("normal", szFieldname) == 0)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "GeoDesc::getFieldAndDesc : internal "
              << szFieldname << std::endl;
#endif

        pField = pGeo->getField("normals");

        if(pField != NULL)
            pDesc = pGeo->getType().findFieldDescription("normals");
    }
    else if(stringcasecmp("color", szFieldname) == 0)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "GeoDesc::getFieldAndDesc : internal "
              << szFieldname << std::endl;
#endif

        pField = pGeo->getField("colors");

        if(pField != NULL)
            pDesc = pGeo->getType().findFieldDescription("colors");
    }
    else if(stringcasecmp("texCoord", szFieldname) == 0)
    {
#ifdef OSG_DEBUG_VRML
        indentLog(getIndent(), PINFO);
        PINFO << "GeoDesc::getFieldAndDesc : internal "
              << szFieldname << std::endl;
#endif

        pField = pGeo->getField("texCoords");

        if(pField != NULL)
            pDesc = pGeo->getType().findFieldDescription("texCoords");
    }
    else
    {
        VRMLNodeDesc::getFieldAndDesc(pGeo,
                                      szFieldname,
                                      pField,
                                      pDesc);
    }
}

/*-------------------------------------------------------------------------*/
/*                                Node                                     */

FieldContainerPtr VRMLGeometryDesc::beginNode(
    const Char8       *,
    const Char8       *,
    FieldContainerPtr)
{
    FieldContainerPtr pFC         = NullFC;
    NodePtr           pNode       = NullFC;
    NodeCorePtr       pNodeCore   = NullFC;
    GenericAttPtr     pAtt        = NullFC;

    if(_pNodeProto != NullFC)
    {
        FieldContainerPtr pAttClone = _pGenAtt->clone();

        pAtt = GenericAttPtr::dcast(pAttClone);

        if(pAtt != NullFC)
        {
            pAtt->setInternal(true);
        }

        pFC = _pNodeProto->shallowCopy();

        pNode = NodePtr::dcast(pFC);

        pFC = _pNodeCoreProto->shallowCopy();

        pNodeCore = NodeCorePtr::dcast(pFC);

        beginEditCP(pNode);
        {
            pNode    ->setCore      (pNodeCore);
            pNodeCore->addAttachment(pAtt);
        }
        endEditCP  (pNode);
    }

#ifdef OSG_DEBUG_VRML
    indentLog(getIndent(), PINFO);
    PINFO << "Begin Geo " << &(*pNode) << std::endl;

    incIndent();
#endif

    return pNode;
}

void VRMLGeometryDesc::endNode(FieldContainerPtr pFC)
{
    NodePtr     pNode = NullFC;
    GeometryPtr pGeo  = NullFC;

    if(pFC == NullFC)
    {
        return;
    }

    pNode = NodePtr::dcast(pFC);

    if(pNode == NullFC)
    {
        return;
    }

    pGeo = GeometryPtr::dcast(pNode->getCore());

    if(pGeo == NullFC)
    {
        return;
    }

          Field            *pField = NULL;
    const FieldDescription *pDesc  = NULL;

    MFInt32  *pCoordIndex           = NULL;
    MFInt32  *pNormalIndex          = NULL;
    MFInt32  *pColorIndex           = NULL;
    MFInt32  *pTexCoordIndex        = NULL;
    SFBool   *pConvex               = NULL;
    SFBool   *pCcw                  = NULL;
    SFBool   *pNormalPerVertex      = NULL;
    SFBool   *pColorPerVertex       = NULL;
    SFReal32 *pCreaseAngle          = NULL;

    Inherited::getFieldAndDesc(pFC,
                               "coordIndex",
                               pField,
                               pDesc);

    if(pField != NULL)
    {
        pCoordIndex = static_cast<MFInt32 *>(pField);
    }

    Inherited::getFieldAndDesc(pFC,
                               "normalIndex",
                               pField,
                               pDesc);