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/plankton/VCreator.hpp>

#include <ocean/shrimp/VObjectStatus.hpp>

#include <ocean/GLvish/VGLRenderObject.hpp>
#include <ocean/GLvish/BoundingBox.hpp>
#include <ocean/GLvish/Colormap.hpp>
#include <ocean/GLvish/Shader.hpp>

#include <ocean/eagle/PhysicalSpace.hpp>

#include <field/DirectProductArray.hpp>

#include <eye/retina/TexturedQuad.hpp>
#include <eye/retina/FieldSlice.hpp>
#include <eye/retina/VFieldRenderObject.hpp>

#include <ocean/plankton/VTimer.hpp>
#include <bone/FieldObject.hpp>

#include <fish/lakeview/GL/Texture.hpp>

namespace Wizt
{


using namespace Fiber;
using namespace Eagle;

class   fisheyescalar_API OrthoSlice : public VFieldRenderObject,
                                       public Fish<Skeleton>,
                                       public Orientation
{
public:
        typedef LIST<double, LIST<float> > InputTypes;

        typedef DirectProductMemArray<Eagle::point3>   ProcArray_t;

        struct  FieldState : State, FieldSlice
        {
                WeakPtr<Colormap>       LastColormap;
                int                     RefinementLevel;
                Ageable                 TriggerAge;
                Range                   DataRange;

                int                     bits;
                double                  shift;

                typedef std::map<RefPtr<CreativeArrayBase>, RefPtr<TexturedQuad> > Blocks_t;
                Blocks_t                Blocks;

                override RefPtr<Quad> extract(const RefPtr<FragmentID>&f,
                                              const MultiIndex<3>&Dims,
                                              const RefPtr<CreativeArrayBase>&FieldBase, index_t Slice);

                void render(VGLRenderContext&Context, const RefPtr<ValueSet>&Values, 
                            bool interpolate) const;

                FieldState()
                : bits(8)
                , shift(0.5) 
                {}

                ~FieldState()
                {
                        puts("~FieldState()"); fflush(stdout);
                }

                using FieldSlice::reset;

                void reset()
                {
                        Blocks.clear();
                }

                bool empty() const
                {
                        return Blocks.size() < 1;
                }

                override bool IrregularFragment(const RefPtr<FragmentID>&f, const RefPtr<CreativeArrayBase>&DC);

        };

        override RefPtr<State> newState() const
        {
                return new FieldState();
        }

        TypedSlot<double>       SliceLocation; 
        TypedSlot<Enum>         Mode;
        TypedSlot<VColormap>    myColormap;
        TypedSlot<Range>        myRange;
        TypedSlot<double>       Transparency; 

        TypedSlot<Enum>         DataOperator;

        TypedSlot<Enum>         Precision;

        TypedSlot<double>       Shift; 

        OrthoSlice(const string&name, int p, const RefPtr<VCreationPreferences>&VP);

        override bool update(VRequest&R, double precision);
        override void render(VGLRenderContext&Context) const;

static string createChildname(const string&parent_name)
        {
                return "Orthoslice<" + parent_name + ">";
        }

//static        RefPtr<VAcceptInfo> accept(const RefPtr<VObject>&vobj);

};

} // namespace Wizt

#endif