diguyAuthorInterface.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.
 */



#ifndef __diguyAuthorInterface_H
#define __diguyAuthorInterface_H

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

#ifdef CPLUSPLUS_ONLY
class diguyAuthorInterface;
class diguyAuthorVisualRegionPaintbrush;
class diguyCharacter;
class diguyCharacterPath;
class diguyGraphicsLink;
class diguyGraphicsShape;
class diguyPathShape;
class diguyWaypoint;
class bdiScenarioEditorInput;

typedef diguyAuthorInterface* diguyAuthorInterfaceCreateFunc(void* internal_data);

#include <stdio.h>
#include <declspec_diguy.h>
#include <diguy_constants.h>
#include <diguy_vector_classes.h>

#define AUTHOR_UI_MAIN_WINDOW_NAME         "main_window"
#define AUTHOR_UI_INPUT_MODE_WINDOW_NAME   "input_mode"
#define AUTHOR_UI_TIME_CONTROL_WINDOW_NAME "time_control"
#define AUTHOR_UI_LOG_WINDOW_NAME          "log"
#define AUTHOR_UI_VISIBILITY_WINDOW_NAME   "visibility"
#define AUTHOR_UI_ELEMENTS_WINDOW_NAME     "elements"
#define AUTHOR_UI_CHARACTER_WINDOW_NAME    "character"
#define AUTHOR_UI_CROWD_WINDOW_NAME        "crowd"
#define AUTHOR_UI_MIND_EDITOR_WINDOW_NAME  "mind_editor"
#define AUTHOR_UI_AI_INSPECTOR_WINOW_NAME  "ai_inspector"


#endif


/*********************************************************************/
class BDI_DECLSPEC_diguy diguyAuthorInterface
{

public:

        /*l
         **  Returns a pointer to the region paintbrush.  Returned pointer may be
         **  NULL.
         */
        diguyAuthorVisualRegionPaintbrush* get_region_paintbrush();


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    Sets the current position of the mouse in screen coordinates.
         **
         **    This should be done whenever a DI-Guy input mode is active and the
         **    mouse moves.
         **
         **    Note that nothing is done with this information until
         **    apply_mouse_inputs() is called.
         **
         *b  Arguments:
         **
         *a    x - horizontal pixel from left edge of window
         *a    y - vertical pixel from bottom edge of window
         */
        void set_mouse_screen_coordinates(int x, int y);

        /*l
         *b  Description:
         **
         **    Sets the current position of the mouse in world coordinates.  This
         **    should be the intersection point of the ray that would begin at
         **    the mouse's screen position, and extend into the far distance (at
         **    least as far as the graphics far plane).
         **
         **    This should be done whenever a DI-Guy input mode is active, and a
         **    point in the 3D world is requested, such as during a call to
         **    convert_screen_to_world().
         **
         **    Note that nothing is done with this information until
         **    apply_mouse_inputs() is called.
         **
         *b  Arguments:
         **
         *a    world_coords - mouse position in world coordinates, in meters from
         *a                   the origin
         */
        void set_mouse_world_coordinates(diguyVec3f world_coords);

        /*l
         *b  Description:
         **
         **    Sets the current state of the left mouse button.
         **
         **    This should be done whenever a DI-Guy input mode is active and the
         **    a mouse button is pressed.
         **
         **    Note that nothing is done with this information until
         **    apply_mouse_inputs() is called.
         **
         *b  Arguments:
         **
         *a    button_state - 1 for down, 0 for up
         */
        void set_mouse_button_l(int button_state);

        /*l
         *b  Description:
         **
         **    Same as set_mouse_button_l(), but for the right mouse button.
         */
        void set_mouse_button_r(int button_state);

        /*l
         *b  Description:
         **
         **    Same as set_mouse_button_m(), but for the middle mouse button.
         */
        void set_mouse_button_m(int button_state);

        /*l
         *b  Description:
         **
         **    Sets the change in the mouse wheel position since the last call
         **    to this function.
         **
         **    This should be done whenever a DI-Guy input mode is active and the
         **    the mouse wheel is moved.
         **
         **    Note that nothing is done with this information until
         **    apply_mouse_inputs() is called.
         **
         *b  Arguments:
         **
         *a    mouse_wheel_change - (units documentation pending)
         */
        void set_mouse_wheel_change(float mouse_wheel_change);

