VertexFieldShader.hpp

#ifndef __ANEMONEFISH_VERTEXFIELD_SHADER_HPP
#define __ANEMONEFISH_VERTEXFIELD_SHADER_HPP
 
#include <fish/pond/anemonefish/FieldAnemone.hpp>
#include <ocean/Anemonia/FloatOrigin.hpp>
#include "FloatingAnemone.hpp"
 
#include <utility>
 
/*
  The Programmable header file is includered merely for convenience of
  derived classes, it is not used here.
 */
#include <ocean/Anemonia/Programmable.hpp>
 
namespace       Wizt
{
 
#if     0
template <typename T>
class   has_getShaderConditionals
{
        /*
private:
 
        template<typename U, U> struct SFINAE {};
 
        template<typename U> static char Test(SFINAE<
                                              string (U::*)(Anemone&RenderAnemone,
                                                            const FieldAnemone::AnemoneCreationContext&ARC,
                                                            const RefPtr<FieldAnemone::AnemoneExplorer>&AE) const, &U::getShaderConditionals>*);
        template<typename U> static int Test(...);
 
public:
static  const bool value = sizeof(Test<T>(0)) == sizeof(char);
        */
 
        struct Fallback {};
 
        template<typename C>
static  auto Test(std::nullptr_t)
        -> decltype( std::declval<C>().getShaderPrefix(
                             std::declval<Anemone>(),
                             std::declval<const FieldAnemone::AnemoneCreationContext>(),
                             std::declval<const RefPtr<FieldAnemone::AnemoneExplorer>>()
                                ) );
 
//      template<typename>
//static        Fallback Test(...);
 
public:
static  bool const value = !std::is_same<decltype(Test<T>(nullptr)),Fallback>::value;
 
};
 
/*
template <bool>
struct  GetDisplayShaderPrefixFunction;
 
template <> struct GetDisplayShaderPrefixFunction<true>
{
        template <class DisplayShader>
static  string  call(const DisplayShader&DS,
                     Anemone&RenderAnemone,
                     const FieldAnemone::AnemoneCreationContext&ARC,
                     const RefPtr<FieldAnemone::AnemoneExplorer>&AE)
{
        return DS.getShaderConditionals(RenderAnemone, ARC, AE);
}
};
 
template <> struct GetDisplayShaderPrefixFunction<false>
{
        template <class DisplayShader>
static string   call(const DisplayShader&DS,
                     Anemone&RenderAnemone,
                     const FieldAnemone::AnemoneCreationContext&ARC,
                     const RefPtr<FieldAnemone::AnemoneExplorer>&AE)
{
        return "";
}
};
*/
#endif
 
template <class DisplayShader>
inline string   getShaderConditionals(const DisplayShader&DS,
                                      Anemone&RenderAnemone,
                                      const FieldAnemone::AnemoneCreationContext&ARC,
                                      const RefPtr<FieldAnemone::AnemoneExplorer>&AE, std::true_type)
{
        return DS.getShaderConditionals(RenderAnemone, ARC, AE);
}
 
template <class DisplayShader>
inline  string getShaderConditionals(const DisplayShader&DS,
                                     Anemone&RenderAnemone,
                                     const FieldAnemone::AnemoneCreationContext&ARC,
                                     const RefPtr<FieldAnemone::AnemoneExplorer>&AE, std::false_type)
{
        return "";
}
 
template <class DisplayShader>
inline string getShaderConditionals(const DisplayShader&DS,
                                    Anemone&RenderAnemone,
                                    const FieldAnemone::AnemoneCreationContext&ARC,
                                    const RefPtr<FieldAnemone::AnemoneExplorer>&AE)
{
/*
        static_assert(has_getShaderConditionals<DisplayShader>::value, "Has NOT shader conditional.");
 
        return getShaderConditionals(DS, RenderAnemone, ARC, AE,
                std::integral_constant<bool, has_getShaderConditionals<DisplayShader>::value>());
*/
 
//      static_assert(DisplayShader::hasShaderConditionals , "Has NOT shader conditional.");
        return getShaderConditionals(DS, RenderAnemone, ARC, AE,
                                     std::integral_constant<bool, DisplayShader::hasShaderConditionals>());
}
 
struct  DisplayShader
{
        template <class T, int EL = VSlotContainer::InvalidExpertLevel >
                using in = VObject::in<T, EL>;
};
 
template <class PrimaryType>
struct  TypedDisplayShader : DisplayShader
{
        typedef PrimaryType     FieldType;
};
 
 
template <class DisplayShader, int RenderCategory = HEAVY_OBJECT>
class    VertexFieldShader : public TypedFieldAnemone< typename DisplayShader::FieldType >
                           , public DisplayShader
                           , public FloatingAnemone
{
public:
 
        typedef typename DisplayShader::FieldType Field_Type_t;
 
        typedef TypedFieldAnemone<Field_Type_t> TypedFieldAnemone_t;
 
        typedef Fiber::GridInspector<Fiber::BundleProperty::Anything> GridInspector;
 
        typedef typename TypedFieldAnemone_t::GridAnemoneState
                GridAnemoneState;
 
        VertexFieldShader(const string&name, int, const RefPtr<VCreationPreferences>&VP )
        : TypedFieldAnemone<Field_Type_t>(name, RenderCategory, VP)
        , DisplayShader(this)
        {}
 
 
        RefPtr<GridAnemone::AnemoneExplorer>
                getAnemoneExplorer(VRenderContext&Context)    const override
        {
                return  FloatingAnemone::getAnemoneExplorer( this->self(), Context);
        }
 
 
 
        string  getShaderAttributeName( const TypedSlot<Fiber::Field>&) const override
        {
                return DisplayShader::getShaderAttributeName();
        }
 
 
 
        GridAnemone::AnemoneRenderStatus
                initializeAnemone(Anemone&RenderAnemone,
                                  const FieldAnemone::AnemoneCreationContext&ARC,
                                  const RefPtr<FieldAnemone::AnemoneExplorer>&AE) const override
        {
        GridAnemone::AnemoneRenderStatus
                InitStatus = TypedFieldAnemone_t::initializeAnemone(RenderAnemone, ARC, AE);
                if (InitStatus != GridAnemone::AnemoneRenderStatus::AllFine)
                        return InitStatus;
 
                /*
                  TODO: Conceive a way to allow the DisplayShader to override the getShaderPrefix
                  functions. For now, this can be done in the derived VertexFieldShader.
                 */
        string  ShaderPrefix = this->TypedFieldAnemone_t::getShaderPrefix(ARC, *AE);
                ShaderPrefix += getShaderConditionals(*this, RenderAnemone, ARC, AE);
 
        RefPtr<RenderBasin::Program>
                ShaderProgram = this->CompileShader(ARC.myContext, this->BaseName(),
                                                    [this, &RenderAnemone, &ARC, AE](const RenderBasin::Program::Parameters&P)
                                                    {
                                                            return this->setProgramParameters(P, RenderAnemone, ARC, AE);
                                                    },
                                                    nullptr,
                                                    ShaderPrefix,
                                                    ShaderPrefix,
                                                    ShaderPrefix
                        );
 
                RenderAnemone.insert( ShaderProgram );
 
                if (!this->initializeTranslation(RenderAnemone, ARC, AE))
                {
                        return GridAnemone::AnemoneRenderStatus::InvalidVertexCoordinates;
                }
 
                RenderAnemone.insert( ARC.myContext.createViewTentacle(ShaderProgram) );
 
                if (RefPtr<AnemoneCreator<> >AC = ARC.myAnemoneCreator)
                {
                        this->FieldAnemone::setNamedTextures(RenderAnemone, ShaderProgram);
 
                        if (this->DisplayShader::initializeAnemone(RenderAnemone, ARC.myContext, *AC))
                                return GridAnemone::AnemoneRenderStatus::AllFine;
                }
 
                return GridAnemone::AnemoneRenderStatus::CouldNotInitialize;
        }
 
        bool    isValidAnemone(const Anemone&RenderAnemone,
                               const FieldAnemone::AnemoneCreationContext&ARC,
                               const RefPtr<FieldAnemone::AnemoneExplorer>&AE) const override
        {
                if (!TypedFieldAnemone_t::isValidAnemone(RenderAnemone, ARC, AE))
                {
                        AppVerbose("Anemonia", 10) << "VertexFieldShader has invalid field Anemone.";
                        return  false;
                }
 
                if (!ARC.myAnemoneCreator)
                {
                        AppVerbose("Anemonia", 10) << "VertexFieldShader has NO Anemone Creator.";
                        return  false;
                }
 
                if (!ARC.myContext.LayeredMultiViews::isValid(RenderAnemone))
                {
                        AppVerbose("Anemonia", 10) << "VertexField Shader Anemone has invalid multiview settings, need to re-create Anemone.";
                        return false;
                }
 
                if (RefPtr<AnemoneCreator<> >AC = ARC.myAnemoneCreator)
                {
                        if (!this->DisplayShader::isValidAnemone(RenderAnemone, ARC.myContext, *AC))
                        {
                                AppVerbose("Anemonia", 10) << "VertexFieldShader has display shader indicating Anemone being invalid.";
                                return  false;
                        }
                }
                else
                {
                        AppVerbose("Anemonia", 10) << "VertexFieldShader has invalid Anemoen Creator.";
                        return false;
                }
 
 
        bool    validShaders = this->hasValidShaderPrograms(RenderAnemone, ARC.myContext);
                if (!validShaders)
                        AppVerbose("Anemonia", 10) << "VertexFieldShader has invalid shader programs which invalidate the Anemone.";
 
                return  validShaders;
        }
 
 
        bool    updateAnemone(Anemone&RenderAnemone,
                              const GridAnemone::AnemoneCreationContext&ARC,
                              const RefPtr<GridAnemone::AnemoneExplorer>&AE) const override
        {
                return  updateTranslation(RenderAnemone, ARC, AE);
        }
 
};
 
} // namespace
 
#endif // __ANEMONEFISH_VERTEXFIELD_SHADER_HPP