Vitreous.hpp

#ifndef __VITREOUS_HPP
#define __VITREOUS_HPP
 
#include <ocean/shrimp/VObjectStatus.hpp>
#include <ocean/shrimp/VEnum.hpp>
#include <ocean/GLvish/GLProgram.hpp>
#include <ocean/GLvish/GLTexture.hpp>
 
#include "VFieldRenderObject.hpp"
#include <eye/retina/SortedFragmentIterator.hpp>
 
#include <bundle/BundleProperty.hpp>
 
namespace Wizt
{
 
class    fisheye_API Vitreous : public VFieldRenderObject
{
protected:
public:
 
        typedef Fiber::GridInspector<isFragmentedUniformCartesianGrid> GridInspector;
 
        typedef map<WeakPtr<FragmentID>, int>   LastSlices_t;
 
        struct  VolumeState : State
        {
                RefPtr<BoundingBox>     GridBBox;
                string                  theFieldname;
 
                typedef map<int, RefPtr<Representation> > RepresentationLevels_t;
                RepresentationLevels_t  RepresentationLevels;
 
                LastSlices_t    LastSlices;
        };
 
        RefPtr<State> newState() const override
        {
                return new VolumeState();
        }
 
        in<Range>               myRange;
        in<double>              Opacity,
                                inGamma,
                                inBase;
 
        in<int>                 tsCancellationSensitivity,
                                nSlices,
                                SubSample;
 
        in<bool>                do16BitTextures,
                                doGamma,
                                doExp;
 
        in<int>                 AMRMinLevel,
                                AMRMaxLevel;
 
public:
        TypedSlot<Enum> SpecialOptions;
 
        Vitreous(const string&name, int, const RefPtr<VCreationPreferences>&VP,
                 const string&inputfieldname);
 
        ~Vitreous();
 
        bool update(VRequest&R, double precision) override;
 
        virtual string  statusInfo(VRequest&Context) const;
 
        virtual RefPtr<GLTexture3D>
                loadVolume(VGLRenderContext     &Context,
                           const RefPtr<GLProgram>&MyProgram,
                           const SortedFragmentIterator::SpatialFragment&VF,
                           const MultiIndex<3>&Left,
                           const MultiIndex<3>&Right,
                           const MultiIndex<3>&Sub) const;
 
static  string  CutCode(const RefPtr<BoundingBox>&CutBox, const string&varname, bool invert);
 
        struct  FragmentRenderer : public SortedFragmentIterator
        {
                int                     NumberOfSlices;
 
                const Vitreous&         VR;
                VGLRenderContext        &Context;
 
                LastSlices_t            &LastSlices;
                bool                    MaximumIntensityProjection;
                RefPtr<GLProgram>       MyProgram;
                int                     done;
 
                double                  CutDistance;
                bool                    CutFront;
 
                FragmentRenderer(const Vitreous&myVR, VGLRenderContext&C, LastSlices_t&LS);
                ~FragmentRenderer();
 
                int     Left, Right, Sub;
 
                /*
                 * Using definition to avoid invalid overloaded virtual hidden warning
                 */
                using SortedFragmentIterator::apply;
                bool    apply(const SpatialFragment&VF) override;
        };
};
 
} //namespace Wizt
 
#endif // VITREOUS_HPP