FragmentSelector.hpp

#ifndef __FISH_BONE_FRAGMENT_HPP
#define __FISH_BONE_FRAGMENT_HPP

#include <ocean/plankton/VValue.hpp>
#include <ocean/plankton/VObject.hpp>
#include <field/FragmentSelector.hpp>

#include "fishboneDllApi.h"

namespace Wizt
{

typedef RefPtr<Fiber::FragmentSelector> VFragmentSelector;

inline  string getExpression(const VFragmentSelector&FS, const string&fname)
{
        if (!FS)
                return "bool "+fname+"(vec4 p){return true;}"; 

        return FS->getExpression(fname);
}

template <>
class fishbone_API VOutput<Fiber::FragmentSelector> : public VOutput<VFragmentSelector>
{
public:
        VOutput(const WeakPtr<VObject>&Source,
                const string&initial_name,
                const VFragmentSelector&FS = NullPtr(),
                const RefPtr<VCreationPreferences>&CP = NullPtr() )
        : VOutput<VFragmentSelector>(Source, initial_name, FS, CP)
        {}
};

template <>
struct  VValueCopyTrait<MemCore::RefPtr<Fiber::FragmentSelector> >
{
static  MemCore::RefPtr<Fiber::FragmentSelector> copy(const MemCore::RefPtr<Fiber::FragmentSelector>&Source)
        {
//              if (!Source)
                return MemCore::NullPtr(); 

//              return RefPtr<Type>(new Type(*Source) );
        }
};

template <> 
class fishbone_API VValueTrait<VFragmentSelector>
{
public:

static  bool setValueFromText(VFragmentSelector&i, const string&s)
        {
                // NOT IMPLEMENTED
                return false;
        } 

static  string Text(const VFragmentSelector&VF)
        {
                return "<empty>";
        }
};

template <>
struct  fishbone_API TypedSlot<Fiber::FragmentSelector> : TypedSlot<VFragmentSelector>
{
        TypedSlot<Fiber::FragmentSelector>(VObject*that, const string&s, int prior=0); 
        ~TypedSlot();
};

} // namespace Wizt

#endif /* __FISH_BONE_FIELD_HPP */