OrthoSlice.hpp

#ifndef _FISHEYE_SCALAR_ORTHOSLICE_HPP
#define _FISHEYE_SCALAR_ORTHOSLICE_HPP
 
#include "fisheyescalarDllApi.h"
 
#include <bone/BundleInput.hpp>
#include <bone/FishField.hpp>
 
#include <ocean/shrimp/VObjectStatus.hpp>
 
#include <ocean/GLvish/VGLRenderObject.hpp>
#include <ocean/GLvish/BoundingBox.hpp>
#include <ocean/GLvish/VGLColormap.hpp>
#include <ocean/GLvish/Shader.hpp>
 
#include <ocean/eagle/PhysicalSpace.hpp>
 
#include <eye/retina/TexturedQuad.hpp>
#include <eye/retina/FieldSlice.hpp>
#include <eye/retina/VFieldRenderObject.hpp>
 
#include <bone/FieldObject.hpp>
 
#include <GL/Texture.hpp>
 
namespace Wizt
{
 
 
using namespace Fiber;
using namespace Eagle;
using namespace META;
 
class   fisheyescalar_API OrthoSlice : virtual public VFieldRenderObject,
                                       virtual public Fish<Skeleton>,
                                       public Orientation
{
public:
        typedef Fiber::GridInspector<isFragmentedUniformCartesianGrid> GridInspector;
 
        typedef LIST<double, LIST<float> > InputTypes;
 
        struct  FieldState : State, FieldSlice
        {
                WeakPtr<Colormap>       LastColormap;
                int                     RefinementLevel;
                Ageable                 TriggerAge;
                Range                   DataRange;
 
                int                     bits;
 
                typedef std::multimap<RefPtr<CreativeArrayBase>, RefPtr<TexturedQuad> > LevelBlocks_t;
                typedef std::map<int, LevelBlocks_t> Blocks_t;
                Blocks_t                Blocks;
 
                RefPtr<Quad> extract(const RefPtr<FragmentID>&f,
                                              const MultiIndex<3>&Dims,
                                              const RefPtr<CreativeArrayBase>&FieldBase, index_t Slice) override;
 
                FieldState()
                : bits(8)
                {}
 
                ~FieldState()
                {
//                      puts("~FieldState()"); fflush(stdout);
                }
 
                using FieldSlice::reset;
 
                void    reset()
                {
                        Blocks.clear();
                }
 
                bool    empty() const
                {
                        return Blocks.size() < 1;
                }
 
                bool    IrregularFragment(const RefPtr<FragmentID>&f, const RefPtr<CreativeArrayBase>&DC) override;
        }; 
 
        RefPtr<State> newState() const override
        {
                return new FieldState();
        }
 
        TypedSlot<double>       SliceLocation; 
        TypedSlot<Enum>         Mode;
        TypedSlot<VColormap>    myColormap;
        TypedSlot<Range>        myRange;
        TypedSlot<double>       Transparency; 
 
        TypedSlot<string>       DataFunction;
 
        TypedSlot<double>       dS;
        TypedSlot<int>          Multiplicity;
 
        TypedSlot<Enum>         Precision;
        TypedSlot<double>       tsEpsilon;
 
        OrthoSlice(const string&name, int p, const RefPtr<VCreationPreferences>&VP);
 
        void setup(const CreationSlots_t&CreationSlots) override;
 
        bool update(VRequest&R, double precision) override;
        bool render(VGLRenderContext&Context) const override;
 
static string createChildname(const string&parent_name)
        {
                return "OrthoSliceFor" + parent_name;
        }
 
//static        RefPtr<VAcceptInfo> accept(const RefPtr<VObject>&vobj);
 
};
 
} // namespace Wizt
 
#endif