        /*l
         *b  Description:
         **
         **    Applies effects of inputs set by set_mouse_screen_coordinates(),
         **    set_mouse_button_l(), etc.  DI-Guy Author will make modifications
         **    on edited objects based on these inputs.
         */
        void apply_mouse_inputs();


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    Sets the current state of the shift key.  The shift key can change
         **    the results of mouse inputs in the 3D window.
         **
         **    This should be done whenever a DI-Guy input mode is active and the
         **    state of the shift key changes.
         **
         *b  Arguments:
         **
         *a    key_state - 1 for down, 0 for up
         */
        void set_keyboard_shift(int key_state);

        /*l
         *b  Description:
         **
         **    Same as set_keyboard_shift(), but for ctrl key.
         */
        void set_keyboard_ctrl(int key_state);

        /*l
         *b  Description:
         **
         **    Same as set_keyboard_alt(), but for alt key.
         */
        void set_keyboard_alt(int key_state);

        /*l
         *b  Description:
         **
         **    Sets the current state of the speficied key.  Key presses can
         **    change the input mode, cause a reset, load camera settings, etc.
         **
         **    *Note:*  Often it will be better for the Host IG to handle key
         **    presses and make the appropriate DI-Guy calls manually.
         **
         *b  Arguments:
         **
         *a    key       - ASCII code of pressed key
         *a    key_state - 1 for down, 0 for up
         */
        void set_key_pressed(int key, int key_state);


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    Sets the current selected DI-Guy object based on the passed uid.
         **    If the uid matches an object in the scenario, that object will
         **    become the selected object.
         **
         **    This function is typically called during a
         **    update_selected_objects() call.
         **
         **    The type of object the uid is associated with can be determined by
         **    calling get_uid_base_type().
         **
         **    DI-Guy Author will internally decide what the uid code means, and
         **    set its selected object pointers appropriately.  The get_selected_*
         **    functions below (e.g., get_selected_character()) will return
         **    objects that are selected as a result of this call.  Calling this
         **    function will un-select all other objects, even if they are of
         **    different types.
         **
         **    Note, however, that in some cases multiple objects may become
         **    selected, if the uid of the object is for an object owned by
         **    another.  For example, selecting a waypoint will also select the
         **    waypoint's path, and the path's character.
         **
         *b  Arguments:
         **
         *a    uid - unique identifier of selected object
         **
         *b  Returns:
         **
         **    1 if uid is valid, 0 if not (e.g., no such object)
         */
        int set_selected_diguy_uid(long uid);

        /*l
         *b  Description:
         **
         **    Same as set_selected_diguy_uid(), but with uid in string form.
         */
        int set_selected_diguy_uid_from_string(const char* uid_string);

        /*l
         *b  Description:
         **
         **    Returns a value that describes the object type associated with the
         **    passed uid.  The returned value will be one of the
         **    DIGUY_TYPE_UID_BASE_* values listed in diguy_constants.h; e.g.,
         **    a return value of DIGUY_TYPE_UID_BASE_CHARACTER means that the
         **    uid is associated with a diguyCharacter object.
         **
         **    DIGUY_TYPE_UID_BASE_NOTHING is returned if the passed value is not
         **    a valid DI-Guy uid.
         **
         *b  Arguments:
         **
         *a    uid - unique identifier to be checked
         **
         *b  Returns:
         **
         **    uid base type enumeration
         */
        int get_uid_base_type(long uid);

        /*l
         *b  Description:
         **
         **    Same as get_uid_base_type(), but with uid in string form.
         */
        int get_uid_base_type_from_string(const char* uid_string);

        /*l
         *b  Description:
         **
         **    Returns the character that was selected as a result of calling
         **    set_selected_diguy_uid().
         **
         *b  Returns:
         **
         **    pointer to type diguyCharacter
         */
        diguyCharacter* get_selected_character();

        /*l
         *b  Description:
         **
         **    diguyCharacterPath version of get_selected_character().
         */
        diguyCharacterPath* get_selected_character_path();

        /*l
         *b  Description:
         **
         **    diguyWaypoint version of get_selected_character().
         */
        diguyWaypoint* get_selected_waypoint();

        /*l
         *b  Description:
         **
         **    diguyPathShape version of get_selected_character().
         */
        diguyPathShape* get_selected_path_shape();

        /*l
         *b  Description:
         **
         **    diguyGraphicsLink version of get_selected_character().
         */
        diguyGraphicsLink* get_selected_link();

