diguy_constants.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 1992-2016 VT MAK
 ** All rights reserved. 
 *********************************************************************/

/*********************************************************************
 **
 *t  DI-Guy API, Constants and Enumerations
 **
 **    The API is subject to change in future releases.
 **
 */

#ifndef __diguy_constants_H
#define __diguy_constants_H

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

#ifdef CPLUSPLUS_ONLY
#include <declspec_bdiutil.h>
#endif


/*****************************************************************************/
/*****************************************************************************/
//now live in diguy_version.h


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

/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy radians and degrees conversion factors.
 **
 */
#define DIGUY_PI (3.14159265358979323f)

#define DIGUY_RAD2DEG (180.0f / DIGUY_PI)
#define DIGUY_DEG2RAD (DIGUY_PI / 180.0f)


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This value is a magic number that, when passed to certain functions,
 **    means that the function should use or compute an appropriate default
 **    value for the argument.
 **
 */
#define DIGUY_DEFAULT_FLOAT (-16384.0f)


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This value is a magic number that, when passed to certain functions,
 **    means that the function should use or compute an appropriate default
 **    value for the argument.
 **
 */
#define DIGUY_DEFAULT_INT   (-16384)


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


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy callbacks return a value of type diguyCallbackReturn,
 **    which will be DIGUY_CALLBACK_STOP or DIGUY_CALLBACK_CONTINUE.
 **    If the callback returns DIGUY_CALLBACK_STOP, the default handler
 **    of the function will not be called; the callback is asserting
 **    that it has done everything necessary for the function call.
 **    If the callback returns DIGUY_CALLBACK_CONTINUE, the default
 **    handler for the function will be called after the callback.
 **
 */
typedef enum
{
        DIGUY_CALLBACK_STOP = 0,
        DIGUY_CALLBACK_CONTINUE

} diguyCallbackReturn;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy character classes.  This is a high-level description of the
 **    type of thing a character represents.
 **
 */
typedef enum
{
        DIGUY_CHARACTER_CLASS_UNKNOWN = 0,
        DIGUY_CHARACTER_CLASS_HUMAN,
        DIGUY_CHARACTER_CLASS_VEHICLE,
        DIGUY_CHARACTER_CLASS_OBJECT,
        DIGUY_CHARACTER_CLASS_EFFECT,
        DIGUY_CHARACTER_CLASS_ANIMAL,
        DIGUY_CHARACTER_CLASS_HUMAN_ON_VEHICLE,
        DIGUY_CHARACTER_CLASS_HUMAN_ON_OBJECT,
        DIGUY_CHARACTER_CLASS_HUMAN_ON_ANIMAL,
        DIGUY_CHARACTER_CLASS_OTHER,
        DIGUY_CHARACTER_CLASS_COUNT

} diguyCharacterClass;

/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy character appearance query API, this is for diguyCharacter::get_num_appearances_of_type()
 **
 */
enum diguyCharacterAppearanceTypes
{
        DIGUY_APPEARANCE_BODY = 0, 
        DIGUY_APPEARANCE_HEAD, 
        DIGUY_APPEARANCE_EXPRESSIVE_HEAD, 
        DIGUY_APPEARANCE_HAND_ITEM,
        DIGUY_APPEARANCE_TYPES_COUNT
};

/****************************************************************************/
/*l
 *b  Description:
 **
 **    This is an enumeration of the different modes a
 **    DI-Guy character can be in.  See diguyCharacter::get_action_mode(),
 **    diguyCharacter::get_position_mode().
 */
typedef enum
{
        DIGUY_CHARACTER_MODE_PATH = 0,
        DIGUY_CHARACTER_MODE_FREE,
        DIGUY_CHARACTER_MODE_COUNT

} diguyCharacterMode;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This is an enumeration of the different parameter comparison
 **    options that can be specified to various DI-Guy function calls,
 **    such as diguyCharacter::get_action_from_description().
 */
typedef enum
{
        DIGUY_PARAMETER_COMPARISON_NEAREST = 0,
        DIGUY_PARAMETER_COMPARISON_EQUAL,
        DIGUY_PARAMETER_COMPARISON_GREATER,
        DIGUY_PARAMETER_COMPARISON_LESS,
        DIGUY_PARAMETER_COMPARISON_COUNT

} diguyParameterComparison;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This is an enumeration of the different muzzles that can
 **    be specified to various DI-Guy function calls, such as
 **    diguyCharacter::set_default_weapon_muzzle() and
 **    diguyCharacter::fire_weapon().
 */
typedef enum
{
        DIGUY_MUZZLE_DEFAULT = 0,
        DIGUY_MUZZLE_RIFLE,
        DIGUY_MUZZLE_GRENADE_LAUNCHER,
        DIGUY_MUZZLE_ACCESSORY1,
        DIGUY_MUZZLE_TURRET1,
        DIGUY_MUZZLE_COUNT

} diguyMuzzle;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This is an enumeration of the different impact types that are found
 **    in diguyImpact.
 */
typedef enum
{
        DIGUY_IMPACT_DIRECT_HIT = 0,
        DIGUY_IMPACT_NEARBY_DETONATION,
        DIGUY_IMPACT_VEHICLE_COLLISION,
        DIGUY_IMPACT_NO_IMPACT,
        DIGUY_IMPACT_USER_GENERATED

} diguyImpactType;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy camera move modes.
 **
 **    In DI-Guy Scenario in Camera Input Mode, the movement
 **    mode of the camera determines what will happen when
 **    mouse buttons are pressed in the view window.
 */
typedef enum
{
        DIGUY_CAMERA_MOVE_DRAG = 0,
        DIGUY_CAMERA_MOVE_ORBIT,
        DIGUY_CAMERA_MOVE_FORWARD,
        DIGUY_CAMERA_MOVE_SIDEWAYS,
        DIGUY_CAMERA_MOVE_VERTICAL

} diguyViewCameraMoveMode;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    Aspects of the DI-Guy camera that can be servoed.
 **
 **    Servoing can also be disabled on each of these.
 */
typedef enum
{
        DIGUY_CAMERA_SERVO_POSITION = 0,
        DIGUY_CAMERA_SERVO_ORIENTATION,
        DIGUY_CAMERA_SERVO_FIX
} diguyViewCameraServoTarget;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy camera projection modes.
 **
 */
typedef enum
{
        DIGUY_CAMERA_PROJECTION_PERSPECTIVE = 0,
        DIGUY_CAMERA_PROJECTION_PLANVIEW_XY,
        DIGUY_CAMERA_PROJECTION_PLANVIEW_XZ,
        DIGUY_CAMERA_PROJECTION_PLANVIEW_YZ

} diguyViewCameraProjectionMode;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy fog modes.
 **
 */
typedef enum
{
        DIGUY_FOG_MODE_DISABLED   = 0,
        DIGUY_FOG_MODE_EXP        = 1,
        DIGUY_FOG_MODE_EXP2       = 2,
        DIGUY_FOG_MODE_LINEAR     = 3,
        DIGUY_FOG_MODE_PIX_EXP    = 4,
        DIGUY_FOG_MODE_PIX_EXP2   = 5,
        DIGUY_FOG_MODE_PIX_LINEAR = 6

} diguyViewFogMode;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy history types.
 **
 */
typedef enum
{
        DIGUY_HISTORY_TYPE_NONE = 0,
        DIGUY_HISTORY_TYPE_COMPLETE,
        DIGUY_HISTORY_TYPE_FIRST,
        DIGUY_HISTORY_TYPE_LAST,
        DIGUY_HISTORY_TYPE_PARTIAL

} diguyHistoryType;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy renderer class ids.
 **
 */
enum
{
        DIGUY_CLASSID_START = 0x400,

        DIGUY_CLASSID_CREATURE,
        DIGUY_CLASSID_LINK,
        DIGUY_CLASSID_SHAPE,

