ObjectEffect.h

Go to the documentation of this file.

#ifndef OBJECTEFFECT_H
#define OBJECTEFFECT_H

#include <vrecko/Ability.h>
#include <osg/Group>
#include <osg/ShapeDrawable>
#include <helpers/DynamicArray.h>
#include <vrecko/SP_CommonDefs.h>

using namespace vrecko;

namespace APObjectUtils
{

    class ObjectEffect: public Ability
    {
    public:

        enum EffectType {
            None,
                // Nothing is displayed
            BoundingSphere,
                // Displays bounding sphere of the object
            BoundingBox,
                // Displays bounding box of the object
            Transparency,
                // Changes the object to be transparent. The transparency value is retrieved from alpha part of the [color]
                // The COLOR values are IGNORED.
                // Alternatively, you can use "Colorize", which includes the color values.
            Colorize,
                // Changes the object material to specified color.
                // THIS INCLUDES TRANSPARENCY AS WELL.
                // Alternatively, you can use "Transparency", which ignores the color values.
            Collisions,
                // Displays collision pairs.
                // Requires that there is a collision detection registered
                // in the Scene through Scene::addPartitioningSceneInterface().
                // If also PartitioningObjectInterface was registered, it will be used automatically.
            SphereBVH,
                // Displays a layer of spher ebounding volumes. (The layer index can be changed.)
                // REQUIRES that current object has either SphereBVH_Object_Data or SNCH_Object_Data ability
            SNCH,
                // Displays SNCH cones.
                // REQUIRES that current object has either SNCH_Object_Data ability
            SNCHFaceGroups,
            VertexNormals,
                // Displays vertex normals.
                // REQUIRES that current object has either SphereBVH_Object_Data or SNCH_Object_Data ability
            FaceNormals,
                // Displays face normals.
                // REQUIRES that current object has either SphereBVH_Object_Data or SNCH_Object_Data ability
            TransparencyOnTop,
                // Similar to "Transparency" effect, but this time the object is also rendered on top of other objects.
                // The COLOR values are IGNORED.
                // Alternatively, you can use "ColorizeOnTop", which includes the color values.
            ColorizeOnTop,
                // Similar to "Colorize", but object is rendered on top of other objects.
                // THIS INCLUDES TRANSPARENCY AS WELL.
                // Alternatively, you can use "TransparencyOnTop", which ignores the color values.
            VoxelGrid,
                // Visualize the voxel grid.
                // REQUIRES that the owner object has the VoxelGrid_Object_Data ability
            VoxelGridCollisions,
                // Visualize the voxel grid.
                // REQUIRES that the owner object has the VoxelGrid_Object_Data ability
            PointShell,
                // Visualize the point shell.
                // REQUIRES that the owner object has the PointShell_Object_Data ability
            DoubleSided,
                // Turns on the double-sided rendering
            PolygonNormals,
                // displays the normals of faces
                // require to Pointshell_Object_Data
        };

        ObjectEffect();
        virtual ~ObjectEffect();

        virtual void preInitialize();
        virtual void postInitialize();
        virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *pParametersNode);
        virtual void update();
//      virtual void processEvent(const std::string &strInputName, void *pValue);
        virtual void clean();

        void setEffectType(EffectType newType);
        EffectType getEffectType(void) { return effectType; }

        bool isEffectCreated() { return bEffectCreated; }

    protected:
        EffectType effectType;

        bool bEffectCreated;

        int iDistanceFieldValue; // used for a DistanceField/Voxel Grid Show

        osg::Vec4 color;
        int iLevelMin, iLevelMax;
            // used for SphereBVH/SNCH/PointShell: Min and Max level o hierarchy to display
            // The level numbering starts from 0 (root, min. level).
            // Either variable can be -1, which means the lowest (iLevelMin)
            // or the highest (iLevelMax) level.
        inline int getLevelMin() { return iLevelMin; }
        inline int getLevelMax() { return iLevelMax; }
        void setLevelMinMax(int newLevelMin, int newLevelMax);

        float fRadius;
            // used for PointShell: Point radius for visualization

        bool bShowLeafInLevelNotReached;
            // SphereBVH/SNCH: Render leaf nodes, if a level was selected, which has not been
            // reached in the current subtree
        bool bCollisions_NoCalculation;
            // Collisions: Perform no calculations and only use the data that is
            // available if anyone else is performing any calculations in the bakcground.

        osg::ref_ptr<EnvironmentObject> graphicObject;
        osg::ref_ptr<osg::Geode> osgGeode;
        osg::ref_ptr<osg::MatrixTransform> osgTransform;
        osg::ref_ptr<osg::Sphere> shapeSphere;
        osg::ref_ptr<osg::Box> shapeBox;
        osg::ref_ptr<osg::ShapeDrawable> shapeDraw;

        std::vector<osg::ref_ptr<osg::ShapeDrawable>> shapeDrawables;

        osg::ref_ptr<osg::StateSet> originalStateSet;
            // StateSet of the owner object before the effect was applied.
            // This StateSet will be restored when the effect is destroyed.

        COLLISIONS_INFO_VECTOR *colInfo;
            // For displaying colisions

        void createEffect();
        bool createEffect_SphereHierarchy_ProcessLevel(
            vrecko::Ability *dataAbility, void *node, int iCurrentLevel);
            // helper function for creating SphereBVH/SNCH hierarchy
        bool createEffect_PointShellHierarchy_ProcessLevel( vrecko::Ability *dataAbility, void *node, int iCurrentLevel, bool draw);
            // helper function for creating PointShell hierarchy
        bool draw_Effect_PointShellHierarchy_Node(vrecko::Ability *dataAbility, void *node, int iCurrentLevel);
            // draws Nodes from pointshell
        bool createEffect_Lines(vrecko::Ability *dataAbility);
            // For Collisions effect, the [dataAbility] is not used (might be NULL)
        bool createEffect_Reconstruction(vrecko::Ability *dataAbility);
            // For SNCHFaceGroups where original objects are recreated entirely from the SNCH_Object_Data ability
        bool createEffect_VoxelGrid(vrecko::Ability *dataAbility);
            // For the VoxelGrid effect
        void destroyEffect();

        void HSVtoRGB (float *r, float *g, float *b, float h, float s, float v);
        // Ranges are from 0.0 to 1.0

        DECLARE_INPUT(ShiftLevels, MessageInt);
    };

}


#endif