        /*l
         *b  Description:
         **
         **    diguyGraphicsShape version of get_selected_character().
         */
        diguyGraphicsShape* get_selected_shape();


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    This function will be called when DI-Guy Author nneds to know the
         **    world position behind the given screen coordinate.
         **
         **    See above for information on the world and screen coordinate
         **    systems.
         **
         **    A typical implementation will construct a ray with its beginning at
         **    the world coordinate corresponding to the screen coordinate,
         **    projected some distance into the world using a camera projection
         **    matrix.
         **
         *b  Arguments:
         **
         *a    screen_xyz - screen coordinates as described above
         *a    world_xyz  - return value world intersection point
         **
         *b  Returns:
         **
         **    1 if an intersection occurred, 0 if not
         */
        virtual int convert_screen_to_world(const diguyVec3f& screen_xyz,
                diguyVec3f* world_xyz) = 0;

        /*l
         *b  Description:
         **
         **    This function is the inverse of convert_screen_to_world().  It
         **    takes a world position and returns the corresponding screen
         **    coordinate.
         **
         *b  Arguments:
         **
         *a    world_xyz  - point in world coordinates
         *a    screen_xyz - return value screen coordinate that covers that point
         **
         *b  Returns:
         **
         **    1 if an intersection occurred, 0 if not
         */
        virtual int convert_world_to_screen(const diguyVec3f& world_xyz,
                diguyVec3f* screen_xyz) = 0;

        virtual float get_altitude(float x, float y, float old_z,
                float from_height = 10.0f,
                int* valid_result = NULL) = 0;

        /*
         *  In overridden function call set_selected_diguy_uid() or
         *   set_selected_diguy_uid_from_string()
         */
        virtual int update_selected_objects(const diguyVec3f& screen_xyz) = 0;

        virtual int check_z_clearance(const diguyVec3f& pos,
                const float radius,
                const float ground_angle,
                float z_clear_height,
                int check_below = 1) const = 0;


/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    Calling this function will tell the DI-Guy Author UI to show or
         **    hide the specified window.
         **
         *b  Arguments:
         **
         *a    window_name - name of the window to show or hide
         *a    visible     - pass 1 to show the window, 0 to hide it
         **
         **    Currently valid window names are:
         **
         *-      - "input_mode"
         *-      - "time_control"
         *-      - "log"
         *-      - "elements"
         */
        int set_author_ui_window_visible(const char* window_name, int visible);

        /*l
         *b  Returns:
         **
         **    1 if the specified DI-Guy Author UI window is shown, 0 if not
         **
         *b  Arguments:
         **
         *a    window_name - name of the window to show or hide
         */
        int get_author_ui_window_visible(const char* window_name);

        /*l
         *b  Description:
         **
         **    Calling this function will tell the DI-Guy Author UI to show
         **    the specified panel in the elements window.
         **
         *b  Arguments:
         **
         *a    panel_name - name of the window to show or hide
         **
         **    Currently valid window names are:
         **
         *-      - "Character"
         *-      - "Crowd"
         */
        int set_author_ui_panel_visible(const char* panel_name);

        /*l
         *b  Description:
         **
         **    Calling this function will tell the DI-Guy Author UI to select
         **    the specified character in the crowd page.
         **
         *b  Arguments:
         **
         *a    character - name of the character to select in the crowd window
         **
         */
        int set_author_ui_select_crowd_character(diguyCharacter* character);

        /*l
         *b  Description:
         **
         **    Calling this function will tell the DI-Guy Author UI to select
         **    the specified script for the character.
         **
         *b  Arguments:
         **
         *a    character - name of the character to select in the crowd window
         **
         */
        int set_author_ui_select_code_browser_script(diguyCharacter* character);




/*****************************************************************************/
#ifdef CPLUSPLUS_ONLY

        /*l
         *b  Description:
         **
         **    Called if the named window in the Author UI application changes
         **    visibility state.
         */
        virtual void author_ui_window_visibility_changed(const char* window_name,
                int is_visible);

#endif


/*****************************************************************************/
#ifdef CPLUSPLUS_ONLY

