glc_3dviewcollection.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_3DVIEWCOLLECTION_H_
#define GLC_3DVIEWCOLLECTION_H_


#include <QHash>
#include "glc_3dviewinstance.h"
#include "../glc_global.h"
#include "../viewport/glc_frustum.h"

#include "../glc_config.h"

class GLC_SpacePartitioning;
class GLC_Material;
class GLC_Shader;
class GLC_Viewport;

typedef QHash< GLC_uint, GLC_3DViewInstance> ViewInstancesHash;

typedef QHash<GLC_uint, GLC_3DViewInstance*> PointerViewInstanceHash;

typedef QHash<GLuint, PointerViewInstanceHash*> HashList;

typedef QHash<GLC_uint, GLuint> ShaderIdToInstancesId;




class GLC_LIB_EXPORT GLC_3DViewCollection
{



public:
        GLC_3DViewCollection();


        virtual ~GLC_3DViewCollection();




public:

        inline bool isEmpty() const
        {return m_3DViewInstanceHash.size() == 0;}

        inline int size(void) const
        {return m_3DViewInstanceHash.size();}

        QList<GLC_3DViewInstance*> instancesHandle();

        QList<GLC_3DViewInstance*> visibleInstancesHandle();

        QList<GLC_3DViewInstance*> viewableInstancesHandle();


        GLC_3DViewInstance* instanceHandle(GLC_uint Key);


        GLC_BoundingBox boundingBox(bool allObject= false);

        inline int selectionSize(void) const
        {return m_SelectedInstances.size();}

        inline PointerViewInstanceHash* selection()
        {return &m_SelectedInstances;}

        inline bool contains(GLC_uint key) const
        {return m_3DViewInstanceHash.contains(key);}

        inline bool isSelected(GLC_uint key) const
        {return m_SelectedInstances.contains(key);}

        inline bool showState() const
        {return m_IsInShowSate;}

        int drawableObjectsSize() const;

        inline GLuint shadingGroup(GLC_uint key) const
        { return m_ShaderGroup.value(key);}

        inline bool isInAShadingGroup(GLC_uint key) const
        { return m_ShaderGroup.contains(key);}

        QList<QString> instanceNamesFromShadingGroup(GLuint) const;

        int numberOfUsedShadingGroup() const;

        inline bool spacePartitioningIsUsed() const
        {return m_UseSpacePartitioning;}

        inline GLC_SpacePartitioning* spacePartitioningHandle()
        {return m_pSpacePartitioning;}





public:

         /* return true if success false if shader is already bind*/
        bool bindShader(GLuint);

        /* return true if success false otherwise*/
        bool unBindShader(GLuint);

        bool unBindAllShader();


        bool add(const GLC_3DViewInstance& ,GLuint shaderID=0);

        /* Move the specified instances into
         * the specified shading group
         * Return true if success false otherwise*/
        void changeShadingGroup(GLC_uint, GLuint);


        bool remove(GLC_uint Key);

        void clear(void);

        bool select(GLC_uint, bool primitive= false);

        void selectAll(bool allShowState= false);

        bool unselect(GLC_uint);

        void unselectAll();

        void setPolygonModeForAll(GLenum, GLenum);

        void setVisibility(const GLC_uint, const bool);

        void showAll();

        void hideAll();

        inline void swapShowState()
        {m_IsInShowSate= !m_IsInShowSate;}

        inline void setLodUsage(const bool usage, GLC_Viewport* pView)
        {
                m_UseLod= usage;
                m_pViewport= pView;
        }

        void bindSpacePartitioning(GLC_SpacePartitioning*);

        void unbindSpacePartitioning();

        inline void setSpacePartitionningUsage(bool use)
        {m_UseSpacePartitioning= use;}


        void updateInstanceViewableState(GLC_Matrix4x4* pMatrix= NULL);

        void updateInstanceViewableState(const GLC_Frustum&);

        inline void setAttachedViewport(GLC_Viewport* pViewport)
        {m_pViewport= pViewport;}



public:

        void render(GLuint, glc::RenderFlag);

        void renderShaderGroup(glc::RenderFlag);





private:
        void glDraw(GLuint, glc::RenderFlag);

        inline void glDrawInstancesOf(PointerViewInstanceHash*, glc::RenderFlag);


// Private members
private:
        ViewInstancesHash m_3DViewInstanceHash;

        PointerViewInstanceHash m_SelectedInstances;

        HashList m_ShadedPointerViewInstanceHash;

        ShaderIdToInstancesId m_ShaderGroup;

        PointerViewInstanceHash m_MainInstances;

        bool m_IsInShowSate;

        bool m_UseLod;

        GLC_Viewport* m_pViewport;

        GLC_SpacePartitioning* m_pSpacePartitioning;

        bool m_UseSpacePartitioning;


};

// Draw instances of a PointerViewInstanceHash
void GLC_3DViewCollection::glDrawInstancesOf(PointerViewInstanceHash* pHash, glc::RenderFlag renderFlag)
{
        bool forceDisplay= false;
        if (GLC_State::isInSelectionMode())
        {
                forceDisplay= true;
        }

        PointerViewInstanceHash::iterator iEntry= pHash->begin();
        // The current instance
        GLC_3DViewInstance* pCurInstance;
        if (forceDisplay)
        {
                while (iEntry != pHash->constEnd())
                {
                        pCurInstance= iEntry.value();
                        if ((pCurInstance->viewableFlag() != GLC_3DViewInstance::NoViewable) && (pCurInstance->isVisible() == m_IsInShowSate))
                        {
                                pCurInstance->render(renderFlag, m_UseLod, m_pViewport);
                        }
                        ++iEntry;
                }
        }
        else
        {
                if (!(renderFlag == glc::TransparentRenderFlag))
                {
                        while (iEntry != pHash->constEnd())
                        {
                                pCurInstance= iEntry.value();
                                if ((pCurInstance->viewableFlag() != GLC_3DViewInstance::NoViewable) && (pCurInstance->isVisible() == m_IsInShowSate))
                                {
                                        if (!pCurInstance->isTransparent() || pCurInstance->renderPropertiesHandle()->isSelected() || (renderFlag == glc::WireRenderFlag))
                                        {
                                                pCurInstance->render(renderFlag, m_UseLod, m_pViewport);
                                        }
                                }

                                ++iEntry;
                        }

                }
                else
                {
                        while (iEntry != pHash->constEnd())
                        {
                                pCurInstance= iEntry.value();
                                if ((pCurInstance->viewableFlag() != GLC_3DViewInstance::NoViewable) && (pCurInstance->isVisible() == m_IsInShowSate))
                                {
                                        if (pCurInstance->hasTransparentMaterials())
                                        {
                                                pCurInstance->render(renderFlag, m_UseLod, m_pViewport);
                                        }
                                }

                                ++iEntry;
                        }
           }

        }
}

#endif //GLC_3DVIEWCOLLECTION_H_