glc_renderproperties.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)
 Version 2.0.0 Beta 1, packaged on April 2010.

 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 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 General Public License for more details.

 You should have received a copy of the GNU 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_RENDERPROPERTIES_H_
#define GLC_RENDERPROPERTIES_H_

#include "glc_material.h"
#include "../glc_global.h"

#include <QSet>
#include <QHash>
#include <QtOpenGL>

#include "../glc_config.h"

namespace glc
{
        enum RenderMode
        {
                NormalRenderMode,
                OverwriteMaterial,
                OverwriteTransparency,
                PrimitiveSelected,
                OverwritePrimitiveMaterial,
                BodySelection,
                PrimitiveSelection
        };

        enum RenderFlag
        {
                ShadingFlag= 800,
                WireRenderFlag,
                TransparentRenderFlag
        };
};


class GLC_LIB_EXPORT GLC_RenderProperties
{



public:
        GLC_RenderProperties();

        GLC_RenderProperties(const GLC_RenderProperties&);

        GLC_RenderProperties &operator=(const GLC_RenderProperties&);

        virtual ~GLC_RenderProperties();



public:
        inline bool isSelected() const
        {return m_IsSelected;}

        inline glc::RenderMode renderingMode() const
        {return m_RenderMode;}

        inline glc::RenderMode savedRenderingMode() const
        {return m_SavedRenderMode;}

        inline GLC_Material* overwriteMaterial() const
        {return m_pOverwriteMaterial;}

        inline float overwriteTransparency() const
        {return m_OverwriteTransparency;}

        inline QSet<GLC_uint>* setOfSelectedPrimitivesId() const
        {
                Q_ASSERT(NULL != m_pBodySelectedPrimitvesId);
                if (m_pBodySelectedPrimitvesId->contains(m_CurrentBody))
                        return m_pBodySelectedPrimitvesId->value(m_CurrentBody);
                else return NULL;
        }

        inline bool setOfSelectedPrimitiveIdIsEmpty() const
        {return (!((NULL != m_pBodySelectedPrimitvesId) && m_pBodySelectedPrimitvesId->contains(m_CurrentBody)));}

        bool primitiveIsSelected(int index, GLC_uint id) const;

        inline QHash<GLC_uint, GLC_Material*>* hashOfOverwritePrimitiveMaterials() const
        {
                Q_ASSERT(NULL != m_pOverwritePrimitiveMaterialMaps);
                if (m_pOverwritePrimitiveMaterialMaps->contains(m_CurrentBody))
                        return m_pOverwritePrimitiveMaterialMaps->value(m_CurrentBody);
                else return NULL;
        }

        inline bool hashOfOverwritePrimitiveMaterialsIsEmpty() const
        {return (!((NULL != m_pOverwritePrimitiveMaterialMaps) && m_pOverwritePrimitiveMaterialMaps->contains(m_CurrentBody)));}


        inline GLenum polyFaceMode() const
        {return m_PolyFace;}


        inline GLenum polygonMode() const
        {return m_PolyMode;}

        inline glc::RenderFlag renderingFlag() const
        {return m_RenderingFlag;}

        bool needToRenderWithTransparency() const;

        inline int currentBodyIndex() const
        {return m_CurrentBody;}

        bool isDefault() const;




public:

        void clear();



public:
        inline void select(bool primitive);

        inline void unselect(void);

        inline void setRenderingMode(glc::RenderMode mode)
        {m_RenderMode= mode;}

        void setOverwriteMaterial(GLC_Material*);

        inline void setOverwriteTransparency(float alpha)
        {m_OverwriteTransparency= alpha;}

        void addSetOfSelectedPrimitivesId(const QSet<GLC_uint>&, int body= 0);

        void addSelectedPrimitive(GLC_uint, int body= 0);

        void clearSelectedPrimitives();

        void addOverwritePrimitiveMaterial(GLC_uint, GLC_Material*, int bodyIndex= 0);

        void clearOverwritePrimitiveMaterials();


        inline void setPolygonMode(GLenum Face, GLenum Mode)
        {
                m_PolyFace= Face;
                m_PolyMode= Mode;
        }

        inline void setRenderingFlag(glc::RenderFlag flag)
        {m_RenderingFlag= flag;}

        inline void setCurrentBodyIndex(int index)
        {m_CurrentBody= index;}

        inline void useMaterial(GLC_Material*);

        inline void unUseMaterial(GLC_Material*);



//Private attributes
private:
        GLC_uint m_Uid;

        bool m_IsSelected;

        GLenum m_PolyFace;
        GLenum m_PolyMode;

        glc::RenderMode m_RenderMode;

        glc::RenderMode m_SavedRenderMode;

        GLC_Material* m_pOverwriteMaterial;

        float m_OverwriteTransparency;

        QHash<int, QSet<GLC_uint>* >* m_pBodySelectedPrimitvesId;

        QHash<int, QHash<GLC_uint, GLC_Material* >* >* m_pOverwritePrimitiveMaterialMaps;

        glc::RenderFlag m_RenderingFlag;

        int m_CurrentBody;

        QHash<GLC_Material*, int> m_MaterialsUsage;

};

// Select the instance
void GLC_RenderProperties::select(bool primitive)
{
        m_IsSelected= true;
        if (primitive && (m_RenderMode != glc::PrimitiveSelected))
        {
                m_SavedRenderMode= m_RenderMode;
                m_RenderMode= glc::PrimitiveSelected;
        }
}

// Unselect the instance
void GLC_RenderProperties::unselect(void)
{
        m_IsSelected= false;
        if (m_RenderMode == glc::PrimitiveSelected)
        {
                m_RenderMode= m_SavedRenderMode;
        }
}
// Used the specified material
void GLC_RenderProperties::useMaterial(GLC_Material* pMaterial)
{
        if (m_MaterialsUsage.contains(pMaterial))
        {
                QHash<GLC_Material*, int>::iterator iMat= m_MaterialsUsage.find(pMaterial);
                iMat.value()= iMat.value() + 1;
        }
        else
        {
                m_MaterialsUsage.insert(pMaterial, 1);
                pMaterial->addUsage(m_Uid);
        }

}

// Unused the specified material
void GLC_RenderProperties::unUseMaterial(GLC_Material* pMaterial)
{
        Q_ASSERT(m_MaterialsUsage.contains(pMaterial));
        QHash<GLC_Material*, int>::iterator iMat= m_MaterialsUsage.find(pMaterial);
        iMat.value()= iMat.value() - 1;
        if (iMat.value() == 0)
        {
                pMaterial->delUsage(m_Uid);
                if (pMaterial->isUnused()) delete pMaterial;
                m_MaterialsUsage.remove(pMaterial);
        }
}

#endif /* GLC_RENDERPROPERTIES_H_ */