        DIGUY_CLASSID_CHARACTER,
        DIGUY_CLASSID_SCENE_OBJECT,
        DIGUY_CLASSID_PATH,
        DIGUY_CLASSID_PATH_SHAPE,
        DIGUY_CLASSID_SENSOR_REGION
} ;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy renderer pass masks, set via diguyApp::set_render_pass_flags().
 *>
 *i   DIGUY_RENDER_PASS_SKIP_PARTICLES
 **
 **      Particle rendering is skipped.
 **
 *i   DIGUY_RENDER_PASS_USE_STORED_LOD_SETTINGS
 **
 **      LOD recalculation is skipped (for built-in OGL pipeline).
 **
 *i   DIGUY_RENDER_PASS_REFLECTION
 **
 **      Internal use; water reflection objects are skipped.
 **
 *i   DIGUY_RENDER_PASS_SHADOW
 **
 **      Shadow pass assumed; water, environmental effects are skipped.
 **
 *i   DIGUY_RENDER_PASS_INTERSECTION
 **
 **      Pick pass assumed; link and shape colors are sent.
 *<
 */
enum diguyRenderPassFlags
{
        DIGUY_RENDER_PASS_SKIP_PARTICLES          = 0x00000001,
        DIGUY_RENDER_PASS_USE_STORED_LOD_SETTINGS = 0x00000002,
        DIGUY_RENDER_PASS_REFLECTION              = 0x00000004,
        DIGUY_RENDER_PASS_SHADOW                  = 0x00000008,
        DIGUY_RENDER_PASS_INTERSECTION            = 0x00000010,
        DIGUY_RENDER_PASS_DEBUGGING               = 0x00000020
};



/*****************************************************************************/
/*****************************************************************************/
typedef enum
{
        DIGUY_LOAD_INSTANTLY = 0,
        DIGUY_LOAD_PRIORITY_ASYNC = 1,
        DIGUY_LOAD_ASYNC = 2,

} diguyGraphicsTextureLoadingBehavior;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy error codes.
 **
 */
enum
{
        DIGUY_ERROR                                       = -1,

        DIGUY_ERROR_LICENSE_FAILURE                       = -100,
        DIGUY_ERROR_LICENSE_SOFTWARE_INITIALIZATION_ERROR = -101,
        DIGUY_ERROR_LICENSE_NOT_FOUND                     = -102,
        DIGUY_ERROR_LICENSE_EXPIRED                       = -103,
        DIGUY_ERROR_LICENSE_VERSION_MISMATCH              = -104,
        DIGUY_ERROR_LICENSE_COUNT_TOO_LOW                 = -105,
        DIGUY_ERROR_LICENSE_FILE_NOT_FOUND                = -106,
        DIGUY_ERROR_LICENSE_SERVER_ERROR                  = -107,
        DIGUY_ERROR_LICENSE_NO_DONGLE                     = -108,
        DIGUY_ERROR_LICENSE_NO_DONGLE_DRIVER              = -109,
        DIGUY_ERROR_LICENSE_UNKNOWN_ERROR                 = -199,

        DIGUY_ERROR_GRAPHICS_SUBSYSTEM_INIT_FAILED        = -200,
        DIGUY_ERROR_SIMULATION_SUBSYSTEM_INIT_FAILED      = -201,
        DIGUY_ERROR_DATA_INSTALLATION_MISSING             = -202,
        DIGUY_ERROR_DATA_VERSION_TOO_LOW                  = -203,
        DIGUY_ERROR_RENDERER_LICENSE_CHECK_FAILED         = -204
};


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy vector indices.
 **
 */
enum
{
        DIGUY_VEC_X = 0,
        DIGUY_VEC_Y,
        DIGUY_VEC_Z,
        DIGUY_VEC_W,

        DIGUY_VEC_RZ = 0,
        DIGUY_VEC_RX,
        DIGUY_VEC_RY,

        DIGUY_VEC_QX = 0,
        DIGUY_VEC_QY,
        DIGUY_VEC_QZ,
        DIGUY_VEC_QW
};


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy graphics joint types.
 **
 */
typedef enum
{
        DIGUY_GRAPHICS_JOINT_TYPE_UNKNOWN = 0,
        DIGUY_GRAPHICS_JOINT_TYPE_FROZEN,
        DIGUY_GRAPHICS_JOINT_TYPE_PIN,
        DIGUY_GRAPHICS_JOINT_TYPE_SLIDER,
        DIGUY_GRAPHICS_JOINT_TYPE_CYLINDER,
        DIGUY_GRAPHICS_JOINT_TYPE_UNIVERSAL,
        DIGUY_GRAPHICS_JOINT_TYPE_PLANAR,
        DIGUY_GRAPHICS_JOINT_TYPE_GIMBAL,
        DIGUY_GRAPHICS_JOINT_TYPE_BALL,
        DIGUY_GRAPHICS_JOINT_TYPE_6DOF,
        DIGUY_GRAPHICS_JOINT_TYPE_TRANSLATION_AND_PIN,
        DIGUY_GRAPHICS_JOINT_TYPE_TRANSLATION_AND_GIMBAL,
        DIGUY_GRAPHICS_JOINT_TYPE_COUNT

} diguyGraphicsJointType;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    When a scene is rendered in order to select a DI-Guy object from,
 **    say, a mouse click, the type of object selected is identified by
 **    this enumeration.
 **
 */
enum
{
        DIGUY_TYPE_UID_BASE_NOTHING = 0,
        DIGUY_TYPE_UID_BASE_CHARACTER,
        DIGUY_TYPE_UID_BASE_CHARACTER_LINK,
        DIGUY_TYPE_UID_BASE_CHARACTER_SHAPE,
        DIGUY_TYPE_UID_BASE_CHARACTER_PATH,
        DIGUY_TYPE_UID_BASE_CHARACTER_PATH_WAYPOINT,
        DIGUY_TYPE_UID_BASE_CHARACTER_BEAD,
        DIGUY_TYPE_UID_BASE_CROWD,
        DIGUY_TYPE_UID_BASE_REGION,
        DIGUY_TYPE_UID_BASE_LABEL,
        DIGUY_TYPE_UID_BASE_PATH_SHAPE,
        DIGUY_TYPE_UID_BASE_PATH_SHAPE_WAYPOINT,
        DIGUY_TYPE_UID_BASE_SCENE_OBJECT,
        DIGUY_TYPE_UID_BASE_SENSOR_REGION,
        DIGUY_TYPE_UID_BASE_OTHER,
        DIGUY_TYPE_UID_BASE_USER,
        DIGUY_TYPE_UID_BASE_COUNT
};


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration identifies which playback mode time should follow.
 **    Only valid inside DI-Guy Scenario.
 */
typedef enum
{
        DIGUY_SCENARIO_PLAYBACK_MODE_STOP = 0,
        DIGUY_SCENARIO_PLAYBACK_MODE_PLAY,
        DIGUY_SCENARIO_PLAYBACK_MODE_PLAY_REVERSE,
        DIGUY_SCENARIO_PLAYBACK_MODE_FF,
        DIGUY_SCENARIO_PLAYBACK_MODE_FF_REVERSE,
        DIGUY_SCENARIO_PLAYBACK_MODE_SS,
        DIGUY_SCENARIO_PLAYBACK_MODE_SS_REVERSE,
        DIGUY_SCENARIO_PLAYBACK_MODE_REWIND,
        DIGUY_SCENARIO_PLAYBACK_MODE_COUNT

} diguyScenarioPlaybackMode;

BDI_DECLSPEC_bdiutil const char* diguy_playback_mode_to_string(diguyScenarioPlaybackMode playback_mode);
BDI_DECLSPEC_bdiutil diguyScenarioPlaybackMode diguy_playback_mode_from_string(const char* string);


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the visibility options for various objects
 **    in the DI-Guy Scenario environment.
 */
typedef enum
{
        DIGUY_VISIBLE_NONE = 0,
        DIGUY_VISIBLE_CURRENT,
        DIGUY_VISIBLE_ALL,
        DIGUY_VISIBLE_PER_OBJECT

} diguyVisibleFlag;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists which parts of a visual object may need to be
 **    updated.  The values can be or-ed together.
 **
 *i    DIGUY_GRAPHICS_VISUAL_UPDATE_NONE
 **
 **      Nothing in the visual needs to be updated.
 **
 *i    DIGUY_GRAPHICS_VISUAL_UPDATE_GEOMETRY
 **
 **      The overall geometry of the visual needs to be updated.  This means
 **      that vertices and other parts of polygons need to be recalculated.
 **
 *i    DIGUY_GRAPHICS_VISUAL_UPDATE_POSITION
 **
 **      The position and/or orientation of the visual needs to be updated.
 **      The overall geometry of the visual (polygons, lines, etc.) remains
 **      unchanged.
 **
 *i    DIGUY_GRAPHICS_VISUAL_UPDATE_MATERIAL
 **
 **      The material of the visual needs to be updated.  This can include
 **      color, fill options, line width, etc.  The geometry and position of
 **      the visual remain the same.
 **
 *i    DIGUY_GRAPHICS_VISUAL_UPDATE_ALL
 **
 **      All aspects of the visual need to be updated.
 **
 */
