DataBlock_Predict_Float.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __DATABLOCK_PREDICT_FLOAT_H__
#define __DATABLOCK_PREDICT_FLOAT_H__

#include "RNReplicaNet/Inc/DataBlock.h"
#include "RNPlatform/Inc/RegistryManagerMap.h"

namespace RNReplicaNet
{

class DataBlock_Predict_Float : public DataBlock
{
public:
    RN_CLASS_MINIMAL_RTTI();
    DataBlock_Predict_Float();

    virtual ~DataBlock_Predict_Float();

    virtual void Poll(DataBlockReason *reason,const bool discardOlderIncluded = false,const unsigned int discardOrder = 0);

    virtual void ParseMessage(MessageHelper *message);

    virtual void GiveDeltaHint(void *pdata,int dataLen);

    virtual void GiveDeltaHint(const float delta);

    virtual void ContinuityBreak(unsigned char breakTypes);

    virtual bool GetLastDelta(bool &continuityBreak, float &sample, SysTimeType &time, float &delta);

    bool IsAttached(void *data);

    static DataBlock_Predict_Float *Register(float *data);

    void RegisterInClassPointer(float *data)
    {
        mData = data;
    }

    void SetMinError(float minerror = 0.1f);

    void SetMaxError(float maxerror = 1.0f);

    void SetMinDistance(float distance = 0.1f);

    void SetMaxDistance(float distance = 1.0f);

    void SetInterpolationFilter(float interpolation = 0.1f);

    void SetQuadratic(void)
    {
        mIsQuadratic = true;
    }

    void SetLinear(void)
    {
        mIsQuadratic = false;
    }

    void SetLagged(const float time = 0.0f);

    void SetSnapToDifference(const float difference = -1.0f);

    void BoundaryEnable(void);

    void BoundaryDisable(void);

    void BoundaryWrapAround(void);

    void BoundaryCapped(void);

    void BoundaryLowerUpper(const float lower,const float upper);

    void BoundaryApplyToMaster(void);

    void BoundaryDoNotApplyToMaster(void);

    static bool BoundaryApplyToValue(ReplicaObject *object,float &value);

    void SetValueFloat(void);

    void SetValueShortFloat(void);

    void SetDeltaFloat(void);

    void SetDeltaShortFloat(void);

    void ReplicaContinuityBreak(const SysTimeType time, const float sample, const float delta, const bool continuityBreak, const bool ignoreTimeCheck = false, const bool clearPreviousUpdates = false);

    void SetTimeDelta(const float timeDelta = 0.0f);

protected:  // User defined DataBlocks have access to these variables.
    float *mData;
    bool mContinuityBreak;
    bool mIsDistanceBased;
    float mMinDistance;
    float mMaxDistance;
    float mMinError;
    bool mIsQuadratic;
    bool mGotData;
    bool mImplementTeleport;
    bool mDoPrep;


    float mTestData;

    float mMaxError;
    float mInterpolationFilter;


    struct SessionBlock_Predict_Float
    {
        SessionBlock_Predict_Float();

        virtual ~SessionBlock_Predict_Float();

        unsigned int mDiscardOrder;
        bool mContinuityBreak;
        float mTestData;
        float mDelta;

        float mSample;
        SysTimeType mSampleTime;

        bool mImplementTeleport;

        // Forced updates
        // This works off local time, not network time
        SysTimeType mLastUpdateSentLocalTime;
        int mNumForcedUpdates;
    };

    RegistryManagerMap<int,SessionBlock_Predict_Float> mPerSessionData;

    struct ReplicaData
    {
        bool mFirstTime;
        bool mFirstTimeNotReset;

        float mDelta;
        float mSample;
        SysTimeType mSampleTime;
    };

    ReplicaData mReplicaData;

    struct MasterData
    {
        float mDelta;
        float mSample;
        SysTimeType mSampleTime;
        float mSampleHistory[2];
        SysTimeType mSampleHistoryTime[2];          // This is the network time and is used as values to send to any replicas
        SysTimeType mSampleHistoryTimeLocal[2];     // This is the local time and is only used to calculate deltas
        bool mGotDeltaHint;
        float mTheDeltaHint;
    };
    MasterData mMasterData;

    bool mDoneMasterPoll;

    // When lagged parsing is enabled any incoming replica packets are stored with this structure into mParsedByTime
    struct ParsedData
    {
        float mSample;
        float mDelta;
        bool mFirstTime;
    };
    std::map<SysTimeType,ParsedData> mParsedByTime;

