GenesisII SDK v1.0 - April/1999, updated for GenesisIV April/2005

Callback Reference

Download the Plugin SDK Development Kit

---

Introduction

  result = G2INTERFACE.GLGCreateNewGrid(NULL,x,y);

With the exception of grid point manipulation, all coordinate information is retrieved and set in terms of the current Georeference information.

Memory allocation and housekeeping functions are the responsibility of the programmer. Some function calls require that memory is allocated and passed as a pointer for holding coordinate or height information - it the programmers responsibility to ensure that the correct size block is allocated and freed as necessary.  

---

Support and Plugin Distribution

Support for GenesisIV and the SDK are available from our website at http://www.geomantics.com or by email at support@geomantics.com. Developers are encouraged to join our discussion forums on our site.

The SDK is a freeware product. Plugins created with the SDK may be used and distributed royalty-free. Both Freeware and Commercial developments are allowed.

We encourage plugin authors to make there products available to other users. We are happy to place plugins on our site for download on our plugin page at http://www.geomantics.com/plugins.htm. We are also happy to make commercial plugins available from our site and process orders for you - please contact us for terms.

---

Plugin functions

This section describes functions and data types that must be supported by the plugin.

Note that all functions are defined as DLLExport using #define DLLExport extern "C" _stdcall _export

• DescribePlugin
• InitPlugin
• RunPlugin

DescribePlugin

DLLExport void* DescribePlugin(
char* description,
int* version
);

Purpose: Returns identification string and SDK version to GenesisIV.

This is the first function that GenesisIV will call on initialization. The description string will be added to the Plugin Interface menu. The version number is included for forwards compatibility - it must be set to 1 for this version of the SDK or the plugin will be rejected.

InitPlugin

DLLExport void* InitPlugin(
G2_INTERFACE* g2,
);

Purpose: Returns list of callback functions to the Plugin.

If GenesisIV successfully identifies the plugin it will call this function to pass the plugin a data structure containing a set of callback functions. These will be subsequently used by the plugin to access GenesisIV functions and data. A typical call into GenesisIV will look like this:

result = G2INTERFACE.GLGCreateNewGrid(NULL,x,y);

RunPlugin

DLLExport int* RunPlugin(
);

Purpose: Executes the plugin function code.

This function is called by GenesisIV whenever the plugin's menu item is selected. You are responsible for all memory and resources used by the plugin.

Callback functions

Basic project/grid parameters

• GLGGetParameters
• GLGSetParameters

Working with Vegetation/Plants

• GLGGetPlantInfo
• GLGSetPlantInfo
• GLGCreateNewPlant

Deletion functions for polygons, lines and models

• GLGDeleteAllPolygonsInLayer
• GLGDeleteAllLinesInLayer
• GLGDeleteAllModelsInLayer

Working with Polygons

• GLGGetPolygonInfo
• GLGGetPolygonCoordinates
• GLGAddPolygon

Working with Lines

• GLGGetLineInfo
• GLGGetLineCoordinates
• GLGAddLine

Working with Models

• GLGGetModelInfo
• GLGAddModel

GLGGetParameters

DLLExport void GLGGetParameters(
void *self,
G2_PARAMETERS *G2Parameters
);

Purpose: Retrieves basic project and grid information.

This would normally be the first function called by a plugin. It retrieves basic information about grid size, spacing and georeferencing data - see data structures section for details. Note that the initial void pointer to self is a read only pointer used by the underlying Delphi implementation and should normally be passed as NULL. See the Data Structures section for further information on i/o and fields.

GLGSetParameters

DLLExport void GLGSetParameters(
void *self,
G2_PARAMETERS *G2Parameters
);

Purpose: Sets basic project and grid information.

Sets basic project parameters. Note that although for simplicity the same data structure is used as for GLGGetParameters some information is not updates. See data structures section for details. See the Data Structures section for further information on i/o and fields.

GLGGetViewingParameters

DLLExport void GLGGetViewingParameters(
void *self,
G2_VIEWPARAMETERS *G2ViewParameters
);

Purpose: Retrieves basic viewing information.

