glc_world.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 http://glc-lib.sourceforge.net

 GLC-lib 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 3 of the License, or
 (at your option) any later version.

 GLC-lib 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 GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************/


#ifndef GLC_WORLD_H_
#define GLC_WORLD_H_

#include "glc_3dviewcollection.h"
#include "glc_structoccurence.h"
#include "glc_structreference.h"
#include "glc_structinstance.h"
#include "glc_worldhandle.h"

#include "../glc_config.h"



class GLC_LIB_EXPORT GLC_World
{


public:
        GLC_World();

        GLC_World(const GLC_World&);

        virtual ~GLC_World();



public:
        inline GLC_BoundingBox boundingBox()
        { return m_pWorldHandle->collection()->boundingBox();}

        inline GLC_StructOccurence* rootOccurence() const
        {return m_pRoot;}

        inline GLC_3DViewCollection* collection()
        {return m_pWorldHandle->collection();}

        inline int size() const
        {return m_pWorldHandle->collection()->size();}

        inline bool isEmpty() const
        {return  m_pWorldHandle->collection()->isEmpty() && !m_pRoot->hasChild();}

        inline int numberOfFaces() const
        {return m_pRoot->numberOfFaces();}

        inline int numberOfVertex() const
        {return m_pRoot->numberOfVertex();}

        inline int numberOfMaterials() const
        {return m_pRoot->numberOfMaterials();}

        inline QList<GLC_Material*> listOfMaterials() const
        {return m_pRoot->materialSet().toList();}

        inline QList<GLC_3DViewInstance*> instancesHandle() const
        {return m_pWorldHandle->collection()->instancesHandle();}

        inline QList<GLC_3DViewInstance*> visibleInstancesHandle() const
        {return m_pWorldHandle->collection()->visibleInstancesHandle();}

        inline QList<QString> instanceNamesFromShadingGroup(GLuint id) const
        {return m_pWorldHandle->collection()->instanceNamesFromShadingGroup(id);}

        inline int numberOfUsedShadingGroup() const
        {return m_pWorldHandle->collection()->numberOfUsedShadingGroup();}

        inline GLC_WorldHandle* worldHandle()
        {return m_pWorldHandle;}


        inline GLC_StructOccurence* occurence(GLC_uint id) const
        {return m_pWorldHandle->getOccurence(id);}

        inline QList<GLC_StructOccurence*> listOfOccurence() const
        {return m_pWorldHandle->occurences();}

        inline int numberOfOccurence() const
        {return m_pWorldHandle->numberOfOccurence();}

        inline int containsOccurence(GLC_uint id) const
        {return m_pWorldHandle->containsOccurence(id);}

        inline QList<GLC_StructInstance*> instances() const
        {return m_pWorldHandle->instances();}

        inline QList<GLC_StructReference*> references() const
        {return m_pWorldHandle->references();}

        inline int numberOfBody() const
        {return m_pWorldHandle->numberOfBody();}

        inline int representationCount() const
        {return m_pWorldHandle->representationCount();}

        inline GLC_Vector3d upVector() const
        {return m_pWorldHandle->upVector();}

        int selectionSize() const
        {return m_pWorldHandle->selectionSetHandle()->size();}

        inline bool isSelected(const GLC_StructOccurence* pOccurence) const
        {return m_pWorldHandle->selectionSetHandle()->contains(pOccurence);}

        inline bool isSelected(GLC_uint selectionId) const
        {return m_pWorldHandle->selectionSetHandle()->contains(selectionId);}

        inline QList<GLC_StructOccurence*> selectedOccurenceList() const
        {return m_pWorldHandle->selectionSetHandle()->occurencesList();}

        inline QList<GLC_StructOccurence*> selectedPrimitiveOccurenceList() const
        {return m_pWorldHandle->selectionSetHandle()->occurencesListWithSelectedPrimitive();}




public:
        void mergeWithAnotherWorld(GLC_World &);

        inline void reversePartNormal() {m_pRoot->reverseNormals();}

        GLC_World& clear() {return *this= GLC_World();}

        inline void setRootName(const QString& name)
        {m_pRoot->setName(name);}

        inline void setUpVector(const GLC_Vector3d& vect)
        {m_pWorldHandle->setUpVector(vect);}

        inline void setAttachedViewport(GLC_Viewport* pViewport)
        {m_pWorldHandle->setAttachedViewport(pViewport);}


        inline void select(const GLC_StructOccurence* pOccurence)
        {m_pWorldHandle->select(pOccurence->id());}


        inline void select(GLC_uint occurenceId)
        {m_pWorldHandle->select(occurenceId);}


        inline void unselect(GLC_uint occurenceId)
        {m_pWorldHandle->unselect(occurenceId);}

        inline void selectAllWith3DViewInstance()
        {m_pWorldHandle->selectAllWith3DViewInstance(true);}

        inline void selectAllWith3DViewInstanceInCurrentShowState()
        {m_pWorldHandle->selectAllWith3DViewInstance(false);}

        inline void unselectAll()
        {m_pWorldHandle->unselectAll();}

        inline void showHideSelected3DViewInstance()
        {m_pWorldHandle->showHideSelected3DViewInstance();}

        inline void showSelected3DViewInstance()
        {m_pWorldHandle->setSelected3DViewInstanceVisibility(true);}

        inline void hideSelected3DViewInstance()
        {m_pWorldHandle->setSelected3DViewInstanceVisibility(false);}





public:
        GLC_World& operator=(const GLC_World&);



public:
        inline void render(GLuint groupId, glc::RenderFlag renderFlag= glc::ShadingFlag)
        {m_pWorldHandle->collection()->render(groupId, renderFlag);}

        inline void renderShaderGroup(glc::RenderFlag renderFlag= glc::ShadingFlag)
        {m_pWorldHandle->collection()->renderShaderGroup(renderFlag);}


// private members
private:
        GLC_WorldHandle* m_pWorldHandle;

        GLC_StructOccurence* m_pRoot;
};

#endif /*GLC_WORLD_H_*/