typedef enum
{
        DIGUY_GRAPHICS_VISUAL_UPDATE_NONE     = 0,
        DIGUY_GRAPHICS_VISUAL_UPDATE_GEOMETRY = 1,
        DIGUY_GRAPHICS_VISUAL_UPDATE_POSITION = 2,
        DIGUY_GRAPHICS_VISUAL_UPDATE_MATERIAL = 4,
        DIGUY_GRAPHICS_VISUAL_UPDATE_ALL      = 255

} diguyAuthorVisualUpdateFlag;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy Euler angle orders.
 **
 **    ZXY is the order most commonly used in DIGuy. The meaning is: "rotate around
 **    object's z axis (yaw), then its x axis (roll), then its y axis (pitch)."
 **
 **    However, the DI-Guy camera system uses ZYX, since that's more intuitive.
 **
 */
typedef enum
{
        DIGUY_EULER_ANGLE_ORDER_ZXY = 0,
        DIGUY_EULER_ANGLE_ORDER_ZYZ,
        DIGUY_EULER_ANGLE_ORDER_XYZ,
        DIGUY_EULER_ANGLE_ORDER_XZY,
        DIGUY_EULER_ANGLE_ORDER_YXZ,
        DIGUY_EULER_ANGLE_ORDER_YZX,
        DIGUY_EULER_ANGLE_ORDER_ZYX

} diguyEulerAngleOrder;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration is used for various variables in the
 **    diguyScenarioMergeSettings object.  In general it tells
 **    the diguyScenario::merge() function whether to load
 **    objects of a specified type at all, and if so, what to
 **    do if a merged object conflicts with an existing object.
 **
 *i    DIGUY_MERGE_FLAG_DONT_MERGE
 **
 **      Objects in the merged scenario are not loaded.
 **
 *i    DIGUY_MERGE_FLAG_OVERWRITE_EXISTING
 **
 **      Objects in the merged scenario are loaded.
 **
 **      In the case of a conflict, the exiting object is overwritten
 **      with the values of the merge object.
 **
 *i    DIGUY_MERGE_FLAG_KEEP_BOTH
 **
 **      Objects in the merged scenario are loaded.
 **
 **      In the case of a conflict, both the exiting object
 **      and the merge object are kept, with no modifications.
 **      Note that this will leave some ambiguity of referencing
 **      objects by name.  A warning will be printed.
 **
 **      Note that this value is here to allow for backward
 **      compatibility; it is not recommended for general use.
 **
 *i    DIGUY_MERGE_FLAG_KEEP_EXISTING_ONLY
 **
 **      Objects in the merged scenario are loaded.
 **
 **      In the case of a conflict, the exiting object is kept
 **      as is and the merge object is discarded.
 **
 *i    DIGUY_MERGE_FLAG_KEEP_EXISTING_ONLY_AND_WARN
 **
 **      Same as DIGUY_MERGE_FLAG_KEEP_EXISTING, but also prints
 **      a warning.
 **
 *i    DIGUY_MERGE_FLAG_RENAME_MERGED
 **
 **      Objects in the merged scenario are loaded.
 **
 **      In the case of a conflict, both the exiting object
 **      and the merge object are kept, but the merged object
 **      is renamed.
 **
 *i    DIGUY_MERGE_FLAG_RENAME_MERGED_AND_WARN
 **
 **      Same as DIGUY_MERGE_FLAG_RENAME_MERGED, but also prints
 **      a warning.
 **
 *i    DIGUY_MERGE_FLAG_RENAME_MERGED_IF_NOT_EQUAL
 **
 **      Objects in the merged scenario are loaded.
 **
 **      In the case of a conflict, the existing object and merged
 **      object are checked for "equality".  If they are the same,
 **      the existing object will be kept and the merge object will
 **      be discarded.  If they are different, both objects will
 **      be kept, but the merge object will be renamed.
 **
 */
typedef enum
{
        DIGUY_MERGE_FLAG_DONT_MERGE = 0,
        DIGUY_MERGE_FLAG_OVERWRITE_EXISTING,
        DIGUY_MERGE_FLAG_KEEP_BOTH,
        DIGUY_MERGE_FLAG_KEEP_EXISTING_ONLY,
        DIGUY_MERGE_FLAG_KEEP_EXISTING_ONLY_AND_WARN,
        DIGUY_MERGE_FLAG_RENAME_MERGED,
        DIGUY_MERGE_FLAG_RENAME_MERGED_AND_WARN,
        DIGUY_MERGE_FLAG_RENAME_MERGED_IF_NOT_EQUAL,

} diguyScenarioMergeFlag;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration tells DI-Guy what values to use as defaults
 **    when the diguyScenario::create_merge_settings() functions
 **    is called.  See the documentation for that function for
 **    details on what the different values mean.
 **
 */
typedef enum
{
        DIGUY_MERGE_INITIAL_SETTINGS_DEFAULT = 0,
        DIGUY_MERGE_INITIAL_SETTINGS_MERGE_EVERYTHING,
        DIGUY_MERGE_INITIAL_SETTINGS_MERGE_NOTHING,
        DIGUY_MERGE_INITIAL_SETTINGS_DIGUY6_COMPATIBLE,
        DIGUY_MERGE_INITIAL_SETTINGS_PASTE

} diguyScenarioMergeInitialSettings;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration tells DI-Guy which scenario elements should be
 **    reset after the merge is complete.
 **
 */
typedef enum
{
        DIGUY_MERGE_RESET_NONE = 0,
        DIGUY_MERGE_RESET_MERGED,
        DIGUY_MERGE_RESET_ALL

} diguyScenarioMergeResetFlag;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the cursors returnable by the plugin
 **    function get_cursor().
 **
 *i    DIGUY_PLUGIN_MOUSE_CURSOR_NONE
 **
 **      Plugin takes responsibility for drawing cursor, if any.
 **
 *i    DIGUY_PLUGIN_MOUSE_CURSOR_LEFT_ARROW
 **
 **      The standard window-system left arrow cursor is shown.
 **
 *i    DIGUY_PLUGIN_MOUSE_CURSOR_CROSSHAIR
 **
 **      Crosshair (plus-shaped) cursor is shown.
 **
 *i    DIGUY_PLUGIN_MOUSE_CURSOR_POINTING_HAND
 **
 **      Pointing hand cursor is shown.
 **
 *i    DIGUY_PLUGIN_MOUSE_CURSOR_FORBIDDEN
 **
 **      Action forbidden cursor is shown.
 */
typedef enum
{
        DIGUY_PLUGIN_MOUSE_CURSOR_NONE = 0,
        DIGUY_PLUGIN_MOUSE_CURSOR_LEFT_ARROW,
        DIGUY_PLUGIN_MOUSE_CURSOR_CROSSHAIR,
        DIGUY_PLUGIN_MOUSE_CURSOR_POINTING_HAND,
        DIGUY_PLUGIN_MOUSE_CURSOR_FORBIDDEN

} diguyPluginMouseCursor;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists which cross-sections are available for
 **    DI-Guy chain simulation visuals.
 **
 *i    DIGUY_CHAIN_CROSS_SECTION_SQUARE
 **
 **      The square cross-section is good for tube-like visuals, such as
 **      hoses.  The normals of the square cross-section point radially
 **      outward from the center, giving the visual a rounded, tube-like
 **      appearance.
 **
 *i    DIGUY_CHAIN_CROSS_SECTION_PLUS
 **
 **      The plus cross-section is good for thin, chain-like visuals.
 **
 *i    DIGUY_CHAIN_CROSS_SECTION_COIL
 **
 **      The coil cross-section is good for wires.  The chain masses are
 **      connected by line segments.
 */
