diguyWaypoint.h

Go to the documentation of this file.

/*
 *  Copyright (C) 1992-2013 Boston Dynamics
 *  ALL RIGHTS RESERVED.
 *
 *  These coded instructions, statements, and computer programs
 *  contain unpublished proprietary information of Boston Dynamics
 *  and are protected by Copyright Laws of the United States.
 *  They may not be used, duplicated, or disclosed in any form, in
 *  whole or in part, without the prior written consent from Boston
 *  Dynamics.
 *
 *  RESTRICTED RIGHTS LEGEND
 *  Use, duplication, or disclosure by the government is subject
 *  to restrictions as set forth in FAR 52.227.19(c)(2) or
 *  subparagraph (c)(1)(ii) of the Rights in Technical Data and
 *  Computer Software clause at DFARS 252.227-7013 and/or in
 *  similar or successor clauses in the FAR, or the DOD or NASA
 *  FAR Supplement, or to subparagraphs (c)(1) and (c)(2) of the
 *  Commercial Computer Software--Restricted Rights at 48 CFR
 *  52.227-19, as applicable.  Unpublished-rights reserved under
 *  the Copyright Laws of the United States.
 *  Contractor/Manufacturer is:
 *  Boston Dynamics/78 Fourth Avenue/Waltham MA 02451.
 */

/*********************************************************************
 **
 *t  diguyWaypoint
 **
 *b    Link against: libdiguy
 */

#ifndef __diguyWaypoint_H
#define __diguyWaypoint_H

#ifdef SWIG
%module diguyWaypoint
#else
#define CPLUSPLUS_ONLY
#endif

#ifdef CPLUSPLUS_ONLY
class bdiBeadWaypoint;
#endif


#include <declspec_diguy.h>

/****************************************************************************/
class BDI_DECLSPEC_diguy diguyWaypoint
{

public:

/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    Returns the name of the object.  This pointer will never be NULL.
         **
         *b  Returns:
         **
         **    name of the object
         */
        const char* get_name();

        /*l
         *b  Description:
         **
         **    All waypoints are assigned a unique identifier, or uid.  This
         **    function returns this waypoints's uid.
         **
         **    *Note*: unique identifiers will change between DI-Guy runs!
         **
         *b  Returns:
         **
         **    unique identifier of object
         */
        long get_uid();

        /*l
         *b  Returns:
         **
         **    1 if waypoint is selected in DI-Guy Scenario or DI-Guy Author, 0
         **    if not.
         */
        int get_selected();



/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    This function sets the x, y, z coordinates of the waypoint in
         **    meters.
         **
         **    Requires subsequent call to diguyCharacterPath::update() or
         **    diguyPathShape::update().  (See above.)
         **
         *b  Returns:
         **
         **    x, y, z coordinate of waypoint in meters
         */
        void set_position(float x, float y, float z);

        /*l
         *b  Description:
         **
         **    Double precision version of set_position().
         */
        void set_position_double(double x, double y, double z);