This function retrieves basic viewing information such as camera, target and lighting positions. For simplicity the SDK does not allow access to GenesisIV's atmospheric model. See the Data Structures section for further information on i/o and fields.

GLGSetViewingParameters

DLLExport void* GLGSetViewingParameters(
void *self,
G2_VIEWPARAMETERS *G2ViewParameters
);

Purpose: Sets basic viewing information.

This function sets basic viewing information such as camera, target and lighting positions. For simplicity the SDK does not allow access to GenesisIV's atmospheric model. See the Data Structures section for further information on i/o and fields.

GLGCreateNewGrid

DLLExport bool GLGCreateNewGrid(
void *self,
int x,
int y,
float sx,
float sy
);

Purpose: Creates a new heightfield grid.

x,y: Width (x) and Height (y) of new grid.
sx,sy: Grid point spacing in x and y directions.

This function creates a new heightfield grid. All values are set to G2_NULLHEIGHT. Returns true on success and false on failure. Maximum grid size is implementation-dependent but will be always be at least 1201 x 1201 points (USGS 1 degree dem grid size).

GLGGetPointHeight

DLLExport double GLGGetPointHeight(
void *self,
int x,
int y
);

Purpose: Retrieves grid point heights at grid position x,y.

Note that value is returned as double, but internal implementation is only guaranteed as single precision in GenesisIV 2.x. Returns -MAXINT on invalid coordinates.

GLGSetPointHeight

DLLExport void GLGSetPointHeight(
void *self,
int x,
int y
);

Purpose: Sets grid point heights at grid position x,y.

Note that value is returned as double, but internal implementation is only guaranteed as single precision in GenesisIV 2.x. Returns -MAXINT on invalid coordinates.

GLGGetPointWater

DLLExport bool GLGGetPointWater(
void *self,
int x,
int y
);

Purpose: Retrieves water attribute at grid position x,y.

Returns true if grid point is water (note this refers to lakes, sea etc. and not rivers), otherwise returns false.

GLGSetPointWater

DLLExport void GLGSetPointWater(
void *self,
int x,
int y,
bool isWater,
);

Purpose: Sets water attribute at grid position x,y.

Sets water attribute at grid position x,y to the value of isWater. Set to true for water, false for land. Note that this refers to lakes, sea etc. and not rivers.

GLGGetHeightField

DLLExport void GLGGetHeightField(
void *self,
int Size,
float *HeightField
);

Purpose: Retrieves a heightfield as an array of floats.

GLGGetHeightField retrieves the whole landscape grid in a single call as an array of floats. This is useful (and faster) when working on the whole grid rather than individual points. The programmer is responsible for ensuring that sufficient memory is allocated to retrieve the whole grid and freeing the memory when no longer required.

GLGSetHeightField

DLLExport void GLGSetHeightField(
void *self,
int Size,
float *HeightField
);

Purpose: Sets a heightfield from an array of floats.

GLGSetHeightField sets the the whole landscape grid in a single call from an array of floats. This is useful (and faster) when working on the whole grid rather than individual points. The programmer is responsible for ensuring that sufficient memory is allocated to set the whole grid and freeing the memory when no longer required.

GLGGetTerrainLayerInfo

DLLExport bool GLGGetTerrainLayerInfo(
void *self,
int LayerIdx,
G2_TERRAINLAYER *G2TerrainLayer
);

Purpose: Retrieves Terrain Layer information.

Terrain Layers information corresponds to the information controlled from the Terrain Layers editor in GenesisIV.

Returns true on success, false on failure. GenesisIV can support many terrain layers, each of which has attributes for factor such as ground color and fractalization, and plant and model placement. Terrain layers are mapped onto the landscape surface as Terrain polygons, lines and points. There is hence a one to many relationship between the landscape and the terrain layers, which in turn has a one to many relationship to polygons, lines or points.

Note that this version of GenesisIV always has 4 occurrences of the Surface (G2_SURF) and Plant (G2_PLANT) structures per terrain layer. This will most probably change in future versions of the program and SDK. See the Data Structures section for further information on i/o and fields.

