glc_structoccurence.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_STRUCTOCCURENCE_H_
#define GLC_STRUCTOCCURENCE_H_

#include "../maths/glc_matrix4x4.h"
#include "../glc_boundingbox.h"
#include "glc_structinstance.h"
#include <QSet>

#include "../glc_config.h"

class GLC_WorldHandle;
class GLC_Material;
class GLC_RenderProperties;



class GLC_LIB_EXPORT GLC_StructOccurence
{



public:
        GLC_StructOccurence();

        GLC_StructOccurence(GLC_StructInstance*, GLC_WorldHandle* pWorldHandle= NULL, GLuint shaderId=0);

        GLC_StructOccurence(GLC_3DRep*);

        GLC_StructOccurence(GLC_WorldHandle*, const GLC_StructOccurence&, bool shareInstance);

        virtual ~GLC_StructOccurence();



public:
        inline GLC_uint id() const
        {return m_Uid;}

        inline const QString name() const
        {return m_pStructInstance->name();}

        inline GLC_Matrix4x4 absoluteMatrix() const
        { return m_AbsoluteMatrix;}

        inline bool isOrphan() const
        { return NULL == m_pParent;}

        inline bool hasParent() const
        { return NULL != m_pParent;}

        bool hasRepresentation() const;

        bool has3DViewInstance() const;

        inline GLC_StructInstance* structInstance() const
        { return m_pStructInstance;}

        inline GLC_StructReference* structReference() const
        {
                Q_ASSERT(NULL != m_pStructInstance);
                return m_pStructInstance->structReference();
        }

        inline int childCount() const
        { return m_Childs.size();}

        inline bool hasChild() const
        {return childCount() > 0;}

        bool canBeAddedToChildren(GLC_StructOccurence* pOccurence) const;

        inline GLC_StructOccurence* parent() const
        {return m_pParent;}


        inline GLC_StructOccurence* child(const int index) const
        {return m_Childs.at(index);}

        inline QList<GLC_StructOccurence*> children() const
        {return m_Childs;}

        QList<GLC_StructOccurence*> subOccurenceList() const;

        unsigned int numberOfFaces() const;

        unsigned int numberOfVertex() const;

        unsigned int numberOfMaterials() const;

        QSet<GLC_Material*> materialSet() const;

        GLC_StructOccurence* clone(GLC_WorldHandle*, bool shareInstance) const;

        bool isVisible() const;

        GLC_BoundingBox boundingBox() const;

        inline unsigned int occurenceNumber() const
        {return m_OccurenceNumber;}

        GLC_RenderProperties* renderPropertiesHandle() const
        {return m_pRenderProperties;}

        unsigned int nodeCount() const;

        inline GLC_WorldHandle* worldHandle() const
        {return m_pWorldHandle;}

        QSet<GLC_StructReference*> childrenReferences() const;

        static QSet<GLC_StructReference*> parentsReferences(const GLC_StructOccurence* pOccurence);

        inline bool useAutomatic3DViewInstanceCreation() const
        {return m_AutomaticCreationOf3DViewInstance;}





public:

        inline void setName(const QString name) {m_pStructInstance->setName(name);}

        GLC_StructOccurence* updateAbsoluteMatrix();

        GLC_StructOccurence* updateChildrenAbsoluteMatrix();


        void addChild(GLC_StructOccurence*);

        GLC_StructOccurence* addChild(GLC_StructInstance*);

        void makeOrphan();


        bool removeChild(GLC_StructOccurence* pChild);

        void reverseNormals();

        bool create3DViewInstance();

        bool remove3DViewInstance();

        void setWorldHandle(GLC_WorldHandle*);

        bool loadRepresentation();

        bool unloadRepresentation();

        inline void setOccurenceNumber(unsigned int n)
        {m_OccurenceNumber= n;}

        unsigned int updateOccurenceNumber(unsigned int n);

        void setVisibility(bool visibility);

        void setRenderProperties(const GLC_RenderProperties& renderProperties);

        void removeEmptyChildren();

        void setReference(GLC_StructReference* pRef);

        inline void setAutomatic3DViewInstanceCreationUsage(bool usage)
        {m_AutomaticCreationOf3DViewInstance= usage;}



// Private services function
private:
        void detach();

// Private members
private:
        GLC_uint m_Uid;

        GLC_WorldHandle* m_pWorldHandle;

        int* m_pNumberOfOccurence;

        GLC_StructInstance* m_pStructInstance;

        GLC_StructOccurence* m_pParent;

        QList<GLC_StructOccurence*> m_Childs;

        GLC_Matrix4x4 m_AbsoluteMatrix;

        unsigned int m_OccurenceNumber;

        bool m_IsVisible;

        GLC_RenderProperties* m_pRenderProperties;

        bool m_AutomaticCreationOf3DViewInstance;

};

#endif /* GLC_STRUCTOCCURENCE_H_ */