        /*l
         *b  Description:
         **
         **    Generates vertices for a sphere with the passed radius.  The
         **    data returned in the vertices, normals, texture_indices, and
         **    indices pointers must be deleted using delete_generated_vertices().
         **
         **    Untransformed, the sphere's center will be at the local origin.
         **
         **    The slices will radiate around the z axis.  The stacks will be
         **    along the z axis.
         **
         *b  Arguments:
         **
         *a    radius           - (input) radius of sphere, in meters
         *a    num_slices       - (input) number of radial slices; think slices in
         *a                       a cake
         *a    num_layers       - (input) number of vertical layers; think layers
         *a                       in a cake
         *a    position_offset  - (input) position offset of sphere from local
         *a                       origin, in meters
         *a    orientation      - (input) orientation offset of sphere about local
         *a                       origin, in degrees
         *a    num_vertices     - (output) number of generated vertices
         *a    vertices         - (output) vertex data
         *a    normals          - (output) normal data
         *a    texture_indices  - (output) texture index data (not currently used)
         *a    indices_for_wireframe - (input) pass 1 if vertices are for a
         *a                       wireframe object that will be represented be
         *a                       line segments, 0 if the vertices are for a
         *a                       solid object represented by polygons
         *a    num_indices      - (output) number of indices telling how vertices
         *a                       connect
         *a    indices          - (output) data on how vertices connect
         **
         *b  Returns:
         **
         **    0 on success, -1 on error
         */
        static int generate_sphere_vertices(float radius,
                int num_slices,
                int num_layers,
                const diguyVec3f& position_offset,
                const diguyVec3f& orientation,      // degrees
                int* num_vertices,
                diguyVec3f** vertices,
                diguyVec3f** normals,
                diguyVec2f** texture_indices,
                int indices_for_wireframe,
                int* num_indices,
                unsigned int** indices);

        /*l
         *b  Description:
         **
         **    Similar to generate_sphere_vertices(), but for cones.
         **
         **    Untransformed, the cone's base will be at the local origin, with
         **    the point tapering in positive z.
         **
         **    The slices will radiate around the z axis.  The stacks will be
         **    along the z axis.
         */
        static int generate_cone_vertices(float radius,
                float height,
                int num_slices,
                int num_layers,
                const diguyVec3f& position_offset,
                const diguyVec3f& orientation,      // degrees
                int* num_vertices,
                diguyVec3f** vertices,
                diguyVec3f** normals,
                diguyVec2f** texture_indices,
                int indices_for_wireframe,
                int* num_indices,
                unsigned int** indices);

        /*l
         *b  Description:
         **
         **    Similar to generate_sphere_vertices(), but for cylinders.
         **
         **    Untransformed, the cylinder's base will be at the local origin,
         **    the top above the base in positive z.
         **
         **    The slices will radiate around the z axis.  The stacks will be
         **    along the z axis.
         */
        static int generate_cylinder_vertices(float radius,
                float height,
                int num_slices,
                int num_layers,
                const diguyVec3f& position_offset,
                const diguyVec3f& orientation,      // degrees
                int* num_vertices,
                diguyVec3f** vertices,
                diguyVec3f** normals,
                diguyVec2f** texture_indices,
                int indices_for_wireframe,
                int* num_indices,
                unsigned int** indices);

        /*l
         *b  Description:
         **
         **    Similar to generate_sphere_vertices(), but for boxes, AKA
         **    rectangular solids.
         **
         **    Untransformed, the box's corners are represented by the passed min
         **    and max vectors, relative to the local origin.
         */
        static int generate_box_vertices(diguyVec3f min,
                diguyVec3f max,
                const diguyVec3f& position_offset,
                const diguyVec3f& orientation,      // degrees
                int* num_vertices,
                diguyVec3f** vertices,
                diguyVec3f** normals,
                diguyVec2f** texture_indices,
                int indices_for_wireframe,
                int* num_indices,
                unsigned int** indices);

        /*l
         *b  Description:
         **
         **    For deleting data generated by the various generate_*_vertices()
         **    functions.
         */
        static void delete_generated_vertices(diguyVec3f* vertices,
                diguyVec3f* normals,
                diguyVec2f* texture_indices,
                unsigned int* indices);

#endif

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

#ifdef CPLUSPLUS_ONLY

        bdiScenarioEditorInput* get_scripted_object() {return m_scripted_object;}

protected:

        // protected constructor
        diguyAuthorInterface(void* internal_data);

        // protected destructor
        virtual ~diguyAuthorInterface();

        // pointer to internal data
        friend class bdiScenarioApp;
        friend class bdiScenarioEditorInput;
        bdiScenarioEditorInput* m_scripted_object;

        static diguyAuthorInterfaceCreateFunc* s_create_func;

#endif

};

#endif /* __diguyAuthorInterface_H */