GLGSetTerrainLayerInfo

DLLExport bool GLGSetTerrainLayerInfo(
void *self,
int LayerIdx,
G2_TERRAINLAYER *G2TerrainLayer
);

Purpose: Sets Terrain Layer information.

Terrain Layers information corresponds to the information controlled from the Terrain Layers editor in GenesisIV.

Returns true on success, false on failure. GenesisIV can support many terrain layers, each of which has attributes for factor such as ground color and fractalization, and plant and model placement. Terrain layers are mapped onto the landscape surface as Terrain polygons, lines and points. There is hence a one to many relationship between the landscape and the terrain layers, which in turn has a one to many relationship to polygons, lines or points.

Note that this version of GenesisIV always has 4 occurrences of the Surface (G2_SURF) and Plant (G2_PLANT) structures per terrain layer. This will most probably change in future versions of the program and SDK. See the Data Structures section for further information on i/o and fields.

GLGCreateNewTerrainLayer

DLLExport int GLGCreateNewTerrainLayer(
void *self,
G2_TERRAINLAYER *G2TerrainLayer
);

Purpose: Creates a new terrain layer.

Terrain Layers information corresponds to the information controlled from the Terrain Layers editor in GenesisIV.

GLGCreateNewTerrainLayer creates a new terrain layer using the information passed in the G2_TERRAINLAYER structure (note that the value passed in the ID field is ignored and will be set to the new ID on return). If successful the call returns the LayerIdx value for the created layer, otherwise -1 is returned if the call fails.

GLGGetPlantInfo

DLLExport bool GLGGetPlantInfo(
void *self,
int PlantIdx,
G2_PLANTPARAMETERS *G2PlantParameters
);

Purpose: Retrieves Vegetation or Plant information.

Vegetation information corresponds to the information controlled from the Vegetation editor in GenesisIV.

Returns true on success, false on failure. GenesisIV can support many plants, each of which is a 2D bitmap displayed as a billboard. Vegetation is mapped onto the landscape using the attributes of defined by Terrain layers and polygon or line placement. There is hence a one to many relation ship between the landscape and the plants, terrain layers and plants, and lines/polygons and plants.

GLGSetPlantInfo

DLLExport bool GLGSetPlantInfo(
void *self,
int PlantIdx,
G2_PLANTPARAMETERS *G2PlantParameters
);

Purpose: Sets Vegetation or Plant information.

Vegetation information corresponds to the information controlled from the Vegetation editor in GenesisIV.

Returns true on success, false on failure. GenesisIV can support many plants, each of which is a 2D bitmap displayed as a billboard. Vegetation is mapped onto the landscape using the attributes of defined by Terrain layers and polygon or line placement. There is hence a one to many relation ship between the landscape and the plants, terrain layers and plants, and lines/polygons and plants.

GLGCreateNewPlant

DLLExport int GLGCreateNewPlant(
void *self,
G2_PLANTPARAMETERS *G2PlantParameters
);

Purpose: Creates a new plant.

Vegetation information corresponds to the information controlled from the Vegetation editor in GenesisIV.

GLGCreateNewPlant creates a new plant using the information passed in the G2_PLANTPARAMETERS structure (note that the value passed in the ID field is ignored and will be set to the new ID on return). If successful the call returns the PlantIdx value for the created layer, otherwise -1 is returned if the call fails.

GLGDeleteAllPolygonsInLayer

DLLExport bool GLGDeleteAllPolygonsInLayer(
void *self,
int LayerIdx
);

Purpose: Deletes all polygons for a terrain layer.

This action corresponds to right clicking on a polygon in GenesisIV's landscape editor and selecting 'delete all polygons in this layer'.

Returns true on success, false on failure. Note that GenesisIV doesn't actually delete any polygons until the project is saved, the polygons just being flagged as deleted. However no SDK access is available to the polygons once flagged.

GLGDeleteAllLinesInLayer

DLLExport bool GLGDeleteAllLinesInLayer(
void *self,
int LayerIdx
);

Purpose: Deletes all lines for a terrain layer.

