SplatRenderObject.hpp

#ifndef __SPLATRENDEROBJECT_HPP
#define __SPLATRENDEROBJECT_HPP

#include <bone/BundleInput.hpp>
#include <bone/FishField.hpp>

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

#include <ocean/eagle/PhysicalSpace.hpp>

#include <ocean/shrimp/VEnum.hpp>

#include <GL/fieldGL.hpp>
#include <GL/FieldBuffer.hpp>
#include <GL/PartialElementRenderer.hpp>

#include <eye/retina/VertexRenderObject.hpp>
#include <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>       AnimationSpeed;

        TypedSlot<double>       MaxSize; 

        TypedSlot<VEnum>        renderMode; 

        SplatRenderObject(const string&name, int p, const RefPtr<VCreationPreferences>&VP,
                          double SizeScale = 5.0, 
                          int AnimationVisibility = 5);

        ~SplatRenderObject(); 

        struct  fisheye_API Renderer : GL::PartialElementRenderer
        {
                RefPtr<Iris::PointShape> Shape; 

                enum    mode
                {
                        accumulative,
                        depthsorted,
                        alphaclamped,
                        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(); 

                override void prefix(); 

                override bool draw();

                override void postfix();
        };

static  const char*setPointAttenuation();

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;

        override RefPtr<VBO::Renderer> createRenderer(VGLRenderContext&Context,
                                                      const RefPtr<MemBase>&FieldCoordinates,
                                                      const RefPtr<FragmentSelector>&FS) const;

/*
        virtual void    updateRenderer(VRenderContext&Context,
                                       const RefPtr<VBO::Renderer>&R,
                                       const RefPtr<MemBase>&FieldCoordinates,
                                       const RefPtr<FragmentSelector>&FS) const;
*/

        override 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); 

        override void render(VGLRenderContext&Context) const; 

static  string createChildname(const string&parent_name);
};

} // namespace Wizt

#endif // __SPLATRENDEROBJECT_HPP