52 set_pos(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
63 bool result = (x != _sample._pos[0]);
80 bool result = (y != _sample._pos[1]);
97 bool result = (z != _sample._pos[2]);
143 set_hpr(PN_stdfloat h, PN_stdfloat p, PN_stdfloat r) {
154 bool result = (h != _sample._hpr[0]);
171 bool result = (p != _sample._hpr[1]);
188 bool result = (r != _sample._hpr[2]);
235 set_pos_hpr(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z, PN_stdfloat h, PN_stdfloat p, PN_stdfloat r) {
278 if (timestamp != 0.0)
285 _sample._timestamp = now - _expected_broadcast_period;
288 _sample._timestamp = now;
290 _has_most_recent_timestamp =
true;
291 _most_recent_timestamp = _sample._timestamp;
309 _sample._timestamp = timestamp;
310 _has_most_recent_timestamp =
true;
311 _most_recent_timestamp = timestamp;
312 record_timestamp_delay(timestamp);
322 return _has_most_recent_timestamp;
332 return _most_recent_timestamp;
371 return _forward_axis;
485 return _smooth_forward_velocity;
499 return _smooth_lateral_velocity;
512 return _smooth_rotational_velocity;
548 _prediction_mode = mode;
559 return _prediction_mode;
607 _accept_clock_skew = flag;
618 return _accept_clock_skew;
630 _max_position_age = age;
642 return _max_position_age;
656 _expected_broadcast_period = period;
668 return _expected_broadcast_period;
683 _reset_velocity_age = age;
695 return _reset_velocity_age;
711 _directional_velocity = flag;
722 return _directional_velocity;
737 _default_to_standing_still = flag;
748 return _default_to_standing_still;
761 INLINE
double SmoothMover::
762 get_avg_timestamp_delay()
const {
763 nassertr(!_timestamp_delays.
empty(), 0.0);
764 return (
double)_net_timestamp_delay / (double)_timestamp_delays.
size() / 1000.0;
const LPoint3 & get_smooth_pos() const
Returns the smoothed position as computed by a previous call to compute_smooth_position().
void compute_and_apply_smooth_pos_hpr(NodePath &pos_node, NodePath &hpr_node)
A further optimization to reduce Python calls.
void apply_smooth_pos_hpr(NodePath &pos_node, NodePath &hpr_node) const
Applies the smoothed position and orientation to the indicated NodePath.
bool set_h(PN_stdfloat h)
Sets the heading only.
static ClockObject * get_global_clock()
Returns a pointer to the global ClockObject.
void set_phony_timestamp(double timestamp=0.0, bool period_adjust=false)
Lies and specifies that the current position report was received now.
void set_prediction_mode(PredictionMode mode)
Sets the predictioning mode of all SmoothMovers in the world.
void set_smooth_mode(SmoothMode mode)
Sets the smoothing mode of all SmoothMovers in the world.
This is the base class for all three-component vectors and points.
void compute_and_apply_smooth_pos(NodePath &node)
A further optimization to reduce Python calls.
bool get_default_to_standing_still()
Returns the current state of the 'default to standing still' flag.
bool set_r(PN_stdfloat r)
Sets the roll only.
bool set_hpr(const LVecBase3 &hpr)
Specifies the orientation of the SmoothMover at a particular time in the past.
void set_default_to_standing_still(bool flag)
Sets the flag that indicates whether to assume that the node stopped moving during periods when we do...
bool empty() const
Returns true if the buffer is empty.
int size() const
Returns the number of items currently in the buffer.
void set_reset_velocity_age(double age)
Sets the amount of time that should elapse after the last position report before the velocity is rese...
bool compute_smooth_position()
Computes the smoothed position (and orientation) of the mover at the indicated point in time...
const LVecBase3 & get_smooth_hpr() const
Returns the smoothed orientation as computed by a previous call to compute_smooth_position().
This is a three-component point in space (as opposed to a three-component vector, which represents a ...
double get_frame_time(Thread *current_thread=Thread::get_current_thread()) const
Returns the time in seconds as of the last time tick() was called (typically, this will be as of the ...
double get_expected_broadcast_period()
Returns the interval at which we expect the SmoothNodes to broadcast their position, in elapsed seconds.
double get_reset_velocity_age()
Returns the amount of time that should elapse after the last position report before the velocity is r...
PredictionMode get_prediction_mode()
Returns the predictioning mode of all SmoothMovers in the world.
SmoothMode get_smooth_mode()
Returns the smoothing mode of all SmoothMovers in the world.
void set_max_position_age(double age)
Sets the maximum amount of time a position is allowed to remain unchanged before assuming it represen...
bool set_p(PN_stdfloat p)
Sets the pitch only.
void set_expected_broadcast_period(double period)
Sets the interval at which we expect the SmoothNodes to broadcast their position, in elapsed seconds...
bool set_pos_hpr(const LVecBase3 &pos, const LVecBase3 &hpr)
Specifies the position and orientation of the SmoothMover at a particular time in the past...
void set_timestamp(double timestamp)
Specifies the time that the current position report applies.
PN_stdfloat get_smooth_lateral_velocity() const
Returns the speed at which the avatar is moving, in feet per second, along its own lateral axis (afte...
void apply_smooth_hpr(NodePath &node) const
Applies the smoothed orientation to the indicated NodePath.
const LVecBase3 & get_sample_hpr() const
Returns the current orientation of the working sample point.
bool set_pos(const LVecBase3 &pos)
Specifies the position of the SmoothMover at a particular time in the past.
double get_max_position_age()
Returns the maximum amount of time a position is allowed to remain unchanged before assuming it repre...
double get_most_recent_timestamp() const
Returns most recently recorded timestamp.
double get_delay()
Returns the amount of time, in seconds, to delay the computed position of a SmoothMover.
void set_hpr(PN_stdfloat h, PN_stdfloat p, PN_stdfloat r)
Sets the rotation component of the transform, leaving translation and scale untouched.
bool get_directional_velocity()
Returns the current state of the 'directional velocity' flag.
PN_stdfloat get_smooth_forward_velocity() const
Returns the speed at which the avatar is moving, in feet per second, along its own forward axis (afte...
bool has_most_recent_timestamp() const
Returns true if we have most recently recorded timestamp.
const LPoint3 & get_sample_pos() const
Returns the current position of the working sample point.
bool set_y(PN_stdfloat y)
Sets the Y position only.
bool set_x(PN_stdfloat x)
Sets the X position only.
void set_delay(double delay)
Sets the amount of time, in seconds, to delay the computed position of a SmoothMover.
void set_accept_clock_skew(bool flag)
Sets the 'accept clock skew' flag.
bool get_accept_clock_skew()
Returns the current state of the 'accept clock skew' flag.
void apply_smooth_pos(NodePath &node) const
Applies the smoothed position to the indicated NodePath.
bool set_z(PN_stdfloat z)
Sets the Z position only.
NodePath is the fundamental system for disambiguating instances, and also provides a higher-level int...
void set_directional_velocity(bool flag)
Sets the flag that indicates whether the avatar's direction is considered in computing the velocity...
PN_stdfloat get_smooth_rotational_velocity() const
Returns the speed at which the avatar is rotating in the horizontal plane (i.e.
void compute_and_apply_smooth_hpr(NodePath &hpr_node)
A further optimization to reduce Python calls.
const LVecBase3 & get_forward_axis() const
Returns the smoothed position as computed by a previous call to compute_smooth_position().