cValueCurve.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cValueCurve_H
#define _INC_cValueCurve_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cArray.h"
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class GRAYLIB_LINK cArrayVal<float>;
}
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cValueCurvef);
        class cVariant;
 
        template < typename TYPE = float >
        class GRAYLIB_LINK cValueCurveT
        {
        public:
                typedef cValueCurveT<TYPE> THIS_t;
                typedef TYPE VALUE_t;           
 
        protected:
                cArrayVal<VALUE_t> m_aValues;           
 
        public:
                cValueCurveT() noexcept
                {
                }
                cValueCurveT(const THIS_t& src)
                {
                        m_aValues.SetCopy(src.m_aValues);
                }
                THIS_t& operator = (const THIS_t& src)
                {
                        m_aValues.SetCopy(src.m_aValues);
                        return(*this);
                }
 
                bool isEmpty() const noexcept
                {
                        return m_aValues.IsEmpty();
                }
                void Init()
                {
                        m_aValues.RemoveAll();
                }
 
                ITERATE_t get_EnumQty() const
                {
                        return m_aValues.GetSize();
                }
                VALUE_t EnumValue(ITERATE_t i) const
                {
                        return m_aValues[i];
                }
                VALUE_t EnumValueCheck(ITERATE_t i) const
                {
                        if (!m_aValues.IsValidIndex(i))
                                return 0;
                        return m_aValues[i];
                }
 
                static VALUE_t GRAYCALL GetLinearA(const VALUE_t* pnArray, ITERATE_t iQty, ITERATE_t iSelect, ITERATE_t iSelectRange)
                {
                        ASSERT(iSelectRange > 1);
                        ITERATE_t iIndex;       // interpolate between this index and the one after it.
                        ITERATE_t iSelectElement = 0;   // single element range.
                        switch (iQty)
                        {
                        case 0:
                                return(0);      // no values defined !
                        case 1:
                                // iSelect value is irrelevant.
                                return(pnArray[0]);
                        case 2:
                                iIndex = 0;
                                break;
                        default:
                                iIndex = Calc::MulDiv<ITERATE_t>(iSelect, iQty, iSelectRange);
                                iQty--;
                                if (iIndex < 0)
                                        iIndex = 0;
                                if (iIndex >= iQty)
                                        iIndex = iQty - 1;
                                iSelectElement = iSelectRange / iQty;
                                iSelect -= (iIndex * iSelectElement);
                                break;
                        }
 
                        // linear interpolate the 2 nearest values.
                        VALUE_t nLoVal = pnArray[iIndex + 0];
                        VALUE_t nHiVal = pnArray[iIndex + 1];
                        VALUE_t nVal = nLoVal + Calc::MulDiv<VALUE_t>(nHiVal - nLoVal, (VALUE_t)iSelect, (VALUE_t)iSelectElement);
 
                        // NOTE: nVal can be extrapolated above or below the range.
                        //  i.e. nVal can be negative.
                        return(nVal);
                }
 
                VALUE_t GetLinearN(ITERATE_t iSelect, ITERATE_t iSelectRange) const
                {
                        if (iSelectRange <= 0)
                        {
                                iSelect = 0;
                                iSelectRange = 1;
                        }
                        return(GetLinearA(m_aValues.GetData(), m_aValues.GetSize(), iSelect, iSelectRange));
                }
 
                VALUE_t GetLinear1(float fOne) const
                {
                        return(GetLinearA(m_aValues.GetData(), m_aValues.GetSize(), (ITERATE_t)(fOne * SHRT_MAX), SHRT_MAX));
                }
 
                void SetValues(ITERATE_t iQty, const VALUE_t* pnVals)
                {
                        ASSERT(pnVals != nullptr);
                        m_aValues.SetSize(iQty);
                        for (ITERATE_t i = 0; i < iQty; i++)
                        {
                                m_aValues.SetAt(i, pnVals[i]);
                        }
                }
                void SetValuesRange(VALUE_t nLo, VALUE_t nHi)
                {
                        m_aValues.SetSize(2);
                        m_aValues.SetAt(0, nLo);
                        m_aValues.SetAt(1, nHi);
                }
        };
 
        class GRAYLIB_LINK cValueCurvef : public cValueCurveT<float>
        {
        public:
                cValueCurvef() noexcept
                {
                }
                cValueCurvef(const cValueCurvef& src)
                        : cValueCurveT<float>(src)
                {
                }
 
                bool v_SetCurve(const cVariant& vVal);
                void v_GetCurve(cVariant& vVal) const;
 
                VALUE_t GetLinearF(float fAge, float fLife) const;
                VALUE_t GetLinear1000(int iPercent1000) const;
                VALUE_t GetChance1000(int iPercent1000) const;
 
                UNITTEST_FRIEND(cValueCurvef);
        };
}
 
#endif // _INC_cValueCurve_H