driveInterface.I

Go to the documentation of this file.

/**
 * 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."
 *
 * @file driveInterface.I
 * @author drose
 * @date 2002-03-12
 */

/**
 * Sets the speed of full forward motion, when the mouse is at the very top of
 * the window.  This is in units (e.g.  feet) per second.
 */
INLINE void DriveInterface::
set_forward_speed(PN_stdfloat speed) {
  _forward_speed = speed;
}

/**
 * Returns the speed of full forward motion, when the mouse is at the very top
 * of the window.  This is in units (e.g.  feet) per second.
 */
INLINE PN_stdfloat DriveInterface::
get_forward_speed() const {
  return _forward_speed;
}

/**
 * Sets the speed of full reverse motion, when the mouse is at the very bottom
 * of the window.  This is in units (e.g.  feet) per second.
 */
INLINE void DriveInterface::
set_reverse_speed(PN_stdfloat speed) {
  _reverse_speed = speed;
}

/**
 * Returns the speed of full reverse motion, when the mouse is at the very
 * bottom of the window.  This is in units (e.g.  feet) per second.
 */
INLINE PN_stdfloat DriveInterface::
get_reverse_speed() const {
  return _reverse_speed;
}

/**
 * Sets the maximum rate at which the user can rotate left or right, when the
 * mouse is at the very edge of the window.  This is in degrees per second.
 */
INLINE void DriveInterface::
set_rotate_speed(PN_stdfloat speed) {
  _rotate_speed = speed;
}

/**
 * Returns the maximum rate at which the user can rotate left or right, when
 * the mouse is at the very edge of the window.  This is in degrees per
 * second.
 */
INLINE PN_stdfloat DriveInterface::
get_rotate_speed() const {
  return _rotate_speed;
}

/**
 * Sets the size of the horizontal bar in the center of the screen that
 * represents the "dead zone" of vertical motion: the region in which the
 * mouse does not report vertical motion.  This is in a fraction of the window
 * height, so 0.5 will set a dead zone as large as half the screen.
 */
INLINE void DriveInterface::
set_vertical_dead_zone(PN_stdfloat speed) {
  _vertical_dead_zone = speed;
}

/**
 * Returns the size of the horizontal bar in the center of the screen that
 * represents the "dead zone" of vertical motion: the region in which the
 * mouse does not report vertical motion.  This is in a fraction of the window
 * height, so 0.5 will set a dead zone as large as half the screen.
 */
INLINE PN_stdfloat DriveInterface::
get_vertical_dead_zone() const {
  return _vertical_dead_zone;
}

/**
 * Sets the size of the vertical bar in the center of the screen that
 * represents the "dead zone" of horizontal motion: the region in which the
 * mouse does not report horizontal motion.  This is in a fraction of the
 * window width, so 0.5 will set a dead zone as large as half the screen.
 */
INLINE void DriveInterface::
set_horizontal_dead_zone(PN_stdfloat speed) {
  _horizontal_dead_zone = speed;
}

/**
 * Returns the size of the vertical bar in the center of the screen that
 * represents the "dead zone" of horizontal motion: the region in which the
 * mouse does not report horizontal motion.  This is in a fraction of the
 * window width, so 0.5 will set a dead zone as large as half the screen.
 */
INLINE PN_stdfloat DriveInterface::
get_horizontal_dead_zone() const {
  return _horizontal_dead_zone;
}

/**
 * Sets the amount of time, in seconds, it takes between the time an up or
 * down arrow key is pressed and the time it registers full forward or
 * backward motion.
 */
INLINE void DriveInterface::
set_vertical_ramp_up_time(PN_stdfloat ramp_up_time) {
  _vertical_ramp_up_time = ramp_up_time;
}

/**
 * Returns the amount of time, in seconds, it takes between the time an up or
 * down arrow key is pressed and the time it registers full forward or
 * backward motion.
 */
INLINE PN_stdfloat DriveInterface::
get_vertical_ramp_up_time() const {
  return _vertical_ramp_up_time;
}

/**
 * Sets the amount of time, in seconds, it takes between the time an up or
 * down arrow key is released and the time it registers no motion.
 */
INLINE void DriveInterface::
set_vertical_ramp_down_time(PN_stdfloat ramp_down_time) {
  _vertical_ramp_down_time = ramp_down_time;
}

/**
 * Returns the amount of time, in seconds, it takes between the time an up or
 * down arrow key is released and the time it registers no motion.
 */
INLINE PN_stdfloat DriveInterface::
get_vertical_ramp_down_time() const {
  return _vertical_ramp_down_time;
}

/**
 * Sets the amount of time, in seconds, it takes between the time a left or
 * right arrow key is pressed and the time it registers full rotation.
 */
INLINE void DriveInterface::
set_horizontal_ramp_up_time(PN_stdfloat ramp_up_time) {
  _horizontal_ramp_up_time = ramp_up_time;
}

/**
 * Returns the amount of time, in seconds, it takes between the time a left or
 * right arrow key is pressed and the time it registers full rotation.
 */
INLINE PN_stdfloat DriveInterface::
get_horizontal_ramp_up_time() const {
  return _horizontal_ramp_up_time;
}

