zoidcom_replicator_movement.h

Go to the documentation of this file.

/****************************************
* zoidcom_replicator_movement.h
* extrapolating replicator
*
* This file is part of the "Zoidcom Automated Networking System" application library.
* Copyright (C)2002-2007 by Joerg Rueppel. See documentation for copyright and licensing details.
*****************************************/


#ifndef _ZOIDREPLICATORMOVEMENT_H_
#define _ZOIDREPLICATORMOVEMENT_H_

#include "zoidcom.h"
#include "zoidcom_typehelper.h"

// forward
template <typename T, int SIZE> class ZCom_ReplicateMovementPrivate;



#define ZCOM_REPMOVE_USE_ERROR_FUNC                   (1L << 2)


// Replicator parameter class

template <typename T>
class ZCOM_API ZCom_RSetupMovement : public ZCom_RSetupNumeric
{
public:
  ZCOM_TAPI ZCom_RSetupMovement(zU8 _rbits, zU8 _flags, zU8 _rules, zU8 _intercept_id = 0,
                                  zS16 _mindelay = -1, zS16 _maxdelay = -1)
  : ZCom_RSetupNumeric(_rbits, _flags, _rules, _intercept_id, _mindelay, _maxdelay)
  {
    m_inputsizebits = 8;
    m_extflags = 0;
    m_interpolation_time = 100;
    m_error.constant = 25;
  }

  ZCOM_TAPI ZCom_ReplicatorSetup* Duplicate();

  void setInputsizeBits(zU8 _inputbits) { m_inputsizebits = _inputbits; }
  zU8 getInputsizeBits() const { return m_inputsizebits; }

  zU8 getExtendedFlags() const { return m_extflags; }

  void setConstantErrorThreshold(zFloat _threshold) { m_error.constant = _threshold; }
  zFloat getConstantErrorThreshold() const { return m_error.constant; }

  zU32 getInterpolationTime() const { return m_interpolation_time; }

  void setInterpolationTime(zU32 _time) { m_interpolation_time = _time; }

protected:
  zU8   m_extflags;
  zU8   m_inputsizebits;
  zU32  m_interpolation_time;

  // constant error threshold or error function
  union {
    zFloat constant;
  } m_error;
};

// Movement replicator callbacks

template <typename T>
class ZCOM_API ZCom_MoveUpdateListener
{
public:
  virtual void 
    inputUpdated(ZCom_BitStream& _inputstream, bool _inputchanged, zU32 _client_time, zU32 _estimated_time_sent) = 0;

  virtual void 
    inputSent(ZCom_BitStream& _inputstream) = 0;

  virtual void 
    correctionReceived(T *_pos, zFloat* _vel, zFloat *_acc, bool _teleport, zU32 _estimated_time_sent) = 0;

  virtual void 
    updateReceived(ZCom_BitStream& _inputstream, T *_pos, zFloat* _vel, zFloat *_acc, zU32 _estimated_time_sent) = 0;
};


// Movement replicator implementation

template <typename T, int SIZE>
class ZCOM_API ZCom_Replicate_Movement : public ZCom_ReplicatorAdvanced
{
  // make T a non-pointer
  typedef typename ZCom_TypeHelper<T>::value_type TYPE;
public:
  // forward
  class UpdateListener;
public:
  ZCOM_TAPI ZCom_Replicate_Movement(ZCom_RSetupMovement<TYPE>* _setup);
  ZCOM_TAPI ZCom_Replicate_Movement(zU8 _rbits, zU8 _flags, zU8 _rules, zU8 _intercept_id = 0,
    zS16 _mindelay = -1, zS16 _maxdelay = -1);
  ZCOM_TAPI ~ZCom_Replicate_Movement();

  ZCOM_TAPI void setTimeScale(zFloat _scale);

  ZCOM_TAPI void setUpdateListener(ZCom_MoveUpdateListener<TYPE> *_listener);

  ZCOM_TAPI void updateInput(T *_pos, ZCom_BitStream *_inputstream);

  ZCOM_TAPI ZCom_BitStream* getNextInputHistoryEntry(zU32* _deltatime, void** _iter);

  ZCOM_TAPI void updateState(TYPE *_newpos, zFloat *_newvel, zFloat *_newaccel, bool _teleport);

  ZCOM_TAPI void overrideState(TYPE *_newpos, zFloat *_newvel, zFloat *_newaccel, zS32 _time = 0);

  ZCOM_TAPI void getExtrapolatedPosition(zS32 _attime, TYPE *_data);

  ZCOM_TAPI void getExtrapolatedVelocity(zS32 _attime, zFloat *_data);

  ZCOM_TAPI void getAcceleration(zFloat *_data);

  ZCOM_TAPI void getLastReceivedPosition(T *_data);

  ZCOM_TAPI void getLastReceivedVelocity(zFloat *_data);

  ZCOM_TAPI void getSplinePoint(zFloat t, TYPE *_data);

  ZCOM_TAPI void getSplineControlPoint(zU32 _idx, TYPE *_data);

protected:
  ZCOM_TAPI virtual void onPreSendData(ZCom_ConnID _cid, eZCom_NodeRole _remoterole, zU32 *_lastupdate);
  ZCOM_TAPI virtual void onDataReceived(ZCom_ConnID _cid, eZCom_NodeRole _remoterole, ZCom_BitStream &_stream,
                                       bool _store, zU32 _estimated_time_sent);
  ZCOM_TAPI virtual void onDataLost(ZCom_ConnID _cid, zU32 _reference_id, ZCom_BitStream *_data);
  ZCOM_TAPI virtual void onDataAcked(ZCom_ConnID _cid, zU32 _reference_id, ZCom_BitStream *_data);
  ZCOM_TAPI virtual void onPacketReceived(ZCom_ConnID _cid);
  ZCOM_TAPI virtual void onConnectionAdded(ZCom_ConnID _cid, eZCom_NodeRole _remoterole);
  ZCOM_TAPI virtual void onConnectionRemoved(ZCom_ConnID _cid, eZCom_NodeRole _remoterole);
  ZCOM_TAPI virtual void onLocalRoleChanged(eZCom_NodeRole _oldrole, eZCom_NodeRole _newrole);
  ZCOM_TAPI virtual void onRemoteRoleChanged(ZCom_ConnID _cid, eZCom_NodeRole _oldrole, eZCom_NodeRole _newrole) {};

  ZCOM_TAPI virtual void  Process(eZCom_NodeRole _localrole, zU32 _simulation_time_passed);
  ZCOM_TAPI virtual void* peekData();
  ZCOM_TAPI virtual void  clearPeekData() {};
protected:
  ZCom_ReplicateMovementPrivate<T, SIZE> *m_priv;
};

#endif

---