typedef enum
{
        DIGUY_CHAIN_CROSS_SECTION_SQUARE = 0,
        DIGUY_CHAIN_CROSS_SECTION_PLUS,
        DIGUY_CHAIN_CROSS_SECTION_COIL

} diguyChainCrossSection;


/****************************************************************************/
/*l
 *b  Description:
 **
 */
#define DIGUY_LOAD_MANAGER_NUM_ZONES                 (4)
#define DIGUY_LOAD_MANAGER_NUM_NONVISIBLE_ZONE_INDEX (3)


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the input modes available in DI-Guy
 **    Scenario views (3D windows) and for DI-Guy Author.
 */
typedef enum
{
        DIGUY_SCENARIO_INPUT_MODE_NONE = 0,
        DIGUY_SCENARIO_INPUT_MODE_CAMERA,
        DIGUY_SCENARIO_INPUT_MODE_PEOPLE_BLITZER,
        DIGUY_SCENARIO_INPUT_MODE_WAYPOINT_MOVE,
        DIGUY_SCENARIO_INPUT_MODE_WAYPOINT_CREATE,
        DIGUY_SCENARIO_INPUT_MODE_BEAD_MOVE,
        DIGUY_SCENARIO_INPUT_MODE_BEAD_CREATE,
        DIGUY_SCENARIO_INPUT_MODE_SENSOR_REGION_MOVE,
        DIGUY_SCENARIO_INPUT_MODE_SENSOR_REGION_CREATE,
        DIGUY_SCENARIO_INPUT_MODE_PLUGIN,
        DIGUY_SCENARIO_INPUT_MODE_POINT_SELECT,
        DIGUY_SCENARIO_INPUT_MODE_POINT_SELECT_WITH_CAMERA,
        DIGUY_SCENARIO_INPUT_MODE_GROUP_MOVE,
        DIGUY_SCENARIO_INPUT_MODE_CHARACTER_MOVE,
        DIGUY_SCENARIO_INPUT_MODE_IGUY,
        DIGUY_SCENARIO_INPUT_MODE_CROWD_EDITOR,
        DIGUY_SCENARIO_INPUT_MODE_CROWD_BLITZER,
        DIGUY_SCENARIO_INPUT_MODE_REGION_PAINTER,
        DIGUY_SCENARIO_INPUT_MODE_NAVMESH_PAINTER,
        DIGUY_SCENARIO_INPUT_MODE_COUNT

} diguyScenarioInputMode;

BDI_DECLSPEC_bdiutil const char* diguy_input_mode_to_string(diguyScenarioInputMode input_mode);
BDI_DECLSPEC_bdiutil diguyScenarioInputMode diguy_input_mode_from_string(const char* string);


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the windows that can be shown in the
 **    DI-Guy Scenario application.
 */
typedef enum
{
        DIGS_WINDOW_ALL_WINDOWS = 0,
        DIGS_WINDOW_TIME_CONTROL,
        DIGS_WINDOW_INPUT_MODE,
        DIGS_WINDOW_ACTION_SPREADSHEET,
        DIGS_WINDOW_SIGNAL_PALETTE,
        DIGS_WINDOW_SCENARIO_ELEMENTS,
        DIGS_WINDOW_CHARACTER_ELEMENTS,
        DIGS_WINDOW_DIGUY_AI_ELEMENTS,
        DIGS_WINDOW_CROWD_ELEMENTS = DIGS_WINDOW_DIGUY_AI_ELEMENTS,
        DIGS_WINDOW_VIEW_SETTINGS,
        DIGS_WINDOW_EVENT_HANDLERS,
        DIGS_WINDOW_NETWORK_SETTINGS,
        DIGS_WINDOW_LOG,
        DIGS_WINDOW_MOVIE_SETTINGS,
        DIGS_WINDOW_SECONDARY_3D_VIEW_0,
        DIGS_WINDOW_SECONDARY_3D_VIEW_1,
        DIGS_WINDOW_SECONDARY_3D_VIEW_2,
        DIGS_WINDOW_SECONDARY_3D_VIEW_3,
        DIGS_WINDOW_SECONDARY_3D_VIEW_4,
        DIGS_WINDOW_SECONDARY_3D_VIEW_5,
        DIGS_WINDOW_SECONDARY_3D_VIEW_6,
        DIGS_WINDOW_SECONDARY_3D_VIEW_7,
        DIGS_WINDOW_SECONDARY_3D_VIEW_8,
        DIGS_WINDOW_COUNT

} diguyScenarioWindowId;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists different types of editing actions that
 **    can be performed in the DI-Guy Scenario application.
 */
typedef enum
{
        // File menu
        DIGS_EDIT_ACTION_FILE_OPEN = 0,
        DIGS_EDIT_ACTION_FILE_MERGE,
        DIGS_EDIT_ACTION_FILE_SAVE,
        DIGS_EDIT_ACTION_FILE_SAVE_AS,
        DIGS_EDIT_ACTION_FILE_CLOSE,
        DIGS_EDIT_ACTION_FILE_SAVE_REVIEW_DATA,
        DIGS_EDIT_ACTION_FILE_LOAD_REVIEW_DATA,
        DIGS_EDIT_ACTION_FILE_EXIT,

        // Edit menu
        DIGS_EDIT_ACTION_EDIT_UNDO,
        DIGS_EDIT_ACTION_EDIT_CUT,
        DIGS_EDIT_ACTION_EDIT_COPY,
        DIGS_EDIT_ACTION_EDIT_PASTE,
        DIGS_EDIT_ACTION_EDIT_DELETE,
        DIGS_EDIT_ACTION_EDIT_PREFERENCES,

        // Help menu
        DIGS_EDIT_ACTION_HELP_KEY_MAPPINGS,
        DIGS_EDIT_ACTION_HELP_ABOUT,
        DIGS_EDIT_ACTION_HELP_API_DOCS,

        // number of edit actions
        DIGS_EDIT_ACTION_COUNT

} diguyScenarioEditAction;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists "special" (non-ASCII) keys that DI-Guy plugins
 **    may respond to.
 **
 **    (These enumerations currently match the Qt 4 Qt::Key_* values.)
 */
enum
{
        DIGUY_SPECIAL_KEY_MIN       = 0x1000000,
        DIGUY_SPECIAL_KEY_ESC       = 0x1000000,
        DIGUY_SPECIAL_KEY_TAB       = 0x1000001,
        DIGUY_SPECIAL_KEY_BACKTAB   = 0x1000002,
        DIGUY_SPECIAL_KEY_BACKSPACE = 0x1000003,
        DIGUY_SPECIAL_KEY_RETURN    = 0x1000004,
        DIGUY_SPECIAL_KEY_ENTER     = 0x1000005,
        DIGUY_SPECIAL_KEY_INSERT    = 0x1000006,
        DIGUY_SPECIAL_KEY_DELETE    = 0x1000007,
        DIGUY_SPECIAL_KEY_PAUSE     = 0x1000008,
        DIGUY_SPECIAL_KEY_PRINT     = 0x1000009,
        DIGUY_SPECIAL_KEY_HOME      = 0x1000010,
        DIGUY_SPECIAL_KEY_END       = 0x1000011,
        DIGUY_SPECIAL_KEY_LEFT      = 0x1000012,
        DIGUY_SPECIAL_KEY_UP        = 0x1000013,
        DIGUY_SPECIAL_KEY_RIGHT     = 0x1000014,
        DIGUY_SPECIAL_KEY_DOWN      = 0x1000015,
        DIGUY_SPECIAL_KEY_PAGE_UP   = 0x1000016,
        DIGUY_SPECIAL_KEY_PAGE_DOWN = 0x1000017,
        DIGUY_SPECIAL_KEY_SHIFT     = 0x1000020,