This action corresponds to right clicking on a line in GenesisIV's landscape editor and selecting 'delete all lines in this layer'.

Returns true on success, false on failure. Note that GenesisIV doesn't actually delete any lines until the project is saved, the lines just being flagged as deleted. However no SDK access is available to the lines once flagged.

GLGDeleteAllModelsInLayer

DLLExport bool GLGDeleteAllModelsInLayer(
void *self,
int LayerIdx
);

Purpose: Deletes all models for a terrain layer.

This action corresponds to right clicking on a model in GenesisIV's landscape editor and selecting 'delete all models in this layer'.

Returns true on success, false on failure. Note that GenesisIV doesn't actually delete any models until the project is saved, the models just being flagged as deleted. However no SDK access is available to the models once flagged.

GLGGetPolygonInfo

DLLExport bool GLGGetPolygonInfo(
void *self,
int PolygonIdx,
G2_POLYGONINFO *G2PolygonInfo
);

Purpose: Retrieves basic information about a polygon.

This call retrieves all information about a polygon - most importantly LayerIdx, and the number of point coordinates which define the polygon (excluding the closing point). It does not retrieve the polygon coordinates themselves as this is variable, instead the programmer should allocate memory to hold an array of floats to define the points and retrieve these by calling GLCGetPolygonCoordinates.

Returns true on success, false on failure. GenesisIV can support many polygons, each of which is assigned to a terrain layer. There is hence a one to many relation ship between terrain layers and polygons.

GLGGetPolygonCoordinates

DLLExport bool GLGGetPolygonCoordinates(
void *self,
int PolygonIdx,
G2_POLYGONINFO *G2PolygonInfo
);

Purpose: Retrieves coordinate information for a polygon.

This call retrieves all points for a polygon as an array of floats (x,y corresponding to alternate items). It is the programmers responsibility to allocate sufficient memory to hold this data before the call and free the memory once used. Failure to allocate sufficient memory may crash GenesisIV.

Returns true on success, false on failure.

GLGAddPolygon

DLLExport int GLGAddPolygon(
void *self,
G2_POLYGONINFO *G2PolygonInfo
);

Purpose: Creates a new polygon.

GLGAddPolygon creates a new terrain polygon using the information passed in the G2_POLYGONINFO structure (note that the value passed in the ID field is ignored and will be set to the new ID on return). If successful the call returns the PolygonIdx value for the created layer, otherwise -1 is returned if the call fails. The call validates the terrain layer value passed and will fail if this is not valid. As with GLGGetPolygonCoordinates it is the programmers responsibility to allocate sufficient memory to hold coordinate information.

GLGGetLineInfo

DLLExport bool GLGGetLineInfo(
void *self,
int LineIdx,
G2_LINEINFO *G2LineInfo
);

Purpose: Retrieves basic information about a line.

This call retrieves all information about a line - most importantly LayerIdx, and the number of point coordinates which define the line. It does not retrieve the line coordinates themselves as this is variable, instead the programmer should allocate memory to hold an array of floats to define the points and retrieve these by calling GLCGetLineCoordinates.

Returns true on success, false on failure. GenesisIV can support many lines, each of which is assigned to a terrain layer. There is hence a one to many relation ship between terrain layers and lines.

GLGGetLineCoordinates

DLLExport bool GLGGetLineCoordinates(
void *self,
int LineIdx,
G2_LINEINFO *G2LineInfo
);

Purpose: Retrieves coordinate information for a line.

This call retrieves all points for a line as an array of floats (x,y corresponding to alternate items). It is the programmers responsibility to allocate sufficient memory to hold this data before the call and free the memory once used. Failure to allocate sufficient memory may crash GenesisIV.

Returns true on success, false on failure.

GLGAddLine

DLLExport int GLGAddLine(
void *self,
G2_LINEINFO *G2LineInfo
);

Purpose: Creates a new line.

GLGAddLine creates a new terrain line using the information passed in the G2_LINEINFO structure (note that the value passed in the ID field is ignored and will be set to the new ID on return). If successful the call returns the LineIdx value for the created layer, otherwise -1 is returned if the call fails. The call validates the terrain layer value passed and will fail if this is not valid. As with GLGGetLineCoordinates it is the programmers responsibility to allocate sufficient memory to hold coordinate information.