        /*l
         *b  Returns:
         **
         **    x, y, z coordinate of waypoint in meters
         **
         **  Note: in Lua this will return 3 values.
         */
        void get_position(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Double precision version of get_position().
         **    
         **  Note: in Lua this will return 3 values.
         */
        void get_position_double(double* tx, double* ty, double* tz);

        /*l
         *b  Description:
         **
         **    Sets the orientation of the path entering the waypoint.
         **
         **    If the angles in and angles out are coupled (e.g.,
         **    get_yaw_coupled() returns 1) this will set rz out, as well.  The
         **    new angle out will be angle in plus the angle coupling offset.
         **
         **    Requires subsequent call to diguyCharacterPath::update() or
         **    diguyPathShape::update().  (See above.)
         **
         *b  Arguments:
         **
         *a    rz, rx, ry - orientations in degrees
         */
        void set_orientation_in(float rz, float rx, float ry);

        /*l
         *b  Description:
         **
         **    Retrieves the orientation of the path entering the waypoint.
         **
         *b  Arguments:
         **
         *a    rz, rx, ry - orientations in degrees counter-clockwise from the
         *a                 positive X axis
         **  
         **  Note: in Lua this will return 3 values.
         */
        void get_orientation_in(float* rz, float* rx, float* ry);

        /*l
         *b  Description:
         **
         **    Equivalent to set_orientation_in(), but for the path exiting the
         **    waypoint.
         */
        void set_orientation_out(float rz, float rx, float ry);

        /*l
         *b  Description:
         **
         **    Equivalent to get_orientation_in(), but for the path exiting the
         **    waypoint.
         **  
         **  Note: in Lua this will return 3 values.
         */
        void get_orientation_out(float* rz, float* rx, float* ry);

        /*l
         *b  Description:
         **
         **    This function sets whether the yaw in and yaw out angles are
         **    coupled together.  In general, for paths to look smooth, the in and
         **    out angles should be coupled together with 0 coupling offset.
         **
         **    Requires subsequent call to diguyCharacterPath::update() or
         **    diguyPathShape::update().  (See above.)
         **
         *b  Arguments:
         **
         *a    yaw_coupled - pass 1 to couple yaw in to yaw out
         */
        void set_yaw_coupled(int yaw_coupled);

        /*l
         *b  Returns:
         **
         **    whether the yaw in and yaw out angles are coupled together;
         **    see set_yaw_coupled()
         */
        int get_yaw_coupled();

        /*l
         *b  Description:
         **
         **    This function sets by how much the yaw in and yaw out angles should
         **    be offset when they are coupled together.
         **
         **    Requires subsequent call to diguyCharacterPath::update() or
         **    diguyPathShape::update().  (See above.)
         **
         *b  Arguments:
         **
         *a    yaw_coupling_offset - new yaw coupling offset, in degrees
         */
        void set_yaw_coupling_offset(float yaw_coupling_offset);

        /*l
         *b  Returns:
         **
         **    the offset between yaw in and yaw out when the yaw angles are
         **    coupled together; see set_yaw_coupling_offset()
         */
        float get_yaw_coupling_offset();

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the x axis.
         */
        void set_roll_coupled(int roll_coupled);

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the x axis.
         */
        int get_roll_coupled();

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the x axis.
         */
        void set_roll_coupling_offset(float roll_coupling_offset);

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the x axis.
         */
        float get_roll_coupling_offset();

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the y axis.
         */
        void set_pitch_coupled(int pitch_coupled);

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the y axis.
         */
        int get_pitch_coupled();

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the y axis.
         */
        void set_pitch_coupling_offset(float pitch_coupling_offset);

        /*l
         *b  Description:
         **
         **    This function is the same as its yaw counterpart, but rotation
         **    is about the y axis.
         */
        float get_pitch_coupling_offset();


/*****************************************************************************
 **
 *2  Control Point Functions
 **
 **   Unless otherwise noted all functions in this class section are callable from:
 **    
 *-    - C++
 *-    - Script
 **    
 */

        /*l
         *b  Description:
         **
         **    This function sets the weight of the control handle heading into
         **    the waypoint.  The weights of the waypoint set how long the
         **    "control handles" of the waypoint are, in meters.  The longer the
         **    control handle, the more the path will be stretched in the
         **    direction of the waypoint's orientation.
         **
         **    If the weight in and weight out are coupled (get_weight_coupled()
         **    returns 1) this will set weight out, as well.
         **
         **    Requires subsequent call to diguyCharacterPath::update() or
         **    diguyPathShape::update().  (See above.)
         */
        void set_weight_in(float weight_in);

        /*l
         *b  Returns:
         **
         **    weight heading into the waypoint, in meters; see set_weight_in()
         */
        float get_weight_in();

        /*l
         *b  Description:
         **
         **    Similar to set_weight_in(), but for the outgoing weight.
         */
        void set_weight_out(float weight_out);

        /*l
         *b  Returns:
         **
         **    weight heading out of the waypoint, in meters; see
         **    set_weight_out().
         */
        float get_weight_out();

        /*l
         *b  Description:
         **
         **    This function sets whether the weight in and weight out are
         **    coupled together.
         **
         **    If this waypoint is part of a diguyCharacterPath or diguyPathShape,
         **    the diguyCharacterPath::update() or diguyPathShape::update()
         **    function must be called for changes to take effect.
         */
        void set_weight_coupled(int weight_coupled);

        /*l
         *b  Returns:
         **
         **    whether the weight in and weight out are coupled together;
         **    see set_weight_coupled()
         */
        int get_weight_coupled();

        /*l
         *b  Description:
         **
         **    This function returns the world position of the control point
         **    heading into the waypoint.  This is derived from the waypoint's
         **    position, orientation in, and the weights of the in control bar.
         */
        void get_control_point_in_position(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Similar to get_control_point_in_position(), but for out control
         **    point.
         */
        void get_control_point_out_position(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    This function returns the normal vector of the control bar heading
         **    into the waypoint.
         */
        void get_forward_normal_in(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Similar to get_forward_normal_in(), but for left normal.
         */
        void get_left_normal_in(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Similar to get_out_normal_in(), but for up normal.
         */
        void get_up_normal_in(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Similar to get_forward_normal_in(), but for out control bar.
         */
        void get_forward_normal_out(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Similar to get_left_normal_in(), but for out control bar.
         */
        void get_left_normal_out(float* x, float* y, float* z);

        /*l
         *b  Description:
         **
         **    Similar to get_up_normal_in(), but for out control bar.
         */
        void get_up_normal_out(float* x, float* y, float* z);


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    This function sets how many segments the path portion this waypoint
         **    begins will be divided into.  This is strictly for visualization
         **    purposes only and will have no functional effect.
         **
         **    If this waypoint is part of a diguyCharacterPath or diguyPathShape,
         **    the diguyCharacterPath::update() or diguyPathShape::update()
         **    function must be called for changes to take effect.
         **
         *b  Arguments:
         **
         *a    num_segments - number of segments to divide path portion into;
         **                   default is 64
         */
        void set_num_segments(int num_segments);

        /*l
         *b  Returns:
         **
         **    how many segments the path portion this waypoint begins will be
         **    divided into; see set_num_segments()
         */
        int get_num_segments();


/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/

        /*l
         **    This function is deprecated.  Use set_position() instead.
         */
        void set_x(float x);

        /*l
         **    This function is deprecated.  Use get_position() instead.
         */
        float get_x();

        /*l
         **    This function is deprecated.  Use set_position() instead.
         */
        void set_y(float y);

        /*l
         **    This function is deprecated.  Use get_position() instead.
         */
        float get_y();

        /*l
         **    This function is deprecated.  Use set_position() instead.
         */
        void set_z(float z);

        /*l
         **    This function is deprecated.  Use get_position() instead.
         */
        float get_z();

        /*l
         **    This function is deprecated.  Use set_orientation_in() instead.
         */
        void set_yaw_in(float yaw);

        /*l
         **    This function is deprecated.  Use get_orientation_in() instead.
         */
        float get_yaw_in();

        /*l
         **    This function is deprecated.  Use set_orientation_out() instead.
         */
        void set_yaw_out(float yaw);

        /*l
         **    This function is deprecated.  Use get_orientation_out() instead.
         */
        float get_yaw_out();

        /*l
         **    This function is deprecated.  Use get_yaw_coupled() instead.
         */
        int get_yaw_smooth();

        /*l
         **    This function is deprecated.  Use set_yaw_coupled() instead.
         */
        void set_yaw_smooth(int yaw_smooth);

        /*l
         **    This function is deprecated.  Use get_yaw_coupling_offset()
         **    instead.
         */
        float get_yaw_offset();

        /*l
         **    This function is deprecated.  Use set_yaw_coupling_offset()
         **    instead.
         */
        void set_yaw_offset(float yaw_offset);

        /*l
         **    This function is deprecated.  Use set_orientation_in() instead.
         */
        void set_roll_in(float roll);

        /*l
         **    This function is deprecated.  Use get_orientation_in() instead.
         */
        float get_roll_in();

        /*l
         **    This function is deprecated.  Use set_orientation_out() instead.
         */
        void set_roll_out(float roll);

        /*l
         **    This function is deprecated.  Use get_orientation_out() instead.
         */
        float get_roll_out();

        /*l
         **    This function is deprecated.  Use get_roll_coupled() instead.
         */
        int get_roll_smooth();

        /*l
         **    This function is deprecated.  Use set_roll_coupled() instead.
         */
        void set_roll_smooth(int roll_smooth);

        /*l
         **    This function is deprecated.  Use get_roll_coupling_offset()
         **    instead.
         */
        float get_roll_offset();

        /*l
         **    This function is deprecated.  Use set_roll_coupling_offset()
         **    instead.
         */
        void set_roll_offset(float roll_offset);

        /*l
         **    This function is deprecated.  Use set_orientation_in() instead.
         */
        void set_pitch_in(float pitch);

        /*l
         **    This function is deprecated.  Use get_orientation_in() instead.
         */
        float get_pitch_in();

        /*l
         **    This function is deprecated.  Use set_orientation_out() instead.
         */
        void set_pitch_out(float pitch);

        /*l
         **    This function is deprecated.  Use get_orientation_out() instead.
         */
        float get_pitch_out();

        /*l
         **    This function is deprecated.  Use get_pitch_coupled() instead.
         */
        int get_pitch_smooth();

        /*l
         **    This function is deprecated.  Use set_pitch_coupled() instead.
         */
        void set_pitch_smooth(int pitch_smooth);

        /*l
         **    This function is deprecated.  Use get_pitch_coupling_offset()
         **    instead.
         */
        float get_pitch_offset();

        /*l
         **    This function is deprecated.  Use get_pitch_coupling_offset()
         **    instead.
         */
        void set_pitch_offset(float pitch_offset);

        /*l
         **    This function is deprecated.  Use get_weight_coupled()
         **    instead.
         */
        int get_distance_smooth();

        /*l
         **    This function is deprecated.  Use set_weight_coupled()
         **    instead.
         */
        void set_distance_smooth(int distance_smooth);


/****************************************************************************/
/****************************************************************************/

#ifdef CPLUSPLUS_ONLY

        bdiBeadWaypoint* get_scripted_object() {return m_scripted_object;}

private:

        /*l
         **    A private constructor.
         */
        diguyWaypoint(bdiBeadWaypoint* waypoint);

        /*l
         **    A private destructor.
         */
        ~diguyWaypoint();

        /*l
         **    A pointer to internal data.
         */
        bdiBeadWaypoint* m_scripted_object;

        friend class diguyScenario;
        friend class bdiBeadWaypoint;

#endif

};


#endif /* __diguyWaypoint_H */