NvTweakVar.h

Go to the documentation of this file.

// TAGRELEASE: PUBLIC

#ifndef NV_TWEAKVAR_H
#define NV_TWEAKVAR_H

#include <NvFoundation.h>

struct NvTweakVarBase {
protected:
    const char* mName; 
    const char* mDesc; 
    uint32_t mActionCode; 
        NvTweakVarBase(const char* name, const char *description=NULL)
    : mName(name)
    , mDesc(description)
    , mActionCode(0)
        {
        /*no-op*/
    }

public:
        virtual void increment() = 0;
        virtual void decrement() = 0;
        virtual void reset() = 0;
    const char *getName() { return mName; }
    const char *getDesc() { return mDesc; }

    void setActionCode(uint32_t code) { mActionCode = code; }
    uint32_t getActionCode() { return mActionCode; }
};


template<class T>
struct NvTweakVar : public NvTweakVarBase {
private:   
        NvTweakVar() {}
        NvTweakVar& operator=( const NvTweakVar& v) {}
        NvTweakVar( const NvTweakVar& v){}

protected:   
        T& mValRef; 
    T mValInitial; 
    T mValSelf; 
        T mValMin; 
        T mValMax; 
        T mValStep; 
        bool mValClamped; 
    bool mValLoop; 
public:
        operator T&() { return mValRef;}
        operator const T&() const { return mValRef;}
        const NvTweakVar& operator=( T val) { mValRef = val; return *this; }

        NvTweakVar( T& refVal, const char* name, T minVal, T maxVal, T step, char *description=NULL)
    : NvTweakVarBase(name, description)
    , mValRef(refVal)
    , mValInitial(refVal)
    , mValMin(minVal)
    , mValMax(maxVal)
    , mValStep((step==0)?1:step)
    , mValClamped(true)
    , mValLoop(false)
    {
        /* no-op */
    }

        NvTweakVar(const char* name, T minVal, T maxVal, T step, char *description=NULL)
    : NvTweakVarBase(name, description)
    , mValRef(mValSelf)
    , mValInitial(0)
    , mValSelf(0)
    , mValMin(minVal)
    , mValMax(maxVal)
    , mValStep((step==0)?1:step)
    , mValClamped(true)
    , mValLoop(false)
    {
        /* no-op */
    }

        NvTweakVar( T& refVal, const char* name, const char *description=NULL)
    : NvTweakVarBase(name, description)
    , mValRef(refVal)
    , mValInitial(refVal)
    , mValMin((T)0)
    , mValMax((T)0)
    , mValStep((T)1)
    , mValClamped(false)
    , mValLoop(false)
    {
        /* no-op */
    }

        NvTweakVar(const char* name, const char *description=NULL)
    : NvTweakVarBase(name, description)
    , mValRef(mValSelf)
    , mValInitial(0)
    , mValSelf(0)
    , mValMin((T)0)
    , mValMax((T)0)
    , mValStep((T)1)
    , mValClamped(false)
    , mValLoop(false)
    {
        /* no-op */
    }
    
    void setValLoop(bool loop) { mValLoop = loop; }

    virtual void increment();
    virtual void decrement();

        virtual void reset() {
        mValRef = mValInitial;
    }
};

struct NvTweakCmd {
    enum Enum {
        NONE = 0, 
        RESET, 
        INCREMENT, 
        DECREMENT, 
    };
};

struct NvTweakBind {
    NvTweakCmd::Enum mCmd;
    NvTweakVarBase *mVar;

    NvTweakBind()
        : mCmd(NvTweakCmd::NONE), mVar(NULL) { /* no-op */ };
    NvTweakBind(NvTweakCmd::Enum cmd, NvTweakVarBase *var)
        : mCmd(cmd), mVar(var) { /* no-op */ };
};

#endif //NV_TWEAKVAR_H

©2014 NVIDIA Corporation.