/**
 * Sets the amount of time, in seconds, it takes between the time a left or
 * right arrow key is released and the time it registers no motion.
 */
INLINE void DriveInterface::
set_horizontal_ramp_down_time(PN_stdfloat ramp_down_time) {
  _horizontal_ramp_down_time = ramp_down_time;
}

/**
 * Returns the amount of time, in seconds, it takes between the time a left or
 * right arrow key is released and the time it registers no motion.
 */
INLINE PN_stdfloat DriveInterface::
get_horizontal_ramp_down_time() const {
  return _horizontal_ramp_down_time;
}

/**
 * Returns the speed of the previous update in units/sec
 */
INLINE PN_stdfloat DriveInterface::
get_speed() const {
  return _speed;
}

/**
 * Returns the rot_speed of the previous update in units/sec
 */
INLINE PN_stdfloat DriveInterface::
get_rot_speed() const {
  return _rot_speed;
}

/**
 * Returns the driver's position.
 */
INLINE const LPoint3 &DriveInterface::
get_pos() const {
  return _xyz;
}

INLINE PN_stdfloat DriveInterface::
get_x() const {
  return _xyz[0];
}

INLINE PN_stdfloat DriveInterface::
get_y() const {
  return _xyz[1];
}

INLINE PN_stdfloat DriveInterface::
get_z() const {
  return _xyz[2];
}


/**
 * Directly sets the driver's position.
 */
INLINE void DriveInterface::
set_pos(const LVecBase3 &vec) {
  _xyz = vec;
}

INLINE void DriveInterface::
set_pos(PN_stdfloat x, PN_stdfloat y, PN_stdfloat z) {
  _xyz.set(x, y, z);
}

INLINE void DriveInterface::
set_x(PN_stdfloat x) {
  _xyz[0] = x;
}

INLINE void DriveInterface::
set_y(PN_stdfloat y) {
  _xyz[1] = y;
}

INLINE void DriveInterface::
set_z(PN_stdfloat z) {
  _xyz[2] = z;
}


/**
 * Returns the driver's orientation.
 */
INLINE const LVecBase3 &DriveInterface::
get_hpr() const {
  return _hpr;
}

INLINE PN_stdfloat DriveInterface::
get_h() const {
  return _hpr[0];
}

INLINE PN_stdfloat DriveInterface::
get_p() const {
  return _hpr[1];
}

INLINE PN_stdfloat DriveInterface::
get_r() const {
  return _hpr[2];
}


/**
 * Directly sets the driver's orientation.
 */
INLINE void DriveInterface::
set_hpr(const LVecBase3 &hpr) {
  set_hpr(hpr[0], hpr[1], hpr[2]);
}

INLINE void DriveInterface::
set_hpr(PN_stdfloat h, PN_stdfloat p, PN_stdfloat r) {
  set_h(h);
  set_p(p);
  set_r(r);
}

INLINE void DriveInterface::
set_h(PN_stdfloat h) {
  _hpr[0] = _hpr_quantize * floor(h / _hpr_quantize + 0.5f);
}

INLINE void DriveInterface::
set_p(PN_stdfloat p) {
  _hpr[1] = _hpr_quantize * floor(p / _hpr_quantize + 0.5f);
}

INLINE void DriveInterface::
set_r(PN_stdfloat r) {
  _hpr[2] = _hpr_quantize * floor(r / _hpr_quantize + 0.5f);
}

/**
 * Changes the state of the ignore_mouse flag.  If this flag is true, the
 * DriveInterface will ignore mouse down button events (but still recognize
 * mouse up button events); the user will not be able to start the
 * DriveInterface going again if it is stopped, but if the user is currently
 * holding down a mouse button it will not stop immediately until the user
 * eventually releases the button.
 */
INLINE void DriveInterface::
set_ignore_mouse(bool ignore_mouse) {
  _ignore_mouse = ignore_mouse;
}

/**
 * Returns the current setting of the ignore_mouse flag.  See
 * set_ignore_mouse().
 */
INLINE bool DriveInterface::
get_ignore_mouse() const {
  return _ignore_mouse;
}

/**
 * Changes the state of the force_mouse flag.  If this flag is true, the mouse
 * button need not be held down in order to drive the avatar around.
 */
INLINE void DriveInterface::
set_force_mouse(bool force_mouse) {
  _force_mouse = force_mouse;
}

/**
 * Returns the current setting of the force_mouse flag.  See
 * set_force_mouse().
 */
INLINE bool DriveInterface::
get_force_mouse() const {
  return _force_mouse;
}

/**
 * If stop_this_frame is true, the next time the frame is computed no motion
 * will be allowed, and then the flag is reset to false.  This can be used to
 * prevent too much movement when we know a long time has artificially
 * elapsed, for instance when we take a screenshot, without munging the clock
 * for everything else.
 */
INLINE void DriveInterface::
set_stop_this_frame(bool stop_this_frame) {
  _stop_this_frame = stop_this_frame;
}

/**
 * Returns the current setting of the stop_this_frame flag.  See
 * set_stop_this_frame().
 */
INLINE bool DriveInterface::
get_stop_this_frame() const {
  return _stop_this_frame;
}