HeightDots.hpp

#include <anemonefish/ShadedFieldAnemone.hpp>
#include <anemonefish/CarpetAnemone.hpp>
#include <ocean/shrimp/VEnum.hpp>
#include <ocean/Anemonia/ShaderConditionals.hpp>
#include <eye/retina/Billboard.hpp>
#include <pond/eye/shaders/ContourLines.hpp>
#include <anemonefish/Texturizer.hpp>
#include <eye/shaders/Phong.hpp>
#include <ocean/Anemonia/FogInjector.hpp>
#include <eye/retina/FieldVisibilityInjector.hpp>
#include <ocean/Anemonia/Cursor3DProperties.hpp>
 
 
namespace  Wizt
{
 
using namespace Fiber;
 
struct  Masking
{
        VObject::in<VEnum>              inMaskMode, inMaskDisplayMode;
        VObject::in<double>             inMaskThreshold;
        TypedSlot<Fiber::Field>         MaskField;
        VObject::in<Color>              inMaskColor;
        VObject::in<double>             inMaskVisibilityBoost,
                                        inMaskScaleFactor;
 
        Masking(VObject*that, int EL=5)
        : inMaskMode(that, "maskmode", VEnum{"Show All", "Mask", "No Mask"}, EL)
        , inMaskDisplayMode(that, "maskdisplay",
                            VEnum{1, "Interior" , "Exterior" , "Stars" , "Spikes",
                                     "tInterior", "tStars", "tSpikes"}, EL+2)
        , inMaskThreshold(that, "maskthreshold", 0.5, EL)
        , MaskField(that, "mask", EL)
        , inMaskColor(that, "maskcolor", Color{1,0,0,0.7}, EL)
        , inMaskVisibilityBoost(that, "MaskVisibilityBoost", 1.0, EL+4)
        , inMaskScaleFactor(that, "MaskScaleFactor", 0.0, EL+4)
        {
                inMaskScaleFactor     /=
                inMaskVisibilityBoost /=
                inMaskMode            /=
                inMaskDisplayMode     /=
                MaskField             /=
                inMaskThreshold       /=
                inMaskColor           /=
                that->recognizeInputClass("masking");
 
                inMaskVisibilityBoost.setProperty("min", 1.0);
                inMaskVisibilityBoost.setProperty("max", 1.1);
                inMaskVisibilityBoost.setProperty<string>("tooltip",
                                                          "Enhance the visibility of masked points in a strongly visual, though unnatural, way "
                                                          " by placing them into the foreground of unmasked points.");
 
                inMaskScaleFactor.setProperty<string>("tooltip",
                                                      "Increase visible size of masked points. This increase is dependent on the mask value "
                                                      "such that heavily masked points are scaled even stronger. For boolean-valued masks "
                                                      "all increments are identical."
                        );
 
 
                inMaskScaleFactor.setProperty("min", -.004);
                inMaskScaleFactor.setProperty("max", +.01);
        }
 
 
        void    initializeVertexAnemoneMaskProperties(Anemone&RenderAnemone,
                                                      const FieldAnemone::AnemoneCreationContext&ARC,
                                                      AnemoneCreator<>&AC) const
        {
        VRenderContext&Context = ARC.myContext;
 
                RenderAnemone << Context << "MaskThreshold"       << inMaskThreshold;
                RenderAnemone << Context << "MaskColor"           << inMaskColor;
                RenderAnemone << Context << "MaskVisibilityBoost" << inMaskVisibilityBoost;
                RenderAnemone << Context << "MaskScaleFactor"     << inMaskScaleFactor;
        }
};
 
 
struct HeightDots : ShadedFieldAnemone
                  , BillboardBase
                  , CarpetAnemone
                  , Phong
                  , ContourLines
                  , ShaderConditionals
                  , Texturizer
                  , Masking
                  , Cursor3D
{
        using   FieldType = LIST<uint8_t, uint16_t, int, rgba_t,rgb_t, float, double>;
        using   InputTypes = FieldType;
 
        in<Range>               inHeightRange,
                                inColorRange,
                                inSizeRange;
 
        in<int>                 inColorSteps,
                                inHeightSteps;
 
        in<double>              inColorBlendFactor,
                                inGamma,
                                inBrightness,
                                inBorder,
                                inSidedness
                ,               inAlphaThreshold;
                                //scaleHeight;
 
        in<double,6>            inExtendedHeightSensitivity       = { "HeightSensitivity"     , 10.0 },
                                inExtendedHeightSensitivityWeight = { "HeightSensitivityWeight", 0.0 };
 
        in<double>              inNormalValidityOffset;
 
        TypedSlot<VColormap>    myFieldColormap;
 
        in<bool>                inOrientHeightDots,
                                inDoShading,
                                inCircularHeightDots,
                                inDoHighlights,
                                inXray,
                                inInvertNormals,
                                inDoConsiderInputAsSRGBColorSpace;
 
        in<bool , 61>           inDoFog  = { "Fog"    , false };
 
        in<RefPtr<Fog>,4>               inFog;
        in<RefPtr<FieldVisibility>,2>   inFieldVisibility;
 
        TypedSlot<Fiber::Field> NormalField    = {this, "normalvectors" , 3};
        TypedSlot<Fiber::Field> NormalValidity = {this, "normalvalidity", 5};
 
        TypedSlot<Fiber::Field> AlphaChannelField ;
        TypedSlot<Fiber::Field> OverrideHeightField;
        TypedSlot<Fiber::Field> SelectionField;
        TypedSlot<Fiber::Field> inSizeField;
 
        HeightDots(const string&Name, int, const RefPtr<VCreationPreferences>&VP );
        ~HeightDots();
 
 
        bool    addFields(VRequest&Context, Fiber::Info<Fiber::Grid>&iG,
                          RenderFields&FAS,
                          const RefPtr<Fiber::Skeleton>&theVertexSkeleton,
                          const RefPtr<Fiber::Chart>&theChart,
                          string&InfoString) override;
//static        constexpr bool hasShaderConditionals = true;
 
        string  getShaderConditionals(Anemone&RenderAnemone,
                                      const FieldAnemone::AnemoneCreationContext&ARC,
                                      const RefPtr<FieldAnemone::AnemoneExplorer>&AE) const override;
 
        bool    isValidVertexAnemone(const Anemone&RenderAnemone,
                                     VRenderContext&Context,
                                     const AnemoneCreator<>&AC) const override;
 
        RefPtr<DataRangeBase>   getHeight(const RefPtr<ValuePool>&Context, bool) const;
 
        RefPtr<BoundingBox>     getModifiedBBox(const RefPtr<ValuePool>&Context,
                                                CreativeArrayBase&CoordinateFragment,
                                                const RefPtr<FragmentID>&theFragmentID,
                                                const RefPtr<Fiber::Skeleton>&DestVertexSkeleton,
                                                const RefPtr<Fiber::Chart>&chart,
                                                bool    AllowAsynchLoading) const override;
 
        bool    initializeVertexAnemone(Anemone&RenderAnemone,
                                        const RefPtr<RenderBasin::Program>&ShaderProgram,
                                        const FieldAnemone::AnemoneCreationContext&ARC,
                                        AnemoneCreator<>&AC) const override;
 
 
        bool    validateAnemoneData(VRenderContext&theContext,
                                    map<string, RefPtr<MemBase>>&AnemoneData,
                                    const RefPtr<Fiber::FragmentID>&theFragmentID,
                                    const Fiber::SkeletonID&theSkeletonID) const override;
 
 
        RenderBasin::Program::Parameters setProgramParameters(RenderBasin::Program::Parameters P,
                                                              Anemone&RenderAnemone,
                                                              const GridAnemone::AnemoneCreationContext&ARC,
                                                              const RefPtr<GridAnemone::AnemoneExplorer>&AE) const override;
 
        std::string     VertexShaderPrefix(VRenderContext&Context) const override;
        std::string     GeometryShaderPrefix(VRenderContext&Context) const override;
        std::string     FragmentShaderPrefix(VRenderContext&Context) const override;
 
 
        RenderNamespace::glsl
        vertex_shader(VRenderContext&Context) const override;
 
        std::string     geometry_shader(VRenderContext&Context) const override;
 
        std::string     fragment_shader(VRenderContext&Context) const override;
 
        string  getShaderAttributeName( const TypedSlot<Fiber::Field>&) const override;
 
};
 
 
} // namespace