        DIGUY_SPECIAL_F1            = 0x1000030,
        DIGUY_SPECIAL_F2            = 0x1000031,
        DIGUY_SPECIAL_F3            = 0x1000032,
        DIGUY_SPECIAL_F4            = 0x1000033,
        DIGUY_SPECIAL_F5            = 0x1000034,
        DIGUY_SPECIAL_F6            = 0x1000035,
        DIGUY_SPECIAL_F7            = 0x1000036,
        DIGUY_SPECIAL_F8            = 0x1000037,
        DIGUY_SPECIAL_F9            = 0x1000038,
        DIGUY_SPECIAL_F10           = 0x1000039,
        DIGUY_SPECIAL_F11           = 0x100003A,
        DIGUY_SPECIAL_F12           = 0x100003B,

        DIGUY_SPECIAL_KEY_MAX       = 0x10000FF
};


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy aim algorithms.
 **
 */
typedef enum
{
        DIGUY_AIM_ALGORITHM_7 = 7,
        DIGUY_AIM_ALGORITHM_8 = 8

} diguyAimAlgorithm;




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


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the methods available for collision detection
 **    and avoidance against dynamic objects.
 **
 *i    DIGUY_DYNAMIC_AVOIDANCE_METHOD_DISABLED
 **
 **      Dynamic objects are not detected or avoided.  In effect this means
 **      that characters will walk through each other.
 **
 **      If a crowd is far away from the viewpoint, it is not obvious that
 **      this is happening.  Disabling the crowd's dynamic avoidance can
 **      reduce the overhead of the crowd on performance.
 **
 *i    DIGUY_DYNAMIC_AVOIDANCE_METHOD_REPULSION_ZONES
 **
 **      Characters are surrounded by zones of repulsion.  Other characters
 **      that enter these zones have their position, orientation, and/or
 **      action changed to try to get out of the zones.
 **
 *i    DIGUY_DYNAMIC_AVOIDANCE_METHOD_SIMPLE
 **
 **      This is an experimental method that is still being developed.
 **      It should not be used for now.
 */
typedef enum
{
        DIGUY_DYNAMIC_AVOIDANCE_METHOD_DISABLED = 0,
        DIGUY_DYNAMIC_AVOIDANCE_METHOD_REPULSION_ZONES,
        DIGUY_DYNAMIC_AVOIDANCE_METHOD_REPULSION_ZONES_AND_PROJECTED_FORCES

} diguyDynamicAvoidanceMethod;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the methods available for collision detection
 **    and avoidance against static objects in the environment.  These are
 **    usually scene objects and non-moving props.
 **
 *i    DIGUY_STATIC_AVOIDANCE_METHOD_DISABLED
 **
 **      Static objects are not detected or avoided.  In effect this means
 **      that characters can walk through walls.
 **
 **      If a crowd is not near any buildings, walls, or solid objects,
 **      disabling static avoidance can reduce the overhead of the crowd
 **      on performance.
 **
 *i    DIGUY_STATIC_AVOIDANCE_METHOD_FEELERS
 **
 **      The character uses 'feelers' to detect static objects and turn
 **      away from them.
 */
typedef enum
{
        DIGUY_STATIC_AVOIDANCE_METHOD_DISABLED = 0,
        DIGUY_STATIC_AVOIDANCE_METHOD_FEELERS

} diguyStaticAvoidanceMethod;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the standard feelers used for static object
 **    avoidance used by I-Guy and agent characters.
 */
typedef int diguyCharacterFeelerNumber;

enum
{
        DIGUY_CHARACTER_FEELER_F = 0,  // front
        DIGUY_CHARACTER_FEELER_FR,     // front right
        DIGUY_CHARACTER_FEELER_FL,     // front left
        DIGUY_CHARACTER_FEELER_L,      // left
        DIGUY_CHARACTER_FEELER_R,      // right
        DIGUY_CHARACTER_FEELER_BL,     // back left
        DIGUY_CHARACTER_FEELER_BR,     // back right
        DIGUY_CHARACTER_FEELER_B,      // back
        DIGUY_CHARACTER_FEELER_COUNT
};


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the state character feelers may be in.
 **
 *i    DIGUY_CHARACTER_FEELER_STATUS_NO_CONTACT
 **
 **      Feeler is not in contact with anything.
 **
 *i    DIGUY_CHARACTER_FEELER_STATUS_CONTACT_TURN
 **
 **      Feeler is in contact with an object just enough to cause the
 **      character to begin to turn.
 **
 *i    DIGUY_CHARACTER_FEELER_STATUS_CONTACT_COLLIDE
 **
 **      Feeler is in close contact with an object.  The object should be
 **      pushing the character away.
 **
 *i    DIGUY_CHARACTER_FEELER_STATUS_CONTACT_TURN_AND_COLLIDE
 **
 **      Feeler is within both turn and contact distances of an object.
 */
typedef enum
{
        DIGUY_CHARACTER_FEELER_STATUS_NO_CONTACT      = 0,
        DIGUY_CHARACTER_FEELER_STATUS_CONTACT_TURN    = 1,
        DIGUY_CHARACTER_FEELER_STATUS_CONTACT_COLLIDE = 2,
        DIGUY_CHARACTER_FEELER_STATUS_CONTACT_TURN_AND_COLLIDE = 3

} diguyCharacterFeelerStatus;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the turn directions a feeler can use when
 **    its status is DIGUY_CHARACTER_FEELER_STATUS_CONTACT_TURN.
 **
 *i    DIGUY_CHARACTER_FEELER_TURN_DIRECTION_NONE
 **
 **      Feeler does not turn the character.
 **
 *i    DIGUY_CHARACTER_FEELER_TURN_DIRECTION_L
 **
 **      Feeler turns the character to the left.
 **
 *i    DIGUY_CHARACTER_FEELER_TURN_DIRECTION_R
 **
 **      Feeler turns the character to the right.
 **
 *i    DIGUY_CHARACTER_FEELER_TURN_DIRECTION_L_OR_R
 **
 **      Feeler turns the character to the left or right, whichever
 **      will result in the turn behavior ending more quickly.
 */
typedef enum
{
        DIGUY_CHARACTER_FEELER_TURN_DIRECTION_NONE = 0, // as string: "none"
        DIGUY_CHARACTER_FEELER_TURN_DIRECTION_L,        // as string: "left"
        DIGUY_CHARACTER_FEELER_TURN_DIRECTION_R,        // as string: "right"
        DIGUY_CHARACTER_FEELER_TURN_DIRECTION_L_OR_R    // as string: "left_or_right"

} diguyCharacterFeelerTurnDirection;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    Directions a character can be traveling on a navigation path
 **    (nav path).
 **
 **    The travel behavior of agents use nav paths.
 **
 */
typedef enum
{
        DIGUY_NAV_PATH_DIRECTION_UNKNOWN = 0,    // as string: "unknown"
        DIGUY_NAV_PATH_DIRECTION_FORWARD,        // as string: "forward"
        DIGUY_NAV_PATH_DIRECTION_BACKWARD,       // as string: "backward"
        DIGUY_NAV_PATH_DIRECTION_COUNT

} diguyNavPathDirection;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    What a character following a nav path will do once it reaches the
 **    end of a nav path.
 **
 **    The travel behavior of agents use nav paths.
 **
 *i    DIGUY_NAV_PATH_AT_END_REVERSE
 **
 **      Agent reverses direction on the nav path, going through waypoints
 **      in opposite order.
 **
 *i    DIGUY_NAV_PATH_AT_END_LOOP
 **
 **      Agent's next waypoint is waypoint 0.  Best when last waypoint and
 **      first waypoint are close to each other, as in a loop path.
 **
 *i    DIGUY_NAV_PATH_AT_END_STOP
 **
 **      Stop at the end, switching to behavior none.
 **
 *i    DIGUY_NAV_PATH_AT_END_TELEPORT
 **
 **      Teleport to the beginning.  In general agents should be out of view
 **      at the beginning and end of the path, if possible.
 */
typedef enum
{
        DIGUY_NAV_PATH_AT_END_UNKNOWN = 0,       // as string: "unknown"
        DIGUY_NAV_PATH_AT_END_REVERSE,           // as string: "reverse"
        DIGUY_NAV_PATH_AT_END_LOOP,              // as string: "loop"
        DIGUY_NAV_PATH_AT_END_STOP,              // as string: "stop"
        DIGUY_NAV_PATH_AT_END_TELEPORT,          // as string: "teleport"

        // internal use only
        DIGUY_NAV_PATH_AT_END_SWITCH_BEHAVIOR,

        DIGUY_NAV_PATH_AT_END_COUNT

} diguyNavPathAtEnd;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    Errors various nav path functions may return.
 */
