Real Name
This commit is contained in:
@@ -0,0 +1,167 @@
|
||||
#ifndef _XPLMCamera_h_
|
||||
#define _XPLMCamera_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* XPLMCamera - THEORY OF OPERATION The XPLMCamera APIs allow plug-ins to
|
||||
* control the camera angle in X-Plane. This has a number of applications,
|
||||
* including but not limited to:
|
||||
*
|
||||
* - Creating new views (including dynamic/user-controllable views) for the
|
||||
* user.
|
||||
*
|
||||
* - Creating applications that use X-Plane as a renderer of scenery,
|
||||
* aircrafts, or both.
|
||||
*
|
||||
* The camera is controlled via six parameters: a location in OpenGL
|
||||
* coordinates and pitch, roll and yaw, similar to an airplane's position.
|
||||
* OpenGL coordinate info is described in detail in the XPLMGraphics
|
||||
* documentation; generally you should use the XPLMGraphics routines to
|
||||
* convert from world to local coordinates. The camera's orientation starts
|
||||
* facing level with the ground directly up the negative-Z axis
|
||||
* (approximately north) with the horizon horizontal. It is then rotated
|
||||
* clockwise for yaw, pitched up for positive pitch, and rolled clockwise
|
||||
* around the vector it is looking along for roll.
|
||||
*
|
||||
* You control the camera either either until the user selects a new view or
|
||||
* permanently (the later being similar to how UDP camera control works). You
|
||||
* control the camera by registering a callback per frame from which you
|
||||
* calculate the new camera positions. This guarantees smooth camera motion.
|
||||
*
|
||||
* Use the XPLMDataAccess APIs to get information like the position of the
|
||||
* aircraft, etc. for complex camera positioning.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* CAMERA CONTROL
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMCameraControlDuration
|
||||
*
|
||||
* This enumeration states how long you want to retain control of the camera.
|
||||
* You can retain it indefinitely or until the user selects a new view.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* Control the camera until the user picks a new view. */
|
||||
xplm_ControlCameraUntilViewChanges = 1
|
||||
|
||||
/* Control the camera until your plugin is disabled or another plugin
|
||||
* forcably * takes control. */
|
||||
,
|
||||
xplm_ControlCameraForever = 2
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMCameraControlDuration;
|
||||
|
||||
/*
|
||||
* XPLMCameraPosition_t
|
||||
*
|
||||
* This structure contains a full specification of the camera. X, Y, and Z
|
||||
* are the camera's position in OpenGL coordiantes; pitch, roll, and yaw are
|
||||
* rotations from a camera facing flat north in degrees. Positive pitch means
|
||||
* nose up, positive roll means roll right, and positive yaw means yaw right,
|
||||
* all in degrees. Zoom is a zoom factor, with 1.0 meaning normal zoom and 2.0
|
||||
* magnifying by 2x (objects appear larger).
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float pitch;
|
||||
float heading;
|
||||
float roll;
|
||||
float zoom;
|
||||
} XPLMCameraPosition_t;
|
||||
|
||||
/*
|
||||
* XPLMCameraControl_f
|
||||
*
|
||||
* You use an XPLMCameraControl function to provide continuous control over
|
||||
* the camera. You are passed in a structure in which to put the new camera
|
||||
* position; modify it and return 1 to reposition the camera. Return 0 to
|
||||
* surrender control of the camera; camera control will be handled by X-Plane
|
||||
* on this draw loop. The contents of the structure as you are called are
|
||||
* undefined.
|
||||
*
|
||||
* If X-Plane is taking camera control away from you, this function will be
|
||||
* called with inIsLosingControl set to 1 and ioCameraPosition NULL.
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMCameraControl_f)(
|
||||
XPLMCameraPosition_t *outCameraPosition, /* Can be NULL */
|
||||
int inIsLosingControl,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMControlCamera
|
||||
*
|
||||
* This function repositions the camera on the next drawing cycle. You must
|
||||
* pass a non-null control function. Specify in inHowLong how long you'd like
|
||||
* control (indefinitely or until a key is pressed).
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMControlCamera(XPLMCameraControlDuration inHowLong,
|
||||
XPLMCameraControl_f inControlFunc,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMDontControlCamera
|
||||
*
|
||||
* This function stops you from controlling the camera. If you have a camera
|
||||
* control function, it will not be called with an inIsLosingControl flag.
|
||||
* X-Plane will control the camera on the next cycle.
|
||||
*
|
||||
* For maximum compatibility you should not use this routine unless you are in
|
||||
* posession of the camera.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDontControlCamera(void);
|
||||
|
||||
/*
|
||||
* XPLMIsCameraBeingControlled
|
||||
*
|
||||
* This routine returns 1 if the camera is being controlled, zero if it is
|
||||
* not. If it is and you pass in a pointer to a camera control duration, the
|
||||
* current control duration will be returned.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMIsCameraBeingControlled(
|
||||
XPLMCameraControlDuration *outCameraControlDuration); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMReadCameraPosition
|
||||
*
|
||||
* This function reads the current camera position.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMReadCameraPosition(XPLMCameraPosition_t *outCameraPosition);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,670 @@
|
||||
#ifndef _XPLMDataAccess_h_
|
||||
#define _XPLMDataAccess_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* XPLM Data Access API - Theory of Operation
|
||||
*
|
||||
* The data access API gives you a generic, flexible, high performance way to
|
||||
* read and write data to and from X-Plane and other plug-ins. For example,
|
||||
* this API allows you to read and set the nav radios, get the plane location,
|
||||
* determine the current effective graphics frame rate, etc.
|
||||
*
|
||||
* The data access APIs are the way that you read and write data from the sim
|
||||
* as well as other plugins.
|
||||
*
|
||||
* The API works using opaque data references. A data reference is a source
|
||||
* of data; you do not know where it comes from, but once you have it you can
|
||||
* read the data quickly and possibly write it. To get a data reference, you
|
||||
* look it up.
|
||||
*
|
||||
* Data references are identified by verbose string names
|
||||
* (sim/cockpit/radios/nav1_freq_hz). The actual numeric value of the data
|
||||
* reference is implementation defined and is likely to change each time the
|
||||
* simulator is run (or the plugin that provides the datareference is
|
||||
* reloaded).
|
||||
*
|
||||
* The task of looking up a data reference is relatively expensive; look up
|
||||
* your data references once based on verbose strings, and save the opaque
|
||||
* data reference value for the duration of your plugin's operation. Reading
|
||||
* and writing data references is relatively fast (the cost is equivalent to
|
||||
* two function calls through function pointers).
|
||||
*
|
||||
* This allows data access to be high performance, while leaving in
|
||||
* abstraction; since data references are opaque and are searched for, the
|
||||
* underlying data access system can be rebuilt.
|
||||
*
|
||||
* A note on typing: you must know the correct data type to read and write.
|
||||
* APIs are provided for reading and writing data in a number of ways. You
|
||||
* can also double check the data type for a data ref. Note that automatic
|
||||
* conversion is not done for you.
|
||||
*
|
||||
* A note for plugins sharing data with other plugins: the load order of
|
||||
* plugins is not guaranteed. To make sure that every plugin publishing data
|
||||
* has published their data references before other plugins try to subscribe,
|
||||
* publish your data references in your start routine but resolve them the
|
||||
* first time your 'enable' routine is called, or the first time they are
|
||||
* needed in code.
|
||||
*
|
||||
* X-Plane publishes well over 1000 datarefs; a complete list may be found in
|
||||
* the reference section of the SDK online documentation (from the SDK home
|
||||
* page, choose Documentation).
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* READING AND WRITING DATA
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These routines allow you to access a wide variety of data from within
|
||||
* x-plane and modify some of it.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMDataRef
|
||||
*
|
||||
* A data ref is an opaque handle to data provided by the simulator or another
|
||||
* plugin. It uniquely identifies one variable (or array of variables) over
|
||||
* the lifetime of your plugin. You never hard code these values; you always
|
||||
* get them from XPLMFindDataRef.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMDataRef;
|
||||
|
||||
/*
|
||||
* XPLMDataTypeID
|
||||
*
|
||||
* This is an enumeration that defines the type of the data behind a data
|
||||
* reference. This allows you to sanity check that the data type matches what
|
||||
* you expect. But for the most part, you will know the type of data you are
|
||||
* expecting from the online documentation.
|
||||
*
|
||||
* Data types each take a bit field, so sets of data types may be formed.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* Data of a type the current XPLM doesn't do. */
|
||||
xplmType_Unknown = 0
|
||||
|
||||
/* A single 4-byte integer, native endian. */
|
||||
,
|
||||
xplmType_Int = 1
|
||||
|
||||
/* A single 4-byte float, native endian. */
|
||||
,
|
||||
xplmType_Float = 2
|
||||
|
||||
/* A single 8-byte double, native endian. */
|
||||
,
|
||||
xplmType_Double = 4
|
||||
|
||||
/* An array of 4-byte floats, native endian. */
|
||||
,
|
||||
xplmType_FloatArray = 8
|
||||
|
||||
/* An array of 4-byte integers, native endian. */
|
||||
,
|
||||
xplmType_IntArray = 16
|
||||
|
||||
/* A variable block of data. */
|
||||
,
|
||||
xplmType_Data = 32
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMDataTypeID;
|
||||
|
||||
/*
|
||||
* XPLMFindDataRef
|
||||
*
|
||||
* Given a c-style string that names the data ref, this routine looks up the
|
||||
* actual opaque XPLMDataRef that you use to read and write the data. The
|
||||
* string names for datarefs are published on the x-plane SDK web site.
|
||||
*
|
||||
* This function returns NULL if the data ref cannot be found.
|
||||
*
|
||||
* NOTE: this function is relatively expensive; save the XPLMDataRef this
|
||||
* function returns for future use. Do not look up your data ref by string
|
||||
* every time you need to read or write it.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMDataRef XPLMFindDataRef(const char *inDataRefName);
|
||||
|
||||
/*
|
||||
* XPLMCanWriteDataRef
|
||||
*
|
||||
* Given a data ref, this routine returns true if you can successfully set
|
||||
* the data, false otherwise. Some datarefs are read-only.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMCanWriteDataRef(XPLMDataRef inDataRef);
|
||||
|
||||
/*
|
||||
* XPLMIsDataRefGood
|
||||
*
|
||||
* WARNING: This function is deprecated and should not be used. Datarefs are
|
||||
* valid until plugins are reloaded or the sim quits. Plugins sharing
|
||||
* datarefs should support these semantics by not unregistering datarefs
|
||||
* during operation. (You should however unregister datarefs when your plugin
|
||||
* is unloaded, as part of general resource cleanup.)
|
||||
*
|
||||
* This function returns whether a data ref is still valid. If it returns
|
||||
* false, you should refind the data ref from its original string. Calling an
|
||||
* accessor function on a bad data ref will return a default value, typically
|
||||
* 0 or 0-length data.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMIsDataRefGood(XPLMDataRef inDataRef);
|
||||
|
||||
/*
|
||||
* XPLMGetDataRefTypes
|
||||
*
|
||||
* This routine returns the types of the data ref for accessor use. If a data
|
||||
* ref is available in multiple data types, they will all be returned.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMDataTypeID XPLMGetDataRefTypes(XPLMDataRef inDataRef);
|
||||
|
||||
/***************************************************************************
|
||||
* DATA ACCESSORS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These routines read and write the data references. For each supported data
|
||||
* type there is a reader and a writer.
|
||||
*
|
||||
* If the data ref is invalid or the plugin that provides it is disabled or
|
||||
* there is a type mismatch, the functions that read data will return 0 as a
|
||||
* default value or not modify the passed in memory. The plugins that write
|
||||
* data will not write under these circumstances or if the data ref is
|
||||
* read-only. NOTE: to keep the overhead of reading datarefs low, these
|
||||
* routines do not do full validation of a dataref; passing a junk value for
|
||||
* a dataref can result in crashing the sim.
|
||||
*
|
||||
* For array-style datarefs, you specify the number of items to read/write and
|
||||
* the offset into the array; the actual number of items read or written is
|
||||
* returned. This may be less to prevent an array-out-of-bounds error.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMGetDatai
|
||||
*
|
||||
* Read an integer data ref and return its value. The return value is the
|
||||
* dataref value or 0 if the dataref is invalid/NULL or the plugin is
|
||||
* disabled.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDatai(XPLMDataRef inDataRef);
|
||||
|
||||
/*
|
||||
* XPLMSetDatai
|
||||
*
|
||||
* Write a new value to an integer data ref. This routine is a no-op if the
|
||||
* plugin publishing the dataref is disabled, the dataref is invalid, or the
|
||||
* dataref is not writable.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDatai(XPLMDataRef inDataRef, int inValue);
|
||||
|
||||
/*
|
||||
* XPLMGetDataf
|
||||
*
|
||||
* Read a single precision floating point dataref and return its value. The
|
||||
* return value is the dataref value or 0.0 if the dataref is invalid/NULL or
|
||||
* the plugin is disabled.
|
||||
*
|
||||
*/
|
||||
XPLM_API float XPLMGetDataf(XPLMDataRef inDataRef);
|
||||
|
||||
/*
|
||||
* XPLMSetDataf
|
||||
*
|
||||
* Write a new value to a single precision floating point data ref. This
|
||||
* routine is a no-op if the plugin publishing the dataref is disabled, the
|
||||
* dataref is invalid, or the dataref is not writable.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDataf(XPLMDataRef inDataRef, float inValue);
|
||||
|
||||
/*
|
||||
* XPLMGetDatad
|
||||
*
|
||||
* Read a double precision floating point dataref and return its value. The
|
||||
* return value is the dataref value or 0.0 if the dataref is invalid/NULL or
|
||||
* the plugin is disabled.
|
||||
*
|
||||
*/
|
||||
XPLM_API double XPLMGetDatad(XPLMDataRef inDataRef);
|
||||
|
||||
/*
|
||||
* XPLMSetDatad
|
||||
*
|
||||
* Write a new value to a double precision floating point data ref. This
|
||||
* routine is a no-op if the plugin publishing the dataref is disabled, the
|
||||
* dataref is invalid, or the dataref is not writable.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDatad(XPLMDataRef inDataRef, double inValue);
|
||||
|
||||
/*
|
||||
* XPLMGetDatavi
|
||||
*
|
||||
* Read a part of an integer array dataref. If you pass NULL for outVaules,
|
||||
* the routine will return the size of the array, ignoring inOffset and inMax.
|
||||
*
|
||||
*
|
||||
* If outValues is not NULL, then up to inMax values are copied from the
|
||||
* dataref into outValues, starting at inOffset in the dataref. If inMax +
|
||||
* inOffset is larger than the size of the dataref, less than inMax values
|
||||
* will be copied. The number of values copied is returned.
|
||||
*
|
||||
* Note: the semantics of array datarefs are entirely implemented by the
|
||||
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
|
||||
* above description is how these datarefs are intended to work, but a rogue
|
||||
* plugin may have different behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDatavi(XPLMDataRef inDataRef,
|
||||
int *outValues, /* Can be NULL */
|
||||
int inOffset,
|
||||
int inMax);
|
||||
|
||||
/*
|
||||
* XPLMSetDatavi
|
||||
*
|
||||
* Write part or all of an integer array dataref. The values passed by
|
||||
* inValues are written into the dataref starting at inOffset. Up to inCount
|
||||
* values are written; however if the values would write "off the end" of the
|
||||
* dataref array, then fewer values are written.
|
||||
*
|
||||
* Note: the semantics of array datarefs are entirely implemented by the
|
||||
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
|
||||
* above description is how these datarefs are intended to work, but a rogue
|
||||
* plugin may have different behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDatavi(XPLMDataRef inDataRef,
|
||||
int *inValues,
|
||||
int inoffset,
|
||||
int inCount);
|
||||
|
||||
/*
|
||||
* XPLMGetDatavf
|
||||
*
|
||||
* Read a part of a single precision floating point array dataref. If you
|
||||
* pass NULL for outVaules, the routine will return the size of the array,
|
||||
* ignoring inOffset and inMax.
|
||||
*
|
||||
* If outValues is not NULL, then up to inMax values are copied from the
|
||||
* dataref into outValues, starting at inOffset in the dataref. If inMax +
|
||||
* inOffset is larger than the size of the dataref, less than inMax values
|
||||
* will be copied. The number of values copied is returned.
|
||||
*
|
||||
* Note: the semantics of array datarefs are entirely implemented by the
|
||||
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
|
||||
* above description is how these datarefs are intended to work, but a rogue
|
||||
* plugin may have different behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDatavf(XPLMDataRef inDataRef,
|
||||
float *outValues, /* Can be NULL */
|
||||
int inOffset,
|
||||
int inMax);
|
||||
|
||||
/*
|
||||
* XPLMSetDatavf
|
||||
*
|
||||
* Write part or all of a single precision floating point array dataref. The
|
||||
* values passed by inValues are written into the dataref starting at
|
||||
* inOffset. Up to inCount values are written; however if the values would
|
||||
* write "off the end" of the dataref array, then fewer values are written.
|
||||
*
|
||||
* Note: the semantics of array datarefs are entirely implemented by the
|
||||
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
|
||||
* above description is how these datarefs are intended to work, but a rogue
|
||||
* plugin may have different behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDatavf(XPLMDataRef inDataRef,
|
||||
float *inValues,
|
||||
int inoffset,
|
||||
int inCount);
|
||||
|
||||
/*
|
||||
* XPLMGetDatab
|
||||
*
|
||||
* Read a part of a byte array dataref. If you pass NULL for outVaules, the
|
||||
* routine will return the size of the array, ignoring inOffset and inMax.
|
||||
*
|
||||
* If outValues is not NULL, then up to inMax values are copied from the
|
||||
* dataref into outValues, starting at inOffset in the dataref. If inMax +
|
||||
* inOffset is larger than the size of the dataref, less than inMax values
|
||||
* will be copied. The number of values copied is returned.
|
||||
*
|
||||
* Note: the semantics of array datarefs are entirely implemented by the
|
||||
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
|
||||
* above description is how these datarefs are intended to work, but a rogue
|
||||
* plugin may have different behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDatab(XPLMDataRef inDataRef,
|
||||
void *outValue, /* Can be NULL */
|
||||
int inOffset,
|
||||
int inMaxBytes);
|
||||
|
||||
/*
|
||||
* XPLMSetDatab
|
||||
*
|
||||
* Write part or all of a byte array dataref. The values passed by inValues
|
||||
* are written into the dataref starting at inOffset. Up to inCount values
|
||||
* are written; however if the values would write "off the end" of the dataref
|
||||
* array, then fewer values are written.
|
||||
*
|
||||
* Note: the semantics of array datarefs are entirely implemented by the
|
||||
* plugin (or X-Plane) that provides the dataref, not the SDK itself; the
|
||||
* above description is how these datarefs are intended to work, but a rogue
|
||||
* plugin may have different behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDatab(XPLMDataRef inDataRef,
|
||||
void *inValue,
|
||||
int inOffset,
|
||||
int inLength);
|
||||
|
||||
/***************************************************************************
|
||||
* PUBLISHING YOUR PLUGINS DATA
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These functions allow you to create data references that other plug-ins can
|
||||
* access via the above data access APIs. Data references published by other
|
||||
* plugins operate the same as ones published by x-plane in all manners except
|
||||
* that your data reference will not be available to other plugins if/when
|
||||
* your plugin is disabled.
|
||||
*
|
||||
* You share data by registering data provider callback functions. When a
|
||||
* plug-in requests your data, these callbacks are then called. You provide
|
||||
* one callback to return the value when a plugin 'reads' it and another to
|
||||
* change the value when a plugin 'writes' it.
|
||||
*
|
||||
* Important: you must pick a prefix for your datarefs other than "sim/" -
|
||||
* this prefix is reserved for X-Plane. The X-Plane SDK website contains a
|
||||
* registry where authors can select a unique first word for dataref names, to
|
||||
* prevent dataref collisions between plugins.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMGetDatai_f
|
||||
*
|
||||
* Data provider function pointers.
|
||||
*
|
||||
* These define the function pointers you provide to get or set data. Note
|
||||
* that you are passed a generic pointer for each one. This is the same
|
||||
* pointer you pass in your register routine; you can use it to find global
|
||||
* variables, etc.
|
||||
*
|
||||
* The semantics of your callbacks are the same as the dataref accessor above
|
||||
* - basically routines like XPLMGetDatai are just pass-throughs from a caller
|
||||
* to your plugin. Be particularly mindful in implementing array dataref
|
||||
* read-write accessors; you are responsible for avoiding overruns, supporting
|
||||
* offset read/writes, and handling a read with a NULL buffer.
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMGetDatai_f)(void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMSetDatai_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMSetDatai_f)(void *inRefcon, int inValue);
|
||||
|
||||
/*
|
||||
* XPLMGetDataf_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef float (*XPLMGetDataf_f)(void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMSetDataf_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMSetDataf_f)(void *inRefcon, float inValue);
|
||||
|
||||
/*
|
||||
* XPLMGetDatad_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef double (*XPLMGetDatad_f)(void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMSetDatad_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMSetDatad_f)(void *inRefcon, double inValue);
|
||||
|
||||
/*
|
||||
* XPLMGetDatavi_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMGetDatavi_f)(void *inRefcon,
|
||||
int *outValues, /* Can be NULL */
|
||||
int inOffset,
|
||||
int inMax);
|
||||
|
||||
/*
|
||||
* XPLMSetDatavi_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMSetDatavi_f)(void *inRefcon,
|
||||
int *inValues,
|
||||
int inOffset,
|
||||
int inCount);
|
||||
|
||||
/*
|
||||
* XPLMGetDatavf_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMGetDatavf_f)(void *inRefcon,
|
||||
float *outValues, /* Can be NULL */
|
||||
int inOffset,
|
||||
int inMax);
|
||||
|
||||
/*
|
||||
* XPLMSetDatavf_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMSetDatavf_f)(void *inRefcon,
|
||||
float *inValues,
|
||||
int inOffset,
|
||||
int inCount);
|
||||
|
||||
/*
|
||||
* XPLMGetDatab_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMGetDatab_f)(void *inRefcon,
|
||||
void *outValue, /* Can be NULL */
|
||||
int inOffset,
|
||||
int inMaxLength);
|
||||
|
||||
/*
|
||||
* XPLMSetDatab_f
|
||||
*
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMSetDatab_f)(void *inRefcon,
|
||||
void *inValue,
|
||||
int inOffset,
|
||||
int inLength);
|
||||
|
||||
/*
|
||||
* XPLMRegisterDataAccessor
|
||||
*
|
||||
* This routine creates a new item of data that can be read and written. Pass
|
||||
* in the data's full name for searching, the type(s) of the data for
|
||||
* accessing, and whether the data can be written to. For each data type you
|
||||
* support, pass in a read accessor function and a write accessor function if
|
||||
* necessary. Pass NULL for data types you do not support or write accessors
|
||||
* if you are read-only.
|
||||
*
|
||||
* You are returned a data ref for the new item of data created. You can use
|
||||
* this data ref to unregister your data later or read or write from it.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMDataRef XPLMRegisterDataAccessor(const char *inDataName,
|
||||
XPLMDataTypeID inDataType,
|
||||
int inIsWritable,
|
||||
XPLMGetDatai_f inReadInt,
|
||||
XPLMSetDatai_f inWriteInt,
|
||||
XPLMGetDataf_f inReadFloat,
|
||||
XPLMSetDataf_f inWriteFloat,
|
||||
XPLMGetDatad_f inReadDouble,
|
||||
XPLMSetDatad_f inWriteDouble,
|
||||
XPLMGetDatavi_f inReadIntArray,
|
||||
XPLMSetDatavi_f inWriteIntArray,
|
||||
XPLMGetDatavf_f inReadFloatArray,
|
||||
XPLMSetDatavf_f inWriteFloatArray,
|
||||
XPLMGetDatab_f inReadData,
|
||||
XPLMSetDatab_f inWriteData,
|
||||
void *inReadRefcon,
|
||||
void *inWriteRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnregisterDataAccessor
|
||||
*
|
||||
* Use this routine to unregister any data accessors you may have registered.
|
||||
* You unregister a data ref by the XPLMDataRef you get back from
|
||||
* registration. Once you unregister a data ref, your function pointer will
|
||||
* not be called anymore.
|
||||
*
|
||||
* For maximum compatibility, do not unregister your data accessors until
|
||||
* final shutdown (when your XPluginStop routine is called). This allows
|
||||
* other plugins to find your data reference once and use it for their entire
|
||||
* time of operation.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMUnregisterDataAccessor(XPLMDataRef inDataRef);
|
||||
|
||||
/***************************************************************************
|
||||
* SHARING DATA BETWEEN MULTIPLE PLUGINS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The data reference registration APIs from the previous section allow a
|
||||
* plugin to publish data in a one-owner manner; the plugin that publishes the
|
||||
* data reference owns the real memory that the data ref uses. This is
|
||||
* satisfactory for most cases, but there are also cases where plugnis need to
|
||||
* share actual data.
|
||||
*
|
||||
* With a shared data reference, no one plugin owns the actual memory for the
|
||||
* data reference; the plugin SDK allocates that for you. When the first
|
||||
* plugin asks to 'share' the data, the memory is allocated. When the data is
|
||||
* changed, every plugin that is sharing the data is notified.
|
||||
*
|
||||
* Shared data references differ from the 'owned' data references from the
|
||||
* previous section in a few ways:
|
||||
*
|
||||
* - With shared data references, any plugin can create the data reference;
|
||||
* with owned plugins one plugin must create the data reference and others
|
||||
* subscribe. (This can be a problem if you don't know which set of plugins
|
||||
* will be present).
|
||||
*
|
||||
* - With shared data references, every plugin that is sharing the data is
|
||||
* notified when the data is changed. With owned data references, only the
|
||||
* one owner is notified when the data is changed.
|
||||
*
|
||||
* - With shared data references, you cannot access the physical memory of the
|
||||
* data reference; you must use the XPLMGet... and XPLMSet... APIs. With an
|
||||
* owned data reference, the one owning data reference can manipulate the
|
||||
* data reference's memory in any way it sees fit.
|
||||
*
|
||||
* Shared data references solve two problems: if you need to have a data
|
||||
* reference used by several plugins but do not know which plugins will be
|
||||
* installed, or if all plugins sharing data need to be notified when that
|
||||
* data is changed, use shared data references.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMDataChanged_f
|
||||
*
|
||||
* An XPLMDataChanged_f is a callback that the XPLM calls whenever any other
|
||||
* plug-in modifies shared data. A refcon you provide is passed back to help
|
||||
* identify which data is being changed. In response, you may want to call one
|
||||
* of the XPLMGetDataxxx routines to find the new value of the data.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMDataChanged_f)(void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMShareData
|
||||
*
|
||||
* This routine connects a plug-in to shared data, creating the shared data if
|
||||
* necessary. inDataName is a standard path for the data ref, and inDataType
|
||||
* specifies the type. This function will create the data if it does not
|
||||
* exist. If the data already exists but the type does not match, an error is
|
||||
* returned, so it is important that plug-in authors collaborate to establish
|
||||
* public standards for shared data.
|
||||
*
|
||||
* If a notificationFunc is passed in and is not NULL, that notification
|
||||
* function will be called whenever the data is modified. The notification
|
||||
* refcon will be passed to it. This allows your plug-in to know which shared
|
||||
* data was changed if multiple shared data are handled by one callback, or if
|
||||
* the plug-in does not use global variables.
|
||||
*
|
||||
* A one is returned for successfully creating or finding the shared data; a
|
||||
* zero if the data already exists but is of the wrong type.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMShareData(const char *inDataName,
|
||||
XPLMDataTypeID inDataType,
|
||||
XPLMDataChanged_f inNotificationFunc,
|
||||
void *inNotificationRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnshareData
|
||||
*
|
||||
* This routine removes your notification function for shared data. Call it
|
||||
* when done with the data to stop receiving change notifications. Arguments
|
||||
* must match XPLMShareData. The actual memory will not necessarily be freed,
|
||||
* since other plug-ins could be using it.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMUnshareData(const char *inDataName,
|
||||
XPLMDataTypeID inDataType,
|
||||
XPLMDataChanged_f inNotificationFunc,
|
||||
void *inNotificationRefcon);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,518 @@
|
||||
#ifndef _XPLMDefs_h_
|
||||
#define _XPLMDefs_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file is contains the cross-platform and basic definitions for the
|
||||
* X-Plane SDK.
|
||||
*
|
||||
* The preprocessor macros APL and IBM must be defined to specify the
|
||||
* compilation target; define APL to 1 and IBM 0 to compile on Macintosh and
|
||||
* APL to 0 and IBM to 1 for Windows. You must specify these macro definitions
|
||||
* before including XPLMDefs.h or any other XPLM headers. You can do this
|
||||
* using the -D command line option or a preprocessor header.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if IBM
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
/***************************************************************************
|
||||
* DLL Definitions
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These definitions control the importing and exporting of functions within
|
||||
* the DLL.
|
||||
*
|
||||
* You can prefix your five required callbacks with the PLUGIN_API macro to
|
||||
* declare them as exported C functions. The XPLM_API macro identifies
|
||||
* functions that are provided to you via the plugin SDK. (Link against
|
||||
* XPLM.lib to use these functions.)
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if APL
|
||||
#if __GNUC__ >= 4
|
||||
#define PLUGIN_API extern "C" __attribute__((visibility("default")))
|
||||
#elif __MACH__
|
||||
#define PLUGIN_API extern "C"
|
||||
#else
|
||||
#define PLUGIN_API extern "C" __declspec(dllexport)
|
||||
#endif
|
||||
#elif IBM
|
||||
#define PLUGIN_API extern "C" __declspec(dllexport)
|
||||
#elif LIN
|
||||
#if __GNUC__ >= 4
|
||||
#define PLUGIN_API extern "C" __attribute__((visibility("default")))
|
||||
#else
|
||||
#define PLUGIN_API extern "C"
|
||||
#endif
|
||||
#else
|
||||
#error "Platform not defined!"
|
||||
#endif
|
||||
#else
|
||||
#if APL
|
||||
#if __GNUC__ >= 4
|
||||
#define PLUGIN_API __attribute__((visibility("default")))
|
||||
#elif __MACH__
|
||||
#define PLUGIN_API
|
||||
#else
|
||||
#define PLUGIN_API __declspec(dllexport)
|
||||
#endif
|
||||
#elif IBM
|
||||
#define PLUGIN_API __declspec(dllexport)
|
||||
#elif LIN
|
||||
#if __GNUC__ >= 4
|
||||
#define PLUGIN_API __attribute__((visibility("default")))
|
||||
#else
|
||||
#define PLUGIN_API
|
||||
#endif
|
||||
#else
|
||||
#error "Platform not defined!"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if APL
|
||||
#if XPLM
|
||||
#if __GNUC__ >= 4
|
||||
#define XPLM_API __attribute__((visibility("default")))
|
||||
#elif __MACH__
|
||||
#define XPLM_API
|
||||
#else
|
||||
#define XPLM_API __declspec(dllexport)
|
||||
#endif
|
||||
#else
|
||||
#define XPLM_API
|
||||
#endif
|
||||
#elif IBM
|
||||
#if XPLM
|
||||
#define XPLM_API __declspec(dllexport)
|
||||
#else
|
||||
#define XPLM_API __declspec(dllimport)
|
||||
#endif
|
||||
#elif LIN
|
||||
#if XPLM
|
||||
#if __GNUC__ >= 4
|
||||
#define XPLM_API __attribute__((visibility("default")))
|
||||
#else
|
||||
#define XPLM_API
|
||||
#endif
|
||||
#else
|
||||
#define XPLM_API
|
||||
#endif
|
||||
#else
|
||||
#error "Platform not defined!"
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* GLOBAL DEFINITIONS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These definitions are used in all parts of the SDK.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMPluginID
|
||||
*
|
||||
* Each plug-in is identified by a unique integer ID. This ID can be used to
|
||||
* disable or enable a plug-in, or discover what plug-in is 'running' at the
|
||||
* time. A plug-in ID is unique within the currently running instance of
|
||||
* X-Plane unless plug-ins are reloaded. Plug-ins may receive a different
|
||||
* unique ID each time they are loaded.
|
||||
*
|
||||
* For persistent identification of plug-ins, use XPLMFindPluginBySignature in
|
||||
* XPLMUtiltiies.h
|
||||
*
|
||||
* -1 indicates no plug-in.
|
||||
*
|
||||
*/
|
||||
typedef int XPLMPluginID;
|
||||
|
||||
/* No plugin. */
|
||||
#define XPLM_NO_PLUGIN_ID (-1)
|
||||
|
||||
/* X-Plane itself */
|
||||
#define XPLM_PLUGIN_XPLANE (0)
|
||||
|
||||
/* The current XPLM revision is 2.10 (210). */
|
||||
#define kXPLM_Version (210)
|
||||
|
||||
/*
|
||||
* XPLMKeyFlags
|
||||
*
|
||||
* These bitfields define modifier keys in a platform independent way. When a
|
||||
* key is pressed, a series of messages are sent to your plugin. The down
|
||||
* flag is set in the first of these messages, and the up flag in the last.
|
||||
* While the key is held down, messages are sent with neither to indicate that
|
||||
* the key is being held down as a repeated character.
|
||||
*
|
||||
* The control flag is mapped to the control flag on Macintosh and PC.
|
||||
* Generally X-Plane uses the control key and not the command key on
|
||||
* Macintosh, providing a consistent interface across platforms that does not
|
||||
* necessarily match the Macintosh user interface guidelines. There is not
|
||||
* yet a way for plugins to access the Macintosh control keys without using
|
||||
* #ifdefed code.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* The shift key is down */
|
||||
xplm_ShiftFlag = 1
|
||||
|
||||
/* The option or alt key is down */
|
||||
,
|
||||
xplm_OptionAltFlag = 2
|
||||
|
||||
/* The control key is down* */
|
||||
,
|
||||
xplm_ControlFlag = 4
|
||||
|
||||
/* The key is being pressed down */
|
||||
,
|
||||
xplm_DownFlag = 8
|
||||
|
||||
/* The key is being released */
|
||||
,
|
||||
xplm_UpFlag = 16
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMKeyFlags;
|
||||
|
||||
/***************************************************************************
|
||||
* ASCII CONTROL KEY CODES
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These definitions define how various control keys are mapped to ASCII key
|
||||
* codes. Not all key presses generate an ASCII value, so plugin code should
|
||||
* be prepared to see null characters come from the keyboard...this usually
|
||||
* represents a key stroke that has no equivalent ASCII, like a page-down
|
||||
* press. Use virtual key codes to find these key strokes. ASCII key codes
|
||||
* take into account modifier keys; shift keys will affect capitals and
|
||||
* punctuation; control key combinations may have no vaild ASCII and produce
|
||||
* NULL. To detect control-key combinations, use virtual key codes, not ASCII
|
||||
* keys.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#define XPLM_KEY_RETURN 13
|
||||
|
||||
#define XPLM_KEY_ESCAPE 27
|
||||
|
||||
#define XPLM_KEY_TAB 9
|
||||
|
||||
#define XPLM_KEY_DELETE 8
|
||||
|
||||
#define XPLM_KEY_LEFT 28
|
||||
|
||||
#define XPLM_KEY_RIGHT 29
|
||||
|
||||
#define XPLM_KEY_UP 30
|
||||
|
||||
#define XPLM_KEY_DOWN 31
|
||||
|
||||
#define XPLM_KEY_0 48
|
||||
|
||||
#define XPLM_KEY_1 49
|
||||
|
||||
#define XPLM_KEY_2 50
|
||||
|
||||
#define XPLM_KEY_3 51
|
||||
|
||||
#define XPLM_KEY_4 52
|
||||
|
||||
#define XPLM_KEY_5 53
|
||||
|
||||
#define XPLM_KEY_6 54
|
||||
|
||||
#define XPLM_KEY_7 55
|
||||
|
||||
#define XPLM_KEY_8 56
|
||||
|
||||
#define XPLM_KEY_9 57
|
||||
|
||||
#define XPLM_KEY_DECIMAL 46
|
||||
|
||||
/***************************************************************************
|
||||
* VIRTUAL KEY CODES
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These are cross-platform defines for every distinct keyboard press on the
|
||||
* computer. Every physical key on the keyboard has a virtual key code. So
|
||||
* the "two" key on the top row of the main keyboard has a different code
|
||||
* from the "two" key on the numeric key pad. But the 'w' and 'W' character
|
||||
* are indistinguishable by virtual key code because they are the same
|
||||
* physical key (one with and one without the shift key).
|
||||
*
|
||||
* Use virtual key codes to detect keystrokes that do not have ASCII
|
||||
* equivalents, allow the user to map the numeric keypad separately from the
|
||||
* main keyboard, and detect control key and other modifier-key combinations
|
||||
* that generate ASCII control key sequences (many of which are not available
|
||||
* directly via character keys in the SDK).
|
||||
*
|
||||
* To assign virtual key codes we started with the Microsoft set but made some
|
||||
* additions and changes. A few differences:
|
||||
*
|
||||
* 1. Modifier keys are not available as virtual key codes. You cannot get
|
||||
* distinct modifier press and release messages. Please do not try to use
|
||||
* modifier keys as regular keys; doing so will almost certainly interfere
|
||||
* with users' abilities to use the native x-plane key bindings.
|
||||
*
|
||||
* 2. Some keys that do not exist on both Mac and PC keyboards are removed.
|
||||
*
|
||||
* 3. Do not assume that the values of these keystrokes are interchangeable
|
||||
* with MS v-keys.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#define XPLM_VK_BACK 0x08
|
||||
|
||||
#define XPLM_VK_TAB 0x09
|
||||
|
||||
#define XPLM_VK_CLEAR 0x0C
|
||||
|
||||
#define XPLM_VK_RETURN 0x0D
|
||||
|
||||
#define XPLM_VK_ESCAPE 0x1B
|
||||
|
||||
#define XPLM_VK_SPACE 0x20
|
||||
|
||||
#define XPLM_VK_PRIOR 0x21
|
||||
|
||||
#define XPLM_VK_NEXT 0x22
|
||||
|
||||
#define XPLM_VK_END 0x23
|
||||
|
||||
#define XPLM_VK_HOME 0x24
|
||||
|
||||
#define XPLM_VK_LEFT 0x25
|
||||
|
||||
#define XPLM_VK_UP 0x26
|
||||
|
||||
#define XPLM_VK_RIGHT 0x27
|
||||
|
||||
#define XPLM_VK_DOWN 0x28
|
||||
|
||||
#define XPLM_VK_SELECT 0x29
|
||||
|
||||
#define XPLM_VK_PRINT 0x2A
|
||||
|
||||
#define XPLM_VK_EXECUTE 0x2B
|
||||
|
||||
#define XPLM_VK_SNAPSHOT 0x2C
|
||||
|
||||
#define XPLM_VK_INSERT 0x2D
|
||||
|
||||
#define XPLM_VK_DELETE 0x2E
|
||||
|
||||
#define XPLM_VK_HELP 0x2F
|
||||
|
||||
/* XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
|
||||
#define XPLM_VK_0 0x30
|
||||
|
||||
#define XPLM_VK_1 0x31
|
||||
|
||||
#define XPLM_VK_2 0x32
|
||||
|
||||
#define XPLM_VK_3 0x33
|
||||
|
||||
#define XPLM_VK_4 0x34
|
||||
|
||||
#define XPLM_VK_5 0x35
|
||||
|
||||
#define XPLM_VK_6 0x36
|
||||
|
||||
#define XPLM_VK_7 0x37
|
||||
|
||||
#define XPLM_VK_8 0x38
|
||||
|
||||
#define XPLM_VK_9 0x39
|
||||
|
||||
/* XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
|
||||
#define XPLM_VK_A 0x41
|
||||
|
||||
#define XPLM_VK_B 0x42
|
||||
|
||||
#define XPLM_VK_C 0x43
|
||||
|
||||
#define XPLM_VK_D 0x44
|
||||
|
||||
#define XPLM_VK_E 0x45
|
||||
|
||||
#define XPLM_VK_F 0x46
|
||||
|
||||
#define XPLM_VK_G 0x47
|
||||
|
||||
#define XPLM_VK_H 0x48
|
||||
|
||||
#define XPLM_VK_I 0x49
|
||||
|
||||
#define XPLM_VK_J 0x4A
|
||||
|
||||
#define XPLM_VK_K 0x4B
|
||||
|
||||
#define XPLM_VK_L 0x4C
|
||||
|
||||
#define XPLM_VK_M 0x4D
|
||||
|
||||
#define XPLM_VK_N 0x4E
|
||||
|
||||
#define XPLM_VK_O 0x4F
|
||||
|
||||
#define XPLM_VK_P 0x50
|
||||
|
||||
#define XPLM_VK_Q 0x51
|
||||
|
||||
#define XPLM_VK_R 0x52
|
||||
|
||||
#define XPLM_VK_S 0x53
|
||||
|
||||
#define XPLM_VK_T 0x54
|
||||
|
||||
#define XPLM_VK_U 0x55
|
||||
|
||||
#define XPLM_VK_V 0x56
|
||||
|
||||
#define XPLM_VK_W 0x57
|
||||
|
||||
#define XPLM_VK_X 0x58
|
||||
|
||||
#define XPLM_VK_Y 0x59
|
||||
|
||||
#define XPLM_VK_Z 0x5A
|
||||
|
||||
#define XPLM_VK_NUMPAD0 0x60
|
||||
|
||||
#define XPLM_VK_NUMPAD1 0x61
|
||||
|
||||
#define XPLM_VK_NUMPAD2 0x62
|
||||
|
||||
#define XPLM_VK_NUMPAD3 0x63
|
||||
|
||||
#define XPLM_VK_NUMPAD4 0x64
|
||||
|
||||
#define XPLM_VK_NUMPAD5 0x65
|
||||
|
||||
#define XPLM_VK_NUMPAD6 0x66
|
||||
|
||||
#define XPLM_VK_NUMPAD7 0x67
|
||||
|
||||
#define XPLM_VK_NUMPAD8 0x68
|
||||
|
||||
#define XPLM_VK_NUMPAD9 0x69
|
||||
|
||||
#define XPLM_VK_MULTIPLY 0x6A
|
||||
|
||||
#define XPLM_VK_ADD 0x6B
|
||||
|
||||
#define XPLM_VK_SEPARATOR 0x6C
|
||||
|
||||
#define XPLM_VK_SUBTRACT 0x6D
|
||||
|
||||
#define XPLM_VK_DECIMAL 0x6E
|
||||
|
||||
#define XPLM_VK_DIVIDE 0x6F
|
||||
|
||||
#define XPLM_VK_F1 0x70
|
||||
|
||||
#define XPLM_VK_F2 0x71
|
||||
|
||||
#define XPLM_VK_F3 0x72
|
||||
|
||||
#define XPLM_VK_F4 0x73
|
||||
|
||||
#define XPLM_VK_F5 0x74
|
||||
|
||||
#define XPLM_VK_F6 0x75
|
||||
|
||||
#define XPLM_VK_F7 0x76
|
||||
|
||||
#define XPLM_VK_F8 0x77
|
||||
|
||||
#define XPLM_VK_F9 0x78
|
||||
|
||||
#define XPLM_VK_F10 0x79
|
||||
|
||||
#define XPLM_VK_F11 0x7A
|
||||
|
||||
#define XPLM_VK_F12 0x7B
|
||||
|
||||
#define XPLM_VK_F13 0x7C
|
||||
|
||||
#define XPLM_VK_F14 0x7D
|
||||
|
||||
#define XPLM_VK_F15 0x7E
|
||||
|
||||
#define XPLM_VK_F16 0x7F
|
||||
|
||||
#define XPLM_VK_F17 0x80
|
||||
|
||||
#define XPLM_VK_F18 0x81
|
||||
|
||||
#define XPLM_VK_F19 0x82
|
||||
|
||||
#define XPLM_VK_F20 0x83
|
||||
|
||||
#define XPLM_VK_F21 0x84
|
||||
|
||||
#define XPLM_VK_F22 0x85
|
||||
|
||||
#define XPLM_VK_F23 0x86
|
||||
|
||||
#define XPLM_VK_F24 0x87
|
||||
|
||||
/* The following definitions are extended and are not based on the Microsoft *
|
||||
* key set. */
|
||||
#define XPLM_VK_EQUAL 0xB0
|
||||
|
||||
#define XPLM_VK_MINUS 0xB1
|
||||
|
||||
#define XPLM_VK_RBRACE 0xB2
|
||||
|
||||
#define XPLM_VK_LBRACE 0xB3
|
||||
|
||||
#define XPLM_VK_QUOTE 0xB4
|
||||
|
||||
#define XPLM_VK_SEMICOLON 0xB5
|
||||
|
||||
#define XPLM_VK_BACKSLASH 0xB6
|
||||
|
||||
#define XPLM_VK_COMMA 0xB7
|
||||
|
||||
#define XPLM_VK_SLASH 0xB8
|
||||
|
||||
#define XPLM_VK_PERIOD 0xB9
|
||||
|
||||
#define XPLM_VK_BACKQUOTE 0xBA
|
||||
|
||||
#define XPLM_VK_ENTER 0xBB
|
||||
|
||||
#define XPLM_VK_NUMPAD_ENT 0xBC
|
||||
|
||||
#define XPLM_VK_NUMPAD_EQ 0xBD
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,743 @@
|
||||
#ifndef _XPLMDisplay_h_
|
||||
#define _XPLMDisplay_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* XPLM Display APIs - THEORY OF OPERATION
|
||||
*
|
||||
* This API provides the basic hooks to draw in X-Plane and create user
|
||||
* interface. All X-Plane drawing is done in OpenGL. The X-Plane plug-in
|
||||
* manager takes care of properly setting up the OpenGL context and matrices.
|
||||
* You do not decide when in your code's execution to draw; X-Plane tells you
|
||||
* when it is ready to have your plugin draw.
|
||||
*
|
||||
* X-Plane's drawing strategy is straightforward: every "frame" the screen is
|
||||
* rendered by drawing the 3-d scene (dome, ground, objects, airplanes, etc.)
|
||||
* and then drawing the cockpit on top of it. Alpha blending is used to
|
||||
* overlay the cockpit over the world (and the gauges over the panel, etc.).
|
||||
*
|
||||
* There are two ways you can draw: directly and in a window.
|
||||
*
|
||||
* Direct drawing involves drawing to the screen before or after X-Plane
|
||||
* finishes a phase of drawing. When you draw directly, you can specify
|
||||
* whether x-plane is to complete this phase or not. This allows you to do
|
||||
* three things: draw before x-plane does (under it), draw after x-plane does
|
||||
* (over it), or draw instead of x-plane.
|
||||
*
|
||||
* To draw directly, you register a callback and specify what phase you want
|
||||
* to intercept. The plug-in manager will call you over and over to draw that
|
||||
* phase.
|
||||
*
|
||||
* Direct drawing allows you to override scenery, panels, or anything. Note
|
||||
* that you cannot assume that you are the only plug-in drawing at this
|
||||
* phase.
|
||||
*
|
||||
* Window drawing provides slightly higher level functionality. With window
|
||||
* drawing you create a window that takes up a portion of the screen. Window
|
||||
* drawing is always two dimensional. Window drawing is front-to-back
|
||||
* controlled; you can specify that you want your window to be brought on
|
||||
* top, and other plug-ins may put their window on top of you. Window drawing
|
||||
* also allows you to sign up for key presses and receive mouse clicks.
|
||||
*
|
||||
* There are three ways to get keystrokes:
|
||||
*
|
||||
* If you create a window, the window can take keyboard focus. It will then
|
||||
* receive all keystrokes. If no window has focus, X-Plane receives
|
||||
* keystrokes. Use this to implement typing in dialog boxes, etc. Only one
|
||||
* window may have focus at a time; your window will be notified if it loses
|
||||
* focus.
|
||||
*
|
||||
* If you need to associate key strokes with commands/functions in your
|
||||
* plug-in, use a hot key. A hoy is a key-specific callback. Hotkeys are
|
||||
* sent based on virtual key strokes, so any key may be distinctly mapped with
|
||||
* any modifiers. Hot keys can be remapped by other plug-ins. As a plug-in,
|
||||
* you don't have to worry about what your hot key ends up mapped to; other
|
||||
* plug-ins may provide a UI for remapping keystrokes. So hotkeys allow a
|
||||
* user to resolve conflicts and customize keystrokes.
|
||||
*
|
||||
* If you need low level access to the keystroke stream, install a key
|
||||
* sniffer. Key sniffers can be installed above everything or right in front
|
||||
* of the sim.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* DRAWING CALLBACKS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* Basic drawing callbacks, for low level intercepting of render loop. The
|
||||
* purpose of drawing callbacks is to provide targeted additions or
|
||||
* replacements to x-plane's graphics environment (for example, to add extra
|
||||
* custom objects, or replace drawing of the AI aircraft). Do not assume that
|
||||
* the drawing callbacks will be called in the order implied by the
|
||||
* enumerations. Also do not assume that each drawing phase ends before
|
||||
* another begins; they may be nested.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMDrawingPhase
|
||||
*
|
||||
* This constant indicates which part of drawing we are in. Drawing is done
|
||||
* from the back to the front. We get a callback before or after each item.
|
||||
* Metaphases provide access to the beginning and end of the 3d (scene) and 2d
|
||||
* (cockpit) drawing in a manner that is independent of new phases added via
|
||||
* x-plane implementation.
|
||||
*
|
||||
* WARNING: As X-Plane's scenery evolves, some drawing phases may cease to
|
||||
* exist and new ones may be invented. If you need a particularly specific
|
||||
* use of these codes, consult Austin and/or be prepared to revise your code
|
||||
* as X-Plane evolves.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* This is the earliest point at which you can draw in 3-d. */
|
||||
xplm_Phase_FirstScene = 0
|
||||
|
||||
/* Drawing of land and water. */
|
||||
,
|
||||
xplm_Phase_Terrain = 5
|
||||
|
||||
/* Drawing runways and other airport detail. */
|
||||
,
|
||||
xplm_Phase_Airports = 10
|
||||
|
||||
/* Drawing roads, trails, trains, etc. */
|
||||
,
|
||||
xplm_Phase_Vectors = 15
|
||||
|
||||
/* 3-d objects (houses, smokestacks, etc. */
|
||||
,
|
||||
xplm_Phase_Objects = 20
|
||||
|
||||
/* External views of airplanes, both yours and the AI aircraft. */
|
||||
,
|
||||
xplm_Phase_Airplanes = 25
|
||||
|
||||
/* This is the last point at which you can draw in 3-d. */
|
||||
,
|
||||
xplm_Phase_LastScene = 30
|
||||
|
||||
/* This is the first phase where you can draw in 2-d. */
|
||||
,
|
||||
xplm_Phase_FirstCockpit = 35
|
||||
|
||||
/* The non-moving parts of the aircraft panel. */
|
||||
,
|
||||
xplm_Phase_Panel = 40
|
||||
|
||||
/* The moving parts of the aircraft panel. */
|
||||
,
|
||||
xplm_Phase_Gauges = 45
|
||||
|
||||
/* Floating windows from plugins. */
|
||||
,
|
||||
xplm_Phase_Window = 50
|
||||
|
||||
/* The last change to draw in 2d. */
|
||||
,
|
||||
xplm_Phase_LastCockpit = 55
|
||||
|
||||
#if defined(XPLM200)
|
||||
/* 3-d Drawing for the local map. Use regular OpenGL coordinates to draw in
|
||||
* * this phase. */
|
||||
,
|
||||
xplm_Phase_LocalMap3D = 100
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#if defined(XPLM200)
|
||||
/* 2-d Drawing of text over the local map. */
|
||||
,
|
||||
xplm_Phase_LocalMap2D = 101
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#if defined(XPLM200)
|
||||
/* Drawing of the side-profile view in the local map screen. */
|
||||
,
|
||||
xplm_Phase_LocalMapProfile = 102
|
||||
|
||||
#endif /* XPLM200 */
|
||||
|
||||
};
|
||||
typedef int XPLMDrawingPhase;
|
||||
|
||||
/*
|
||||
* XPLMDrawCallback_f
|
||||
*
|
||||
* This is the prototype for a low level drawing callback. You are passed in
|
||||
* the phase and whether it is before or after. If you are before the phase,
|
||||
* return 1 to let x-plane draw or 0 to suppress x-plane drawing. If you are
|
||||
* after the phase the return value is ignored.
|
||||
*
|
||||
* Refcon is a unique value that you specify when registering the callback,
|
||||
* allowing you to slip a pointer to your own data to the callback.
|
||||
*
|
||||
* Upon entry the OpenGL context will be correctly set up for you and OpenGL
|
||||
* will be in 'local' coordinates for 3d drawing and panel coordinates for 2d
|
||||
* drawing. The OpenGL state (texturing, etc.) will be unknown.
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMDrawCallback_f)(XPLMDrawingPhase inPhase,
|
||||
int inIsBefore,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMKeySniffer_f
|
||||
*
|
||||
* This is the prototype for a low level key-sniffing function. Window-based
|
||||
* UI _should not use this_! The windowing system provides high-level
|
||||
* mediated keyboard access. By comparison, the key sniffer provides low
|
||||
* level keyboard access.
|
||||
*
|
||||
* Key sniffers are provided to allow libraries to provide non-windowed user
|
||||
* interaction. For example, the MUI library uses a key sniffer to do pop-up
|
||||
* text entry.
|
||||
*
|
||||
* inKey is the character pressed, inRefCon is a value you supply during
|
||||
* registration. Return 1 to pass the key on to the next sniffer, the window
|
||||
* mgr, x-plane, or whomever is down stream. Return 0 to consume the key.
|
||||
*
|
||||
* Warning: this API declares virtual keys as a signed character; however the
|
||||
* VKEY #define macros in XPLMDefs.h define the vkeys using unsigned values
|
||||
* (that is 0x80 instead of -0x80). So you may need to cast the incoming vkey
|
||||
* to an unsigned char to get correct comparisons in C.
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMKeySniffer_f)(char inChar,
|
||||
XPLMKeyFlags inFlags,
|
||||
char inVirtualKey,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMRegisterDrawCallback
|
||||
*
|
||||
* This routine registers a low level drawing callback. Pass in the phase you
|
||||
* want to be called for and whether you want to be called before or after.
|
||||
* This routine returns 1 if the registration was successful, or 0 if the
|
||||
* phase does not exist in this version of x-plane. You may register a
|
||||
* callback multiple times for the same or different phases as long as the
|
||||
* refcon is unique each time.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMRegisterDrawCallback(XPLMDrawCallback_f inCallback,
|
||||
XPLMDrawingPhase inPhase,
|
||||
int inWantsBefore,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnregisterDrawCallback
|
||||
*
|
||||
* This routine unregisters a draw callback. You must unregister a callback
|
||||
* for each time you register a callback if you have registered it multiple
|
||||
* times with different refcons. The routine returns 1 if it can find the
|
||||
* callback to unregister, 0 otherwise.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMUnregisterDrawCallback(XPLMDrawCallback_f inCallback,
|
||||
XPLMDrawingPhase inPhase,
|
||||
int inWantsBefore,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMRegisterKeySniffer
|
||||
*
|
||||
* This routine registers a key sniffing callback. You specify whether you
|
||||
* want to sniff before the window system, or only sniff keys the window
|
||||
* system does not consume. You should ALMOST ALWAYS sniff non-control keys
|
||||
* after the window system. When the window system consumes a key, it is
|
||||
* because the user has "focused" a window. Consuming the key or taking
|
||||
* action based on the key will produce very weird results. Returns 1 if
|
||||
* successful.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMRegisterKeySniffer(XPLMKeySniffer_f inCallback,
|
||||
int inBeforeWindows,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnregisterKeySniffer
|
||||
*
|
||||
* This routine unregisters a key sniffer. You must unregister a key sniffer
|
||||
* for every time you register one with the exact same signature. Returns 1
|
||||
* if successful.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMUnregisterKeySniffer(XPLMKeySniffer_f inCallback,
|
||||
int inBeforeWindows,
|
||||
void *inRefcon);
|
||||
|
||||
/***************************************************************************
|
||||
* WINDOW API
|
||||
***************************************************************************/
|
||||
/*
|
||||
* Window API, for higher level drawing with UI interaction.
|
||||
*
|
||||
* Note: all 2-d (and thus all window drawing) is done in 'cockpit pixels'.
|
||||
* Even when the OpenGL window contains more than 1024x768 pixels, the cockpit
|
||||
* drawing is magnified so that only 1024x768 pixels are available.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMMouseStatus
|
||||
*
|
||||
* When the mouse is clicked, your mouse click routine is called repeatedly.
|
||||
* It is first called with the mouse down message. It is then called zero or
|
||||
* more times with the mouse-drag message, and finally it is called once with
|
||||
* the mouse up message. All of these messages will be directed to the same
|
||||
* window.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
xplm_MouseDown = 1
|
||||
|
||||
,
|
||||
xplm_MouseDrag = 2
|
||||
|
||||
,
|
||||
xplm_MouseUp = 3
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMMouseStatus;
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMCursorStatus
|
||||
*
|
||||
* XPLMCursorStatus describes how you would like X-Plane to manage the cursor.
|
||||
* See XPLMHandleCursor_f for more info.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* X-Plane manages the cursor normally, plugin does not affect the cusrsor.
|
||||
*/
|
||||
xplm_CursorDefault = 0
|
||||
|
||||
/* X-Plane hides the cursor. */
|
||||
,
|
||||
xplm_CursorHidden = 1
|
||||
|
||||
/* X-Plane shows the cursor as the default arrow. */
|
||||
,
|
||||
xplm_CursorArrow = 2
|
||||
|
||||
/* X-Plane shows the cursor but lets you select an OS cursor. */
|
||||
,
|
||||
xplm_CursorCustom = 3
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMCursorStatus;
|
||||
#endif /* XPLM200 */
|
||||
|
||||
/*
|
||||
* XPLMWindowID
|
||||
*
|
||||
* This is an opaque identifier for a window. You use it to control your
|
||||
* window. When you create a window, you will specify callbacks to handle
|
||||
* drawing and mouse interaction, etc.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMWindowID;
|
||||
|
||||
/*
|
||||
* XPLMDrawWindow_f
|
||||
*
|
||||
* This function handles drawing. You are passed in your window and its
|
||||
* refcon. Draw the window. You can use XPLM functions to find the current
|
||||
* dimensions of your window, etc. When this callback is called, the OpenGL
|
||||
* context will be set properly for cockpit drawing. NOTE: Because you are
|
||||
* drawing your window over a background, you can make a translucent window
|
||||
* easily by simply not filling in your entire window's bounds.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMDrawWindow_f)(XPLMWindowID inWindowID, void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMHandleKey_f
|
||||
*
|
||||
* This function is called when a key is pressed or keyboard focus is taken
|
||||
* away from your window. If losingFocus is 1, you are losign the keyboard
|
||||
* focus, otherwise a key was pressed and inKey contains its character. You
|
||||
* are also passewd your window and a refcon. Warning: this API declares
|
||||
* virtual keys as a signed character; however the VKEY #define macros in
|
||||
* XPLMDefs.h define the vkeys using unsigned values (that is 0x80 instead of
|
||||
* -0x80). So you may need to cast the incoming vkey to an unsigned char to
|
||||
* get correct comparisons in C.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMHandleKey_f)(XPLMWindowID inWindowID,
|
||||
char inKey,
|
||||
XPLMKeyFlags inFlags,
|
||||
char inVirtualKey,
|
||||
void *inRefcon,
|
||||
int losingFocus);
|
||||
|
||||
/*
|
||||
* XPLMHandleMouseClick_f
|
||||
*
|
||||
* You receive this call when the mouse button is pressed down or released.
|
||||
* Between then these two calls is a drag. You receive the x and y of the
|
||||
* click, your window, and a refcon. Return 1 to consume the click, or 0 to
|
||||
* pass it through.
|
||||
*
|
||||
* WARNING: passing clicks through windows (as of this writing) causes mouse
|
||||
* tracking problems in X-Plane; do not use this feature!
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMHandleMouseClick_f)(XPLMWindowID inWindowID,
|
||||
int x,
|
||||
int y,
|
||||
XPLMMouseStatus inMouse,
|
||||
void *inRefcon);
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMHandleCursor_f
|
||||
*
|
||||
* The SDK calls your cursor status callback when the mouse is over your
|
||||
* plugin window. Return a cursor status code to indicate how you would like
|
||||
* X-Plane to manage the cursor. If you return xplm_CursorDefault, the SDK
|
||||
* will try lower-Z-order plugin windows, then let the sim manage the cursor.
|
||||
*
|
||||
* Note: you should never show or hide the cursor yourself - these APIs are
|
||||
* typically reference-counted and thus cannot safely and predictably be used
|
||||
* by the SDK. Instead return one of xplm_CursorHidden to hide the cursor or
|
||||
* xplm_CursorArrow/xplm_CursorCustom to show the cursor.
|
||||
*
|
||||
* If you want to implement a custom cursor by drawing a cursor in OpenGL, use
|
||||
* xplm_CursorHidden to hide the OS cursor and draw the cursor using a 2-d
|
||||
* drawing callback (after xplm_Phase_Window is probably a good choice). If
|
||||
* you want to use a custom OS-based cursor, use xplm_CursorCustom to ask
|
||||
* X-Plane to show the cursor but not affect its image. You can then use an
|
||||
* OS specific call like SetThemeCursor (Mac) or SetCursor/LoadCursor
|
||||
* (Windows).
|
||||
*
|
||||
*/
|
||||
typedef XPLMCursorStatus (*XPLMHandleCursor_f)(XPLMWindowID inWindowID,
|
||||
int x,
|
||||
int y,
|
||||
void *inRefcon);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMHandleMouseWheel_f
|
||||
*
|
||||
* The SDK calls your mouse wheel callback when one of the mouse wheels is
|
||||
* turned within your window. Return 1 to consume the mouse wheel clicks or
|
||||
* 0 to pass them on to a lower window. (You should consume mouse wheel
|
||||
* clicks even if they do nothing if your window appears opaque to the user.)
|
||||
* The number of clicks indicates how far the wheel was turned since the last
|
||||
* callback. The wheel is 0 for the vertical axis or 1 for the horizontal axis
|
||||
* (for OS/mouse combinations that support this).
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMHandleMouseWheel_f)(XPLMWindowID inWindowID,
|
||||
int x,
|
||||
int y,
|
||||
int wheel,
|
||||
int clicks,
|
||||
void *inRefcon);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMCreateWindow_t
|
||||
*
|
||||
* The XPMCreateWindow_t structure defines all of the parameters used to
|
||||
* create a window using XPLMCreateWindowEx. The structure will be expanded
|
||||
* in future SDK APIs to include more features. Always set the structSize
|
||||
* member to the size of your struct in bytes!
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
int structSize;
|
||||
int left;
|
||||
int top;
|
||||
int right;
|
||||
int bottom;
|
||||
int visible;
|
||||
XPLMDrawWindow_f drawWindowFunc;
|
||||
XPLMHandleMouseClick_f handleMouseClickFunc;
|
||||
XPLMHandleKey_f handleKeyFunc;
|
||||
XPLMHandleCursor_f handleCursorFunc;
|
||||
XPLMHandleMouseWheel_f handleMouseWheelFunc;
|
||||
void *refcon;
|
||||
} XPLMCreateWindow_t;
|
||||
#endif /* XPLM200 */
|
||||
|
||||
/*
|
||||
* XPLMGetScreenSize
|
||||
*
|
||||
* This routine returns the size of the size of the X-Plane OpenGL window in
|
||||
* pixels. Please note that this is not the size of the screen when doing
|
||||
* 2-d drawing (the 2-d screen is currently always 1024x768, and graphics are
|
||||
* scaled up by OpenGL when doing 2-d drawing for higher-res monitors). This
|
||||
* number can be used to get a rough idea of the amount of detail the user
|
||||
* will be able to see when drawing in 3-d.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetScreenSize(int *outWidth, /* Can be NULL */
|
||||
int *outHeight); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMGetMouseLocation
|
||||
*
|
||||
* This routine returns the current mouse location in cockpit pixels. The
|
||||
* bottom left corner of the display is 0,0. Pass NULL to not receive info
|
||||
* about either parameter.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetMouseLocation(int *outX, /* Can be NULL */
|
||||
int *outY); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMCreateWindow
|
||||
*
|
||||
* This routine creates a new window. Pass in the dimensions and offsets to
|
||||
* the window's bottom left corner from the bottom left of the screen. You
|
||||
* can specify whether the window is initially visible or not. Also, you pass
|
||||
* in three callbacks to run the window and a refcon. This function returns a
|
||||
* window ID you can use to refer to the new window.
|
||||
*
|
||||
* NOTE: windows do not have "frames"; you are responsible for drawing the
|
||||
* background and frame of the window. Higher level libraries have routines
|
||||
* which make this easy.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMWindowID XPLMCreateWindow(int inLeft,
|
||||
int inTop,
|
||||
int inRight,
|
||||
int inBottom,
|
||||
int inIsVisible,
|
||||
XPLMDrawWindow_f inDrawCallback,
|
||||
XPLMHandleKey_f inKeyCallback,
|
||||
XPLMHandleMouseClick_f inMouseCallback,
|
||||
void *inRefcon);
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMCreateWindowEx
|
||||
*
|
||||
* This routine creates a new window - you pass in an XPLMCreateWindow_t
|
||||
* structure with all of the fields set in. You must set the structSize of
|
||||
* the structure to the size of the actual structure you used. Also, you
|
||||
* must provide funtions for every callback - you may not leave them null!
|
||||
* (If you do not support the cursor or mouse wheel, use functions that return
|
||||
* the default values.) The numeric values of the XPMCreateWindow_t structure
|
||||
* correspond to the parameters of XPLMCreateWindow.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMWindowID XPLMCreateWindowEx(XPLMCreateWindow_t *inParams);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
/*
|
||||
* XPLMDestroyWindow
|
||||
*
|
||||
* This routine destroys a window. The callbacks are not called after this
|
||||
* call. Keyboard focus is removed from the window before destroying it.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDestroyWindow(XPLMWindowID inWindowID);
|
||||
|
||||
/*
|
||||
* XPLMGetWindowGeometry
|
||||
*
|
||||
* This routine returns the position and size of a window in cockpit pixels.
|
||||
* Pass NULL to not receive any paramter.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetWindowGeometry(XPLMWindowID inWindowID,
|
||||
int *outLeft, /* Can be NULL */
|
||||
int *outTop, /* Can be NULL */
|
||||
int *outRight, /* Can be NULL */
|
||||
int *outBottom); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMSetWindowGeometry
|
||||
*
|
||||
* This routine allows you to set the position or height aspects of a window.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetWindowGeometry(XPLMWindowID inWindowID,
|
||||
int inLeft,
|
||||
int inTop,
|
||||
int inRight,
|
||||
int inBottom);
|
||||
|
||||
/*
|
||||
* XPLMGetWindowIsVisible
|
||||
*
|
||||
* This routine returns whether a window is visible.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetWindowIsVisible(XPLMWindowID inWindowID);
|
||||
|
||||
/*
|
||||
* XPLMSetWindowIsVisible
|
||||
*
|
||||
* This routine shows or hides a window.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetWindowIsVisible(XPLMWindowID inWindowID, int inIsVisible);
|
||||
|
||||
/*
|
||||
* XPLMGetWindowRefCon
|
||||
*
|
||||
* This routine returns a windows refcon, the unique value you can use for
|
||||
* your own purposes.
|
||||
*
|
||||
*/
|
||||
XPLM_API void *XPLMGetWindowRefCon(XPLMWindowID inWindowID);
|
||||
|
||||
/*
|
||||
* XPLMSetWindowRefCon
|
||||
*
|
||||
* This routine sets a window's reference constant. Use this to pass data to
|
||||
* yourself in the callbacks.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetWindowRefCon(XPLMWindowID inWindowID, void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMTakeKeyboardFocus
|
||||
*
|
||||
* This routine gives a specific window keyboard focus. Keystrokes will be
|
||||
* sent to that window. Pass a window ID of 0 to pass keyboard strokes
|
||||
* directly to X-Plane.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMTakeKeyboardFocus(XPLMWindowID inWindow);
|
||||
|
||||
/*
|
||||
* XPLMBringWindowToFront
|
||||
*
|
||||
* This routine brings the window to the front of the Z-order. Windows are
|
||||
* brought to the front when they are created...beyond that you should make
|
||||
* sure you are front before handling mouse clicks.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMBringWindowToFront(XPLMWindowID inWindow);
|
||||
|
||||
/*
|
||||
* XPLMIsWindowInFront
|
||||
*
|
||||
* This routine returns true if you pass inthe ID of the frontmost visible
|
||||
* window.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMIsWindowInFront(XPLMWindowID inWindow);
|
||||
|
||||
/***************************************************************************
|
||||
* HOT KEYS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* Hot Keys - keystrokes that can be managed by others.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMHotKey_f
|
||||
*
|
||||
* Your hot key callback simply takes a pointer of your choosing.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMHotKey_f)(void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMHotKeyID
|
||||
*
|
||||
* Hot keys are identified by opaque IDs.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMHotKeyID;
|
||||
|
||||
/*
|
||||
* XPLMRegisterHotKey
|
||||
*
|
||||
* This routine registers a hot key. You specify your preferred key stroke
|
||||
* virtual key/flag combination, a description of what your callback does (so
|
||||
* other plug-ins can describe the plug-in to the user for remapping) and a
|
||||
* callback function and opaque pointer to pass in). A new hot key ID is
|
||||
* returned. During execution, the actual key associated with your hot key
|
||||
* may change, but you are insulated from this.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMHotKeyID XPLMRegisterHotKey(char inVirtualKey,
|
||||
XPLMKeyFlags inFlags,
|
||||
const char *inDescription,
|
||||
XPLMHotKey_f inCallback,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnregisterHotKey
|
||||
*
|
||||
* This API unregisters a hot key. You can only register your own hot keys.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMUnregisterHotKey(XPLMHotKeyID inHotKey);
|
||||
|
||||
/*
|
||||
* XPLMCountHotKeys
|
||||
*
|
||||
* Returns the number of current hot keys.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMCountHotKeys(void);
|
||||
|
||||
/*
|
||||
* XPLMGetNthHotKey
|
||||
*
|
||||
* Returns a hot key by index, for iteration on all hot keys.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMHotKeyID XPLMGetNthHotKey(int inIndex);
|
||||
|
||||
/*
|
||||
* XPLMGetHotKeyInfo
|
||||
*
|
||||
* Returns information about the hot key. Return NULL for any parameter you
|
||||
* don't want info about. The description should be at least 512 chars long.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetHotKeyInfo(XPLMHotKeyID inHotKey,
|
||||
char *outVirtualKey, /* Can be NULL */
|
||||
XPLMKeyFlags *outFlags, /* Can be NULL */
|
||||
char *outDescription, /* Can be NULL */
|
||||
XPLMPluginID *outPlugin); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMSetHotKeyCombination
|
||||
*
|
||||
* XPLMSetHotKeyCombination remaps a hot keys keystrokes. You may remap
|
||||
* another plugin's keystrokes.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetHotKeyCombination(XPLMHotKeyID inHotKey,
|
||||
char inVirtualKey,
|
||||
XPLMKeyFlags inFlags);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,413 @@
|
||||
#ifndef _XPLMGraphics_h_
|
||||
#define _XPLMGraphics_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Graphics routines for X-Plane and OpenGL.
|
||||
*
|
||||
* A few notes on coordinate systems:
|
||||
*
|
||||
* X-Plane uses three kinds of coordinates. Global coordinates are specified
|
||||
* as latitude, longitude and elevation. This coordinate system never changes
|
||||
* but is not very precise.
|
||||
*
|
||||
* OpenGL (or 'local') coordinates are cartesian and shift with the plane.
|
||||
* They offer more precision and are used for 3-d OpenGL drawing. The X axis
|
||||
* is aligned east-west with positive X meaning east. The Y axis is aligned
|
||||
* straight up and down at the point 0,0,0 (but since the earth is round it is
|
||||
* not truly straight up and down at other points). The Z axis is aligned
|
||||
* north-south at 0, 0, 0 with positive Z pointing south (but since the earth
|
||||
* is round it isn't exactly north-south as you move east or west of 0, 0, 0).
|
||||
* One unit is one meter and the point 0,0,0 is on the surface of the earth
|
||||
* at sea level for some latitude and longitude picked by the sim such that
|
||||
* the user's aircraft is reasonably nearby.
|
||||
*
|
||||
* Cockpit coordinates are 2d, with the X axis horizontal and the Y axis
|
||||
* vertical. The point 0,0 is the bottom left and 1024,768 is the upper right
|
||||
* of the screen. This is true no matter what resolution the user's monitor is
|
||||
* in; when running in higher resolution, graphics will be scaled.
|
||||
*
|
||||
* Use X-Plane's routines to convert between global and local coordinates. Do
|
||||
* not attempt to do this conversion yourself; the precise 'roundness' of
|
||||
* X-Plane's physics model may not match your own, and (to make things
|
||||
* weirder) the user can potentially customize the physics of the current
|
||||
* planet.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* X-PLANE GRAPHICS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These routines allow you to use OpenGL with X-Plane.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMTextureID
|
||||
*
|
||||
* XPLM Texture IDs name well-known textures in the sim for you to use. This
|
||||
* allows you to recycle textures from X-Plane, saving VRAM.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* The bitmap that contains window outlines, button outlines, fonts, etc. */
|
||||
xplm_Tex_GeneralInterface = 0
|
||||
|
||||
/* The exterior paint for the user's aircraft (daytime). */
|
||||
,
|
||||
xplm_Tex_AircraftPaint = 1
|
||||
|
||||
/* The exterior light map for the user's aircraft. */
|
||||
,
|
||||
xplm_Tex_AircraftLiteMap = 2
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMTextureID;
|
||||
|
||||
/*
|
||||
* XPLMSetGraphicsState
|
||||
*
|
||||
* XPLMSetGraphicsState changes OpenGL's graphics state in a number of ways:
|
||||
*
|
||||
* inEnableFog - enables or disables fog, equivalent to: glEnable(GL_FOG);
|
||||
*
|
||||
* inNumberTexUnits - enables or disables a number of multitexturing units. If
|
||||
* the number is 0, 2d texturing is disabled entirely, as in
|
||||
* glDisable(GL_TEXTURE_2D); Otherwise, 2d texturing is enabled, and a
|
||||
* number of multitexturing units are enabled sequentially, starting with
|
||||
* unit 0, e.g. glActiveTextureARB(GL_TEXTURE0_ARB); glEnable
|
||||
* (GL_TEXTURE_2D);
|
||||
*
|
||||
* inEnableLighting - enables or disables OpenGL lighting, e.g.
|
||||
* glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);
|
||||
*
|
||||
* inEnableAlphaTesting - enables or disables the alpha test per pixel, e.g.
|
||||
* glEnable(GL_ALPHA_TEST);
|
||||
*
|
||||
* inEnableAlphaBlending - enables or disables alpha blending per pixel, e.g.
|
||||
* glEnable(GL_BLEND);
|
||||
*
|
||||
* inEnableDepthTesting - enables per pixel depth testing, as in
|
||||
* glEnable(GL_DEPTH_TEST);
|
||||
*
|
||||
* inEnableDepthWriting - enables writing back of depth information to the
|
||||
* depth bufffer, as in glDepthMask(GL_TRUE);
|
||||
*
|
||||
* The purpose of this function is to change OpenGL state while keeping
|
||||
* X-Plane aware of the state changes; this keeps X-Plane from getting
|
||||
* surprised by OGL state changes, and prevents X-Plane and plug-ins from
|
||||
* having to set all state before all draws; XPLMSetGraphicsState internally
|
||||
* skips calls to change state that is already properly enabled.
|
||||
*
|
||||
* X-Plane does not have a 'default' OGL state to plug-ins; plug-ins should
|
||||
* totally set OGL state before drawing. Use XPLMSetGraphicsState instead of
|
||||
* any of the above OpenGL calls.
|
||||
*
|
||||
* WARNING: Any routine that performs drawing (e.g. XPLMDrawString or widget
|
||||
* code) may change X-Plane's state. Always set state before drawing after
|
||||
* unknown code has executed.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetGraphicsState(int inEnableFog,
|
||||
int inNumberTexUnits,
|
||||
int inEnableLighting,
|
||||
int inEnableAlphaTesting,
|
||||
int inEnableAlphaBlending,
|
||||
int inEnableDepthTesting,
|
||||
int inEnableDepthWriting);
|
||||
|
||||
/*
|
||||
* XPLMBindTexture2d
|
||||
*
|
||||
* XPLMBindTexture2d changes what texture is bound to the 2d texturing target.
|
||||
* This routine caches the current 2d texture across all texturing units in
|
||||
* the sim and plug-ins, preventing extraneous binding. For example, consider
|
||||
* several plug-ins running in series; if they all use the 'general interface'
|
||||
* bitmap to do UI, calling this function will skip the rebinding of the
|
||||
* general interface texture on all but the first plug-in, which can provide
|
||||
* better frame rate son some graphics cards.
|
||||
*
|
||||
* inTextureID is the ID of the texture object to bind; inTextureUnit is a
|
||||
* zero-based texture unit (e.g. 0 for the first one), up to a maximum of 4
|
||||
* units. (This number may increase in future versions of x-plane.)
|
||||
*
|
||||
* Use this routine instead of glBindTexture(GL_TEXTURE_2D, ....);
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMBindTexture2d(int inTextureNum, int inTextureUnit);
|
||||
|
||||
/*
|
||||
* XPLMGenerateTextureNumbers
|
||||
*
|
||||
* This routine generates unused texture numbers that a plug-in can use to
|
||||
* safely bind textures. Use this routine instead of glGenTextures;
|
||||
* glGenTextures will allocate texture numbers in ranges that X-Plane reserves
|
||||
* for its own use but does not always use; for example, it might provide an
|
||||
* ID within the range of textures reserved for terrain...loading a new .env
|
||||
* file as the plane flies might then cause X-Plane to use this texture ID.
|
||||
* X-Plane will then overwrite the plug-ins texture. This routine returns
|
||||
* texture IDs that are out of X-Plane's usage range.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGenerateTextureNumbers(int *outTextureIDs, int inCount);
|
||||
|
||||
/*
|
||||
* XPLMGetTexture
|
||||
*
|
||||
* XPLMGetTexture returns the OpenGL texture enumeration of an X-Plane texture
|
||||
* based on a generic identifying code. For example, you can get the texture
|
||||
* for X-Plane's UI bitmaps. This allows you to build new gauges that take
|
||||
* advantage of x-plane's textures, for smooth artwork integration and also
|
||||
* saving texture memory. Note that the texture might not be loaded yet,
|
||||
* depending on what the plane's panel contains.
|
||||
*
|
||||
* OPEN ISSUE: We really need a way to make sure X-Plane loads this texture if
|
||||
* it isn't around, or at least a way to find out whether it is loaded or not.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetTexture(XPLMTextureID inTexture);
|
||||
|
||||
/*
|
||||
* XPLMWorldToLocal
|
||||
*
|
||||
* This routine translates coordinates from latitude, longitude, and altitude
|
||||
* to local scene coordinates. Latitude and longitude are in decimal degrees,
|
||||
* and altitude is in meters MSL (mean sea level). The XYZ coordinates are in
|
||||
* meters in the local OpenGL coordinate system.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMWorldToLocal(double inLatitude,
|
||||
double inLongitude,
|
||||
double inAltitude,
|
||||
double *outX,
|
||||
double *outY,
|
||||
double *outZ);
|
||||
|
||||
/*
|
||||
* XPLMLocalToWorld
|
||||
*
|
||||
* This routine translates a local coordinate triplet back into latitude,
|
||||
* longitude, and altitude. Latitude and longitude are in decimal degrees,
|
||||
* and altitude is in meters MSL (mean sea level). The XYZ coordinates are in
|
||||
* meters in the local OpenGL coordinate system.
|
||||
*
|
||||
* NOTE: world coordinates are less precise than local coordinates; you should
|
||||
* try to avoid round tripping from local to world and back.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMLocalToWorld(double inX,
|
||||
double inY,
|
||||
double inZ,
|
||||
double *outLatitude,
|
||||
double *outLongitude,
|
||||
double *outAltitude);
|
||||
|
||||
/*
|
||||
* XPLMDrawTranslucentDarkBox
|
||||
*
|
||||
* This routine draws a translucent dark box, partially obscuring parts of the
|
||||
* screen but making text easy to read. This is the same graphics primitive
|
||||
* used by X-Plane to show text files and ATC info.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDrawTranslucentDarkBox(int inLeft,
|
||||
int inTop,
|
||||
int inRight,
|
||||
int inBottom);
|
||||
|
||||
/***************************************************************************
|
||||
* X-PLANE TEXT
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMFontID
|
||||
*
|
||||
* X-Plane features some fixed-character fonts. Each font may have its own
|
||||
* metrics.
|
||||
*
|
||||
* WARNING: Some of these fonts are no longer supported or may have changed
|
||||
* geometries. For maximum copmatibility, see the comments below.
|
||||
*
|
||||
* Note: X-Plane 7 supports proportional-spaced fonts. Since no measuring
|
||||
* routine is available yet, the SDK will normally draw using a fixed-width
|
||||
* font. You can use a dataref to enable proportional font drawing on XP7 if
|
||||
* you want to.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* Mono-spaced font for user interface. Available in all versions of the
|
||||
SDK. */
|
||||
xplmFont_Basic = 0
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_Menus = 1
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_Metal = 2
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_Led = 3
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_LedWide = 4
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_PanelHUD = 5
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_PanelEFIS = 6
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_PanelGPS = 7
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_RadiosGA = 8
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_RadiosBC = 9
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_RadiosHM = 10
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_RadiosGANarrow = 11
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_RadiosBCNarrow = 12
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_RadiosHMNarrow = 13
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_Timer = 14
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_FullRound = 15
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_SmallRound = 16
|
||||
|
||||
/* Deprecated, do not use. */
|
||||
,
|
||||
xplmFont_Menus_Localized = 17
|
||||
|
||||
#if defined(XPLM200)
|
||||
/* Proportional UI font. */
|
||||
,
|
||||
xplmFont_Proportional = 18
|
||||
|
||||
#endif /* XPLM200 */
|
||||
|
||||
};
|
||||
typedef int XPLMFontID;
|
||||
|
||||
/*
|
||||
* XPLMDrawString
|
||||
*
|
||||
* This routine draws a NULL termianted string in a given font. Pass in the
|
||||
* lower left pixel that the character is to be drawn onto. Also pass the
|
||||
* character and font ID. This function returns the x offset plus the width of
|
||||
* all drawn characters. The color to draw in is specified as a pointer to an
|
||||
* array of three floating point colors, representing RGB intensities from 0.0
|
||||
* to 1.0.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDrawString(float *inColorRGB,
|
||||
int inXOffset,
|
||||
int inYOffset,
|
||||
char *inChar,
|
||||
int *inWordWrapWidth, /* Can be NULL */
|
||||
XPLMFontID inFontID);
|
||||
|
||||
/*
|
||||
* XPLMDrawNumber
|
||||
*
|
||||
* This routine draws a number similar to the digit editing fields in
|
||||
* PlaneMaker and data output display in X-Plane. Pass in a color, a
|
||||
* position, a floating point value, and formatting info. Specify how many
|
||||
* integer and how many decimal digits to show and whether to show a sign, as
|
||||
* well as a character set. This routine returns the xOffset plus width of the
|
||||
* string drawn.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDrawNumber(float *inColorRGB,
|
||||
int inXOffset,
|
||||
int inYOffset,
|
||||
double inValue,
|
||||
int inDigits,
|
||||
int inDecimals,
|
||||
int inShowSign,
|
||||
XPLMFontID inFontID);
|
||||
|
||||
/*
|
||||
* XPLMGetFontDimensions
|
||||
*
|
||||
* This routine returns the width and height of a character in a given font.
|
||||
* It also tells you if the font only supports numeric digits. Pass NULL if
|
||||
* you don't need a given field. Note that for a proportional font the width
|
||||
* will be an arbitrary, hopefully average width.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetFontDimensions(XPLMFontID inFontID,
|
||||
int *outCharWidth, /* Can be NULL */
|
||||
int *outCharHeight, /* Can be NULL */
|
||||
int *outDigitsOnly); /* Can be NULL */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMMeasureString
|
||||
*
|
||||
* This routine returns the width in pixels of a string using a given font.
|
||||
* The string is passed as a pointer plus length (and does not need to be null
|
||||
* terminated); this is used to allow for measuring substrings. The return
|
||||
* value is floating point; it is possible that future font drawing may allow
|
||||
* for fractional pixels.
|
||||
*
|
||||
*/
|
||||
XPLM_API float
|
||||
XPLMMeasureString(XPLMFontID inFontID, const char *inChar, int inNumChars);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,210 @@
|
||||
#ifndef _XPLMMenus_h_
|
||||
#define _XPLMMenus_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* XPLMMenus - Theory of Operation
|
||||
*
|
||||
* Plug-ins can create menus in the menu bar of X-Plane. This is done by
|
||||
* creating a menu and then creating items. Menus are referred to by an
|
||||
* opaque ID. Items are referred to by index number. For each menu and item
|
||||
* you specify a void *. Per menu you specify a handler function that is
|
||||
* called with each void * when the menu item is picked. Menu item indices
|
||||
* are zero based.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* XPLM MENUS
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMMenuCheck
|
||||
*
|
||||
* These enumerations define the various 'check' states for an X-Plane menu.
|
||||
* 'checking' in x-plane actually appears as a light which may or may not be
|
||||
* lit. So there are three possible states.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* there is no symbol to the left of the menu item. */
|
||||
xplm_Menu_NoCheck = 0
|
||||
|
||||
/* the menu has a mark next to it that is unmarked (not lit). */
|
||||
,
|
||||
xplm_Menu_Unchecked = 1
|
||||
|
||||
/* the menu has a mark next to it that is checked (lit). */
|
||||
,
|
||||
xplm_Menu_Checked = 2
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMMenuCheck;
|
||||
|
||||
/*
|
||||
* XPLMMenuID
|
||||
*
|
||||
* This is a unique ID for each menu you create.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMMenuID;
|
||||
|
||||
/*
|
||||
* XPLMMenuHandler_f
|
||||
*
|
||||
* A menu handler function takes two reference pointers, one for the menu
|
||||
* (specified when the menu was created) and one for the item (specified when
|
||||
* the item was created).
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMMenuHandler_f)(void *inMenuRef, void *inItemRef);
|
||||
|
||||
/*
|
||||
* XPLMFindPluginsMenu
|
||||
*
|
||||
* This function returns the ID of the plug-ins menu, which is created for you
|
||||
* at startup.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMMenuID XPLMFindPluginsMenu(void);
|
||||
|
||||
/*
|
||||
* XPLMCreateMenu
|
||||
*
|
||||
* This function creates a new menu and returns its ID. It returns NULL if
|
||||
* the menu cannot be created. Pass in a parent menu ID and an item index to
|
||||
* create a submenu, or NULL for the parent menu to put the menu in the menu
|
||||
* bar. The menu's name is only used if the menu is in the menubar. You also
|
||||
* pass a handler function and a menu reference value. Pass NULL for the
|
||||
* handler if you do not need callbacks from the menu (for example, if it only
|
||||
* contains submenus).
|
||||
*
|
||||
* Important: you must pass a valid, non-empty menu title even if the menu is
|
||||
* a submenu where the title is not visible.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMMenuID XPLMCreateMenu(const char *inName,
|
||||
XPLMMenuID inParentMenu,
|
||||
int inParentItem,
|
||||
XPLMMenuHandler_f inHandler,
|
||||
void *inMenuRef);
|
||||
|
||||
/*
|
||||
* XPLMDestroyMenu
|
||||
*
|
||||
* This function destroys a menu that you have created. Use this to remove a
|
||||
* submenu if necessary. (Normally this function will not be necessary.)
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDestroyMenu(XPLMMenuID inMenuID);
|
||||
|
||||
/*
|
||||
* XPLMClearAllMenuItems
|
||||
*
|
||||
* This function removes all menu items from a menu, allowing you to rebuild
|
||||
* it. Use this function if you need to change the number of items on a menu.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMClearAllMenuItems(XPLMMenuID inMenuID);
|
||||
|
||||
/*
|
||||
* XPLMAppendMenuItem
|
||||
*
|
||||
* This routine appends a new menu item to the bottom of a menu and returns
|
||||
* its index. Pass in the menu to add the item to, the items name, and a void
|
||||
* * ref for this item. If you pass in inForceEnglish, this menu item will be
|
||||
* drawn using the english character set no matter what language x-plane is
|
||||
* running in. Otherwise the menu item will be drawn localized. (An example
|
||||
* of why you'd want to do this is for a proper name.) See XPLMUtilities for
|
||||
* determining the current langauge.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMAppendMenuItem(XPLMMenuID inMenu,
|
||||
const char *inItemName,
|
||||
void *inItemRef,
|
||||
int inForceEnglish);
|
||||
|
||||
/*
|
||||
* XPLMAppendMenuSeparator
|
||||
*
|
||||
* This routine adds a seperator to the end of a menu.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMAppendMenuSeparator(XPLMMenuID inMenu);
|
||||
|
||||
/*
|
||||
* XPLMSetMenuItemName
|
||||
*
|
||||
* This routine changes the name of an existing menu item. Pass in the menu
|
||||
* ID and the index of the menu item.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetMenuItemName(XPLMMenuID inMenu,
|
||||
int inIndex,
|
||||
const char *inItemName,
|
||||
int inForceEnglish);
|
||||
|
||||
/*
|
||||
* XPLMCheckMenuItem
|
||||
*
|
||||
* Set whether a menu item is checked. Pass in the menu ID and item index.
|
||||
*
|
||||
*/
|
||||
XPLM_API void
|
||||
XPLMCheckMenuItem(XPLMMenuID inMenu, int index, XPLMMenuCheck inCheck);
|
||||
|
||||
/*
|
||||
* XPLMCheckMenuItemState
|
||||
*
|
||||
* This routine returns whether a menu item is checked or not. A menu item's
|
||||
* check mark may be on or off, or a menu may not have an icon at all.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCheckMenuItemState(XPLMMenuID inMenu,
|
||||
int index,
|
||||
XPLMMenuCheck *outCheck);
|
||||
|
||||
/*
|
||||
* XPLMEnableMenuItem
|
||||
*
|
||||
* Sets whether this menu item is enabled. Items start out enabled.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMEnableMenuItem(XPLMMenuID inMenu, int index, int enabled);
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMRemoveMenuItem
|
||||
*
|
||||
* Removes one item from a menu. Note that all menu items below are moved up
|
||||
* one; your plugin must track the change in index numbers.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMRemoveMenuItem(XPLMMenuID inMenu, int inIndex);
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,373 @@
|
||||
#ifndef _XPLMNavigation_h_
|
||||
#define _XPLMNavigation_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* XPLMNavigation - THEORY OF OPERATION
|
||||
*
|
||||
* The XPLM Navigation APIs give you some access to the navigation databases
|
||||
* inside X-Plane. X-Plane stores all navigation information in RAM, so by
|
||||
* using these APIs you can gain access to most information without having to
|
||||
* go to disk or parse the files yourself.
|
||||
*
|
||||
* You can also use this API to program the FMS. You must use the navigation
|
||||
* APIs to find the nav-aids you want to program into the FMS, since the FMS
|
||||
* is powered internally by x-plane's navigation database.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* NAVIGATION DATABASE ACCESS
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMNavType
|
||||
*
|
||||
* These enumerations define the different types of navaids. They are each
|
||||
* defined with a separate bit so that they may be bit-wise added together to
|
||||
* form sets of nav-aid types.
|
||||
*
|
||||
* NOTE: xplm_Nav_LatLon is a specific lat-lon coordinate entered into the
|
||||
* FMS. It will not exist in the database, and cannot be programmed into the
|
||||
* FMS. Querying the FMS for navaids will return it. Use
|
||||
* XPLMSetFMSEntryLatLon to set a lat/lon waypoint.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
xplm_Nav_Unknown = 0
|
||||
|
||||
,
|
||||
xplm_Nav_Airport = 1
|
||||
|
||||
,
|
||||
xplm_Nav_NDB = 2
|
||||
|
||||
,
|
||||
xplm_Nav_VOR = 4
|
||||
|
||||
,
|
||||
xplm_Nav_ILS = 8
|
||||
|
||||
,
|
||||
xplm_Nav_Localizer = 16
|
||||
|
||||
,
|
||||
xplm_Nav_GlideSlope = 32
|
||||
|
||||
,
|
||||
xplm_Nav_OuterMarker = 64
|
||||
|
||||
,
|
||||
xplm_Nav_MiddleMarker = 128
|
||||
|
||||
,
|
||||
xplm_Nav_InnerMarker = 256
|
||||
|
||||
,
|
||||
xplm_Nav_Fix = 512
|
||||
|
||||
,
|
||||
xplm_Nav_DME = 1024
|
||||
|
||||
,
|
||||
xplm_Nav_LatLon = 2048
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMNavType;
|
||||
|
||||
/*
|
||||
* XPLMNavRef
|
||||
*
|
||||
* XPLMNavRef is an iterator into the navigation database. The navigation
|
||||
* database is essentially an array, but it is not necessarily densely
|
||||
* populated. The only assumption you can safely make is that like-typed
|
||||
* nav-aids are grouped together.
|
||||
*
|
||||
* Use XPLMNavRef to refer to a nav-aid.
|
||||
*
|
||||
* XPLM_NAV_NOT_FOUND is returned by functions that return an XPLMNavRef when
|
||||
* the iterator must be invalid.
|
||||
*
|
||||
*/
|
||||
typedef int XPLMNavRef;
|
||||
|
||||
#define XPLM_NAV_NOT_FOUND -1
|
||||
|
||||
/*
|
||||
* XPLMGetFirstNavAid
|
||||
*
|
||||
* This returns the very first navaid in the database. Use this to traverse
|
||||
* the entire database. Returns XPLM_NAV_NOT_FOUND if the nav database is
|
||||
* empty.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavRef XPLMGetFirstNavAid(void);
|
||||
|
||||
/*
|
||||
* XPLMGetNextNavAid
|
||||
*
|
||||
* Given a nav aid ref, this routine returns the next navaid. It returns
|
||||
* XPLM_NAV_NOT_FOUND if the nav aid passed in was invalid or if the navaid
|
||||
* passed in was the last one in the database. Use this routine to iterate
|
||||
* across all like-typed navaids or the entire database.
|
||||
*
|
||||
* WARNING: due to a bug in the SDK, when fix loading is disabled in the
|
||||
* rendering settings screen, calling this routine with the last airport
|
||||
* returns a bogus nav aid. Using this nav aid can crash x-plane.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavRef XPLMGetNextNavAid(XPLMNavRef inNavAidRef);
|
||||
|
||||
/*
|
||||
* XPLMFindFirstNavAidOfType
|
||||
*
|
||||
* This routine returns the ref of the first navaid of the given type in the
|
||||
* database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the
|
||||
* database. You must pass exactly one nav aid type to this routine.
|
||||
*
|
||||
* WARNING: due to a bug in the SDK, when fix loading is disabled in the
|
||||
* rendering settings screen, calling this routine with fixes returns a bogus
|
||||
* nav aid. Using this nav aid can crash x-plane.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavRef XPLMFindFirstNavAidOfType(XPLMNavType inType);
|
||||
|
||||
/*
|
||||
* XPLMFindLastNavAidOfType
|
||||
*
|
||||
* This routine returns the ref of the last navaid of the given type in the
|
||||
* database or XPLM_NAV_NOT_FOUND if there are no navaids of that type in the
|
||||
* database. You must pass exactly one nav aid type to this routine.
|
||||
*
|
||||
* WARNING: due to a bug in the SDK, when fix loading is disabled in the
|
||||
* rendering settings screen, calling this routine with fixes returns a bogus
|
||||
* nav aid. Using this nav aid can crash x-plane.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavRef XPLMFindLastNavAidOfType(XPLMNavType inType);
|
||||
|
||||
/*
|
||||
* XPLMFindNavAid
|
||||
*
|
||||
* This routine provides a number of searching capabilities for the nav
|
||||
* database. XPLMFindNavAid will search through every nav aid whose type is
|
||||
* within inType (multiple types may be added together) and return any
|
||||
* nav-aids found based on the following rules:
|
||||
*
|
||||
* If inLat and inLon are not NULL, the navaid nearest to that lat/lon will be
|
||||
* returned, otherwise the last navaid found will be returned.
|
||||
*
|
||||
* If inFrequency is not NULL, then any navaids considered must match this
|
||||
* frequency. Note that this will screen out radio beacons that do not have
|
||||
* frequency data published (like inner markers) but not fixes and airports.
|
||||
*
|
||||
* If inNameFragment is not NULL, only navaids that contain the fragment in
|
||||
* their name will be returned.
|
||||
*
|
||||
* If inIDFragment is not NULL, only navaids that contain the fragment in
|
||||
* their IDs will be returned.
|
||||
*
|
||||
* This routine provides a simple way to do a number of useful searches:
|
||||
*
|
||||
* Find the nearest navaid on this frequency. Find the nearest airport. Find
|
||||
* the VOR whose ID is "KBOS". Find the nearest airport whose name contains
|
||||
* "Chicago".
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavRef XPLMFindNavAid(const char *inNameFragment, /* Can be NULL */
|
||||
const char *inIDFragment, /* Can be NULL */
|
||||
float *inLat, /* Can be NULL */
|
||||
float *inLon, /* Can be NULL */
|
||||
int *inFrequency, /* Can be NULL */
|
||||
XPLMNavType inType);
|
||||
|
||||
/*
|
||||
* XPLMGetNavAidInfo
|
||||
*
|
||||
* This routine returns information about a navaid. Any non-null field is
|
||||
* filled out with information if it is available.
|
||||
*
|
||||
* Frequencies are in the nav.dat convention as described in the X-Plane nav
|
||||
* database FAQ: NDB frequencies are exact, all others are multiplied by 100.
|
||||
*
|
||||
* The buffer for IDs should be at least 6 chars and the buffer for names
|
||||
* should be at least 41 chars, but since these values are likely to go up, I
|
||||
* recommend passing at least 32 chars for IDs and 256 chars for names when
|
||||
* possible.
|
||||
*
|
||||
* The outReg parameter tells if the navaid is within the local "region" of
|
||||
* loaded DSFs. (This information may not be particularly useful to plugins.)
|
||||
* The parameter is a single byte value 1 for true or 0 for false, not a C
|
||||
* string.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetNavAidInfo(XPLMNavRef inRef,
|
||||
XPLMNavType *outType, /* Can be NULL */
|
||||
float *outLatitude, /* Can be NULL */
|
||||
float *outLongitude, /* Can be NULL */
|
||||
float *outHeight, /* Can be NULL */
|
||||
int *outFrequency, /* Can be NULL */
|
||||
float *outHeading, /* Can be NULL */
|
||||
char *outID, /* Can be NULL */
|
||||
char *outName, /* Can be NULL */
|
||||
char *outReg); /* Can be NULL */
|
||||
|
||||
/***************************************************************************
|
||||
* FLIGHT MANAGEMENT COMPUTER
|
||||
***************************************************************************/
|
||||
/*
|
||||
* Note: the FMS works based on an array of entries. Indices into the array
|
||||
* are zero-based. Each entry is a nav-aid plus an altitude. The FMS tracks
|
||||
* the currently displayed entry and the entry that it is flying to.
|
||||
*
|
||||
* The FMS must be programmed with contiguous entries, so clearing an entry at
|
||||
* the end shortens the effective flight plan. There is a max of 100
|
||||
* waypoints in the flight plan.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMCountFMSEntries
|
||||
*
|
||||
* This routine returns the number of entries in the FMS.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMCountFMSEntries(void);
|
||||
|
||||
/*
|
||||
* XPLMGetDisplayedFMSEntry
|
||||
*
|
||||
* This routine returns the index of the entry the pilot is viewing.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDisplayedFMSEntry(void);
|
||||
|
||||
/*
|
||||
* XPLMGetDestinationFMSEntry
|
||||
*
|
||||
* This routine returns the index of the entry the FMS is flying to.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDestinationFMSEntry(void);
|
||||
|
||||
/*
|
||||
* XPLMSetDisplayedFMSEntry
|
||||
*
|
||||
* This routine changes which entry the FMS is showing to the index specified.
|
||||
* *
|
||||
*/
|
||||
XPLM_API void XPLMSetDisplayedFMSEntry(int inIndex);
|
||||
|
||||
/*
|
||||
* XPLMSetDestinationFMSEntry
|
||||
*
|
||||
* This routine changes which entry the FMS is flying the aircraft toward.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetDestinationFMSEntry(int inIndex);
|
||||
|
||||
/*
|
||||
* XPLMGetFMSEntryInfo
|
||||
*
|
||||
* This routine returns information about a given FMS entry. A reference to a
|
||||
* navaid can be returned allowing you to find additional information (such as
|
||||
* a frequency, ILS heading, name, etc.). Some information is available
|
||||
* immediately. For a lat/lon entry, the lat/lon is returned by this routine
|
||||
* but the navaid cannot be looked up (and the reference will be
|
||||
* XPLM_NAV_NOT_FOUND. FMS name entry buffers should be at least 256 chars in
|
||||
* length.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetFMSEntryInfo(int inIndex,
|
||||
XPLMNavType *outType, /* Can be NULL */
|
||||
char *outID, /* Can be NULL */
|
||||
XPLMNavRef *outRef, /* Can be NULL */
|
||||
int *outAltitude, /* Can be NULL */
|
||||
float *outLat, /* Can be NULL */
|
||||
float *outLon); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMSetFMSEntryInfo
|
||||
*
|
||||
* This routine changes an entry in the FMS to have the destination navaid
|
||||
* passed in and the altitude specified. Use this only for airports, fixes,
|
||||
* and radio-beacon navaids. Currently of radio beacons, the FMS can only
|
||||
* support VORs and NDBs. Use the routines below to clear or fly to a lat/lon.
|
||||
*
|
||||
*/
|
||||
XPLM_API void
|
||||
XPLMSetFMSEntryInfo(int inIndex, XPLMNavRef inRef, int inAltitude);
|
||||
|
||||
/*
|
||||
* XPLMSetFMSEntryLatLon
|
||||
*
|
||||
* This routine changes the entry in the FMS to a lat/lon entry with the given
|
||||
* coordinates.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetFMSEntryLatLon(int inIndex,
|
||||
float inLat,
|
||||
float inLon,
|
||||
int inAltitude);
|
||||
|
||||
/*
|
||||
* XPLMClearFMSEntry
|
||||
*
|
||||
* This routine clears the given entry, potentially shortening the flight
|
||||
* plan.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMClearFMSEntry(int inIndex);
|
||||
|
||||
/***************************************************************************
|
||||
* GPS RECEIVER
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These APIs let you read data from the GPS unit.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMGetGPSDestinationType
|
||||
*
|
||||
* This routine returns the type of the currently selected GPS destination,
|
||||
* one of fix, airport, VOR or NDB.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavType XPLMGetGPSDestinationType(void);
|
||||
|
||||
/*
|
||||
* XPLMGetGPSDestination
|
||||
*
|
||||
* This routine returns the current GPS destination.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMNavRef XPLMGetGPSDestination(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,245 @@
|
||||
#ifndef _XPLMPlanes_h_
|
||||
#define _XPLMPlanes_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* The XPLMPlanes APIs allow you to control the various aircraft in x-plane,
|
||||
* both the user's and the sim's.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* USER AIRCRAFT ACCESS
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMSetUsersAircraft
|
||||
*
|
||||
* This routine changes the user's aircraft. Note that this will reinitialize
|
||||
* the user to be on the nearest airport's first runway. Pass in a full path
|
||||
* (hard drive and everything including the .acf extension) to the .acf file.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetUsersAircraft(const char *inAircraftPath);
|
||||
/*
|
||||
* XPLMPlaceUserAtAirport
|
||||
*
|
||||
* This routine places the user at a given airport. Specify the airport by
|
||||
* its ICAO code (e.g. 'KBOS').
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMPlaceUserAtAirport(const char *inAirportCode);
|
||||
/***************************************************************************
|
||||
* GLOBAL AIRCRAFT ACCESS
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/* The user's aircraft is always index 0. */
|
||||
#define XPLM_USER_AIRCRAFT 0
|
||||
/*
|
||||
* XPLMPlaneDrawState_t
|
||||
*
|
||||
* This structure contains additional plane parameter info to be passed to
|
||||
* draw plane. Make sure to fill in the size of the structure field with
|
||||
* sizeof(XPLMDrawPlaneState_t) so that the XPLM can tell how many fields you
|
||||
* knew about when compiling your plugin (since more fields may be added
|
||||
* later).
|
||||
*
|
||||
* Most of these fields are ratios from 0 to 1 for control input. X-Plane
|
||||
* calculates what the actual controls look like based on the .acf file for
|
||||
* that airplane. Note for the yoke inputs, this is what the pilot of the
|
||||
* plane has commanded (post artificial stability system if there were one)
|
||||
* and affects aelerons, rudder, etc. It is not necessarily related to the
|
||||
* actual position of the plane!
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
/* The size of the draw state struct. */
|
||||
int structSize;
|
||||
/* A ratio from [0..1] describing how far the landing gear is extended. */
|
||||
float gearPosition;
|
||||
/* Ratio of flap deployment, 0 = up, 1 = full deploy. */
|
||||
float flapRatio;
|
||||
/* Ratio of spoiler deployment, 0 = none, 1 = full deploy. */
|
||||
float spoilerRatio;
|
||||
/* Ratio of speed brake deployment, 0 = none, 1 = full deploy. */
|
||||
float speedBrakeRatio;
|
||||
/* Ratio of slat deployment, 0 = none, 1 = full deploy. */
|
||||
float slatRatio;
|
||||
/* Wing sweep ratio, 0 = forward, 1 = swept. */
|
||||
float wingSweep;
|
||||
/* Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. */
|
||||
float thrust;
|
||||
/* Total pitch input for this plane. */
|
||||
float yokePitch;
|
||||
/* Total Heading input for this plane. */
|
||||
float yokeHeading;
|
||||
/* Total Roll input for this plane. */
|
||||
float yokeRoll;
|
||||
} XPLMPlaneDrawState_t;
|
||||
/*
|
||||
* XPLMCountAircraft
|
||||
*
|
||||
* This function returns the number of aircraft X-Plane is capable of having,
|
||||
* as well as the number of aircraft that are currently active. These numbers
|
||||
* count the user's aircraft. It can also return the plugin that is currently
|
||||
* controlling aircraft. In X-Plane 7, this routine reflects the number of
|
||||
* aircraft the user has enabled in the rendering options window.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCountAircraft(int *outTotalAircraft,
|
||||
int *outActiveAircraft,
|
||||
XPLMPluginID *outController);
|
||||
/*
|
||||
* XPLMGetNthAircraftModel
|
||||
*
|
||||
* This function returns the aircraft model for the Nth aircraft. Indices are
|
||||
* zero based, with zero being the user's aircraft. The file name should be
|
||||
* at least 256 chars in length; the path should be at least 512 chars in
|
||||
* length.
|
||||
*
|
||||
*/
|
||||
XPLM_API void
|
||||
XPLMGetNthAircraftModel(int inIndex, char *outFileName, char *outPath);
|
||||
/***************************************************************************
|
||||
* EXCLUSIVE AIRCRAFT ACCESS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The following routines require exclusive access to the airplane APIs. Only
|
||||
* one plugin may have this access at a time.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMPlanesAvailable_f
|
||||
*
|
||||
* Your airplanes available callback is called when another plugin gives up
|
||||
* access to the multiplayer planes. Use this to wait for access to
|
||||
* multiplayer.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMPlanesAvailable_f)(void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMAcquirePlanes
|
||||
*
|
||||
* XPLMAcquirePlanes grants your plugin exclusive access to the aircraft. It
|
||||
* returns 1 if you gain access, 0 if you do not. inAircraft - pass in an
|
||||
* array of pointers to strings specifying the planes you want loaded. For
|
||||
* any plane index you do not want loaded, pass a 0-length string. Other
|
||||
* strings should be full paths with the .acf extension. NULL terminates this
|
||||
* array, or pass NULL if there are no planes you want loaded. If you pass in
|
||||
* a callback and do not receive access to the planes your callback will be
|
||||
* called when the airplanes are available. If you do receive airplane access,
|
||||
* your callback will not be called.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMAcquirePlanes(char **inAircraft, /* Can be NULL */
|
||||
XPLMPlanesAvailable_f inCallback,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMReleasePlanes
|
||||
*
|
||||
* Call this function to release access to the planes. Note that if you are
|
||||
* disabled, access to planes is released for you and you must reacquire it.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMReleasePlanes(void);
|
||||
|
||||
/*
|
||||
* XPLMSetActiveAircraftCount
|
||||
*
|
||||
* This routine sets the number of active planes. If you pass in a number
|
||||
* higher than the total number of planes availables, only the total number of
|
||||
* planes available is actually used.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetActiveAircraftCount(int inCount);
|
||||
|
||||
/*
|
||||
* XPLMSetAircraftModel
|
||||
*
|
||||
* This routine loads an aircraft model. It may only be called if you have
|
||||
* exclusive access to the airplane APIs. Pass in the path of the model with
|
||||
* the .acf extension. The index is zero based, but you may not pass in 0
|
||||
* (use XPLMSetUsersAircraft to load the user's aircracft).
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetAircraftModel(int inIndex, const char *inAircraftPath);
|
||||
|
||||
/*
|
||||
* XPLMDisableAIForPlane
|
||||
*
|
||||
* This routine turns off X-Plane's AI for a given plane. The plane will
|
||||
* continue to draw and be a real plane in X-Plane, but will not move itself.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDisableAIForPlane(int inPlaneIndex);
|
||||
|
||||
/*
|
||||
* XPLMDrawAircraft
|
||||
*
|
||||
* This routine draws an aircraft. It can only be called from a 3-d drawing
|
||||
* callback. Pass in the position of the plane in OpenGL local coordinates
|
||||
* and the orientation of the plane. A 1 for full drawing indicates that the
|
||||
* whole plane must be drawn; a 0 indicates you only need the nav lights
|
||||
* drawn. (This saves rendering time when planes are far away.)
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDrawAircraft(int inPlaneIndex,
|
||||
float inX,
|
||||
float inY,
|
||||
float inZ,
|
||||
float inPitch,
|
||||
float inRoll,
|
||||
float inYaw,
|
||||
int inFullDraw,
|
||||
XPLMPlaneDrawState_t *inDrawStateInfo);
|
||||
|
||||
/*
|
||||
* XPLMReinitUsersPlane
|
||||
*
|
||||
* This function recomputes the derived flight model data from the aircraft
|
||||
* structure in memory. If you have used the data access layer to modify the
|
||||
* aircraft structure, use this routine to resynchronize x-plane; since
|
||||
* X-plane works at least partly from derived values, the sim will not behave
|
||||
* properly until this is called.
|
||||
*
|
||||
* WARNING: this routine does not necessarily place the airplane at the
|
||||
* airport; use XPLMSetUsersAircraft to be compatible. This routine is
|
||||
* provided to do special experimentation with flight models without resetting
|
||||
* flight.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMReinitUsersPlane(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,311 @@
|
||||
#ifndef _XPLMPlugin_h_
|
||||
#define _XPLMPlugin_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* These APIs provide facilities to find and work with other plugins and
|
||||
* manage other plugins.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* FINDING PLUGINS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These APIs allow you to find another plugin or yourself, or iterate across
|
||||
* all plugins. For example, if you wrote an FMS plugin that needed to talk
|
||||
* to an autopilot plugin, you could use these APIs to locate the autopilot
|
||||
* plugin.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMGetMyID
|
||||
*
|
||||
* This routine returns the plugin ID of the calling plug-in. Call this to
|
||||
* get your own ID.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMPluginID XPLMGetMyID(void);
|
||||
|
||||
/*
|
||||
* XPLMCountPlugins
|
||||
*
|
||||
* This routine returns the total number of plug-ins that are loaded, both
|
||||
* disabled and enabled.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMCountPlugins(void);
|
||||
|
||||
/*
|
||||
* XPLMGetNthPlugin
|
||||
*
|
||||
* This routine returns the ID of a plug-in by index. Index is 0 based from 0
|
||||
* to XPLMCountPlugins-1, inclusive. Plugins may be returned in any arbitrary
|
||||
* order.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMPluginID XPLMGetNthPlugin(int inIndex);
|
||||
|
||||
/*
|
||||
* XPLMFindPluginByPath
|
||||
*
|
||||
* This routine returns the plug-in ID of the plug-in whose file exists at the
|
||||
* passed in absolute file system path. XPLM_NO_PLUGIN_ID is returned if the
|
||||
* path does not point to a currently loaded plug-in.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMPluginID XPLMFindPluginByPath(const char *inPath);
|
||||
|
||||
/*
|
||||
* XPLMFindPluginBySignature
|
||||
*
|
||||
* This routine returns the plug-in ID of the plug-in whose signature matches
|
||||
* what is passed in or XPLM_NO_PLUGIN_ID if no running plug-in has this
|
||||
* signature. Signatures are the best way to identify another plug-in as they
|
||||
* are independent of the file system path of a plug-in or the human-readable
|
||||
* plug-in name, and should be unique for all plug-ins. Use this routine to
|
||||
* locate another plugin that your plugin interoperates with
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMPluginID XPLMFindPluginBySignature(const char *inSignature);
|
||||
|
||||
/*
|
||||
* XPLMGetPluginInfo
|
||||
*
|
||||
* This routine returns information about a plug-in. Each parameter should be
|
||||
* a pointer to a buffer of at least 256 characters, or NULL to not receive
|
||||
* the information.
|
||||
*
|
||||
* outName - the human-readable name of the plug-in. outFilePath - the
|
||||
* absolute file path to the file that contains this plug-in. outSignature - a
|
||||
* unique string that identifies this plug-in. outDescription - a
|
||||
* human-readable description of this plug-in.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetPluginInfo(XPLMPluginID inPlugin,
|
||||
char *outName, /* Can be NULL */
|
||||
char *outFilePath, /* Can be NULL */
|
||||
char *outSignature, /* Can be NULL */
|
||||
char *outDescription); /* Can be NULL */
|
||||
|
||||
/***************************************************************************
|
||||
* ENABLING/DISABLING PLUG-INS
|
||||
***************************************************************************/
|
||||
/*
|
||||
* These routines are used to work with plug-ins and manage them. Most
|
||||
* plugins will not need to use these APIs.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMIsPluginEnabled
|
||||
*
|
||||
* Returns whether the specified plug-in is enabled for running.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMIsPluginEnabled(XPLMPluginID inPluginID);
|
||||
|
||||
/*
|
||||
* XPLMEnablePlugin
|
||||
*
|
||||
* This routine enables a plug-in if it is not already enabled. It returns 1
|
||||
* if the plugin was enabled or successfully enables itself, 0 if it does not.
|
||||
* Plugins may fail to enable (for example, if resources cannot be acquired)
|
||||
* by returning 0 from their XPluginEnable callback.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMEnablePlugin(XPLMPluginID inPluginID);
|
||||
|
||||
/*
|
||||
* XPLMDisablePlugin
|
||||
*
|
||||
* This routine disableds an enabled plug-in.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDisablePlugin(XPLMPluginID inPluginID);
|
||||
|
||||
/*
|
||||
* XPLMReloadPlugins
|
||||
*
|
||||
* This routine reloads all plug-ins. Once this routine is called and you
|
||||
* return from the callback you were within (e.g. a menu select callback) you
|
||||
* will receive your XPluginDisable and XPluginStop callbacks and your DLL
|
||||
* will be unloaded, then the start process happens as if the sim was starting
|
||||
* up.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMReloadPlugins(void);
|
||||
|
||||
/***************************************************************************
|
||||
* INTERPLUGIN MESSAGING
|
||||
***************************************************************************/
|
||||
/*
|
||||
* Plugin messages are defined as 32-bit integers. Messages below 0x00FFFFFF
|
||||
* are reserved for X-Plane and the plugin SDK.
|
||||
*
|
||||
* Messages have two conceptual uses: notifications and commands. Commands
|
||||
* are sent from one plugin to another to induce behavior; notifications are
|
||||
* sent from one plugin to all others for informational purposes. It is
|
||||
* important that commands and notifications not have the same values because
|
||||
* this could cause a notification sent by one plugin to accidentally induce a
|
||||
* command in another.
|
||||
*
|
||||
* By convention, plugin-defined notifications should have the high bit set
|
||||
* (e.g. be greater or equal to unsigned 0x8000000) while commands should have
|
||||
* this bit be cleared.
|
||||
*
|
||||
* The following messages are sent to your plugin by x-plane.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/* This message is sent to your plugin whenever the user's plane crashes. */
|
||||
#define XPLM_MSG_PLANE_CRASHED 101
|
||||
|
||||
/* This message is sent to your plugin whenever a new plane is loaded. The *
|
||||
* parameter is the number of the plane being loaded; 0 indicates the user's *
|
||||
* plane. */
|
||||
#define XPLM_MSG_PLANE_LOADED 102
|
||||
|
||||
/* This messages is called whenever the user's plane is positioned at a new *
|
||||
* airport. */
|
||||
#define XPLM_MSG_AIRPORT_LOADED 103
|
||||
|
||||
/* This message is sent whenever new scenery is loaded. Use datarefs to *
|
||||
* determine the new scenery files that were loaded. */
|
||||
#define XPLM_MSG_SCENERY_LOADED 104
|
||||
|
||||
/* This message is sent whenever the user adjusts the number of X-Plane *
|
||||
* aircraft models. You must use XPLMCountPlanes to find out how many planes *
|
||||
* are now available. This message will only be sent in XP7 and higher *
|
||||
* because in XP6 the number of aircraft is not user-adjustable. */
|
||||
#define XPLM_MSG_AIRPLANE_COUNT_CHANGED 105
|
||||
|
||||
#if defined(XPLM200)
|
||||
/* This message is sent to your plugin whenever a plane is unloaded. The *
|
||||
* parameter is the number of the plane being unloaded; 0 indicates the user's *
|
||||
* plane. The parameter is of type int, passed as the value of the pointer. *
|
||||
* (That is: the parameter is an int, not a pointer to an int.) */
|
||||
#define XPLM_MSG_PLANE_UNLOADED 106
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/* This message is sent to your plugin right before X-Plane writes its *
|
||||
* preferences file. You can use this for two purposes: to write your own *
|
||||
* preferences, and to modify any datarefs to influence preferences output. *
|
||||
* For example, if your plugin temporarily modifies saved preferences, you can *
|
||||
* put them back to their default values here to avoid having the tweaks be *
|
||||
* persisted if your plugin is not loaded on the next invocation of X-Plane. */
|
||||
#define XPLM_MSG_WILL_WRITE_PREFS 107
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/* This message is sent to your plugin right after a livery is loaded for an *
|
||||
* airplane. You can use this to check the new livery (via datarefs) and *
|
||||
* react accordingly. The parameter is of type int, passed as the value of a *
|
||||
* pointer and represents the aicraft plane number - 0 is the user's plane. */
|
||||
#define XPLM_MSG_LIVERY_LOADED 108
|
||||
#endif /* XPLM210 */
|
||||
|
||||
/*
|
||||
* XPLMSendMessageToPlugin
|
||||
*
|
||||
* This function sends a message to another plug-in or X-Plane. Pass
|
||||
* XPLM_NO_PLUGIN_ID to broadcast to all plug-ins. Only enabled plug-ins with
|
||||
* a message receive function receive the message.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSendMessageToPlugin(XPLMPluginID inPlugin,
|
||||
int inMessage,
|
||||
void *inParam);
|
||||
|
||||
#if defined(XPLM200)
|
||||
/***************************************************************************
|
||||
* Plugin Features API
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The plugin features API allows your plugin to "sign up" for additional
|
||||
* capabilities and plugin system features that are normally disabled for
|
||||
* backward compatibility. This allows advanced plugins to "opt-in" to new
|
||||
* behavior.
|
||||
*
|
||||
* Each feature is defined by a permanent string name. The feature string
|
||||
* names will vary with the particular installation of X-Plane, so plugins
|
||||
* should not expect a feature to be guaranteed present.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMFeatureEnumerator_f
|
||||
*
|
||||
* You pass an XPLMFeatureEnumerator_f to get a list of all features supported
|
||||
* by a given version running version of X-Plane. This routine is called once
|
||||
* for each feature.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMFeatureEnumerator_f)(const char *inFeature, void *inRef);
|
||||
|
||||
/*
|
||||
* XPLMHasFeature
|
||||
*
|
||||
* This returns 1 if the given installation of X-Plane supports a feature, or
|
||||
* 0 if it does not.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMHasFeature(const char *inFeature);
|
||||
|
||||
/*
|
||||
* XPLMIsFeatureEnabled
|
||||
*
|
||||
* This returns 1 if a feature is currently enabled for your plugin, or 0 if
|
||||
* it is not enabled. It is an error to call this routine with an unsupported
|
||||
* feature.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMIsFeatureEnabled(const char *inFeature);
|
||||
|
||||
/*
|
||||
* XPLMEnableFeature
|
||||
*
|
||||
* This routine enables or disables a feature for your plugin. This will
|
||||
* change the running behavior of X-Plane and your plugin in some way,
|
||||
* depending on the feature.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMEnableFeature(const char *inFeature, int inEnable);
|
||||
|
||||
/*
|
||||
* XPLMEnumerateFeatures
|
||||
*
|
||||
* This routine calls your enumerator callback once for each feature that this
|
||||
* running version of X-Plane supports. Use this routine to determine all of
|
||||
* the features that X-Plane can support.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMEnumerateFeatures(XPLMFeatureEnumerator_f inEnumerator,
|
||||
void *inRef);
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,248 @@
|
||||
#ifndef _XPLMProcessing_h_
|
||||
#define _XPLMProcessing_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This API allows you to get regular callbacks during the flight loop, the
|
||||
* part of X-Plane where the plane's position calculates the physics of
|
||||
* flight, etc. Use these APIs to accomplish periodic tasks like logging data
|
||||
* and performing I/O.
|
||||
*
|
||||
* WARNING: Do NOT use these callbacks to draw! You cannot draw during flight
|
||||
* loop callbacks. Use the drawing callbacks (see XPLMDisplay for more info)
|
||||
* for graphics.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* FLIGHT LOOP CALLBACKS
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMFlightLoopPhaseType
|
||||
*
|
||||
* You can register a flight loop callback to run either before or after the
|
||||
* flight model is integrated by X-Plane.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* Your callback runs before X-Plane integrates the flight model. */
|
||||
xplm_FlightLoop_Phase_BeforeFlightModel = 0
|
||||
|
||||
/* Your callback runs after X-Plane integrates the flight model. */
|
||||
,
|
||||
xplm_FlightLoop_Phase_AfterFlightModel = 1
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMFlightLoopPhaseType;
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMFlightLoopID
|
||||
*
|
||||
* This is an opaque identifier for a flight loop callback. You can use this
|
||||
* identifier to easily track and remove your callbacks, or to use the new
|
||||
* flight loop APIs.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMFlightLoopID;
|
||||
#endif /* XPLM210 */
|
||||
|
||||
/*
|
||||
* XPLMFlightLoop_f
|
||||
*
|
||||
* This is your flight loop callback. Each time the flight loop is iterated
|
||||
* through, you receive this call at the end. You receive a time since you
|
||||
* were last called and a time since the last loop, as well as a loop counter.
|
||||
* The 'phase' parameter is deprecated and should be ignored.
|
||||
*
|
||||
* Your return value controls when you will next be called. Return 0 to stop
|
||||
* receiving callbacks. Pass a positive number to specify how many seconds
|
||||
* until the next callback. (You will be called at or after this time, not
|
||||
* before.) Pass a negative number to specify how many loops must go by until
|
||||
* you are called. For example, -1.0 means call me the very next loop. Try
|
||||
* to run your flight loop as infrequently as is practical, and suspend it
|
||||
* (using return value 0) when you do not need it; lots of flight loop
|
||||
* callbacks that do nothing lowers x-plane's frame rate.
|
||||
*
|
||||
* Your callback will NOT be unregistered if you return 0; it will merely be
|
||||
* inactive.
|
||||
*
|
||||
* The reference constant you passed to your loop is passed back to you.
|
||||
*
|
||||
*/
|
||||
typedef float (*XPLMFlightLoop_f)(float inElapsedSinceLastCall,
|
||||
float inElapsedTimeSinceLastFlightLoop,
|
||||
int inCounter,
|
||||
void *inRefcon);
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMCreateFlightLoop_t
|
||||
*
|
||||
* XPLMCreateFlightLoop_t contains the parameters to create a new flight loop
|
||||
* callback. The strsucture can be expanded in future SDKs - always set
|
||||
* structSize to the size of your structure in bytes.
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
int structSize;
|
||||
XPLMFlightLoopPhaseType phase;
|
||||
XPLMFlightLoop_f callbackFunc;
|
||||
void *refcon;
|
||||
} XPLMCreateFlightLoop_t;
|
||||
#endif /* XPLM210 */
|
||||
|
||||
/*
|
||||
* XPLMGetElapsedTime
|
||||
*
|
||||
* This routine returns the elapsed time since the sim started up in decimal
|
||||
* seconds.
|
||||
*
|
||||
*/
|
||||
XPLM_API float XPLMGetElapsedTime(void);
|
||||
|
||||
/*
|
||||
* XPLMGetCycleNumber
|
||||
*
|
||||
* This routine returns a counter starting at zero for each sim cycle
|
||||
* computed/video frame rendered.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetCycleNumber(void);
|
||||
|
||||
/*
|
||||
* XPLMRegisterFlightLoopCallback
|
||||
*
|
||||
* This routine registers your flight loop callback. Pass in a pointer to a
|
||||
* flight loop function and a refcon. inInterval defines when you will be
|
||||
* called. Pass in a positive number to specify seconds from registration
|
||||
* time to the next callback. Pass in a negative number to indicate when you
|
||||
* will be called (e.g. pass -1 to be called at the next cylcle). Pass 0 to
|
||||
* not be called; your callback will be inactive.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMRegisterFlightLoopCallback(XPLMFlightLoop_f inFlightLoop,
|
||||
float inInterval,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnregisterFlightLoopCallback
|
||||
*
|
||||
* This routine unregisters your flight loop callback. Do NOT call it from
|
||||
* your flight loop callback. Once your flight loop callback is
|
||||
* unregistered, it will not be called again.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMUnregisterFlightLoopCallback(XPLMFlightLoop_f inFlightLoop,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMSetFlightLoopCallbackInterval
|
||||
*
|
||||
* This routine sets when a callback will be called. Do NOT call it from your
|
||||
* callback; use the return value of the callback to change your callback
|
||||
* interval from inside your callback.
|
||||
*
|
||||
* inInterval is formatted the same way as in XPLMRegisterFlightLoopCallback;
|
||||
* positive for seconds, negative for cycles, and 0 for deactivating the
|
||||
* callback. If inRelativeToNow is 1, times are from the time of this call;
|
||||
* otherwise they are from the time the callback was last called (or the time
|
||||
* it was registered if it has never been called.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetFlightLoopCallbackInterval(XPLMFlightLoop_f inFlightLoop,
|
||||
float inInterval,
|
||||
int inRelativeToNow,
|
||||
void *inRefcon);
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMCreateFlightLoop
|
||||
*
|
||||
* This routine creates a flight loop callback and returns its ID. The flight
|
||||
* loop callback is created using the input param struct, and is inited to be
|
||||
* unscheduled.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMFlightLoopID
|
||||
XPLMCreateFlightLoop(XPLMCreateFlightLoop_t *inParams);
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMDestroyFlightLoop
|
||||
*
|
||||
* This routine destroys a flight loop callback by ID.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDestroyFlightLoop(XPLMFlightLoopID inFlightLoopID);
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMScheduleFlightLoop
|
||||
*
|
||||
* This routine schedules a flight loop callback for future execution. If
|
||||
* inInterval is negative, it is run in a certain number of frames based on
|
||||
* the absolute value of the input. If the interval is positive, it is a
|
||||
* duration in seconds.
|
||||
*
|
||||
* If inRelativeToNow is true, ties are interpretted relative to the time this
|
||||
* routine is called; otherwise they are relative to the last call time or the
|
||||
* time the flight loop was registered (if never called).
|
||||
*
|
||||
* THREAD SAFETY: it is legal to call this routine from any thread under the
|
||||
* following conditions:
|
||||
*
|
||||
* 1. The call must be between the beginning of an XPLMEnable and the end of
|
||||
* an XPLMDisable sequence. (That is, you must not call this routine from
|
||||
* thread activity when your plugin was supposed to be disabled. Since
|
||||
* plugins are only enabled while loaded, this also implies you cannot run
|
||||
* this routine outside an XPLMStart/XPLMStop sequence.)
|
||||
*
|
||||
* 2. You may not call this routine re-entrantly for a single flight loop ID.
|
||||
* (That is, you can't enable from multiple threads at the same time.)
|
||||
*
|
||||
* 3. You must call this routine between the time after XPLMCreateFlightLoop
|
||||
* returns a value and the time you call XPLMDestroyFlightLoop. (That is, you
|
||||
* must ensure that your threaded activity is within the life of the object.
|
||||
* The SDK does not check this for you, nor does it synchronize destruction of
|
||||
* the object.)
|
||||
*
|
||||
* 4. The object must be unscheduled if this routine is to be called from a
|
||||
* thread other than the main thread.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMScheduleFlightLoop(XPLMFlightLoopID inFlightLoopID,
|
||||
float inInterval,
|
||||
int inRelativeToNow);
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,386 @@
|
||||
#ifndef _XPLMScenery_h_
|
||||
#define _XPLMScenery_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This package contains APIs to interact with X-Plane's scenery system.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined(XPLM200)
|
||||
/***************************************************************************
|
||||
* Terrain Y-Testing
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The Y-testing API allows you to locate the physical scenery mesh. This
|
||||
* would be used to place dynamic graphics on top of the ground in a
|
||||
* plausible way or do physics interactions.
|
||||
*
|
||||
* The Y-test API works via probe objects, which are allocated by your plugin
|
||||
* and used to query terrain. Probe objects exist both to capture which
|
||||
* algorithm you have requested (see probe types) and also to cache query
|
||||
* information.
|
||||
*
|
||||
* Performance guidelines: It is generally faster to use the same probe for
|
||||
* nearby points and different probes for different points. Try not to
|
||||
* allocate more than "hundreds" of probes at most. Share probes if you need
|
||||
* more. Generally, probing operations are expensive, and should be avoided
|
||||
* via caching when possible.
|
||||
*
|
||||
* Y testing returns a location on the terrain, a normal vectory, and a
|
||||
* velocity vector. The normal vector tells you the slope of the terrain at
|
||||
* that point. The velocity vector tells you if that terrain is moving (and
|
||||
* is in meters/second). For example, if your Y test hits the aircraft carrier
|
||||
* deck, this tells you the velocity of that point on the deck.
|
||||
*
|
||||
* Note: the Y-testing API is limited to probing the loaded scenery area,
|
||||
* which is approximately 300x300 km in X-Plane 9. Probes outside this area
|
||||
* will return the height of a 0 MSL sphere.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMProbeType
|
||||
*
|
||||
* XPLMProbeType defines the type of terrain probe - each probe has a
|
||||
* different algorithm. (Only one type of probe is provided right now, but
|
||||
* future APIs will expose more flexible or poewrful or useful probes.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* The Y probe gives you the location of the tallest physical scenery along
|
||||
* * the Y axis going through the queried point. */
|
||||
xplm_ProbeY = 0
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMProbeType;
|
||||
|
||||
/*
|
||||
* XPLMProbeResult
|
||||
*
|
||||
* Probe results - possible results from a probe query.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* The probe hit terrain and returned valid values. */
|
||||
xplm_ProbeHitTerrain = 0
|
||||
|
||||
/* An error in the API call. Either the probe struct size is bad, or the *
|
||||
* probe is invalid or the type is mismatched for the specific query call.
|
||||
*/
|
||||
,
|
||||
xplm_ProbeError = 1
|
||||
|
||||
/* The probe call succeeded but there is no terrain under this point
|
||||
* (perhaps * it is off the side of the planet?) */
|
||||
,
|
||||
xplm_ProbeMissed = 2
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMProbeResult;
|
||||
|
||||
/*
|
||||
* XPLMProbeRef
|
||||
*
|
||||
* An XPLMProbeRef is an opaque handle to a probe, used for querying the
|
||||
* terrain.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMProbeRef;
|
||||
|
||||
/*
|
||||
* XPLMProbeInfo_t
|
||||
*
|
||||
* XPLMProbeInfo_t contains the results of a probe call. Make sure to set
|
||||
* structSize to the size of the struct before using it.
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
/* Size of structure in bytes - always set this before calling the XPLM. */
|
||||
int structSize;
|
||||
/* Resulting X location of the terrain point we hit, in local OpenGL *
|
||||
* coordinates. */
|
||||
float locationX;
|
||||
/* Resulting Y location of the terrain point we hit, in local OpenGL *
|
||||
* coordinates. */
|
||||
float locationY;
|
||||
/* Resulting Z location of the terrain point we hit, in local OpenGL *
|
||||
* coordinates. */
|
||||
float locationZ;
|
||||
/* X component of the normal vector to the terrain we found. */
|
||||
float normalX;
|
||||
/* Y component of the normal vector to the terrain we found. */
|
||||
float normalY;
|
||||
/* Z component of the normal vector to the terrain we found. */
|
||||
float normalZ;
|
||||
/* X component of the velocity vector of the terrain we found. */
|
||||
float velocityX;
|
||||
/* Y component of the velocity vector of the terrain we found. */
|
||||
float velocityY;
|
||||
/* Z component of the velocity vector of the terrain we found. */
|
||||
float velocityZ;
|
||||
/* Tells if the surface we hit is water (otherwise it is land). */
|
||||
int is_wet;
|
||||
} XPLMProbeInfo_t;
|
||||
|
||||
/*
|
||||
* XPLMCreateProbe
|
||||
*
|
||||
* Creates a new probe object of a given type and returns.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMProbeRef XPLMCreateProbe(XPLMProbeType inProbeType);
|
||||
|
||||
/*
|
||||
* XPLMDestroyProbe
|
||||
*
|
||||
* Deallocates an existing probe object.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDestroyProbe(XPLMProbeRef inProbe);
|
||||
|
||||
/*
|
||||
* XPLMProbeTerrainXYZ
|
||||
*
|
||||
* Probes the terrain. Pass in the XYZ coordinate of the probe point, a probe
|
||||
* object, and an XPLMProbeInfo_t struct that has its structSize member set
|
||||
* properly. Other fields are filled in if we hit terrain, and a probe result
|
||||
* is returned.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMProbeResult XPLMProbeTerrainXYZ(XPLMProbeRef inProbe,
|
||||
float inX,
|
||||
float inY,
|
||||
float inZ,
|
||||
XPLMProbeInfo_t *outInfo);
|
||||
|
||||
#endif /* XPLM200 */
|
||||
/***************************************************************************
|
||||
* Object Drawing
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The object drawing routines let you load and draw X-Plane OBJ files.
|
||||
* Objects are loaded by file path and managed via an opaque handle. X-Plane
|
||||
* naturally reference counts objects, so it is important that you balance
|
||||
* every successful call to XPLMLoadObject with a call to XPLMUnloadObject!
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMObjectRef
|
||||
*
|
||||
* An XPLMObjectRef is a opaque handle to an .obj file that has been loaded
|
||||
* into memory.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMObjectRef;
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMDrawInfo_t
|
||||
*
|
||||
* The XPLMDrawInfo_t structure contains positioning info for one object that
|
||||
* is to be drawn. Be sure to set structSize to the size of the structure for
|
||||
* future expansion.
|
||||
*
|
||||
*/
|
||||
typedef struct {
|
||||
/* Set this to the size of this structure! */
|
||||
int structSize;
|
||||
/* X location of the object in local coordinates. */
|
||||
float x;
|
||||
/* Y location of the object in local coordinates. */
|
||||
float y;
|
||||
/* Z location of the object in local coordinates. */
|
||||
float z;
|
||||
/* Pitch in degres to rotate the object, positive is up. */
|
||||
float pitch;
|
||||
/* Heading in local coordinates to rotate the object, clockwise. */
|
||||
float heading;
|
||||
/* Roll to rotate the object. */
|
||||
float roll;
|
||||
} XPLMDrawInfo_t;
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMObjectLoaded_f
|
||||
*
|
||||
* You provide this callback when loading an object asynchronously; it will be
|
||||
* called once the object is loaded. Your refcon is passed back. The object
|
||||
* ref passed in is the newly loaded object (ready for use) or NULL if an
|
||||
* error occured.
|
||||
*
|
||||
* If your plugin is disabled, this callback will be delivered as soon as the
|
||||
* plugin is re-enabled. If your plugin is unloaded before this callback is
|
||||
* ever called, the SDK will release the object handle for you.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMObjectLoaded_f)(XPLMObjectRef inObject, void *inRefcon);
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMLoadObject
|
||||
*
|
||||
* This routine loads an OBJ file and returns a handle to it. If X-plane has
|
||||
* already loaded the object, the handle to the existing object is returned.
|
||||
* Do not assume you will get the same handle back twice, but do make sure to
|
||||
* call unload once for every load to avoid "leaking" objects. The object
|
||||
* will be purged from memory when no plugins and no scenery are using it.
|
||||
*
|
||||
* The path for the object must be relative to the X-System base folder. If
|
||||
* the path is in the root of the X-System folder you may need to prepend ./
|
||||
* to it; loading objects in the root of the X-System folder is STRONGLY
|
||||
* discouraged - your plugin should not dump art resources in the root folder!
|
||||
*
|
||||
*
|
||||
* XPLMLoadObject will return NULL if the object cannot be loaded (either
|
||||
* because it is not found or the file is misformatted). This routine will
|
||||
* load any object that can be used in the X-Plane scenery system.
|
||||
*
|
||||
* It is important that the datarefs an object uses for animation already be
|
||||
* loaded before you load the object. For this reason it may be necessary to
|
||||
* defer object loading until the sim has fully started.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMObjectRef XPLMLoadObject(const char *inPath);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM210)
|
||||
/*
|
||||
* XPLMLoadObjectAsync
|
||||
*
|
||||
* This routine loads an object asynchronously; control is returned to you
|
||||
* immediately while X-Plane loads the object. The sim will not stop flying
|
||||
* while the object loads. For large objects, it may be several seconds
|
||||
* before the load finishes.
|
||||
*
|
||||
* You provide a callback function that is called once the load has completed.
|
||||
* Note that if the object cannot be loaded, you will not find out until the
|
||||
* callback function is called with a NULL object handle.
|
||||
*
|
||||
* There is no way to cancel an asynchronous object load; you must wait for
|
||||
* the load to complete and then release the object if it is no longer
|
||||
* desired.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMLoadObjectAsync(const char *inPath,
|
||||
XPLMObjectLoaded_f inCallback,
|
||||
void *inRefcon);
|
||||
#endif /* XPLM210 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMDrawObjects
|
||||
*
|
||||
* XPLMDrawObjects draws an object from an OBJ file one or more times. You
|
||||
* pass in the object and an array of XPLMDrawInfo_t structs, one for each
|
||||
* place you would like the object to be drawn.
|
||||
*
|
||||
* X-Plane will attempt to cull the objects based on LOD and visibility, and
|
||||
* will pick the appropriate LOD.
|
||||
*
|
||||
* Lighting is a boolean; pass 1 to show the night version of object with
|
||||
* night-only lights lit up. Pass 0 to show the daytime version of the
|
||||
* object.
|
||||
*
|
||||
* earth_relative controls the coordinate system. If this is 1, the rotations
|
||||
* you specify are applied to the object after its coordinate system is
|
||||
* transformed from local to earth-relative coordinates -- that is, an object
|
||||
* with no rotations will point toward true north and the Y axis will be up
|
||||
* against gravity. If this is 0, the object is drawn with your rotations
|
||||
* from local coordanates -- that is, an object with no rotations is drawn
|
||||
* pointing down the -Z axis and the Y axis of the object matches the local
|
||||
* coordinate Y axis.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDrawObjects(XPLMObjectRef inObject,
|
||||
int inCount,
|
||||
XPLMDrawInfo_t *inLocations,
|
||||
int lighting,
|
||||
int earth_relative);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMUnloadObject
|
||||
*
|
||||
* This routine marks an object as no longer being used by your plugin.
|
||||
* Objects are reference counted: once no plugins are using an object, it is
|
||||
* purged from memory. Make sure to call XPLMUnloadObject once for each
|
||||
* successful call to XPLMLoadObject.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMUnloadObject(XPLMObjectRef inObject);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/***************************************************************************
|
||||
* Library Access
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The library access routines allow you to locate scenery objects via the
|
||||
* X-Plane library system. Right now library access is only provided for
|
||||
* objects, allowing plugin-drawn objects to be extended using the library
|
||||
* system.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMLibraryEnumerator_f
|
||||
*
|
||||
* An XPLMLibraryEnumerator_f is a callback you provide that is called once
|
||||
* for each library element that is located. The returned paths will be
|
||||
* relative to the X-System folder.
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMLibraryEnumerator_f)(const char *inFilePath, void *inRef);
|
||||
|
||||
/*
|
||||
* XPLMLookupObjects
|
||||
*
|
||||
* This routine looks up a virtual path in the library system and returns all
|
||||
* matching elements. You provide a callback - one virtual path may match
|
||||
* many objects in the library. XPLMLookupObjects returns the number of
|
||||
* objects found.
|
||||
*
|
||||
* The latitude and longitude parameters specify the location the object will
|
||||
* be used. The library system allows for scenery packages to only provide
|
||||
* objects to certain local locations. Only objects that are allowed at the
|
||||
* latitude/longitude you provide will be returned.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMLookupObjects(const char *inPath,
|
||||
float inLatitude,
|
||||
float inLongitude,
|
||||
XPLMLibraryEnumerator_f enumerator,
|
||||
void *ref);
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,829 @@
|
||||
#ifndef _XPLMUtilities_h_
|
||||
#define _XPLMUtilities_h_
|
||||
|
||||
/*
|
||||
* Copyright 2005-2012 Sandy Barbour and Ben Supnik
|
||||
*
|
||||
* All rights reserved. See license.txt for usage.
|
||||
*
|
||||
* X-Plane SDK Version: 2.1.1
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include "XPLMDefs.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/***************************************************************************
|
||||
* X-PLANE USER INTERACTION
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The user interaction APIs let you simulate commands the user can do with a
|
||||
* joystick, keyboard etc. Note that it is generally safer for future
|
||||
* compatibility to use one of these commands than to manipulate the
|
||||
* underlying sim data.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMCommandKeyID
|
||||
*
|
||||
* These enums represent all the keystrokes available within x-plane. They
|
||||
* can be sent to x-plane directly. For example, you can reverse thrust using
|
||||
* these enumerations.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
xplm_key_pause = 0,
|
||||
xplm_key_revthrust,
|
||||
xplm_key_jettison,
|
||||
xplm_key_brakesreg,
|
||||
xplm_key_brakesmax,
|
||||
xplm_key_gear,
|
||||
xplm_key_timedn,
|
||||
xplm_key_timeup,
|
||||
xplm_key_fadec,
|
||||
xplm_key_otto_dis,
|
||||
xplm_key_otto_atr,
|
||||
xplm_key_otto_asi,
|
||||
xplm_key_otto_hdg,
|
||||
xplm_key_otto_gps,
|
||||
xplm_key_otto_lev,
|
||||
xplm_key_otto_hnav,
|
||||
xplm_key_otto_alt,
|
||||
xplm_key_otto_vvi,
|
||||
xplm_key_otto_vnav,
|
||||
xplm_key_otto_nav1,
|
||||
xplm_key_otto_nav2,
|
||||
xplm_key_targ_dn,
|
||||
xplm_key_targ_up,
|
||||
xplm_key_hdgdn,
|
||||
xplm_key_hdgup,
|
||||
xplm_key_barodn,
|
||||
xplm_key_baroup,
|
||||
xplm_key_obs1dn,
|
||||
xplm_key_obs1up,
|
||||
xplm_key_obs2dn,
|
||||
xplm_key_obs2up,
|
||||
xplm_key_com1_1,
|
||||
xplm_key_com1_2,
|
||||
xplm_key_com1_3,
|
||||
xplm_key_com1_4,
|
||||
xplm_key_nav1_1,
|
||||
xplm_key_nav1_2,
|
||||
xplm_key_nav1_3,
|
||||
xplm_key_nav1_4,
|
||||
xplm_key_com2_1,
|
||||
xplm_key_com2_2,
|
||||
xplm_key_com2_3,
|
||||
xplm_key_com2_4,
|
||||
xplm_key_nav2_1,
|
||||
xplm_key_nav2_2,
|
||||
xplm_key_nav2_3,
|
||||
xplm_key_nav2_4,
|
||||
xplm_key_adf_1,
|
||||
xplm_key_adf_2,
|
||||
xplm_key_adf_3,
|
||||
xplm_key_adf_4,
|
||||
xplm_key_adf_5,
|
||||
xplm_key_adf_6,
|
||||
xplm_key_transpon_1,
|
||||
xplm_key_transpon_2,
|
||||
xplm_key_transpon_3,
|
||||
xplm_key_transpon_4,
|
||||
xplm_key_transpon_5,
|
||||
xplm_key_transpon_6,
|
||||
xplm_key_transpon_7,
|
||||
xplm_key_transpon_8,
|
||||
xplm_key_flapsup,
|
||||
xplm_key_flapsdn,
|
||||
xplm_key_cheatoff,
|
||||
xplm_key_cheaton,
|
||||
xplm_key_sbrkoff,
|
||||
xplm_key_sbrkon,
|
||||
xplm_key_ailtrimL,
|
||||
xplm_key_ailtrimR,
|
||||
xplm_key_rudtrimL,
|
||||
xplm_key_rudtrimR,
|
||||
xplm_key_elvtrimD,
|
||||
xplm_key_elvtrimU,
|
||||
xplm_key_forward,
|
||||
xplm_key_down,
|
||||
xplm_key_left,
|
||||
xplm_key_right,
|
||||
xplm_key_back,
|
||||
xplm_key_tower,
|
||||
xplm_key_runway,
|
||||
xplm_key_chase,
|
||||
xplm_key_free1,
|
||||
xplm_key_free2,
|
||||
xplm_key_spot,
|
||||
xplm_key_fullscrn1,
|
||||
xplm_key_fullscrn2,
|
||||
xplm_key_tanspan,
|
||||
xplm_key_smoke,
|
||||
xplm_key_map,
|
||||
xplm_key_zoomin,
|
||||
xplm_key_zoomout,
|
||||
xplm_key_cycledump,
|
||||
xplm_key_replay,
|
||||
xplm_key_tranID,
|
||||
xplm_key_max
|
||||
};
|
||||
typedef int XPLMCommandKeyID;
|
||||
|
||||
/*
|
||||
* XPLMCommandButtonID
|
||||
*
|
||||
* These are enumerations for all of the things you can do with a joystick
|
||||
* button in X-Plane. They currently match the buttons menu in the equipment
|
||||
* setup dialog, but these enums will be stable even if they change in
|
||||
* X-Plane.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
xplm_joy_nothing = 0,
|
||||
xplm_joy_start_all,
|
||||
xplm_joy_start_0,
|
||||
xplm_joy_start_1,
|
||||
xplm_joy_start_2,
|
||||
xplm_joy_start_3,
|
||||
xplm_joy_start_4,
|
||||
xplm_joy_start_5,
|
||||
xplm_joy_start_6,
|
||||
xplm_joy_start_7,
|
||||
xplm_joy_throt_up,
|
||||
xplm_joy_throt_dn,
|
||||
xplm_joy_prop_up,
|
||||
xplm_joy_prop_dn,
|
||||
xplm_joy_mixt_up,
|
||||
xplm_joy_mixt_dn,
|
||||
xplm_joy_carb_tog,
|
||||
xplm_joy_carb_on,
|
||||
xplm_joy_carb_off,
|
||||
xplm_joy_trev,
|
||||
xplm_joy_trm_up,
|
||||
xplm_joy_trm_dn,
|
||||
xplm_joy_rot_trm_up,
|
||||
xplm_joy_rot_trm_dn,
|
||||
xplm_joy_rud_lft,
|
||||
xplm_joy_rud_cntr,
|
||||
xplm_joy_rud_rgt,
|
||||
xplm_joy_ail_lft,
|
||||
xplm_joy_ail_cntr,
|
||||
xplm_joy_ail_rgt,
|
||||
xplm_joy_B_rud_lft,
|
||||
xplm_joy_B_rud_rgt,
|
||||
xplm_joy_look_up,
|
||||
xplm_joy_look_dn,
|
||||
xplm_joy_look_lft,
|
||||
xplm_joy_look_rgt,
|
||||
xplm_joy_glance_l,
|
||||
xplm_joy_glance_r,
|
||||
xplm_joy_v_fnh,
|
||||
xplm_joy_v_fwh,
|
||||
xplm_joy_v_tra,
|
||||
xplm_joy_v_twr,
|
||||
xplm_joy_v_run,
|
||||
xplm_joy_v_cha,
|
||||
xplm_joy_v_fr1,
|
||||
xplm_joy_v_fr2,
|
||||
xplm_joy_v_spo,
|
||||
xplm_joy_flapsup,
|
||||
xplm_joy_flapsdn,
|
||||
xplm_joy_vctswpfwd,
|
||||
xplm_joy_vctswpaft,
|
||||
xplm_joy_gear_tog,
|
||||
xplm_joy_gear_up,
|
||||
xplm_joy_gear_down,
|
||||
xplm_joy_lft_brake,
|
||||
xplm_joy_rgt_brake,
|
||||
xplm_joy_brakesREG,
|
||||
xplm_joy_brakesMAX,
|
||||
xplm_joy_speedbrake,
|
||||
xplm_joy_ott_dis,
|
||||
xplm_joy_ott_atr,
|
||||
xplm_joy_ott_asi,
|
||||
xplm_joy_ott_hdg,
|
||||
xplm_joy_ott_alt,
|
||||
xplm_joy_ott_vvi,
|
||||
xplm_joy_tim_start,
|
||||
xplm_joy_tim_reset,
|
||||
xplm_joy_ecam_up,
|
||||
xplm_joy_ecam_dn,
|
||||
xplm_joy_fadec,
|
||||
xplm_joy_yaw_damp,
|
||||
xplm_joy_art_stab,
|
||||
xplm_joy_chute,
|
||||
xplm_joy_JATO,
|
||||
xplm_joy_arrest,
|
||||
xplm_joy_jettison,
|
||||
xplm_joy_fuel_dump,
|
||||
xplm_joy_puffsmoke,
|
||||
xplm_joy_prerotate,
|
||||
xplm_joy_UL_prerot,
|
||||
xplm_joy_UL_collec,
|
||||
xplm_joy_TOGA,
|
||||
xplm_joy_shutdown,
|
||||
xplm_joy_con_atc,
|
||||
xplm_joy_fail_now,
|
||||
xplm_joy_pause,
|
||||
xplm_joy_rock_up,
|
||||
xplm_joy_rock_dn,
|
||||
xplm_joy_rock_lft,
|
||||
xplm_joy_rock_rgt,
|
||||
xplm_joy_rock_for,
|
||||
xplm_joy_rock_aft,
|
||||
xplm_joy_idle_hilo,
|
||||
xplm_joy_lanlights,
|
||||
xplm_joy_max
|
||||
};
|
||||
typedef int XPLMCommandButtonID;
|
||||
|
||||
/*
|
||||
* XPLMHostApplicationID
|
||||
*
|
||||
* The plug-in system is based on Austin's cross-platform OpenGL framework and
|
||||
* could theoretically be adapted to run in other apps like WorldMaker. The
|
||||
* plug-in system also runs against a test harness for internal development
|
||||
* and could be adapted to another flight sim (in theory at least). So an ID
|
||||
* is providing allowing plug-ins to indentify what app they are running
|
||||
* under.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
xplm_Host_Unknown = 0
|
||||
|
||||
,
|
||||
xplm_Host_XPlane = 1
|
||||
|
||||
,
|
||||
xplm_Host_PlaneMaker = 2
|
||||
|
||||
,
|
||||
xplm_Host_WorldMaker = 3
|
||||
|
||||
,
|
||||
xplm_Host_Briefer = 4
|
||||
|
||||
,
|
||||
xplm_Host_PartMaker = 5
|
||||
|
||||
,
|
||||
xplm_Host_YoungsMod = 6
|
||||
|
||||
,
|
||||
xplm_Host_XAuto = 7
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMHostApplicationID;
|
||||
|
||||
/*
|
||||
* XPLMLanguageCode
|
||||
*
|
||||
* These enums define what language the sim is running in. These enumerations
|
||||
* do not imply that the sim can or does run in all of these languages; they
|
||||
* simply provide a known encoding in the event that a given sim version is
|
||||
* localized to a certain language.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
xplm_Language_Unknown = 0
|
||||
|
||||
,
|
||||
xplm_Language_English = 1
|
||||
|
||||
,
|
||||
xplm_Language_French = 2
|
||||
|
||||
,
|
||||
xplm_Language_German = 3
|
||||
|
||||
,
|
||||
xplm_Language_Italian = 4
|
||||
|
||||
,
|
||||
xplm_Language_Spanish = 5
|
||||
|
||||
,
|
||||
xplm_Language_Korean = 6
|
||||
|
||||
#if defined(XPLM200)
|
||||
,
|
||||
xplm_Language_Russian = 7
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#if defined(XPLM200)
|
||||
,
|
||||
xplm_Language_Greek = 8
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#if defined(XPLM200)
|
||||
,
|
||||
xplm_Language_Japanese = 9
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#if defined(XPLM200)
|
||||
,
|
||||
xplm_Language_Chinese = 10
|
||||
|
||||
#endif /* XPLM200 */
|
||||
|
||||
};
|
||||
typedef int XPLMLanguageCode;
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMDataFileType
|
||||
*
|
||||
* These enums define types of data files you can load or unload using the
|
||||
* SDK.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* A situation (.sit) file, which starts off a flight in a given *
|
||||
* configuration. */
|
||||
xplm_DataFile_Situation = 1
|
||||
|
||||
/* A situation movie (.smo) file, which replays a past flight. */
|
||||
,
|
||||
xplm_DataFile_ReplayMovie = 2
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMDataFileType;
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMError_f
|
||||
*
|
||||
* An XPLM error callback is a function that you provide to receive debugging
|
||||
* information from the plugin SDK. See XPLMSetErrorCallback for more
|
||||
* information. NOTE: for the sake of debugging, your error callback will be
|
||||
* called even if your plugin is not enabled, allowing you to receive debug
|
||||
* info in your XPluginStart and XPluginStop callbacks. To avoid causing
|
||||
* logic errors in the management code, do not call any other plugin routines
|
||||
* from your error callback - it is only meant for logging!
|
||||
*
|
||||
*/
|
||||
typedef void (*XPLMError_f)(const char *inMessage);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
/*
|
||||
* XPLMSimulateKeyPress
|
||||
*
|
||||
* This function simulates a key being pressed for x-plane. The keystroke
|
||||
* goes directly to x-plane; it is never sent to any plug-ins. However, since
|
||||
* this is a raw key stroke it may be mapped by the keys file or enter text
|
||||
* into a field.
|
||||
*
|
||||
* WARNING: This function will be deprecated; do not use it. Instead use
|
||||
* XPLMCommandKeyStroke.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSimulateKeyPress(int inKeyType, int inKey);
|
||||
|
||||
/*
|
||||
* XPLMSpeakString
|
||||
*
|
||||
* This function displays the string in a translucent overlay over the current
|
||||
* display and also speaks the string if text-to-speech is enabled. The
|
||||
* string is spoken asynchronously, this function returns immediately.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSpeakString(const char *inString);
|
||||
|
||||
/*
|
||||
* XPLMCommandKeyStroke
|
||||
*
|
||||
* This routine simulates a command-key stroke. However, the keys are done by
|
||||
* function, not by actual letter, so this function works even if the user has
|
||||
* remapped their keyboard. Examples of things you might do with this include
|
||||
* pausing the simulator.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCommandKeyStroke(XPLMCommandKeyID inKey);
|
||||
|
||||
/*
|
||||
* XPLMCommandButtonPress
|
||||
*
|
||||
* This function simulates any of the actions that might be taken by pressing
|
||||
* a joystick button. However, this lets you call the command directly rather
|
||||
* than have to know which button is mapped where. Important: you must
|
||||
* release each button you press. The APIs are separate so that you can 'hold
|
||||
* down' a button for a fixed amount of time.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCommandButtonPress(XPLMCommandButtonID inButton);
|
||||
|
||||
/*
|
||||
* XPLMCommandButtonRelease
|
||||
*
|
||||
* This function simulates any of the actions that might be taken by pressing
|
||||
* a joystick button. See XPLMCommandButtonPress
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCommandButtonRelease(XPLMCommandButtonID inButton);
|
||||
|
||||
/*
|
||||
* XPLMGetVirtualKeyDescription
|
||||
*
|
||||
* Given a virtual key code (as defined in XPLMDefs.h) this routine returns a
|
||||
* human-readable string describing the character. This routine is provided
|
||||
* for showing users what keyboard mappings they have set up. The string may
|
||||
* read 'unknown' or be a blank or NULL string if the virtual key is unknown.
|
||||
*
|
||||
*/
|
||||
XPLM_API const char *XPLMGetVirtualKeyDescription(char inVirtualKey);
|
||||
|
||||
/***************************************************************************
|
||||
* X-PLANE MISC
|
||||
***************************************************************************/
|
||||
/*
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMReloadScenery
|
||||
*
|
||||
* XPLMReloadScenery reloads the current set of scenery. You can use this
|
||||
* function in two typical ways: simply call it to reload the scenery, picking
|
||||
* up any new installed scenery, .env files, etc. from disk. Or, change the
|
||||
* lat/ref and lon/ref data refs and then call this function to shift the
|
||||
* scenery environment.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMReloadScenery(void);
|
||||
|
||||
/*
|
||||
* XPLMGetSystemPath
|
||||
*
|
||||
* This function returns the full path to the X-System folder. Note that this
|
||||
* is a directory path, so it ends in a trailing : or /. The buffer you pass
|
||||
* should be at least 512 characters long.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetSystemPath(char *outSystemPath);
|
||||
|
||||
/*
|
||||
* XPLMGetPrefsPath
|
||||
*
|
||||
* This routine returns a full path to the proper directory to store
|
||||
* preferences in. It ends in a : or /. The buffer you pass should be at
|
||||
* least 512 characters long.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetPrefsPath(char *outPrefsPath);
|
||||
|
||||
/*
|
||||
* XPLMGetDirectorySeparator
|
||||
*
|
||||
* This routine returns a string with one char and a null terminator that is
|
||||
* the directory separator for the current platform. This allows you to write
|
||||
* code that concatinates directory paths without having to #ifdef for
|
||||
* platform.
|
||||
*
|
||||
*/
|
||||
XPLM_API const char *XPLMGetDirectorySeparator(void);
|
||||
|
||||
/*
|
||||
* XPLMExtractFileAndPath
|
||||
*
|
||||
* Given a full path to a file, this routine separates the path from the file.
|
||||
* If the path is a partial directory (e.g. ends in : or \) the trailing
|
||||
* directory separator is removed. This routine works in-place; a pointer to
|
||||
* the file part of the buffer is returned; the original buffer still starts
|
||||
* with the path.
|
||||
*
|
||||
*/
|
||||
XPLM_API char *XPLMExtractFileAndPath(char *inFullPath);
|
||||
|
||||
/*
|
||||
* XPLMGetDirectoryContents
|
||||
*
|
||||
* This routine returns a list of files in a directory (specified by a full
|
||||
* path, no trailing : or \). The output is returned as a list of NULL
|
||||
* terminated strings. An index array (if specified) is filled with pointers
|
||||
* into the strings. This routine The last file is indicated by a zero-length
|
||||
* string (and NULL in the indices). This routine will return 1 if you had
|
||||
* capacity for all files or 0 if you did not. You can also skip a given
|
||||
* number of files.
|
||||
*
|
||||
* inDirectoryPath - a null terminated C string containing the full path to
|
||||
* the directory with no trailing directory char.
|
||||
*
|
||||
* inFirstReturn - the zero-based index of the first file in the directory to
|
||||
* return. (Usually zero to fetch all in one pass.)
|
||||
*
|
||||
* outFileNames - a buffer to receive a series of sequential null terminated
|
||||
* C-string file names. A zero-length C string will be appended to the very
|
||||
* end.
|
||||
*
|
||||
* inFileNameBufSize - the size of the file name buffer in bytes.
|
||||
*
|
||||
* outIndices - a pointer to an array of character pointers that will become
|
||||
* an index into the directory. The last file will be followed by a NULL
|
||||
* value. Pass NULL if you do not want indexing information.
|
||||
*
|
||||
* inIndexCount - the max size of the index in entries.
|
||||
*
|
||||
* outTotalFiles - if not NULL, this is filled in with the number of files in
|
||||
* the directory.
|
||||
*
|
||||
* outReturnedFiles - if not NULL, the number of files returned by this
|
||||
* iteration.
|
||||
*
|
||||
* Return value - 1 if all info could be returned, 0 if there was a buffer
|
||||
* overrun.
|
||||
*
|
||||
* WARNING: Before X-Plane 7 this routine did not properly iterate through
|
||||
* directories. If X-Plane 6 compatibility is needed, use your own code to
|
||||
* iterate directories.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMGetDirectoryContents(const char *inDirectoryPath,
|
||||
int inFirstReturn,
|
||||
char *outFileNames,
|
||||
int inFileNameBufSize,
|
||||
char **outIndices, /* Can be NULL */
|
||||
int inIndexCount,
|
||||
int *outTotalFiles, /* Can be NULL */
|
||||
int *outReturnedFiles); /* Can be NULL */
|
||||
|
||||
/*
|
||||
* XPLMInitialized
|
||||
*
|
||||
* This function returns 1 if X-Plane has properly initialized the plug-in
|
||||
* system. If this routine returns 0, many XPLM functions will not work.
|
||||
*
|
||||
* NOTE: Under normal circumstances a plug-in should never be running while
|
||||
* the plug-in manager is not initialized.
|
||||
*
|
||||
* WARNING: This function is generally not needed and may be deprecated in the
|
||||
* future.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMInitialized(void);
|
||||
|
||||
/*
|
||||
* XPLMGetVersions
|
||||
*
|
||||
* This routine returns the revision of both X-Plane and the XPLM DLL. All
|
||||
* versions are three-digit decimal numbers (e.g. 606 for version 6.06 of
|
||||
* X-Plane); the current revision of the XPLM is 200 (2.00). This routine
|
||||
* also returns the host ID of the app running us.
|
||||
*
|
||||
* The most common use of this routine is to special-case around x-plane
|
||||
* version-specific behavior.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMGetVersions(int *outXPlaneVersion,
|
||||
int *outXPLMVersion,
|
||||
XPLMHostApplicationID *outHostID);
|
||||
|
||||
/*
|
||||
* XPLMGetLanguage
|
||||
*
|
||||
* This routine returns the langauge the sim is running in.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMLanguageCode XPLMGetLanguage(void);
|
||||
|
||||
/*
|
||||
* XPLMDebugString
|
||||
*
|
||||
* This routine outputs a C-style string to the Log.txt file. The file is
|
||||
* immediately flushed so you will not lose data. (This does cause a
|
||||
* performance penalty.)
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMDebugString(const char *inString);
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMSetErrorCallback
|
||||
*
|
||||
* XPLMSetErrorCallback installs an error-reporting callback for your plugin.
|
||||
* Normally the plugin system performs minimum diagnostics to maximize
|
||||
* performance. When you install an error callback, you will receive calls
|
||||
* due to certain plugin errors, such as passing bad parameters or incorrect
|
||||
* data.
|
||||
*
|
||||
* The intention is for you to install the error callback during debug
|
||||
* sections and put a break-point inside your callback. This will cause you
|
||||
* to break into the debugger from within the SDK at the point in your plugin
|
||||
* where you made an illegal call.
|
||||
*
|
||||
* Installing an error callback may activate error checking code that would
|
||||
* not normally run, and this may adversely affect performance, so do not
|
||||
* leave error callbacks installed in shipping plugins.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMSetErrorCallback(XPLMError_f inCallback);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMFindSymbol
|
||||
*
|
||||
* This routine will attempt to find the symbol passed in the inString
|
||||
* parameter. If the symbol is found a pointer the function is returned,
|
||||
* othewise the function will return NULL.
|
||||
*
|
||||
*/
|
||||
XPLM_API void *XPLMFindSymbol(const char *inString);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMLoadDataFile
|
||||
*
|
||||
* Loads a data file of a given type. Paths must be relative to the X-System
|
||||
* folder. To clear the replay, pass a NULL file name (this is only valid with
|
||||
* replay movies, not sit files).
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMLoadDataFile(XPLMDataFileType inFileType,
|
||||
const char *inFilePath); /* Can be NULL */
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/*
|
||||
* XPLMSaveDataFile
|
||||
*
|
||||
* Saves the current situation or replay; paths are relative to the X-System
|
||||
* folder.
|
||||
*
|
||||
*/
|
||||
XPLM_API int XPLMSaveDataFile(XPLMDataFileType inFileType,
|
||||
const char *inFilePath);
|
||||
#endif /* XPLM200 */
|
||||
|
||||
#if defined(XPLM200)
|
||||
/***************************************************************************
|
||||
* X-PLANE COMMAND MANAGEMENT
|
||||
***************************************************************************/
|
||||
/*
|
||||
* The command management APIs let plugins interact with the command-system in
|
||||
* X-Plane, the abstraction behind keyboard presses and joystick buttons.
|
||||
* This API lets you create new commands and modify the behavior (or get
|
||||
* notification) of existing ones.
|
||||
*
|
||||
* An X-Plane command consists of three phases: a beginning, continuous
|
||||
* repetition, and an ending. The command may be repeated zero times in the
|
||||
* event that the user presses a button only momentarily.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XPLMCommandPhase
|
||||
*
|
||||
* The phases of a command.
|
||||
*
|
||||
*/
|
||||
enum {
|
||||
/* The command is being started. */
|
||||
xplm_CommandBegin = 0
|
||||
|
||||
/* The command is continuing to execute. */
|
||||
,
|
||||
xplm_CommandContinue = 1
|
||||
|
||||
/* The command has ended. */
|
||||
,
|
||||
xplm_CommandEnd = 2
|
||||
|
||||
|
||||
};
|
||||
typedef int XPLMCommandPhase;
|
||||
|
||||
/*
|
||||
* XPLMCommandRef
|
||||
*
|
||||
* A command ref is an opaque identifier for an X-Plane command. Command
|
||||
* references stay the same for the life of your plugin but not between
|
||||
* executions of X-Plane. Command refs are used to execute commands, create
|
||||
* commands, and create callbacks for particular commands.
|
||||
*
|
||||
* Note that a command is not "owned" by a particular plugin. Since many
|
||||
* plugins may participate in a command's execution, the command does not go
|
||||
* away if the plugin that created it is unloaded.
|
||||
*
|
||||
*/
|
||||
typedef void *XPLMCommandRef;
|
||||
|
||||
/*
|
||||
* XPLMCommandCallback_f
|
||||
*
|
||||
* A command callback is a function in your plugin that is called when a
|
||||
* command is pressed. Your callback receives the commadn reference for the
|
||||
* particular command, the phase of the command that is executing, and a
|
||||
* reference pointer that you specify when registering the callback.
|
||||
*
|
||||
* Your command handler should return 1 to let processing of the command
|
||||
* continue to other plugins and X-Plane, or 0 to halt processing,
|
||||
* potentially bypassing X-Plane code.
|
||||
*
|
||||
*/
|
||||
typedef int (*XPLMCommandCallback_f)(XPLMCommandRef inCommand,
|
||||
XPLMCommandPhase inPhase,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMFindCommand
|
||||
*
|
||||
* XPLMFindCommand looks up a command by name, and returns its command
|
||||
* reference or NULL if the command does not exist.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMCommandRef XPLMFindCommand(const char *inName);
|
||||
|
||||
/*
|
||||
* XPLMCommandBegin
|
||||
*
|
||||
* XPLMCommandBegin starts the execution of a command, specified by its
|
||||
* command reference. The command is "held down" until XPLMCommandEnd is
|
||||
* called.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCommandBegin(XPLMCommandRef inCommand);
|
||||
|
||||
/*
|
||||
* XPLMCommandEnd
|
||||
*
|
||||
* XPLMCommandEnd ends the execution of a given command that was started with
|
||||
* XPLMCommandBegin.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCommandEnd(XPLMCommandRef inCommand);
|
||||
|
||||
/*
|
||||
* XPLMCommandOnce
|
||||
*
|
||||
* This executes a given command momentarily, that is, the command begins and
|
||||
* ends immediately.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMCommandOnce(XPLMCommandRef inCommand);
|
||||
|
||||
/*
|
||||
* XPLMCreateCommand
|
||||
*
|
||||
* XPLMCreateCommand creates a new command for a given string. If the command
|
||||
* already exists, the existing command reference is returned. The
|
||||
* description may appear in user interface contexts, such as the joystick
|
||||
* configuration screen.
|
||||
*
|
||||
*/
|
||||
XPLM_API XPLMCommandRef XPLMCreateCommand(const char *inName,
|
||||
const char *inDescription);
|
||||
|
||||
/*
|
||||
* XPLMRegisterCommandHandler
|
||||
*
|
||||
* XPLMRegisterCommandHandler registers a callback to be called when a command
|
||||
* is executed. You provide a callback with a reference pointer.
|
||||
*
|
||||
* If inBefore is true, your command handler callback will be executed before
|
||||
* X-Plane executes the command, and returning 0 from your callback will
|
||||
* disable X-Plane's processing of the command. If inBefore is false, your
|
||||
* callback will run after X-Plane. (You can register a single callback both
|
||||
* before and after a command.)
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMRegisterCommandHandler(XPLMCommandRef inComand,
|
||||
XPLMCommandCallback_f inHandler,
|
||||
int inBefore,
|
||||
void *inRefcon);
|
||||
|
||||
/*
|
||||
* XPLMUnregisterCommandHandler
|
||||
*
|
||||
* XPLMUnregisterCommandHandler removes a command callback registered with
|
||||
* XPLMRegisterCommandHandler.
|
||||
*
|
||||
*/
|
||||
XPLM_API void XPLMUnregisterCommandHandler(XPLMCommandRef inComand,
|
||||
XPLMCommandCallback_f inHandler,
|
||||
int inBefore,
|
||||
void *inRefcon);
|
||||
|
||||
#endif /* XPLM200 */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user