766 lines
31 KiB
Plaintext
766 lines
31 KiB
Plaintext
// Filename: smoothMover.I
|
|
// Created by: drose (19Oct01)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// PANDA 3D SOFTWARE
|
|
// Copyright (c) Carnegie Mellon University. All rights reserved.
|
|
//
|
|
// All use of this software is subject to the terms of the revised BSD
|
|
// license. You should have received a copy of this license along
|
|
// with this source code in a file named "LICENSE."
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_pos
|
|
// Access: Published
|
|
// Description: Specifies the position of the SmoothMover at a
|
|
// particular time in the past. When mark_position() is
|
|
// called, this will be recorded (along with hpr and
|
|
// timestamp) in a position report, which will then be
|
|
// used along with all other position reports to
|
|
// determine the smooth position at any particular
|
|
// instant.
|
|
//
|
|
// The return value is true if any parameter has changed
|
|
// since the last call to set_pos(), or false if they
|
|
// are the same.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_pos(const LVecBase3 &pos) {
|
|
return set_x(pos[0]) | set_y(pos[1]) | set_z(pos[2]);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_pos
|
|
// Access: Published
|
|
// Description: Specifies the position of the SmoothMover at a
|
|
// particular time in the past. When mark_position() is
|
|
// called, this will be recorded (along with hpr and
|
|
// timestamp) in a position report, which will then be
|
|
// used along with all other position reports to
|
|
// determine the smooth position at any particular
|
|
// instant.
|
|
//
|
|
// The return value is true if any parameter has changed
|
|
// since the last call to set_pos(), or false if they
|
|
// are the same.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_pos(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
|
|
return set_x(x) | set_y(y) | set_z(z);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_x
|
|
// Access: Published
|
|
// Description: Sets the X position only. See set_pos().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_x(PN_stdfloat x) {
|
|
bool result = (x != _sample._pos[0]);
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_x " << x << "\n";
|
|
}
|
|
*/
|
|
_sample._pos[0] = x;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_y
|
|
// Access: Published
|
|
// Description: Sets the Y position only. See set_pos().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_y(PN_stdfloat y) {
|
|
bool result = (y != _sample._pos[1]);
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_y " << y << "\n";
|
|
}
|
|
*/
|
|
_sample._pos[1] = y;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_z
|
|
// Access: Published
|
|
// Description: Sets the Z position only. See set_pos().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_z(PN_stdfloat z) {
|
|
bool result = (z != _sample._pos[2]);
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_z " << z << "\n";
|
|
}
|
|
*/
|
|
_sample._pos[2] = z;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_hpr
|
|
// Access: Published
|
|
// Description: Specifies the orientation of the SmoothMover at a
|
|
// particular time in the past. When mark_position() is
|
|
// called, this will be recorded (along with hpr and
|
|
// timestamp) in a position report, which will then be
|
|
// used along with all other position reports to
|
|
// determine the smooth position at any particular
|
|
// instant.
|
|
//
|
|
// The return value is true if any parameter has changed
|
|
// since the last call to set_hpr(), or false if they
|
|
// are the same.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_hpr(const LVecBase3 &hpr) {
|
|
return set_h(hpr[0]) | set_p(hpr[1]) | set_r(hpr[2]);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_hpr
|
|
// Access: Published
|
|
// Description: Specifies the orientation of the SmoothMover at a
|
|
// particular time in the past. When mark_position() is
|
|
// called, this will be recorded (along with hpr and
|
|
// timestamp) in a position report, which will then be
|
|
// used along with all other position reports to
|
|
// determine the smooth position at any particular
|
|
// instant.
|
|
//
|
|
// The return value is true if any parameter has changed
|
|
// since the last call to set_hpr(), or false if they
|
|
// are the same.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_hpr(PN_stdfloat h, PN_stdfloat p, PN_stdfloat r) {
|
|
return set_h(h) | set_p(p) | set_r(r);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_h
|
|
// Access: Published
|
|
// Description: Sets the heading only. See set_hpr().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_h(PN_stdfloat h) {
|
|
bool result = (h != _sample._hpr[0]);
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_h " << h << "\n";
|
|
}
|
|
*/
|
|
_sample._hpr[0] = h;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_p
|
|
// Access: Published
|
|
// Description: Sets the pitch only. See set_hpr().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_p(PN_stdfloat p) {
|
|
bool result = (p != _sample._hpr[1]);
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_p " << p << "\n";
|
|
}
|
|
*/
|
|
_sample._hpr[1] = p;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_r
|
|
// Access: Published
|
|
// Description: Sets the roll only. See set_hpr().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_r(PN_stdfloat r) {
|
|
bool result = (r != _sample._hpr[2]);
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_r " << r << "\n";
|
|
}
|
|
*/
|
|
_sample._hpr[2] = r;
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_pos_hpr
|
|
// Access: Published
|
|
// Description: Specifies the position and orientation of the SmoothMover at a
|
|
// particular time in the past. When mark_position() is
|
|
// called, this will be recorded (along with
|
|
// timestamp) in a position report, which will then be
|
|
// used along with all other position reports to
|
|
// determine the smooth position at any particular
|
|
// instant.
|
|
//
|
|
// The return value is true if any parameter has changed
|
|
// since the last call to set_pos_hpr(), or false if they
|
|
// are the same.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_pos_hpr(const LVecBase3 &pos, const LVecBase3 &hpr) {
|
|
return (set_x(pos[0]) | set_y(pos[1]) | set_z(pos[2]) |
|
|
set_h(hpr[0]) | set_p(hpr[1]) | set_r(hpr[2]));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_pos_hpr
|
|
// Access: Published
|
|
// Description: Specifies the position of the SmoothMover at a
|
|
// particular time in the past. When mark_position() is
|
|
// called, this will be recorded (along with
|
|
// timestamp) in a position report, which will then be
|
|
// used along with all other position reports to
|
|
// determine the smooth position at any particular
|
|
// instant.
|
|
//
|
|
// The return value is true if any parameter has changed
|
|
// since the last call to set_pos_hpr(), or false if they
|
|
// are the same.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
set_pos_hpr(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z, PN_stdfloat h, PN_stdfloat p, PN_stdfloat r) {
|
|
return set_x(x) | set_y(y) | set_z(z) | set_h(h) | set_p(p) | set_r(r);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_sample_pos
|
|
// Access: Published
|
|
// Description: Returns the current position of the working sample
|
|
// point. This position is updated periodically by
|
|
// set_x(), set_y(), etc., and its current value is
|
|
// copied to the sample point table when
|
|
// mark_position() is called.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE const LPoint3 &SmoothMover::
|
|
get_sample_pos() const {
|
|
return _sample._pos;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_sample_hpr
|
|
// Access: Published
|
|
// Description: Returns the current orientation of the working sample
|
|
// point. This orientation is updated periodically by
|
|
// set_h(), set_p(), etc., and its current value is
|
|
// copied to the sample point table when
|
|
// mark_position() is called.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE const LVecBase3 &SmoothMover::
|
|
get_sample_hpr() const {
|
|
return _sample._hpr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_phony_timestamp
|
|
// Access: Published
|
|
// Description: Lies and specifies that the current position report
|
|
// was received now. This is usually used for very old
|
|
// position reports for which we're not sure of the
|
|
// actual receipt time.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_phony_timestamp(double timestamp, bool period_adjust) {
|
|
double now = ClockObject::get_global_clock()->get_frame_time();
|
|
if (timestamp != 0.0)
|
|
// we were given a specific timestamp to use
|
|
now = timestamp;
|
|
|
|
// adjust by _delay when creating the timestamp since other
|
|
// timestamps received from network updates are adjusted by this
|
|
if (period_adjust) {
|
|
_sample._timestamp = now - _expected_broadcast_period;
|
|
}
|
|
else
|
|
_sample._timestamp = now;
|
|
|
|
_has_most_recent_timestamp = true;
|
|
_most_recent_timestamp = _sample._timestamp;
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_timestamp
|
|
// Access: Published
|
|
// Description: Specifies the time that the current position report
|
|
// applies. This should be called, along with set_pos()
|
|
// and set_hpr(), before a call to mark_position().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_timestamp(double timestamp) {
|
|
/*
|
|
if (deadrec_cat.is_debug()) {
|
|
deadrec_cat.debug() << "set_timestamp " << timestamp << "\n";
|
|
}
|
|
*/
|
|
_sample._timestamp = timestamp;
|
|
_has_most_recent_timestamp = true;
|
|
_most_recent_timestamp = timestamp;
|
|
record_timestamp_delay(timestamp);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::has_most_recent_timestamp
|
|
// Access: Published
|
|
// Description: Returns true if we have most recently recorded timestamp
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
has_most_recent_timestamp() const {
|
|
return _has_most_recent_timestamp;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_most_recent_timestamp
|
|
// Access: Published
|
|
// Description: Returns most recently recorded timestamp
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double SmoothMover::
|
|
get_most_recent_timestamp() const {
|
|
return _most_recent_timestamp;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::compute_smooth_position
|
|
// Access: Published
|
|
// Description: Computes the smoothed position (and orientation) of
|
|
// the mover at the indicated point in time, based on
|
|
// the previous position reports. After this call has
|
|
// been made, get_smooth_pos() etc. may be called to
|
|
// retrieve the smoothed position.
|
|
//
|
|
// With no parameter, the function uses
|
|
// ClockObject::get_frame_time() as the default time.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
compute_smooth_position() {
|
|
return compute_smooth_position(ClockObject::get_global_clock()->get_frame_time());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_smooth_pos
|
|
// Access: Published
|
|
// Description: Returns the smoothed position as computed by a
|
|
// previous call to compute_smooth_position().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE const LPoint3 &SmoothMover::
|
|
get_smooth_pos() const {
|
|
return _smooth_pos;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_forward_axis
|
|
// Access: Published
|
|
// Description: Returns the smoothed position as computed by a
|
|
// previous call to compute_smooth_position().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE const LVecBase3 &SmoothMover::
|
|
get_forward_axis() const {
|
|
return _forward_axis;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_smooth_hpr
|
|
// Access: Published
|
|
// Description: Returns the smoothed orientation as computed by a
|
|
// previous call to compute_smooth_position().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE const LVecBase3 &SmoothMover::
|
|
get_smooth_hpr() const {
|
|
return _smooth_hpr;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::apply_smooth_pos
|
|
// Access: Published
|
|
// Description: Applies the smoothed position to the indicated
|
|
// NodePath. This is equivalent to calling
|
|
// node.set_pos(smooth_mover->get_smooth_pos()). It
|
|
// exists as an optimization only, to avoid the overhead
|
|
// of passing the return value through Python.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
apply_smooth_pos(NodePath &node) const {
|
|
node.set_pos(get_smooth_pos());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::apply_smooth_pos_hpr
|
|
// Access: Published
|
|
// Description: Applies the smoothed position and orientation to the
|
|
// indicated NodePath. This is equivalent to calling
|
|
// node.set_pos_hpr(smooth_mover->get_smooth_pos(),
|
|
// smooth_mover->get_smooth_hpr()). It exists as an
|
|
// optimization only, to avoid the overhead of passing
|
|
// the return value through Python.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
apply_smooth_pos_hpr(NodePath &pos_node, NodePath &hpr_node) const {
|
|
pos_node.set_pos(get_smooth_pos());
|
|
hpr_node.set_hpr(get_smooth_hpr());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::apply_smooth_hpr
|
|
// Access: Published
|
|
// Description: Applies the smoothed orientation to the indicated
|
|
// NodePath. This is equivalent to calling
|
|
// node.set_hpr(smooth_mover->get_smooth_hpr()). It
|
|
// exists as an optimization only, to avoid the overhead
|
|
// of passing the return value through Python.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
apply_smooth_hpr(NodePath &node) const {
|
|
node.set_hpr(get_smooth_hpr());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::compute_and_apply_smooth_pos
|
|
// Access: Published
|
|
// Description: A further optimization to reduce Python calls. This
|
|
// computes the smooth position and applies it to the
|
|
// indicated node in one call.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
compute_and_apply_smooth_pos(NodePath &node) {
|
|
if (compute_smooth_position()) {
|
|
apply_smooth_pos(node);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::compute_and_apply_smooth_pos_hpr
|
|
// Access: Published
|
|
// Description: A further optimization to reduce Python calls. This
|
|
// computes the smooth position and applies it to the
|
|
// indicated node or nodes in one call. The pos_node
|
|
// and hpr_node might be the same NodePath.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
compute_and_apply_smooth_pos_hpr(NodePath &pos_node, NodePath &hpr_node) {
|
|
if (compute_smooth_position()) {
|
|
apply_smooth_pos(pos_node);
|
|
apply_smooth_hpr(hpr_node);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::compute_and_apply_smooth_pos_hpr
|
|
// Access: Published
|
|
// Description: A further optimization to reduce Python calls. This
|
|
// computes the smooth position and applies it to the
|
|
// indicated node or nodes in one call. The pos_node
|
|
// and hpr_node might be the same NodePath.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
compute_and_apply_smooth_hpr(NodePath &hpr_node) {
|
|
if (compute_smooth_position()) {
|
|
apply_smooth_hpr(hpr_node);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_smooth_forward_velocity
|
|
// Access: Published
|
|
// Description: Returns the speed at which the avatar is moving, in
|
|
// feet per second, along its own forward axis (after
|
|
// applying the avatar's hpr). This will be a positive
|
|
// number if the avatar is moving forward, and a
|
|
// negative number if it is moving backward.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE PN_stdfloat SmoothMover::
|
|
get_smooth_forward_velocity() const {
|
|
return _smooth_forward_velocity;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_smooth_lateral_velocity
|
|
// Access: Published
|
|
// Description: Returns the speed at which the avatar is moving, in
|
|
// feet per second, along its own lateral axis (after
|
|
// applying the avatar's hpr). This will be a positive
|
|
// number if the avatar is moving right, and a
|
|
// negative number if it is moving left.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE PN_stdfloat SmoothMover::
|
|
get_smooth_lateral_velocity() const {
|
|
return _smooth_lateral_velocity;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_smooth_rotational_velocity
|
|
// Access: Published
|
|
// Description: Returns the speed at which the avatar is rotating in
|
|
// the horizontal plane (i.e. heading), in degrees per
|
|
// second. This may be positive or negative, according
|
|
// to the direction of rotation.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE PN_stdfloat SmoothMover::
|
|
get_smooth_rotational_velocity() const {
|
|
return _smooth_rotational_velocity;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_smooth_mode
|
|
// Access: Published, Static
|
|
// Description: Sets the smoothing mode of all SmoothMovers in the
|
|
// world. If this is SM_off, no smoothing or prediction
|
|
// will be performed, and get_smooth_pos() will simply
|
|
// return the position last set by mark_position().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_smooth_mode(SmoothMover::SmoothMode mode) {
|
|
_smooth_mode = mode;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_smooth_mode
|
|
// Access: Published, Static
|
|
// Description: Returns the smoothing mode of all SmoothMovers in the
|
|
// world. See set_smooth_mode().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE SmoothMover::SmoothMode SmoothMover::
|
|
get_smooth_mode() {
|
|
return _smooth_mode;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_prediction_mode
|
|
// Access: Published, Static
|
|
// Description: Sets the predictioning mode of all SmoothMovers in the
|
|
// world. If this is PM_off, no prediction will be
|
|
// performed, but smoothing might still be performed.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_prediction_mode(SmoothMover::PredictionMode mode) {
|
|
_prediction_mode = mode;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_prediction_mode
|
|
// Access: Published, Static
|
|
// Description: Returns the predictioning mode of all SmoothMovers in the
|
|
// world. See set_prediction_mode().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE SmoothMover::PredictionMode SmoothMover::
|
|
get_prediction_mode() {
|
|
return _prediction_mode;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_delay
|
|
// Access: Published, Static
|
|
// Description: Sets the amount of time, in seconds, to delay the
|
|
// computed position of a SmoothMover. This is
|
|
// particularly useful when the prediction mode is off,
|
|
// because it can allow the apparent motion of an avatar
|
|
// to appear smooth without relying on prediction, at
|
|
// the cost of introducing additional lag in the
|
|
// avatar's apparent position.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_delay(double delay) {
|
|
_delay = delay;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_delay
|
|
// Access: Published, Static
|
|
// Description: Returns the amount of time, in seconds, to delay the
|
|
// computed position of a SmoothMover. See set_delay().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double SmoothMover::
|
|
get_delay() {
|
|
return _delay;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_accept_clock_skew
|
|
// Access: Published, Static
|
|
// Description: Sets the 'accept clock skew' flag. When this flag is
|
|
// true, clock skew from the other clients will be
|
|
// tolerated by delaying each smooth mover's position an
|
|
// additional amount, on top of that specified by
|
|
// set_delay(), based on the measured average latency
|
|
// for timestamp messages received by the client.
|
|
//
|
|
// In this way, if the other client has significant
|
|
// clock skew with respect to our clock, it will be
|
|
// evident as a large positive or negative average
|
|
// latency for timestamps. By subtracting out this
|
|
// average latency, we compensate for poor clock sync.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_accept_clock_skew(bool flag) {
|
|
_accept_clock_skew = flag;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_accept_clock_skew
|
|
// Access: Published, Static
|
|
// Description: Returns the current state of the 'accept clock skew'
|
|
// flag. See set_accept_clock_skew().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
get_accept_clock_skew() {
|
|
return _accept_clock_skew;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_max_position_age
|
|
// Access: Published, Static
|
|
// Description: Sets the maximum amount of time a position is allowed
|
|
// to remain unchanged before assuming it represents the
|
|
// avatar actually standing still.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_max_position_age(double age) {
|
|
_max_position_age = age;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_max_position_age
|
|
// Access: Published, Static
|
|
// Description: Returns the maximum amount of time a position is
|
|
// allowed to remain unchanged before assuming it
|
|
// represents the avatar actually standing still.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double SmoothMover::
|
|
get_max_position_age() {
|
|
return _max_position_age;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_expected_broadcast_period
|
|
// Access: Published, Static
|
|
// Description: Sets the interval at which we expect the SmoothNodes
|
|
// to broadcast their position, in elapsed seconds.
|
|
// This controls the length of time we assume the object
|
|
// has truly stopped, when we receive a long sequence of
|
|
// no updates.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_expected_broadcast_period(double period) {
|
|
_expected_broadcast_period = period;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_expected_broadcast_period
|
|
// Access: Published, Static
|
|
// Description: Returns the interval at which we expect the SmoothNodes
|
|
// to broadcast their position, in elapsed seconds. See
|
|
// set_expected_broadcast_period().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double SmoothMover::
|
|
get_expected_broadcast_period() {
|
|
return _expected_broadcast_period;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_reset_velocity_age
|
|
// Access: Published, Static
|
|
// Description: Sets the amount of time that should elapse after the
|
|
// last position report before the velocity is reset to
|
|
// 0. This is similar to max_position_age, but it is
|
|
// only used to determine the resetting of the reported
|
|
// velocity. It should always be greater than or equal
|
|
// to max_position_age.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_reset_velocity_age(double age) {
|
|
_reset_velocity_age = age;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_reset_velocity_age
|
|
// Access: Published, Static
|
|
// Description: Returns the amount of time that should elapse after
|
|
// the last position report before the velocity is reset
|
|
// to 0. See set_reset_velocity_age().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double SmoothMover::
|
|
get_reset_velocity_age() {
|
|
return _reset_velocity_age;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_directional_velocity
|
|
// Access: Published, Static
|
|
// Description: Sets the flag that indicates whether the avatar's
|
|
// direction is considered in computing the velocity.
|
|
// When this is true, velocity is automatically
|
|
// decomposed into a forward and a lateral velocity (and
|
|
// both may be positive or negative); when it is false,
|
|
// all velocity is always returned as forward velocity
|
|
// (and it is always positive).
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_directional_velocity(bool flag) {
|
|
_directional_velocity = flag;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_directional_velocity
|
|
// Access: Published, Static
|
|
// Description: Returns the current state of the 'directional
|
|
// velocity' flag. See set_directional_velocity().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
get_directional_velocity() {
|
|
return _directional_velocity;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::set_default_to_standing_still
|
|
// Access: Published, Static
|
|
// Description: Sets the flag that indicates whether to assume that
|
|
// the node stopped moving during periods when we don't
|
|
// get enough position updates. If true, the object will
|
|
// stand still momentarily. If false, the object will
|
|
// continuously lerp between the position updates that
|
|
// we did get.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void SmoothMover::
|
|
set_default_to_standing_still(bool flag) {
|
|
_default_to_standing_still = flag;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_default_to_standing_still
|
|
// Access: Published, Static
|
|
// Description: Returns the current state of the 'default to standing
|
|
// still' flag. See set_default_to_standing_still().
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE bool SmoothMover::
|
|
get_default_to_standing_still() {
|
|
return _default_to_standing_still;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: SmoothMover::get_avg_timestamp_delay
|
|
// Access: Private
|
|
// Description: Returns the average delay observed in the last n
|
|
// timestamps received from this client, in seconds.
|
|
// This number represents the combination of the network
|
|
// lag from this client, as well as the client's clock
|
|
// skew relative to our clock. It could be negative if
|
|
// the client's clock is running faster than our clock.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double SmoothMover::
|
|
get_avg_timestamp_delay() const {
|
|
nassertr(!_timestamp_delays.empty(), 0.0);
|
|
return (double)_net_timestamp_delay / (double)_timestamp_delays.size() / 1000.0;
|
|
}
|