typedef enum
{
        DIGUY_NAV_PATH_ERROR_NONE                     =  0,
        DIGUY_NAV_PATH_ERROR_OUT_OF_TIME              =  1,
        DIGUY_NAV_PATH_ERROR_SEARCH_QUEUED            =  2,
        DIGUY_NAV_PATH_ERROR_UNKNOWN                  = -1,
        DIGUY_NAV_PATH_ERROR_INVALID_CANVAS_OR_REGION = -2,
        DIGUY_NAV_PATH_ERROR_INVALID_START_POINT      = -3,
        DIGUY_NAV_PATH_ERROR_INVALID_END_POINT        = -4,
        DIGUY_NAV_PATH_ERROR_INVALID_LENGTH           = -5,
        DIGUY_NAV_PATH_ERROR_FAILED_TO_FIND_PATH      = -6
} diguyNavPathSearchResults;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    Selection methods for records from crowd profiles.
 */
typedef enum
{
        DIGUY_CROWD_PROFILE_SELECTION_METHOD_RANDOM = 0,
        DIGUY_CROWD_PROFILE_SELECTION_METHOD_SEQUENTIAL,
        DIGUY_CROWD_PROFILE_SELECTION_METHOD_NUM_METHODS

} diguyCrowdProfileSelectionMethod;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy agent repulsion zones for characters with dynamic
 **    avoidance method DIGUY_DYNAMIC_AVOIDANCE_METHOD_REPULSION_ZONES.
 */
typedef enum
{
        DIGUY_AGENT_REPULSION_NONE = 0,
        DIGUY_AGENT_REPULSION_LOW,
        DIGUY_AGENT_REPULSION_MEDIUM,
        DIGUY_AGENT_REPULSION_HIGH,
        DIGUY_AGENT_REPULSION_SOLID,
        DIGUY_AGENT_REPULSION_NUM_ZONES

} diguyAgentRepulsionZone;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy agent behaviors.
 **
 **    Following is a short description of each behavior.  See the DI-Guy AI
 **    documentation for more details.
 **
 *i  DIGUY_AGENT_BEHAVIOR_NONE
 **
 **      Agent functionality is completely inactive.  The character's actions
 **      are determined by its character path or direct DI-Guy API calls.
 **
 *i  DIGUY_AGENT_BEHAVIOR_TRAVEL
 **
 **      Agent attempts to travel close to a path shape.  Many agents can use
 **      the same path shape for the travel behavior.
 **
 *i  DIGUY_AGENT_BEHAVIOR_PATH_FOLLOW
 **
 **      Similar to DIGUY_AGENT_BEHAVIOR_TRAVEL, but agent follows a
 **      character path instead of a path shape, and attempts to match the
 **      timing of the character path in addition to the path shape.  If the
 **      agent is interrupted from the path, it will attempt to resume it
 **      where it left off.
 **
 *i  DIGUY_AGENT_BEHAVIOR_WANDER
 **
 **      Agent wanders a region.  In this case wander means it will select a
 **      random point within the region and move close to it, and then wait
 **      there for a period of time before selecting a new point in the
 **      region.
 **
 *i  DIGUY_AGENT_BEHAVIOR_MINGLE
 **
 **      Similar to wander, but agents attempt to move together to various
 **      places in the region.
 **
 *i  DIGUY_AGENT_BEHAVIOR_FLEE
 **
 **      Agent attempts to move away from a specified character or point.
 **
 *i  DIGUY_AGENT_BEHAVIOR_PURSUE
 **
 **      Agent attempts to stay close to a specified character or member of a
 **      group.
 **
 *i  DIGUY_AGENT_BEHAVIOR_ATTACK
 **
 **      Similar to pursue, but once agents are close enough they will attack
 **      the target.
 **
 *i  DIGUY_AGENT_BEHAVIOR_IDLE
 **
 **      Agent has no particular automatic behavior; it follows its path or
 **      moves toward its desired position as set by
 **      diguyCharacter::set_desired_position().  It will affect other agents
 **      in its crowd, and if pushed away from its desired position it will
 **      move back to it.
 */
typedef enum
{
        DIGUY_AGENT_BEHAVIOR_UNKNOWN = -1,   // as string: "unknown"
        DIGUY_AGENT_BEHAVIOR_NONE = 0,       // as string: "none"
        DIGUY_AGENT_BEHAVIOR_TRAVEL,         // as string: "travel"
        DIGUY_AGENT_BEHAVIOR_PATH_FOLLOW,    // as string: "path_follow"
        DIGUY_AGENT_BEHAVIOR_WANDER,         // as string: "wander"
        DIGUY_AGENT_BEHAVIOR_FLEE,           // as string: "flee"
        DIGUY_AGENT_BEHAVIOR_PURSUE,         // as string: "pursue"
        DIGUY_AGENT_BEHAVIOR_MINGLE,         // as string: "mingle"
        DIGUY_AGENT_BEHAVIOR_ATTACK,         // as string: "attack"
        DIGUY_AGENT_BEHAVIOR_IDLE,           // as string: "idle"
        DIGUY_AGENT_BEHAVIOR_NUM_BEHAVIORS

} diguyAgentBehavior;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy agent untrap methods.
 **
 **      Following is a short description of each untrap method.  See the
 **      DI-Guy AI documentation for more details.
 **
 *i    DIGUY_AGENT_UNTRAP_METHOD_NONE
 **
 **      The agent makes no attempt to become untrapped.  This can result in
 **      the agent blindly walking into a wall until its desired position
 **      changes.
 **
 *i    DIGUY_AGENT_UNTRAP_METHOD_NAV_PATH
 **
 **      The agent will try to create a nav path in its current region to its
 **      desired position.  If the desired position is not inside the region,
 **      a valid nav path may not be able to be found.
 **
 *i    DIGUY_AGENT_UNTRAP_METHOD_RANDOM_TURN
 **
 **      The agent will stop moving and turn a random amount.  This minor
 **      course change can sometimes move a character around a small
 **      obstacle.
 **
 *i    DIGUY_AGENT_UNTRAP_METHOD_GHOST
 **
 **      Agent feelers will stop having an effect for a short time.  This
 **      allows the agent to walk through a wall toward its desired
 **      position.
 **
 *i    DIGUY_AGENT_UNTRAP_METHOD_TELEPORT
 **
 **      This is an extreme method, typically used as a last resort.  The
 **      agent abruptly teleports to its desired position.
 **
 *i    DIGUY_AGENT_UNTRAP_METHOD_STOP_MOVING
 **
 **      Somewhat similar to DIGUY_AGENT_UNTRAP_METHOD_NONE, but the current
 **      behavior of the agent is set to none, and the agent character's
 **      desired position is set to its current position.
 */
typedef enum
{
        DIGUY_AGENT_UNTRAP_METHOD_NONE = 0,     // as string: "none"
        DIGUY_AGENT_UNTRAP_METHOD_NAV_PATH,     // as string: "nav_path"
        DIGUY_AGENT_UNTRAP_METHOD_RANDOM_TURN,  // as string: "random_turn"
        DIGUY_AGENT_UNTRAP_METHOD_GHOST,        // as string: "ghost"
        DIGUY_AGENT_UNTRAP_METHOD_TELEPORT,     // as string: "teleport"
        DIGUY_AGENT_UNTRAP_METHOD_STOP_MOVING,  // as string: "stop_moving"
        DIGUY_AGENT_UNTRAP_METHOD_NUM_METHODS

} diguyAgentUntrapMethod;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy region painting modes.
 **
 **    Painting modes identify what happens when a region paintbrush is used
 **    in some of the DI-Guy input modes.
 **
 *i    DIGUY_REGION_PAINTBRUSH_MODE_ADDITIVE
 **
 **      Painting will add area to the current subregion.  This may end up
 **      adding area to the base subregion, as well, as it contains at
 **      least the areas of all subregions.
 **
 *i    DIGUY_REGION_PAINTBRUSH_MODE_ERASE
 **
 **      Painting will remove area from the current subregion.  If the base
 **      subregion is erased, all matching areas in other subregions will be
 **      erased, as well.
 **
 *i    DIGUY_REGION_PAINTBRUSH_MODE_UNGROUND_CLAMP
 **
 **      Painting will remove area from the current subregion, will also remove 
 **      the height value from the region and the next time the area is painted 
 **      it will adopt the height values of the new paint command.
 **
 *i    DIGUY_REGION_PAINTBRUSH_MODE_MOVE_MESH
 **
 **      Moves the mesh to a new location in space and re-ground clamps
 **
 *i    DIGUY_REGION_PAINTBRUSH_MODE_REACHABLE
 **
 **      Painting reachable will indicate that this is a spot the path planner 
 **      should be willing to traverse. Erasing Reachable colors the spot black 
 **      and indicates that it's not crossable or paint-able.
 **
 *i    DIGUY_REGION_PAINTBRUSH_INTERNAL_MODE_UPDATE_BEHAVIOR_PATH
 **
 **      Internal use only.
 **
 *i    DIGUY_REGION_PAINTBRUSH_INTERNAL_MODE_REPLACE
 **
 **      Internal use only.
 **
 */