GLGGetModelInfo

DLLExport bool GLGGetModelInfo(
void *self,
int ModelIdx,
G2_MODELINFO *G2ModelInfo
);

Purpose: Retrieves information about a model.

This call retrieves all information about a model. Returns true on success, false on failure. GenesisIV can support many models, each of which is assigned to a terrain layer. There is hence a one to many relation ship between terrain layers and models.

GLGAddModel

DLLExport int GLGAddModel(
void *self,
G2_MODELINFO *G2ModelInfo
);

Purpose: Creates a new model.

GLGAddModel creates a new terrain model using the information passed in the G2_MODELINFO structure (note that the value passed in the ID field is ignored and will be set to the new ID on return). If successful the call returns the ModelIdx value for the created layer, otherwise -1 is returned if the call fails. The call validates the terrain layer value passed and will fail if this is not valid.

GLGUpdateChildren

DLLExport bool GLGUpdateChildren(
void *self,
);

Purpose: Forces GenesisIV to redraw all children that might be effected by changes.

Although calls to the plugin SDK may change information in the current GenesisIV project, none of the windows that might be effected by these changes will be updated automatically - this avoids GenesisIV doing repeated redraws whilst the plugin interface is running. However once your plugin has completed it's tasks it should force a redraw if any update changes have been made by calling GLGUpdateChildren as it's final call.

Data Types and Structure

Note that items shown in italics are read-only.

//---------------------------------------------------------------------------
// ** Interface structures **
// These give access to Genesis's drawing model and fall into the following
// categories...
// 1.  Overall Project information and Grid definition
// 2.  Terrain layer definition
// 3.  Terrain structures regions, lines and points definition
// 4.  Vegetation definition
// 5.  Camera/Target/Lighting definition
// 6.  General program functionality - refresh etc.
//
// Much of this corresponds directly to the dialog structure of G2, but
// to summerize...
//
//      +---------+        +------+
//      |         |--------| Grid |
//      |         |        +------+   +------------+
//      | Project |-------------------| Atmosphere | (returned in same block)
//      |         |                   +----------- +
//      |         |-------------------|   Camera   |
//      +---------+                   +------------+
//      |         |
//      |        /|\
//      |    +-------------------------------+
//      |    |          Terrain Layers       |
//      |    +-------------------------------+
//      |             |         |         |
//      |            /|\       /|\       /|\
//      |         +-------+  +-----+  +------+
//      |         |Regions|  |Lines|  |Models|
//      |         +-------+  +-----+  +------+
//      |              |        |
//      |   +----------+        |
//      |   |     +-------------+
//      |   |     |
//     /|\ /|\4  /|\4 *region/lines limited to 4 - may change
//  +---------------+
//  |   Plants      |
//  +---------------+
//
//---------------------------------------------------------------------------

// project and grid parameter information
struct G2_PARAMETERS
{
 // grid
  int    GridWidth;          // Grid width
  int    GridHeight;         // Grid height
  double GridSpacingX;       // Grid point spacing along x
 double GridSpacingY;       // ...and y
 double MaxHeight;          // Grid max height
  double MinHeight;          // ...and min
 double VerticalScale;      // Vertical scaling
  double GeoRef[4];          // Georeferencing info, top,left:bottom,right
  // Terrain layers and vector information
  int    TerrainLayersCount; // number terrain layers
 int    PlantCount;         // number 2D plant images
 int    PolygonCount;       // Number of polygons
 int    LineCount;          // Number of lines
 int    ModelCount;         // Number of models
 // Directory paths
  char   PlantDir[256];      // Plant model directory
  char   ModelDir[256];      // 3D model directory
};

// Camera, Target etc
struct G2_VIEWPARAMETERS
{
 float  CameraPosition[3];  // camera position xyz - y is vertical
  float  TargetPosition[3];  // target position xyz - y is vertical
  double Perspective;        // perspective in degrees
  double LightAltitude;      // Altitude position of light in degrees.  90 is overhead
  double LightAzimuth;       // Azimuth position of light in degrees.    0 is North
};