    float mLagged;
    SysTimeType mFirstLaggedTime;

    float mSnapToDifference;

    bool mBoundaryEnable;
    bool mBoundaryIsWrap;
    float mBoundaryLower,mBoundaryUpper;
    bool mBoundaryWriteBack;

    float ApplyBoundaryToValue(const float value) const;

    SysTimeType mLastGoodDataTime;

    bool mShortValue;
    bool mShortDelta;

    int AddDataBlockData(DynamicMessageHelper *message,const float sample,const SysTimeType time,const float delta);

    float mTimeDelta;

    void FreeSessionBlocks(void);

    float CalculateReplicaValue(DataBlockReason *reason);
};

} // namespace RNReplicaNet

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_VAR macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_VAR(x)   \
    {\
        RNReplicaNet::DataBlock_Predict_Float *datablock = 0;   \
        datablock = RNReplicaNet::DataBlock_Predict_Float::Register(&(basepoint->x));   \
        _RO_DO_SETDATABLOCKVARIABLENAME(x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_VAR macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMAXERROR macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMAXERROR(x)   \
        datablock->SetMaxError((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMAXERROR macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMINERROR macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMINERROR(x)   \
        datablock->SetMinError((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMINERROR macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETERROR macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETERROR(x)  \
        datablock->SetMinError((float)x);   \
        datablock->SetMaxError((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETERROR macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMINDISTANCE macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMINDISTANCE(x)    \
        datablock->SetMinDistance((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMINDISTANCE macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMAXDISTANCE macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMAXDISTANCE(x)    \
        datablock->SetMaxDistance((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETMAXDISTANCE macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETINTERPOLATIONFILTER macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETINTERPOLATIONFILTER(x)    \
        datablock->SetInterpolationFilter((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETINTERPOLATIONFILTER macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETLINEAR macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETLINEAR()  \
        datablock->SetLinear();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETLINEAR macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETQUADRATIC macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETQUADRATIC()   \
        datablock->SetQuadratic();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETQUADRATIC macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETLAGGED macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETLAGGED(x) \
        datablock->SetLagged((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETLAGGED macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETSNAPTODIFFERENCE macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETSNAPTODIFFERENCE(x)   \
        datablock->SetSnapToDifference((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETSNAPTODIFFERENCE macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYENABLE macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYENABLE() \
        datablock->BoundaryEnable();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYENABLE macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYDISABLE macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYDISABLE()    \
        datablock->BoundaryDisable();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYDISABLE macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYWRAPAROUND macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYWRAPAROUND() \
        datablock->BoundaryWrapAround();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYWRAPAROUND macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYCAPPED macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYCAPPED() \
        datablock->BoundaryCapped();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYCAPPED macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYLOWERUPPER macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYLOWERUPPER(x,y)  \
        datablock->BoundaryLowerUpper((float)x,(float)y);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYLOWERUPPER macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYAPPLYTOMASTER macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYAPPLYTOMASTER()  \
        datablock->BoundaryApplyToMaster();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYAPPLYTOMASTER macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYDONOTAPPLYTOMASTER macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYDONOTAPPLYTOMASTER() \
        datablock->BoundaryDoNotApplyToMaster();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_BOUNDARYDONOTAPPLYTOMASTER macro ends here */



/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETVALUEFLOAT macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETVALUEFLOAT()  \
        datablock->SetValueFloat();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETVALUEFLOAT macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETVALUESHORTFLOAT macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETVALUESHORTFLOAT() \
        datablock->SetValueShortFloat();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETVALUESHORTFLOAT macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETDELTAFLOAT macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETDELTAFLOAT()  \
        datablock->SetDeltaFloat();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETDELTAFLOAT macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETDELTASHORTFLOAT macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETDELTASHORTFLOAT() \
        datablock->SetDeltaShortFloat();
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETDELTASHORTFLOAT macro ends here */

/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETTIMEDELTA macro starts here */
#define _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETTIMEDELTA(x)  \
    datablock->SetTimeDelta((float)x);
/* _RO_DO_REGISTERBLOCK_PREDICT_FLOAT_SETTIMEDELTA macro ends here */

#endif