typedef enum
{
        DIGUY_REGION_PAINTBRUSH_MODE_ADDITIVE = 0,
        DIGUY_REGION_PAINTBRUSH_MODE_ERASE,
        DIGUY_REGION_PAINTBRUSH_MODE_UNGROUND_CLAMP,
        DIGUY_REGION_PAINTBRUSH_MODE_MOVE_MESH,
        DIGUY_REGION_PAINTBRUSH_MODE_REACHABLE,
        DIGUY_REGION_PAINTBRUSH_INTERNAL_MODE_UPDATE_BEHAVIOR_PATH,
        DIGUY_REGION_PAINTBRUSH_INTERNAL_MODE_REPLACE,
        DIGUY_REGION_PAINTBRUSH_NUM_MODES

} diguyRegionPaintbrushMode;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy subregions.
 **
 **    Regions are irregularly shaped areas in the scene that can be used
 **    in a number of ways.
 **
 **    Regions contain a number of subregions.  Each subregion is represented
 **    by a different color, and most often the subregions are referred to
 **    by their color.  Subregions are not mutually exclusive; a point in
 **    the scene may be in all of the base, populate, and green subregions,
 **    for example.
 **
 **    Many functions that take one subregion as an argument use the string
 **    name of the subregion.
 **
 **    Functions that can have multiple subregions specified use a subregion
 **    mask made up of diguySubregionMask values that can be or'ed together
 **    to indicate multiple valid subregions.  See diguySubregionMask for
 **    more information.
 **
 *i    DIGUY_SUBREGION_BASE
 **
 **      This subregion is really a "super-region", in that its bounds contain
 **      all of the other subregions, and possibly more.
 **
 **      If any subregion of a top-level region is expanded beyond the bounds
 **      of the base subregion, the base subregion will be expanded until
 **      it encompasses the expansion.
 **
 **      If, however, a non-base subregion is subsequently shrunk, the base
 **      subregion will not shrink.
 **
 **      If the base subregion is shrunk, any portion of each non-base
 **      subregion that is no longer in the base subregion will be removed.
 **
 *i    DIGUY_SUBREGION_POPULATE
 **
 **      The subregion into which new crowd agents will be placed if the
 **      region is populated or repopulated.  This subregion is typically
 **      purple.
 **
 **    DIGUY_SUBREGION_[color]
 **
 **      The "color" subregions are free to be used in any way a scenario
 **      designer wants.  Their colors are based on their name.
 **
 *i    DIGUY_SUBREGION_ROAD
 **
 **      Road subregions are commonly used as preferred subregions for vehicle
 **      travel, and repulsion subregions for human travel.  This subregion
 **      is typically gray.
 **
 *i    DIGUY_SUBREGION_SIDEWALK
 **
 **      Sidewalk subregions are commonly used as preferred subregions for
 **      human travel, and repulsion subregions for vehicles.  This subregion
 **      is typically white.
 **
 *i    DIGUY_SUBREGION_CROSSWALK
 **
 **      Humans will tend to prefer crosswalk subregions over road subregions,
 **      but prefer sidewalk subregions over crosswalk subregions.  This
 **      subregion is typically a light yellow.
 */
typedef enum
{
        DIGUY_SUBREGION_BASE = 0,       // as string: "base"
        DIGUY_SUBREGION_POPULATE,       // as string: "populate"

        DIGUY_SUBREGION_RED,            // as string: "red"
        DIGUY_SUBREGION_GREEN,          // as string: "green"
        DIGUY_SUBREGION_BLUE,           // as string: "blue"
        DIGUY_SUBREGION_YELLOW,         // as string: "yellow"
        DIGUY_SUBREGION_ORANGE,         // as string: "orange"
        DIGUY_SUBREGION_WHITE,          // as string: "white"

        DIGUY_SUBREGION_ROAD,           // as string: "road"
        DIGUY_SUBREGION_SIDEWALK,       // as string: "sidewalk"
        DIGUY_SUBREGION_CROSSWALK,      // as string: "crosswalk"

        DIGUY_SUBREGION_NUM_SUBREGIONS

} diguySubregionIndex;


BDI_DECLSPEC_bdiutil const char* diguy_subregion_index_to_string(diguySubregionIndex subregion_index);
BDI_DECLSPEC_bdiutil diguySubregionIndex diguy_subregion_index_from_string(const char* string);


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy subregions mask values.
 **
 *b  Example:
 **
 **    To specify that a function can use either the red or blue subregions,
 **    the following syntax is used.
 **
 **    In Perl or C++:
 **
 *e      DIGUY_SUBREGION_MASK_RED | DIGUY_SUBREGION_MASK_BLUE
 **
 **    In Lua:
 **
 *e      bit.bor( DIGUY_SUBREGION_MASK_RED, DIGUY_SUBREGION_MASK_BLUE,...)
 **
 **    Lua does not natively support bitfields, but support is automatically
 **    added via the "LuaBit" library located in $DIGUY/bin/lua/bit.lua.
 */
typedef enum
{
        DIGUY_SUBREGION_MASK_NONE          = 0x00000000,
        DIGUY_SUBREGION_MASK_BASE          = 0x00000020,
        DIGUY_SUBREGION_MASK_POPULATE      = 0x00000040,

        DIGUY_SUBREGION_MASK_RED           = 0x00000080,
        DIGUY_SUBREGION_MASK_GREEN         = 0x00000100,
        DIGUY_SUBREGION_MASK_BLUE          = 0x00000200,
        DIGUY_SUBREGION_MASK_YELLOW        = 0x00000400,
        DIGUY_SUBREGION_MASK_ORANGE        = 0x00000800,
        DIGUY_SUBREGION_MASK_WHITE         = 0x00001000,

        DIGUY_SUBREGION_MASK_ROAD          = 0x00002000,
        DIGUY_SUBREGION_MASK_SIDEWALK      = 0x00004000,
        DIGUY_SUBREGION_MASK_CROSSWALK     = 0x00008000,

} diguySubregionMask;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    DI-Guy navigation mesh path planner cost masks.
 **
 **    Documentation pending: these require more explanation.
 **
 */
typedef enum
{
        DIGUY_NAVMESH_SHORTEST_PATH           = 0x00000001,
        DIGUY_NAVMESH_LEAST_VISIBLE           = 0x00000002,
        DIGUY_NAVMESH_MESH_EDGE               = 0x00000004,
        DIGUY_NAVMESH_MESH_EDGE_AND_LEAST_VIS = 0x00000006,
        DIGUY_NAVMESH_MESH_AVOID_EDGES        = 0x00000008,

} diguyNavMeshPathPlannerCostMask;


/****************************************************************************/
/*
 *  USMC chain of command:
 *
 *   fire team    - three individuals            - corporal
 *   squad        - three teams                  - sergeant
 *   platoon      - three squads (usually)       - lieutenant
 *   company      - three platoons               - captain
 *   battalion    - three companies              - lt. colonel
 *   regiment (or brigade) - three battalions    - ?
 *   division     - three regiments              - ?
 *   marine corps - three or more divisions      - ?
 *
 */
