SplatRenderObject.hpp

#ifndef __SPLATRENDEROBJECT_HPP
#define __SPLATRENDEROBJECT_HPP
 
#include <bone/BundleInput.hpp>
#include <bone/FishField.hpp>
 
#include <ocean/GLvish/BoundingBox.hpp>
#include <ocean/GLvish/Shader.hpp>
 
#include <eagle/PhysicalSpace.hpp>
 
#include <ocean/shrimp/VEnum.hpp>
 
#include <GL/fieldGL.hpp>
#include <GL/FieldBuffer.hpp>
#include <GL/PartialElementRenderer.hpp>
 
#include "fish/pond/eye/retina/VertexRenderObject.hpp"
#include "fish/pond/eye/retina/Iris.hpp"
 
namespace Wizt
{
 
using namespace Fiber;
using namespace Eagle;
 
 
class   fisheye_API SplatRenderObject : public VertexRenderObject, public Iris
{
public:
        TypedSlot<double>       sizeFactor;
        TypedSlot<double>       sizeOffset;
 
        TypedSlot<double>       AnimationSpeed;
 
        TypedSlot<double>       MaxSize;
        TypedSlot<double>       m_ref_factor;
 
        TypedSlot<VEnum>        renderMode;
 
        TypedSlot<int>          tsStartPoint,
                                tsHowManyPoints;
 
        SplatRenderObject(const string&name, int p, const RefPtr<VCreationPreferences>&VP,
                          double SizeScale = 150.0,
                          int AnimationVisibility = 5);
 
        ~SplatRenderObject();
 
        struct  fisheye_API Renderer : GL::PartialElementRenderer
        {
                RefPtr<Iris::PointShape> Shape;
 
                enum    mode
                {
                        accumulative,
                        depthsorted,
                        alphaclamped,
 
                        alphaToCoverage,
 
                        accumulative_absorption,
 
                        starlike  = accumulative,
                        particles = depthsorted,
                        massive   = alphaclamped
                };
 
                mode    render_mode;
 
                double  AlphaThreshold;
 
                GLenum  AlphaClampMode;
 
                Renderer(const RefPtr<MemBase>&FieldCoordinates,
                         const RefPtr<FragmentSelector>&FS);
 
                ~Renderer();
 
                void    prefix() override;
 
                bool    draw() override;
 
                void    postfix() override;
        };
 
static  const char*DefaultModifySizeFunction;
 
static  string  setPointAttenuation(const string&ModifySizeFunction = DefaultModifySizeFunction);
 
static  const char default_vertex_shader[];
 
        virtual string splat_vertex_shader(VGLRenderContext&Context) const = 0;
 
static  const char default_fragment_shader[];
 
        virtual string splat_fragment_shader(VGLRenderContext&Context) const = 0;
 
        virtual void setShaderVariables(VGLRenderContext&Context, const RefPtr<GLProgram>&ShaderProgram) const;
 
        RefPtr<VBO::Renderer> createRenderer(VGLRenderContext&Context,
                                             const RefPtr<MemBase>&FieldCoordinates,
                                             const RefPtr<FragmentSelector>&FS) const override;
 
/*
        virtual void    updateRenderer(VRenderContext&Context,
                                       const RefPtr<VBO::Renderer>&R,
                                       const RefPtr<MemBase>&FieldCoordinates,
                                       const RefPtr<FragmentSelector>&FS) const;
*/
 
        void    setRendererParameters(VGLRenderContext&Context,
                                      const RefPtr<VBO::Renderer>&theRenderer,
                                      const RefPtr<CreativeArrayBase>&VertexCoordinates,
                                      const RefPtr<GLProgram>&theShaderProgram) const override;
 
 
/*
        bool request(VRequest&R, double precision,
                             const WeakVObjectPtr&ImmediateRequestor,
                             const WeakVObjectPtr&RootRequestor) override;
*/
 
        bool    must_update(const VRequest&, double precision) const override;
 
        bool    renderGL(VGLRenderContext&Context) const override;
 
        string help(HelpType=HTMLText) const override;
 
//static        string createChildname(const string&parent_name);
 
        virtual string  FragmentShaderPrefix(VRenderContext&) const;
};
 
} // namespace Wizt
 
#endif // __SPLATRENDEROBJECT_HPP