// Surface definition
struct G2_SDEF
{
 float  PrimaryColor[4];    // primary and secondary color series are fractal...
  float  SecondaryColor[4];  // ...mixed to generate the surface
  double Roughness;          // surface roughness
  double Specularity;        // lighting characteristics
  int    Shininess;          //
  double Emission;           //
};

// plant used on a terrain
struct G2_PLANT
{
 int    ID;                 // ID of plant - retrieve details with
 double Size;               // size and...
  double Density;            // ...density of plants plotted
};

// terrain layer definition
struct G2_TERRAINLAYER
{
 int      ID;                     // Unique key for this layer
  bool     OverrideDefaultColor;   // Override default surface colors
  bool     OverrideDefaultSurface; // Override default surface properties (other than colors)
  bool     DrawPlants;             // Draw plants in this layer
  char     Name[256];              // Name of this layer
  bool     DrawLayer;              // polygon drawn in landscape module
  int      SurfaceCount;           // surfaces - must be 4 for for this sdk version
  G2_SDEF  Surface[4];             // Surface definition
  int      PlantCount;             // Plants - must be 4 for for this sdk version
  G2_PLANT Plants[4];              // Plant definition
  char     ModelSource[256];       // 3D model source file - relative path
  double   LineWidth;              // polyline width
  double   ModelSize;              // default model size
  double   ModelRotation;          // default model rotation
  float    LandscapeColor[4];      // color layer is drawn IN LANDSCAPE MODULE
  bool     PolygonLineOnly;        // Draw plants on polygon edges only
  bool     DrawModel;              // Draw 3D models in this layer
};

// Actor info
struct G2_PLANTPARAMETERS
{
 int      ID;             // An ID - internal use by G2 only
 char     Name[256];      // Display name for this plant
  char     FileName[256];  // BMP source file
};

// Polygon info
// Note that responsibility for allocating memory for coordinates is the plugin programmers responsibility
struct G2_POLYGONINFO
{
 int      ID;              // An ID - internal use by G2 only
 bool     Deleted;         // Deleted flag.
  int      TerrainLayerID;  // ID of terrain layer this relates to
  int      CoordinateCount; // coordinates in poly (not including closing point)
  float    *Coordinates;    // Pointer to array of floats holding x,y in georeferenced coordinates
};

// Line info
// Note that responsibility for allocating memory for coordinates is the plugin programmers responsibility
struct G2_LINEINFO
{
 int      ID;              // An ID - internal use by G2 only
 bool     Deleted;         // Deleted flag.
 int      TerrainLayerID;  // ID of terrain layer this relates to
 int      CoordinateCount; // coordinates in poly (not including closing point)
 float    *Coordinates;    // Pointer to array of floats holding x,y
};

// Model info
struct G2_MODELINFO
{
 int      ID;              // An ID - internal use by G2 only
  bool     Deleted;         // Deleted flag.
  int      TerrainLayerID;  // ID of terrain layer this relates to
  float    x;               // x,y position - georeferenced
  float    y;
 float    Size;            // Model size and
  float    Rotation;        // ...Rotation
};