typedef enum
{
        DIGUY_TACTICS_UNIT_TYPE_UNKNOWN    = 0,

        DIGUY_TACTICS_UNIT_TYPE_MARINE,            // an individual
        DIGUY_TACTICS_UNIT_TYPE_MARINE_FIRETEAM,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_SQUAD,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_PLATOON,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_COMPANY,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_BATTALION,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_REGIMENT,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_DIVISION,
        DIGUY_TACTICS_UNIT_TYPE_MARINE_MARINE_CORPS,

        DIGUY_TACTICS_UNIT_TYPE_ARMY_SOLDIER,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_SQUAD,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_PLATOON,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_COMPANY,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_BATTALION,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_BRIGADE,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_DIVISION,
        DIGUY_TACTICS_UNIT_TYPE_ARMY_CORPS,
        DIGUY_TACTICS_UNIT_TYPE_ARMY              // two or more corps

} diguyTacticsUnitType;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the methods in which the datetime of a scenario
 **    can advance.
 **
 *i  DIGUY_DATETIME_ADVANCE_METHOD_MANUAL
 **
 **      Datetime does not advance automatically.  It can only be set
 **      manually, e.g. by a diguyScenario::set_current_datetime() call.
 **
 *i  DIGUY_DATETIME_ADVANCE_METHOD_REAL_TIME_RATE
 **
 **      Datetime advances at the same rate as realtime.
 **
 *i  DIGUY_DATETIME_ADVANCE_METHOD_SIMULATION_TIME_RATE
 **
 **      Datetime advances at the same rate as simulation time.
 */
typedef enum
{
        DIGUY_DATETIME_ADVANCE_METHOD_MANUAL = 0,
        DIGUY_DATETIME_ADVANCE_METHOD_REAL_TIME_RATE,
        DIGUY_DATETIME_ADVANCE_METHOD_SIMULATION_TIME_RATE

} diguyDatetimeAdvanceMethod;


/****************************************************************************/
/*l
 *b  Description:
 **
 *i  DIGUY_DATETIME_NETWORK_MODE_LOCAL_ONLY
 **
 **      Datetime data will be handled locally on this host.  No data will be
 **      sent on the netword, and no data will be read from the network.
 **
 *i  DIGUY_DATETIME_NETWORK_MODE_BROADCAST
 **
 **      Datetime data will be sent from this host to other hosts in the
 **      network.  The datetime will be encoded in a custom
 **      DIGUY_CUSTOM_PDU_ID_BROADCAST_EXERCISE_DATETIME PDU.  In general
 **      there should be only one host on the network broadcasting datetime
 **      data; all others should receive or ignore it.
 **
 *i  DIGUY_DATETIME_NETWORK_MODE_RECEIVE
 **
 **      Datetime data will be read from the network from custom
 **      DIGUY_CUSTOM_PDU_ID_BROADCAST_EXERCISE_DATETIME PDUs.
 */
typedef enum
{
        DIGUY_DATETIME_NETWORK_MODE_LOCAL_ONLY = 0,
        DIGUY_DATETIME_NETWORK_MODE_BROADCAST,
        DIGUY_DATETIME_NETWORK_MODE_RECEIVE

} diguyDatetimeNetworkMode;


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


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists units of speed that can be passed to some
 **    DI-Guy API functions.
 **
 **    Note that if one of these values is used specifying an acceleration,
 **    add an implicit "per second" to the end.  e.g., if 10.0 is passed as
 **    an acceleration, with units DIGUY_SPEED_UNITS_MILES_PER_HOUR,
 **    the resulting acceleration would be 10.0 miles per hour per second;
 **    or in other words, every 1 second speed would increase by 10.0 miles
 **    per hour.
 */
typedef enum
{
        DIGUY_SPEED_UNITS_METERS_PER_SECOND = 0,
        DIGUY_SPEED_UNITS_KILOMETERS_PER_HOUR,
        DIGUY_SPEED_UNITS_MILES_PER_HOUR

} diguySpeedUnits;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the ways that data can be generated for DI-Guy
 **    characters.  Data typically comes from the DI-Guy motion engine,
 **    but at times may be generated by other simulation methods.
 */
typedef enum
{
        DIGUY_CHARACTER_SIMULATOR_UNSET = 0,
        DIGUY_CHARACTER_SIMULATOR_DIGUY_MOTION_ENGINE,
        DIGUY_CHARACTER_SIMULATOR_DIGUY_CHAIN_SIMULATOR,
        DIGUY_CHARACTER_SIMULATOR_DIGUY_VEHICLE_SIMULATOR,
        DIGUY_CHARACTER_SIMULATOR_PHYSICS_SIM_MODULE

} diguyCharacterSimulator;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the modes that a DI-Guy character physics sim
 **    can be in, when the character simulator is set to
 **    DIGUY_CHARACTER_SIMULATOR_PHYSICS_SIM_MODULE.
 */
typedef enum
{
        DIGUY_PHYSICS_SIMULATION_MODE_UNSET = 0,
        DIGUY_PHYSICS_SIMULATION_MODE_SIM_DRIVES_CHARACTER,
        DIGUY_PHYSICS_SIMULATION_MODE_CHARACTER_DRIVES_SIM,
        DIGUY_PHYSICS_SIMULATION_MODE_CHARACTER_DRIVES_SIM_GOAL_DATA  // not yet supported

} diguyPhysicsSimulationMode;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the collision groups that a DI-Guy physics sim
 **    object can be in.  Characters in different collision groups may not
 **    have collisions calculated between them.
 */
typedef enum
{
        DIGUY_PHYSICS_COLLISION_GROUP_CHARACTER0,
        DIGUY_PHYSICS_COLLISION_GROUP_CHARACTER1,
        DIGUY_PHYSICS_COLLISION_GROUP_CHARACTER2,
        DIGUY_PHYSICS_COLLISION_GROUP_CHARACTER3,
        DIGUY_PHYSICS_COLLISION_GROUP_CHARACTER_EVERYTHING,
        DIGUY_PHYSICS_COLLISION_GROUP_CHARACTER_GHOST,

        DIGUY_PHYSICS_COLLISION_GROUP_PROP0,
        DIGUY_PHYSICS_COLLISION_GROUP_PROP1,
        DIGUY_PHYSICS_COLLISION_GROUP_PROP2,
        DIGUY_PHYSICS_COLLISION_GROUP_PROP3,

        DIGUY_PHYSICS_COLLISION_GROUP_SCENE_OBJECT0,
        DIGUY_PHYSICS_COLLISION_GROUP_SCENE_OBJECT1,
        DIGUY_PHYSICS_COLLISION_GROUP_SCENE_OBJECT2,
        DIGUY_PHYSICS_COLLISION_GROUP_SCENE_OBJECT3,

        DIGUY_PHYSICS_COLLISION_GROUP_EFFECT0,

        DIGUY_PHYSICS_COLLISION_GROUP_COUNT

} diguyPhysicsCollisionGroup;


/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists the modes that the DI-Guy vehicle simulator
 **    can be in.
 */
typedef enum
{
        DIGUY_VEHICLE_SIMULATION_MODE_DEFAULT = 0,
        DIGUY_VEHICLE_SIMULATION_MODE_NONE,
        DIGUY_VEHICLE_SIMULATION_MODE_REAR_AXLE_FOLLOWING,
        DIGUY_VEHICLE_SIMULATION_MODE_WHEELS,
        DIGUY_VEHICLE_SIMULATION_MODE_STEERING,
        DIGUY_VEHICLE_SIMULATION_MODE_FULL_PHYSICS

} diguyVehicleSimulationMode;


BDI_DECLSPEC_bdiutil const char* diguy_vehicle_simulation_mode_to_string(diguyVehicleSimulationMode mode);
BDI_DECLSPEC_bdiutil diguyVehicleSimulationMode diguy_vehicle_simulation_mode_from_string(const char* string);


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

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

/****************************************************************************/
/*l
 *b  Description:
 **
 **    This enumeration lists supported shader languages.
 */
typedef enum
{
        DIGUY_GRAPHICS_SHADER_LANGUAGE_GLSL = 0,
        DIGUY_GRAPHICS_SHADER_LANGUAGE_HLSL = 1

} diguyGraphicsShaderLanguage;




#endif /* __diguy_constants_H */