GermanAirlines/GermanAirlinesVA-GAConnector
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Real Name

Browse Source
This commit is contained in:
Kilian Hofmann
2022-01-01 23:50:23 +01:00
parent 94a31b7608
commit 0adf122d1d
553 changed files with 155034 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
XPSDK/Delphi/XPLM/XPLMCamera.pas
+174
View File
@@ -0,0 +1,174 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMCamera;
INTERFACE
{
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.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
XPLMCameraControlDuration = (
{ 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
);
PXPLMCameraControlDuration = ^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).
}
XPLMCameraPosition_t = RECORD
x : single;
y : single;
z : single;
pitch : single;
heading : single;
roll : single;
zoom : single;
END;
PXPLMCameraPosition_t = ^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.
}
XPLMCameraControl_f = FUNCTION(
outCameraPosition : PXPLMCameraPosition_t; { Can be nil }
inIsLosingControl : integer;
inRefcon : pointer) : integer; cdecl;
{
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).
}
PROCEDURE XPLMControlCamera(
inHowLong : XPLMCameraControlDuration;
inControlFunc : XPLMCameraControl_f;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMDontControlCamera;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMIsCameraBeingControlled(
outCameraControlDuration: PXPLMCameraControlDuration) : integer; { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMReadCameraPosition
This function reads the current camera position.
}
PROCEDURE XPLMReadCameraPosition(
outCameraPosition : PXPLMCameraPosition_t);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMDataAccess.pas
+764
View File
@@ -0,0 +1,764 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMDataAccess;
INTERFACE
{
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).
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
{
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.
}
XPLMDataRef = pointer;
PXPLMDataRef = ^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.
}
XPLMDataTypeID = (
{ 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
);
PXPLMDataTypeID = ^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.
}
FUNCTION XPLMFindDataRef(
inDataRefName : Pchar) : XPLMDataRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCanWriteDataRef
Given a data ref, this routine returns true if you can successfully set
the data, false otherwise. Some datarefs are read-only.
}
FUNCTION XPLMCanWriteDataRef(
inDataRef : XPLMDataRef) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMIsDataRefGood(
inDataRef : XPLMDataRef) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDataRefTypes(
inDataRef : XPLMDataRef) : XPLMDataTypeID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
FUNCTION XPLMGetDatai(
inDataRef : XPLMDataRef) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetDatai(
inDataRef : XPLMDataRef;
inValue : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDataf(
inDataRef : XPLMDataRef) : single;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetDataf(
inDataRef : XPLMDataRef;
inValue : single);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDatad(
inDataRef : XPLMDataRef) : real;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetDatad(
inDataRef : XPLMDataRef;
inValue : real);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDatavi(
inDataRef : XPLMDataRef;
outValues : Pinteger; { Can be nil }
inOffset : integer;
inMax : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetDatavi(
inDataRef : XPLMDataRef;
inValues : Pinteger;
inoffset : integer;
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDatavf(
inDataRef : XPLMDataRef;
outValues : Psingle; { Can be nil }
inOffset : integer;
inMax : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetDatavf(
inDataRef : XPLMDataRef;
inValues : Psingle;
inoffset : integer;
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDatab(
inDataRef : XPLMDataRef;
outValue : pointer; { Can be nil }
inOffset : integer;
inMaxBytes : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetDatab(
inDataRef : XPLMDataRef;
inValue : pointer;
inOffset : integer;
inLength : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
TYPE
XPLMGetDatai_f = FUNCTION(
inRefcon : pointer) : integer; cdecl;
{
XPLMSetDatai_f
}
XPLMSetDatai_f = PROCEDURE(
inRefcon : pointer;
inValue : integer); cdecl;
{
XPLMGetDataf_f
}
XPLMGetDataf_f = FUNCTION(
inRefcon : pointer) : single; cdecl;
{
XPLMSetDataf_f
}
XPLMSetDataf_f = PROCEDURE(
inRefcon : pointer;
inValue : single); cdecl;
{
XPLMGetDatad_f
}
XPLMGetDatad_f = FUNCTION(
inRefcon : pointer) : real; cdecl;
{
XPLMSetDatad_f
}
XPLMSetDatad_f = PROCEDURE(
inRefcon : pointer;
inValue : real); cdecl;
{
XPLMGetDatavi_f
}
XPLMGetDatavi_f = FUNCTION(
inRefcon : pointer;
outValues : Pinteger; { Can be nil }
inOffset : integer;
inMax : integer) : integer; cdecl;
{
XPLMSetDatavi_f
}
XPLMSetDatavi_f = PROCEDURE(
inRefcon : pointer;
inValues : Pinteger;
inOffset : integer;
inCount : integer); cdecl;
{
XPLMGetDatavf_f
}
XPLMGetDatavf_f = FUNCTION(
inRefcon : pointer;
outValues : Psingle; { Can be nil }
inOffset : integer;
inMax : integer) : integer; cdecl;
{
XPLMSetDatavf_f
}
XPLMSetDatavf_f = PROCEDURE(
inRefcon : pointer;
inValues : Psingle;
inOffset : integer;
inCount : integer); cdecl;
{
XPLMGetDatab_f
}
XPLMGetDatab_f = FUNCTION(
inRefcon : pointer;
outValue : pointer; { Can be nil }
inOffset : integer;
inMaxLength : integer) : integer; cdecl;
{
XPLMSetDatab_f
}
XPLMSetDatab_f = PROCEDURE(
inRefcon : pointer;
inValue : pointer;
inOffset : integer;
inLength : integer); cdecl;
{
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.
}
FUNCTION XPLMRegisterDataAccessor(
inDataName : Pchar;
inDataType : XPLMDataTypeID;
inIsWritable : integer;
inReadInt : XPLMGetDatai_f;
inWriteInt : XPLMSetDatai_f;
inReadFloat : XPLMGetDataf_f;
inWriteFloat : XPLMSetDataf_f;
inReadDouble : XPLMGetDatad_f;
inWriteDouble : XPLMSetDatad_f;
inReadIntArray : XPLMGetDatavi_f;
inWriteIntArray : XPLMSetDatavi_f;
inReadFloatArray : XPLMGetDatavf_f;
inWriteFloatArray : XPLMSetDatavf_f;
inReadData : XPLMGetDatab_f;
inWriteData : XPLMSetDatab_f;
inReadRefcon : pointer;
inWriteRefcon : pointer) : XPLMDataRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMUnregisterDataAccessor(
inDataRef : XPLMDataRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
TYPE
XPLMDataChanged_f = PROCEDURE(
inRefcon : pointer); cdecl;
{
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.
}
FUNCTION XPLMShareData(
inDataName : Pchar;
inDataType : XPLMDataTypeID;
inNotificationFunc : XPLMDataChanged_f;
inNotificationRefcon: pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMUnshareData(
inDataName : Pchar;
inDataType : XPLMDataTypeID;
inNotificationFunc : XPLMDataChanged_f;
inNotificationRefcon: pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMDefs.pas
+446
View File
@@ -0,0 +1,446 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMDefs;
INTERFACE
{
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.
}
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{$IFDEF LINUX}
{$DEFINE KYLIX}
{$ENDIF}
TYPE
{$IFNDEF DELPHI}
{$IFNDEF KYLIX}
Pchar = ^char;
Ppchar = ^Pchar;
Psingle = ^single;
Pinteger = ^integer;
{$ENDIF}
{$ENDIF}
Preal = ^real;
Plongint = ^longint;
{___________________________________________________________________________
* 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.)
}
{___________________________________________________________________________
* GLOBAL DEFINITIONS
___________________________________________________________________________}
{
These definitions are used in all parts of the SDK.
}
TYPE
{
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.
}
XPLMPluginID = integer;
PXPLMPluginID = ^XPLMPluginID;
CONST
{ No plugin. }
XPLM_NO_PLUGIN_ID = (-1);
{ X-Plane itself }
XPLM_PLUGIN_XPLANE = (0);
{ The current XPLM revision is 2.10 (210). }
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.
}
TYPE
XPLMKeyFlags = (
{ 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
);
PXPLMKeyFlags = ^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.
}
CONST
XPLM_KEY_RETURN = 13;
XPLM_KEY_ESCAPE = 27;
XPLM_KEY_TAB = 9;
XPLM_KEY_DELETE = 8;
XPLM_KEY_LEFT = 28;
XPLM_KEY_RIGHT = 29;
XPLM_KEY_UP = 30;
XPLM_KEY_DOWN = 31;
XPLM_KEY_0 = 48;
XPLM_KEY_1 = 49;
XPLM_KEY_2 = 50;
XPLM_KEY_3 = 51;
XPLM_KEY_4 = 52;
XPLM_KEY_5 = 53;
XPLM_KEY_6 = 54;
XPLM_KEY_7 = 55;
XPLM_KEY_8 = 56;
XPLM_KEY_9 = 57;
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.
}
CONST
XPLM_VK_BACK = $08;
XPLM_VK_TAB = $09;
XPLM_VK_CLEAR = $0C;
XPLM_VK_RETURN = $0D;
XPLM_VK_ESCAPE = $1B;
XPLM_VK_SPACE = $20;
XPLM_VK_PRIOR = $21;
XPLM_VK_NEXT = $22;
XPLM_VK_END = $23;
XPLM_VK_HOME = $24;
XPLM_VK_LEFT = $25;
XPLM_VK_UP = $26;
XPLM_VK_RIGHT = $27;
XPLM_VK_DOWN = $28;
XPLM_VK_SELECT = $29;
XPLM_VK_PRINT = $2A;
XPLM_VK_EXECUTE = $2B;
XPLM_VK_SNAPSHOT = $2C;
XPLM_VK_INSERT = $2D;
XPLM_VK_DELETE = $2E;
XPLM_VK_HELP = $2F;
{ XPLM_VK_0 thru XPLM_VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) }
XPLM_VK_0 = $30;
XPLM_VK_1 = $31;
XPLM_VK_2 = $32;
XPLM_VK_3 = $33;
XPLM_VK_4 = $34;
XPLM_VK_5 = $35;
XPLM_VK_6 = $36;
XPLM_VK_7 = $37;
XPLM_VK_8 = $38;
XPLM_VK_9 = $39;
{ XPLM_VK_A thru XPLM_VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) }
XPLM_VK_A = $41;
XPLM_VK_B = $42;
XPLM_VK_C = $43;
XPLM_VK_D = $44;
XPLM_VK_E = $45;
XPLM_VK_F = $46;
XPLM_VK_G = $47;
XPLM_VK_H = $48;
XPLM_VK_I = $49;
XPLM_VK_J = $4A;
XPLM_VK_K = $4B;
XPLM_VK_L = $4C;
XPLM_VK_M = $4D;
XPLM_VK_N = $4E;
XPLM_VK_O = $4F;
XPLM_VK_P = $50;
XPLM_VK_Q = $51;
XPLM_VK_R = $52;
XPLM_VK_S = $53;
XPLM_VK_T = $54;
XPLM_VK_U = $55;
XPLM_VK_V = $56;
XPLM_VK_W = $57;
XPLM_VK_X = $58;
XPLM_VK_Y = $59;
XPLM_VK_Z = $5A;
XPLM_VK_NUMPAD0 = $60;
XPLM_VK_NUMPAD1 = $61;
XPLM_VK_NUMPAD2 = $62;
XPLM_VK_NUMPAD3 = $63;
XPLM_VK_NUMPAD4 = $64;
XPLM_VK_NUMPAD5 = $65;
XPLM_VK_NUMPAD6 = $66;
XPLM_VK_NUMPAD7 = $67;
XPLM_VK_NUMPAD8 = $68;
XPLM_VK_NUMPAD9 = $69;
XPLM_VK_MULTIPLY = $6A;
XPLM_VK_ADD = $6B;
XPLM_VK_SEPARATOR = $6C;
XPLM_VK_SUBTRACT = $6D;
XPLM_VK_DECIMAL = $6E;
XPLM_VK_DIVIDE = $6F;
XPLM_VK_F1 = $70;
XPLM_VK_F2 = $71;
XPLM_VK_F3 = $72;
XPLM_VK_F4 = $73;
XPLM_VK_F5 = $74;
XPLM_VK_F6 = $75;
XPLM_VK_F7 = $76;
XPLM_VK_F8 = $77;
XPLM_VK_F9 = $78;
XPLM_VK_F10 = $79;
XPLM_VK_F11 = $7A;
XPLM_VK_F12 = $7B;
XPLM_VK_F13 = $7C;
XPLM_VK_F14 = $7D;
XPLM_VK_F15 = $7E;
XPLM_VK_F16 = $7F;
XPLM_VK_F17 = $80;
XPLM_VK_F18 = $81;
XPLM_VK_F19 = $82;
XPLM_VK_F20 = $83;
XPLM_VK_F21 = $84;
XPLM_VK_F22 = $85;
XPLM_VK_F23 = $86;
XPLM_VK_F24 = $87;
{ The following definitions are extended and are not based on the Microsoft }
{ key set. }
XPLM_VK_EQUAL = $B0;
XPLM_VK_MINUS = $B1;
XPLM_VK_RBRACE = $B2;
XPLM_VK_LBRACE = $B3;
XPLM_VK_QUOTE = $B4;
XPLM_VK_SEMICOLON = $B5;
XPLM_VK_BACKSLASH = $B6;
XPLM_VK_COMMA = $B7;
XPLM_VK_SLASH = $B8;
XPLM_VK_PERIOD = $B9;
XPLM_VK_BACKQUOTE = $BA;
XPLM_VK_ENTER = $BB;
XPLM_VK_NUMPAD_ENT = $BC;
XPLM_VK_NUMPAD_EQ = $BD;
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMDisplay.pas
+835
View File
@@ -0,0 +1,835 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMDisplay;
INTERFACE
{
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.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
XPLMDrawingPhase = (
{ 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
{$IFDEF XPLM200}
{ 3-d Drawing for the local map. Use regular OpenGL coordinates to draw in }
{ this phase. }
,xplm_Phase_LocalMap3D = 100
{$ENDIF}
{$IFDEF XPLM200}
{ 2-d Drawing of text over the local map. }
,xplm_Phase_LocalMap2D = 101
{$ENDIF}
{$IFDEF XPLM200}
{ Drawing of the side-profile view in the local map screen. }
,xplm_Phase_LocalMapProfile = 102
{$ENDIF}
);
PXPLMDrawingPhase = ^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.
}
XPLMDrawCallback_f = FUNCTION(
inPhase : XPLMDrawingPhase;
inIsBefore : integer;
inRefcon : pointer) : integer; cdecl;
{
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.
}
XPLMKeySniffer_f = FUNCTION(
inChar : char;
inFlags : XPLMKeyFlags;
inVirtualKey : char;
inRefcon : pointer) : integer; cdecl;
{
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.
}
FUNCTION XPLMRegisterDrawCallback(
inCallback : XPLMDrawCallback_f;
inPhase : XPLMDrawingPhase;
inWantsBefore : integer;
inRefcon : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMUnregisterDrawCallback(
inCallback : XPLMDrawCallback_f;
inPhase : XPLMDrawingPhase;
inWantsBefore : integer;
inRefcon : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMRegisterKeySniffer(
inCallback : XPLMKeySniffer_f;
inBeforeWindows : integer;
inRefcon : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMUnregisterKeySniffer(
inCallback : XPLMKeySniffer_f;
inBeforeWindows : integer;
inRefcon : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
TYPE
XPLMMouseStatus = (
xplm_MouseDown = 1
,xplm_MouseDrag = 2
,xplm_MouseUp = 3
);
PXPLMMouseStatus = ^XPLMMouseStatus;
{$IFDEF XPLM200}
{
XPLMCursorStatus
XPLMCursorStatus describes how you would like X-Plane to manage the cursor.
See XPLMHandleCursor_f for more info.
}
XPLMCursorStatus = (
{ 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
);
PXPLMCursorStatus = ^XPLMCursorStatus;
{$ENDIF}
{
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.
}
XPLMWindowID = pointer;
PXPLMWindowID = ^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.
}
XPLMDrawWindow_f = PROCEDURE(
inWindowID : XPLMWindowID;
inRefcon : pointer); cdecl;
{
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.
}
XPLMHandleKey_f = PROCEDURE(
inWindowID : XPLMWindowID;
inKey : char;
inFlags : XPLMKeyFlags;
inVirtualKey : char;
inRefcon : pointer;
losingFocus : integer); cdecl;
{
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!
}
XPLMHandleMouseClick_f = FUNCTION(
inWindowID : XPLMWindowID;
x : integer;
y : integer;
inMouse : XPLMMouseStatus;
inRefcon : pointer) : integer; cdecl;
{$IFDEF 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).
}
XPLMHandleCursor_f = FUNCTION(
inWindowID : XPLMWindowID;
x : integer;
y : integer;
inRefcon : pointer) : XPLMCursorStatus; cdecl;
{$ENDIF}
{$IFDEF 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).
}
XPLMHandleMouseWheel_f = FUNCTION(
inWindowID : XPLMWindowID;
x : integer;
y : integer;
wheel : integer;
clicks : integer;
inRefcon : pointer) : integer; cdecl;
{$ENDIF}
{$IFDEF 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!
}
XPLMCreateWindow_t = RECORD
structSize : integer;
left : integer;
top : integer;
right : integer;
bottom : integer;
visible : integer;
drawWindowFunc : XPLMDrawWindow_f;
handleMouseClickFunc : XPLMHandleMouseClick_f;
handleKeyFunc : XPLMHandleKey_f;
handleCursorFunc : XPLMHandleCursor_f;
handleMouseWheelFunc : XPLMHandleMouseWheel_f;
refcon : pointer;
END;
PXPLMCreateWindow_t = ^XPLMCreateWindow_t;
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetScreenSize(
outWidth : Pinteger; { Can be nil }
outHeight : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetMouseLocation(
outX : Pinteger; { Can be nil }
outY : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMCreateWindow(
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer;
inIsVisible : integer;
inDrawCallback : XPLMDrawWindow_f;
inKeyCallback : XPLMHandleKey_f;
inMouseCallback : XPLMHandleMouseClick_f;
inRefcon : pointer) : XPLMWindowID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$IFDEF 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.
}
FUNCTION XPLMCreateWindowEx(
inParams : PXPLMCreateWindow_t) : XPLMWindowID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{
XPLMDestroyWindow
This routine destroys a window. The callbacks are not called after this
call. Keyboard focus is removed from the window before destroying it.
}
PROCEDURE XPLMDestroyWindow(
inWindowID : XPLMWindowID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetWindowGeometry
This routine returns the position and size of a window in cockpit pixels.
Pass NULL to not receive any paramter.
}
PROCEDURE XPLMGetWindowGeometry(
inWindowID : XPLMWindowID;
outLeft : Pinteger; { Can be nil }
outTop : Pinteger; { Can be nil }
outRight : Pinteger; { Can be nil }
outBottom : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetWindowGeometry
This routine allows you to set the position or height aspects of a window.
}
PROCEDURE XPLMSetWindowGeometry(
inWindowID : XPLMWindowID;
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetWindowIsVisible
This routine returns whether a window is visible.
}
FUNCTION XPLMGetWindowIsVisible(
inWindowID : XPLMWindowID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetWindowIsVisible
This routine shows or hides a window.
}
PROCEDURE XPLMSetWindowIsVisible(
inWindowID : XPLMWindowID;
inIsVisible : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetWindowRefCon
This routine returns a windows refcon, the unique value you can use for
your own purposes.
}
FUNCTION XPLMGetWindowRefCon(
inWindowID : XPLMWindowID) : pointer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetWindowRefCon
This routine sets a window's reference constant. Use this to pass data to
yourself in the callbacks.
}
PROCEDURE XPLMSetWindowRefCon(
inWindowID : XPLMWindowID;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMTakeKeyboardFocus(
inWindow : XPLMWindowID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMBringWindowToFront(
inWindow : XPLMWindowID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMIsWindowInFront
This routine returns true if you pass inthe ID of the frontmost visible
window.
}
FUNCTION XPLMIsWindowInFront(
inWindow : XPLMWindowID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* HOT KEYS
___________________________________________________________________________}
{
Hot Keys - keystrokes that can be managed by others.
}
{
XPLMHotKey_f
Your hot key callback simply takes a pointer of your choosing.
}
TYPE
XPLMHotKey_f = PROCEDURE(
inRefcon : pointer); cdecl;
{
XPLMHotKeyID
Hot keys are identified by opaque IDs.
}
XPLMHotKeyID = pointer;
PXPLMHotKeyID = ^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.
}
FUNCTION XPLMRegisterHotKey(
inVirtualKey : char;
inFlags : XPLMKeyFlags;
inDescription : Pchar;
inCallback : XPLMHotKey_f;
inRefcon : pointer) : XPLMHotKeyID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMUnregisterHotKey
This API unregisters a hot key. You can only register your own hot keys.
}
PROCEDURE XPLMUnregisterHotKey(
inHotKey : XPLMHotKeyID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCountHotKeys
Returns the number of current hot keys.
}
FUNCTION XPLMCountHotKeys: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetNthHotKey
Returns a hot key by index, for iteration on all hot keys.
}
FUNCTION XPLMGetNthHotKey(
inIndex : integer) : XPLMHotKeyID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetHotKeyInfo(
inHotKey : XPLMHotKeyID;
outVirtualKey : Pchar; { Can be nil }
outFlags : PXPLMKeyFlags; { Can be nil }
outDescription : Pchar; { Can be nil }
outPlugin : PXPLMPluginID); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetHotKeyCombination
XPLMSetHotKeyCombination remaps a hot keys keystrokes. You may remap
another plugin's keystrokes.
}
PROCEDURE XPLMSetHotKeyCombination(
inHotKey : XPLMHotKeyID;
inVirtualKey : char;
inFlags : XPLMKeyFlags);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMGraphics.pas
+441
View File
@@ -0,0 +1,441 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMGraphics;
INTERFACE
{
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.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
XPLMTextureID = (
{ 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
);
PXPLMTextureID = ^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.
}
PROCEDURE XPLMSetGraphicsState(
inEnableFog : integer;
inNumberTexUnits : integer;
inEnableLighting : integer;
inEnableAlphaTesting: integer;
inEnableAlphaBlending: integer;
inEnableDepthTesting: integer;
inEnableDepthWriting: integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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, ....);
}
PROCEDURE XPLMBindTexture2d(
inTextureNum : integer;
inTextureUnit : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGenerateTextureNumbers(
outTextureIDs : Pinteger;
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetTexture(
inTexture : XPLMTextureID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMWorldToLocal(
inLatitude : real;
inLongitude : real;
inAltitude : real;
outX : Preal;
outY : Preal;
outZ : Preal);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMLocalToWorld(
inX : real;
inY : real;
inZ : real;
outLatitude : Preal;
outLongitude : Preal;
outAltitude : Preal);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMDrawTranslucentDarkBox(
inLeft : integer;
inTop : integer;
inRight : integer;
inBottom : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
TYPE
XPLMFontID = (
{ 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
{$IFDEF XPLM200}
{ Proportional UI font. }
,xplmFont_Proportional = 18
{$ENDIF}
);
PXPLMFontID = ^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.
}
PROCEDURE XPLMDrawString(
inColorRGB : Psingle;
inXOffset : integer;
inYOffset : integer;
inChar : Pchar;
inWordWrapWidth : Pinteger; { Can be nil }
inFontID : XPLMFontID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMDrawNumber(
inColorRGB : Psingle;
inXOffset : integer;
inYOffset : integer;
inValue : real;
inDigits : integer;
inDecimals : integer;
inShowSign : integer;
inFontID : XPLMFontID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetFontDimensions(
inFontID : XPLMFontID;
outCharWidth : Pinteger; { Can be nil }
outCharHeight : Pinteger; { Can be nil }
outDigitsOnly : Pinteger); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$IFDEF 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.
}
FUNCTION XPLMMeasureString(
inFontID : XPLMFontID;
inChar : Pchar;
inNumChars : integer) : single;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMMenus.pas
+259
View File
@@ -0,0 +1,259 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMMenus;
INTERFACE
{
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.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
XPLMMenuCheck = (
{ 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
);
PXPLMMenuCheck = ^XPLMMenuCheck;
{
XPLMMenuID
This is a unique ID for each menu you create.
}
XPLMMenuID = pointer;
PXPLMMenuID = ^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).
}
XPLMMenuHandler_f = PROCEDURE(
inMenuRef : pointer;
inItemRef : pointer); cdecl;
{
XPLMFindPluginsMenu
This function returns the ID of the plug-ins menu, which is created for you
at startup.
}
FUNCTION XPLMFindPluginsMenu: XPLMMenuID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMCreateMenu(
inName : Pchar;
inParentMenu : XPLMMenuID;
inParentItem : integer;
inHandler : XPLMMenuHandler_f;
inMenuRef : pointer) : XPLMMenuID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.)
}
PROCEDURE XPLMDestroyMenu(
inMenuID : XPLMMenuID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMClearAllMenuItems(
inMenuID : XPLMMenuID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMAppendMenuItem(
inMenu : XPLMMenuID;
inItemName : Pchar;
inItemRef : pointer;
inForceEnglish : integer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMAppendMenuSeparator
This routine adds a seperator to the end of a menu.
}
PROCEDURE XPLMAppendMenuSeparator(
inMenu : XPLMMenuID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetMenuItemName
This routine changes the name of an existing menu item. Pass in the menu
ID and the index of the menu item.
}
PROCEDURE XPLMSetMenuItemName(
inMenu : XPLMMenuID;
inIndex : integer;
inItemName : Pchar;
inForceEnglish : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCheckMenuItem
Set whether a menu item is checked. Pass in the menu ID and item index.
}
PROCEDURE XPLMCheckMenuItem(
inMenu : XPLMMenuID;
index : integer;
inCheck : XPLMMenuCheck);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMCheckMenuItemState(
inMenu : XPLMMenuID;
index : integer;
outCheck : PXPLMMenuCheck);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMEnableMenuItem
Sets whether this menu item is enabled. Items start out enabled.
}
PROCEDURE XPLMEnableMenuItem(
inMenu : XPLMMenuID;
index : integer;
enabled : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$IFDEF 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.
}
PROCEDURE XPLMRemoveMenuItem(
inMenu : XPLMMenuID;
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMNavigation.pas
+434
View File
@@ -0,0 +1,434 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMNavigation;
INTERFACE
{
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.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
XPLMNavType = (
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
);
PXPLMNavType = ^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.
}
XPLMNavRef = integer;
PXPLMNavRef = ^XPLMNavRef;
CONST
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.
}
FUNCTION XPLMGetFirstNavAid: XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetNextNavAid(
inNavAidRef : XPLMNavRef) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMFindFirstNavAidOfType(
inType : XPLMNavType) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMFindLastNavAidOfType(
inType : XPLMNavType) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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".
}
FUNCTION XPLMFindNavAid(
inNameFragment : Pchar; { Can be nil }
inIDFragment : Pchar; { Can be nil }
inLat : Psingle; { Can be nil }
inLon : Psingle; { Can be nil }
inFrequency : Pinteger; { Can be nil }
inType : XPLMNavType) : XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetNavAidInfo(
inRef : XPLMNavRef;
outType : PXPLMNavType; { Can be nil }
outLatitude : Psingle; { Can be nil }
outLongitude : Psingle; { Can be nil }
outHeight : Psingle; { Can be nil }
outFrequency : Pinteger; { Can be nil }
outHeading : Psingle; { Can be nil }
outID : Pchar; { Can be nil }
outName : Pchar; { Can be nil }
outReg : Pchar); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
FUNCTION XPLMCountFMSEntries: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetDisplayedFMSEntry
This routine returns the index of the entry the pilot is viewing.
}
FUNCTION XPLMGetDisplayedFMSEntry: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetDestinationFMSEntry
This routine returns the index of the entry the FMS is flying to.
}
FUNCTION XPLMGetDestinationFMSEntry: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetDisplayedFMSEntry
This routine changes which entry the FMS is showing to the index specified.
}
PROCEDURE XPLMSetDisplayedFMSEntry(
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetDestinationFMSEntry
This routine changes which entry the FMS is flying the aircraft toward.
}
PROCEDURE XPLMSetDestinationFMSEntry(
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetFMSEntryInfo(
inIndex : integer;
outType : PXPLMNavType; { Can be nil }
outID : Pchar; { Can be nil }
outRef : PXPLMNavRef; { Can be nil }
outAltitude : Pinteger; { Can be nil }
outLat : Psingle; { Can be nil }
outLon : Psingle); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetFMSEntryInfo(
inIndex : integer;
inRef : XPLMNavRef;
inAltitude : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMSetFMSEntryLatLon
This routine changes the entry in the FMS to a lat/lon entry with the given
coordinates.
}
PROCEDURE XPLMSetFMSEntryLatLon(
inIndex : integer;
inLat : single;
inLon : single;
inAltitude : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMClearFMSEntry
This routine clears the given entry, potentially shortening the flight
plan.
}
PROCEDURE XPLMClearFMSEntry(
inIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
FUNCTION XPLMGetGPSDestinationType: XPLMNavType;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetGPSDestination
This routine returns the current GPS destination.
}
FUNCTION XPLMGetGPSDestination: XPLMNavRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMPlanes.pas
+294
View File
@@ -0,0 +1,294 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMPlanes;
INTERFACE
{
The XPLMPlanes APIs allow you to control the various aircraft in x-plane,
both the user's and the sim's.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
PROCEDURE XPLMSetUsersAircraft(
inAircraftPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMPlaceUserAtAirport
This routine places the user at a given airport. Specify the airport by
its ICAO code (e.g. 'KBOS').
}
PROCEDURE XPLMPlaceUserAtAirport(
inAirportCode : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* GLOBAL AIRCRAFT ACCESS
___________________________________________________________________________}
{
}
CONST
{ The user's aircraft is always index 0. }
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!
}
TYPE
XPLMPlaneDrawState_t = RECORD
{ The size of the draw state struct. }
structSize : integer;
{ A ratio from [0..1] describing how far the landing gear is extended. }
gearPosition : single;
{ Ratio of flap deployment, 0 = up, 1 = full deploy. }
flapRatio : single;
{ Ratio of spoiler deployment, 0 = none, 1 = full deploy. }
spoilerRatio : single;
{ Ratio of speed brake deployment, 0 = none, 1 = full deploy. }
speedBrakeRatio : single;
{ Ratio of slat deployment, 0 = none, 1 = full deploy. }
slatRatio : single;
{ Wing sweep ratio, 0 = forward, 1 = swept. }
wingSweep : single;
{ Thrust power, 0 = none, 1 = full fwd, -1 = full reverse. }
thrust : single;
{ Total pitch input for this plane. }
yokePitch : single;
{ Total Heading input for this plane. }
yokeHeading : single;
{ Total Roll input for this plane. }
yokeRoll : single;
END;
PXPLMPlaneDrawState_t = ^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.
}
PROCEDURE XPLMCountAircraft(
outTotalAircraft : Pinteger;
outActiveAircraft : Pinteger;
outController : PXPLMPluginID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetNthAircraftModel(
inIndex : integer;
outFileName : Pchar;
outPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
TYPE
XPLMPlanesAvailable_f = PROCEDURE(
inRefcon : pointer); cdecl;
{
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.
}
FUNCTION XPLMAcquirePlanes(
inAircraft : PPchar; { Can be nil }
inCallback : XPLMPlanesAvailable_f;
inRefcon : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMReleasePlanes;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetActiveAircraftCount(
inCount : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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).
}
PROCEDURE XPLMSetAircraftModel(
inIndex : integer;
inAircraftPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMDisableAIForPlane(
inPlaneIndex : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.)
}
PROCEDURE XPLMDrawAircraft(
inPlaneIndex : integer;
inX : single;
inY : single;
inZ : single;
inPitch : single;
inRoll : single;
inYaw : single;
inFullDraw : integer;
inDrawStateInfo : PXPLMPlaneDrawState_t);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMReinitUsersPlane;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMPlugin.pas
+381
View File
@@ -0,0 +1,381 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMPlugin;
INTERFACE
{
These APIs provide facilities to find and work with other plugins and
manage other plugins.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
FUNCTION XPLMGetMyID: XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCountPlugins
This routine returns the total number of plug-ins that are loaded, both
disabled and enabled.
}
FUNCTION XPLMCountPlugins: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetNthPlugin(
inIndex : integer) : XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMFindPluginByPath(
inPath : Pchar) : XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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
}
FUNCTION XPLMFindPluginBySignature(
inSignature : Pchar) : XPLMPluginID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetPluginInfo(
inPlugin : XPLMPluginID;
outName : Pchar; { Can be nil }
outFilePath : Pchar; { Can be nil }
outSignature : Pchar; { Can be nil }
outDescription : Pchar); { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
FUNCTION XPLMIsPluginEnabled(
inPluginID : XPLMPluginID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMEnablePlugin(
inPluginID : XPLMPluginID) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMDisablePlugin
This routine disableds an enabled plug-in.
}
PROCEDURE XPLMDisablePlugin(
inPluginID : XPLMPluginID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMReloadPlugins;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
CONST
{ This message is sent to your plugin whenever the user's plane crashes. }
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. }
XPLM_MSG_PLANE_LOADED = 102;
{ This messages is called whenever the user's plane is positioned at a new }
{ airport. }
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. }
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. }
XPLM_MSG_AIRPLANE_COUNT_CHANGED = 105;
{$IFDEF 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.) }
XPLM_MSG_PLANE_UNLOADED = 106;
{$ENDIF}
{$IFDEF 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. }
XPLM_MSG_WILL_WRITE_PREFS = 107;
{$ENDIF}
{$IFDEF 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. }
XPLM_MSG_LIVERY_LOADED = 108;
{$ENDIF}
{
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.
}
PROCEDURE XPLMSendMessageToPlugin(
inPlugin : XPLMPluginID;
inMessage : integer;
inParam : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$IFDEF 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.
}
TYPE
XPLMFeatureEnumerator_f = PROCEDURE(
inFeature : Pchar;
inRef : pointer); cdecl;
{
XPLMHasFeature
This returns 1 if the given installation of X-Plane supports a feature, or
0 if it does not.
}
FUNCTION XPLMHasFeature(
inFeature : Pchar) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMIsFeatureEnabled(
inFeature : Pchar) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMEnableFeature(
inFeature : Pchar;
inEnable : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMEnumerateFeatures(
inEnumerator : XPLMFeatureEnumerator_f;
inRef : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMProcessing.pas
+276
View File
@@ -0,0 +1,276 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMProcessing;
INTERFACE
{
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.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{___________________________________________________________________________
* FLIGHT LOOP CALLBACKS
___________________________________________________________________________}
{
}
{$IFDEF XPLM210}
{
XPLMFlightLoopPhaseType
You can register a flight loop callback to run either before or after the
flight model is integrated by X-Plane.
}
TYPE
XPLMFlightLoopPhaseType = (
{ 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
);
PXPLMFlightLoopPhaseType = ^XPLMFlightLoopPhaseType;
{$ENDIF}
{$IFDEF 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.
}
XPLMFlightLoopID = pointer;
PXPLMFlightLoopID = ^XPLMFlightLoopID;
{$ENDIF}
{
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.
}
XPLMFlightLoop_f = FUNCTION(
inElapsedSinceLastCall: single;
inElapsedTimeSinceLastFlightLoop: single;
inCounter : integer;
inRefcon : pointer) : single; cdecl;
{$IFDEF 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.
}
XPLMCreateFlightLoop_t = RECORD
structSize : integer;
phase : XPLMFlightLoopPhaseType;
callbackFunc : XPLMFlightLoop_f;
refcon : pointer;
END;
PXPLMCreateFlightLoop_t = ^XPLMCreateFlightLoop_t;
{$ENDIF}
{
XPLMGetElapsedTime
This routine returns the elapsed time since the sim started up in decimal
seconds.
}
FUNCTION XPLMGetElapsedTime: single;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetCycleNumber
This routine returns a counter starting at zero for each sim cycle
computed/video frame rendered.
}
FUNCTION XPLMGetCycleNumber: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMRegisterFlightLoopCallback(
inFlightLoop : XPLMFlightLoop_f;
inInterval : single;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMUnregisterFlightLoopCallback(
inFlightLoop : XPLMFlightLoop_f;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSetFlightLoopCallbackInterval(
inFlightLoop : XPLMFlightLoop_f;
inInterval : single;
inRelativeToNow : integer;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$IFDEF 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.
}
FUNCTION XPLMCreateFlightLoop(
inParams : PXPLMCreateFlightLoop_t) : XPLMFlightLoopID;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF XPLM210}
{
XPLMDestroyFlightLoop
This routine destroys a flight loop callback by ID.
}
PROCEDURE XPLMDestroyFlightLoop(
inFlightLoopID : XPLMFlightLoopID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
PROCEDURE XPLMScheduleFlightLoop(
inFlightLoopID : XPLMFlightLoopID;
inInterval : single;
inRelativeToNow : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMScenery.pas
+419
View File
@@ -0,0 +1,419 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMScenery;
INTERFACE
{
This package contains APIs to interact with X-Plane's scenery system.
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$ENDIF}
{$IFDEF 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.
}
TYPE
XPLMProbeType = (
{ The Y probe gives you the location of the tallest physical scenery along }
{ the Y axis going through the queried point. }
xplm_ProbeY = 0
);
PXPLMProbeType = ^XPLMProbeType;
{
XPLMProbeResult
Probe results - possible results from a probe query.
}
XPLMProbeResult = (
{ 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
);
PXPLMProbeResult = ^XPLMProbeResult;
{
XPLMProbeRef
An XPLMProbeRef is an opaque handle to a probe, used for querying the
terrain.
}
XPLMProbeRef = pointer;
PXPLMProbeRef = ^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.
}
XPLMProbeInfo_t = RECORD
{ Size of structure in bytes - always set this before calling the XPLM. }
structSize : integer;
{ Resulting X location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationX : single;
{ Resulting Y location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationY : single;
{ Resulting Z location of the terrain point we hit, in local OpenGL }
{ coordinates. }
locationZ : single;
{ X component of the normal vector to the terrain we found. }
normalX : single;
{ Y component of the normal vector to the terrain we found. }
normalY : single;
{ Z component of the normal vector to the terrain we found. }
normalZ : single;
{ X component of the velocity vector of the terrain we found. }
velocityX : single;
{ Y component of the velocity vector of the terrain we found. }
velocityY : single;
{ Z component of the velocity vector of the terrain we found. }
velocityZ : single;
{ Tells if the surface we hit is water (otherwise it is land). }
is_wet : integer;
END;
PXPLMProbeInfo_t = ^XPLMProbeInfo_t;
{
XPLMCreateProbe
Creates a new probe object of a given type and returns.
}
FUNCTION XPLMCreateProbe(
inProbeType : XPLMProbeType) : XPLMProbeRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMDestroyProbe
Deallocates an existing probe object.
}
PROCEDURE XPLMDestroyProbe(
inProbe : XPLMProbeRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMProbeTerrainXYZ(
inProbe : XPLMProbeRef;
inX : single;
inY : single;
inZ : single;
outInfo : PXPLMProbeInfo_t) : XPLMProbeResult;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{___________________________________________________________________________
* 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!
}
{$IFDEF XPLM200}
TYPE
{
XPLMObjectRef
An XPLMObjectRef is a opaque handle to an .obj file that has been loaded
into memory.
}
XPLMObjectRef = pointer;
PXPLMObjectRef = ^XPLMObjectRef;
{$ENDIF}
{$IFDEF 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.
}
XPLMDrawInfo_t = RECORD
{ Set this to the size of this structure! }
structSize : integer;
{ X location of the object in local coordinates. }
x : single;
{ Y location of the object in local coordinates. }
y : single;
{ Z location of the object in local coordinates. }
z : single;
{ Pitch in degres to rotate the object, positive is up. }
pitch : single;
{ Heading in local coordinates to rotate the object, clockwise. }
heading : single;
{ Roll to rotate the object. }
roll : single;
END;
PXPLMDrawInfo_t = ^XPLMDrawInfo_t;
{$ENDIF}
{$IFDEF 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.
}
XPLMObjectLoaded_f = PROCEDURE(
inObject : XPLMObjectRef;
inRefcon : pointer); cdecl;
{$ENDIF}
{$IFDEF 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.
}
FUNCTION XPLMLoadObject(
inPath : Pchar) : XPLMObjectRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
PROCEDURE XPLMLoadObjectAsync(
inPath : Pchar;
inCallback : XPLMObjectLoaded_f;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
PROCEDURE XPLMDrawObjects(
inObject : XPLMObjectRef;
inCount : integer;
inLocations : PXPLMDrawInfo_t;
lighting : integer;
earth_relative : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
PROCEDURE XPLMUnloadObject(
inObject : XPLMObjectRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
TYPE
XPLMLibraryEnumerator_f = PROCEDURE(
inFilePath : Pchar;
inRef : pointer); cdecl;
{
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.
}
FUNCTION XPLMLookupObjects(
inPath : Pchar;
inLatitude : single;
inLongitude : single;
enumerator : XPLMLibraryEnumerator_f;
ref : pointer) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
IMPLEMENTATION
END.
XPSDK/Delphi/XPLM/XPLMUtilities.pas
+927
View File
@@ -0,0 +1,927 @@
{
Copyright 2005-2012 Sandy Barbour and Ben Supnik
All rights reserved. See license.txt for usage.
X-Plane SDK Version: 2.1.1
}
UNIT XPLMUtilities;
INTERFACE
{
}
USES XPLMDefs;
{$A4}
{$IFDEF MSWINDOWS}
{$DEFINE DELPHI}
{$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.
}
TYPE
XPLMCommandKeyID = (
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
);
PXPLMCommandKeyID = ^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.
}
XPLMCommandButtonID = (
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
);
PXPLMCommandButtonID = ^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.
}
XPLMHostApplicationID = (
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
);
PXPLMHostApplicationID = ^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.
}
XPLMLanguageCode = (
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
{$IFDEF XPLM200}
,xplm_Language_Russian = 7
{$ENDIF}
{$IFDEF XPLM200}
,xplm_Language_Greek = 8
{$ENDIF}
{$IFDEF XPLM200}
,xplm_Language_Japanese = 9
{$ENDIF}
{$IFDEF XPLM200}
,xplm_Language_Chinese = 10
{$ENDIF}
);
PXPLMLanguageCode = ^XPLMLanguageCode;
{$IFDEF XPLM200}
{
XPLMDataFileType
These enums define types of data files you can load or unload using the
SDK.
}
XPLMDataFileType = (
{ 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
);
PXPLMDataFileType = ^XPLMDataFileType;
{$ENDIF}
{$IFDEF 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!
}
XPLMError_f = PROCEDURE(
inMessage : Pchar); cdecl;
{$ENDIF}
{
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.
}
PROCEDURE XPLMSimulateKeyPress(
inKeyType : integer;
inKey : integer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMSpeakString(
inString : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMCommandKeyStroke(
inKey : XPLMCommandKeyID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMCommandButtonPress(
inButton : XPLMCommandButtonID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCommandButtonRelease
This function simulates any of the actions that might be taken by pressing
a joystick button. See XPLMCommandButtonPress
}
PROCEDURE XPLMCommandButtonRelease(
inButton : XPLMCommandButtonID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetVirtualKeyDescription(
inVirtualKey : char) : Pchar;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{___________________________________________________________________________
* 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.
}
PROCEDURE XPLMReloadScenery;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetSystemPath(
outSystemPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetPrefsPath(
outPrefsPath : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDirectorySeparator: Pchar;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMExtractFileAndPath(
inFullPath : Pchar) : Pchar;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMGetDirectoryContents(
inDirectoryPath : Pchar;
inFirstReturn : integer;
outFileNames : Pchar;
inFileNameBufSize : integer;
outIndices : PPchar; { Can be nil }
inIndexCount : integer;
outTotalFiles : Pinteger; { Can be nil }
outReturnedFiles : Pinteger) : integer; { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMInitialized: integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
PROCEDURE XPLMGetVersions(
outXPlaneVersion : Pinteger;
outXPLMVersion : Pinteger;
outHostID : PXPLMHostApplicationID);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMGetLanguage
This routine returns the langauge the sim is running in.
}
FUNCTION XPLMGetLanguage: XPLMLanguageCode;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.)
}
PROCEDURE XPLMDebugString(
inString : Pchar);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$IFDEF 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.
}
PROCEDURE XPLMSetErrorCallback(
inCallback : XPLMError_f);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
FUNCTION XPLMFindSymbol(
inString : Pchar) : pointer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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).
}
FUNCTION XPLMLoadDataFile(
inFileType : XPLMDataFileType;
inFilePath : Pchar) : integer; { Can be nil }
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF XPLM200}
{
XPLMSaveDataFile
Saves the current situation or replay; paths are relative to the X-System
folder.
}
FUNCTION XPLMSaveDataFile(
inFileType : XPLMDataFileType;
inFilePath : Pchar) : integer;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
{$IFDEF 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.
}
TYPE
XPLMCommandPhase = (
{ The command is being started. }
xplm_CommandBegin = 0
{ The command is continuing to execute. }
,xplm_CommandContinue = 1
{ The command has ended. }
,xplm_CommandEnd = 2
);
PXPLMCommandPhase = ^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.
}
XPLMCommandRef = pointer;
PXPLMCommandRef = ^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.
}
XPLMCommandCallback_f = FUNCTION(
inCommand : XPLMCommandRef;
inPhase : XPLMCommandPhase;
inRefcon : pointer) : integer; cdecl;
{
XPLMFindCommand
XPLMFindCommand looks up a command by name, and returns its command
reference or NULL if the command does not exist.
}
FUNCTION XPLMFindCommand(
inName : Pchar) : XPLMCommandRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCommandBegin
XPLMCommandBegin starts the execution of a command, specified by its
command reference. The command is "held down" until XPLMCommandEnd is
called.
}
PROCEDURE XPLMCommandBegin(
inCommand : XPLMCommandRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCommandEnd
XPLMCommandEnd ends the execution of a given command that was started with
XPLMCommandBegin.
}
PROCEDURE XPLMCommandEnd(
inCommand : XPLMCommandRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMCommandOnce
This executes a given command momentarily, that is, the command begins and
ends immediately.
}
PROCEDURE XPLMCommandOnce(
inCommand : XPLMCommandRef);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.
}
FUNCTION XPLMCreateCommand(
inName : Pchar;
inDescription : Pchar) : XPLMCommandRef;
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
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.)
}
PROCEDURE XPLMRegisterCommandHandler(
inComand : XPLMCommandRef;
inHandler : XPLMCommandCallback_f;
inBefore : integer;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{
XPLMUnregisterCommandHandler
XPLMUnregisterCommandHandler removes a command callback registered with
XPLMRegisterCommandHandler.
}
PROCEDURE XPLMUnregisterCommandHandler(
inComand : XPLMCommandRef;
inHandler : XPLMCommandCallback_f;
inBefore : integer;
inRefcon : pointer);
{$IFDEF DELPHI}
cdecl; external 'XPLM.DLL';
{$ELSE}
cdecl; external '';
{$ENDIF}
{$ENDIF}
IMPLEMENTATION
END.