// ---- Callback Interface structure returned on plugin initialization -------//
// GensisisII is largely written in Delphi and hence this structure contains  //
// some additions to the normal C/C++ definition.                             //
// The functions reference the current project object in Genesis and carry a  //
// pascal self reference value as parameter 0.  This can safely be ignored    //
// and passed as NULL for C/C++ use.  Additional BYTEs handle 'of object'     //
// flag used by equivalent Delphi record                                      //
//----------------------------------------------------------------------------//
struct G2_INTERFACE
{
 // Get/Set basic project/grid parameters
  void   _stdcall (*GLGGetParameters)(void *self, G2_PARAMETERS *G2Parameters); BYTE f0;
 void   _stdcall (*GLGSetParameters)(void *self, G2_PARAMETERS *G2Parameters); BYTE f1;
 // Get/Set viewing parameters - camera, target etc.
  void   _stdcall (*GLGGetViewingParameters)(void *self, G2_VIEWPARAMETERS *G2ViewParameters); BYTE f2;
 void   _stdcall (*GLGSetViewingParameters)(void *self, G2_VIEWPARAMETERS *G2ViewParameters); BYTE f3;
 // Create grid and Get/Set grid point properties
  bool   _stdcall (*GLGCreateNewGrid)(void *self, int x, int y, float sx, float sy); BYTE f4;
 double _stdcall (*GLGGetPointHeight)(void *self, int x, int y); BYTE f5;
 void   _stdcall (*GLGSetPointHeight)(void *self, int x, int y, double NewHeight); BYTE f6;
 bool   _stdcall (*GLGGetPointWater)(void *self, int x, int y); BYTE f7;
 void   _stdcall (*GLGSetPointWater)(void *self, int x, int y, bool isWater); BYTE f8;
 bool   _stdcall (*GLGGetHeightField)(void *self, int Size, float *HeightField);  BYTE f9;
 bool   _stdcall (*GLGSetHeightField)(void *self, int Size, float *HeightField);  BYTE f10;
 // Create/Get/Set terrain layers
  bool   _stdcall (*GLGGetTerrainLayerInfo)(void *self, int LayerIdx, G2_TERRAINLAYER *G2TerrainLayer); BYTE f11;
 bool   _stdcall (*GLGSetTerrainLayerInfo)(void *self, int LayerIdx, G2_TERRAINLAYER *G2TerrainLayer); BYTE f12;
 int    _stdcall (*GLGCreateNewTerrainLayer)(void *self, G2_TERRAINLAYER *G2TerrainLayer); BYTE f13;
 // Create/Get/Set plant info
  bool   _stdcall (*GlGGetPlantInfo)(void *self, int PlantIdx, G2_PLANTPARAMETERS *G2PlantParameters); BYTE f14;
 bool   _stdcall (*GlGSetPlantInfo)(void *self, int PlantIdx, G2_PLANTPARAMETERS *G2PlantParameters); BYTE f15;
 int    _stdcall (*GlGCreateNewPlant)(void *self, G2_PLANTPARAMETERS *G2PlantParameters); BYTE f16;
 // Deletion functions for polygons, lines and models (points)
  bool   _stdcall (*GLGDeleteAllPolygonsInLayer)(void *self, int LayerIdx); BYTE f17;
 bool   _stdcall (*GLGDeleteAllLinesInLayer)(void *self, int LayerIdx); BYTE f18;
 bool   _stdcall (*GLGDeleteAllModelsInLayer)(void *self, int LayerIdx); BYTE f19;
 // Create polygons and Get info
  bool   _stdcall (*GLGGetPolygonInfo)(void *self, int PolygonIdx, G2_POLYGONINFO *G2PolygonInfo); BYTE f20;
 bool   _stdcall (*GLGGetPolygonCoordinates)(void *self, int PolygonIdx, G2_POLYGONINFO *G2PolygonInfo); BYTE f21;
 bool   _stdcall (*GLGAddPolygon)(void *self, G2_POLYGONINFO *G2PolygonInfo); BYTE f22;
 // Create lines and Get info
  bool   _stdcall (*GLGGetLineInfo)(void *self, int LineIdx, G2_LINEINFO *G2LineInfo); BYTE f23;
 bool   _stdcall (*GLGGetLineCoordinates)(void *self, int LineIdx, G2_LINEINFO *G2LineInfo); BYTE f24;
 bool   _stdcall (*GLGAddLine)(void *self, G2_LINEINFO *G2LineInfo); BYTE f25;
 // Create lines and Get info
  bool   _stdcall (*GLGGetModelInfo)(void *self, int ModelIdx, G2_MODELINFO *G2ModelInfo); BYTE f26;
 bool   _stdcall (*GLGAddModel)(void *self, G2_MODELINFO *G2ModelInfo); BYTE f27;
 // Utility function to force update
 void   _stdcall (*GLGUpdateChildren)(void *self); BYTE f28;
};