Fly3D Documentation

Fly3D SDK 2.0 Documentation

Engine Guide

Engine Reference

Standard Plugins Guide

Standard Plugins Reference

Frontends Guide

Tutorials


Fly3D Guide

Fly3D SDK 2.0 is a 3D real-time rendering engine API, suitable for building games and all kinds of real-time 3D applications. Fly3D uses OpenGL as graphics interface for rendering, and features a powerful object-oriented simulation engine implemented in C++.

Below we discuss all the modules of the engine in greater depth:

Software Architecture
Mathematics module: flyMath
DirectX module: flyDirectx
Rendering module: flyRender
Engine module: flyEngine
Plugins
Files and File Formats
flyBspObject virtual functions
Stock and active objects
BSP recursion
Collision detection
AI and path-finding
Lighting
Cameras and scene drawing
Front-ends
Utilities


Fly3D Guide - Software Architecture

Software Architecture

The Fly3D engine architecture reflects some main motivations that were taken into account when making the early design decisions for the software. The first of them is performance: highly related methods and classes were kept tightly close and accessible in the code, avoiding unnecessary levels of indirection to get the desired piece of data. On the other hand, classes and modules which need no knowledge of each other are kept separated, for the sake of portability, stability and code security.

That explains the option of choosing C++ instead of standard C as the coding language, for the design approach shall take great advantage of the object-oriented paradigm present in C++. As a matter of fact, C++ is becoming the defacto standard in 3D games and applications programming, due to its efficiency, portability and depth as a language, and to the number of compilers available that can build really efficient assembly code out of it.

Other fundamental factors that were considered are ease-of-use and extendability. For the engine to be as versatile as it actually ended up being, design decisions had to be made about how the user could extend the engine to implement a new functionality, and how to insert the engine into the development of a new game or application. The solution was adding plugin-orientation to the engine. With this new approach, it became simpler to add a new behaviour or feature to the software without having to re-compile it all over: just make a plugin DLL and link it to the engine's main library itself. Also, a new game or application can be developed as a plugin DLL linked to the engine, being able to use all the engine's interface classes, methods and variables.

The back-end part of the software is divided into four modules: the mathematics library, the DirectX library, the rendering library and the engine library. Each of these modules are DLLs, and the first three are linked to the engine module, which is the one that integrates them into a powerful rendering and simulation tool.


Fly3D Guide - Mathematics module: flyMath

Mathematics module: flyMath

The Fly3D 2.0 mathematics module flyMath is a DLL including several classes that implement all the mathematical operations needed in the simulation. The DLL exports those classes so that the engine can use them and the operations they offer.

The flyVector class surely is the most used entity in the whole system. It represents a vector in 3D or 4D space, and its coordinates are accessed as x, y, z and w, respectively. Among the various vector operations provided are negation, normalization, length and products.

The flyMatrix class represents a 4x4 matrix that can be used as a rotation matrix. It includes several operations for rotation, along with matrix-matrix product and many others.

The flyQuaternion class implements rotation quaternions, and include operations like rotations and matrix-to-quaternion and quaternion-to-matrix conversions.

The flyMath library also features two other classes: flyPlane, which represents a plane in 3D space, storing its normal and distance to the origin values, and flyVertex, which represents a vertex with texture coordinates, normal and color.

Examples of common math operations are:

flyVector v1(1); // initialize to (1,1,1,1)
flyVector v2(2,2,2); // initialize (2,2,2,0)
flyVector v3(0,1,0,1); // initialize (0,1,0,1)

flyVector v=v1+v2*v3; // v=(1,3,1,1);

float distance=(v1-v2).length();
float dotprod=FLY_VECDOT(v1,v2);

v.cross(v1,v2); // sets v to cross product of v1 and v2

flyMatrix m;
m.set_rotation(10,flyVector(0,0,1)); // set to a rotation matrix of 10 degrees
  around z axis

v.vec(1,2,3); // sets v to (1,2,3,0)
v.normalize(); // set v to unit length

v=v*m; // rotate vector v with matrix m


Fly3D Guide - DirectX module: flyDirectx

DirectX module: flyDirectx

flyDirectX is a DLL that works as an interface between the DirectX API and Fly3D. It is the only module that has access to the data structures and operations provided by DirectX. The library implements classes that deal with input, sound and multiplayer gaming.

The main class of the library is the flyDirectx class, and a global instance of that class, g_flydirectx, is available. Through g_flydirectx, we can check for input from the keyboard or mouse, add a new sound to the simulation, access multiplayer information, join and create multiplayer games, and so forth. The g_flydirectx variable is declared in flyDirectX.h as follows:

// global flyDirectx instance
extern FLY_DIRECTX_API flyDirectx *g_flydirectx;

Please note that the coherence of the g_flydirectx variable is conditioned to the use of two functions, fly_init_diretcx and fly_free_directx, before the simulation starts and after it finishes, respectively. These two functions are declared in flyDirectX.h as follows:

// global DirectX initialisation method
FLY_DIRECTX_API void fly_init_directx(HWND hwnd,HINSTANCE hinst);
// global DirectX release method
FLY_DIRECTX_API void fly_free_directx();


Fly3D Guide - Rendering module: flyRender

Rendering module: flyRender

flyRender DLL is the engine's rendering module. It takes care of all operations and data structures related to the rendering task, using OpenGL as the graphics API. The DLL exports its main class, flyRender, and a global instance of that class, g_flyrender, allowing full access to its functionality. It is declared in flyRender.h as follows:

// global flyRender instance
extern FLY_RENDER_API flyRender *g_flyrender;

Two functions are provided to initialise and free all the flyRender resources: fly_init_render and fly_free_render, respectively. These two functions are declared in flyRender.h as follows:

// global render manager initialisation method
FLY_RENDER_API void fly_init_render(HWND hWnd,HINSTANCE hInst);
// global render manager release method
FLY_RENDER_API void fly_free_render();

The flyRender class holds all the rendering configuration variables, like the color-depth and the number of available texture units, and offers a great number of methods related to rendering, like setting the full-screen mode, drawing text on screen and enabling or disabling 2D and 3D drawing.

The rendering module provides two more classes: flyPicture, which is used to store images loaded from TGA or JPEG files, and flyTexCache, available through the global variable g_flytexcache, which implements a texture management unit for applying textures to objects upon rendering. The g_flytexcache global variable is declared in flyTexCache.h as follows:

// global flyTexCache instance
extern FLY_RENDER_API flyTexCache *g_flytexcache;


Fly3D Guide - Engine module: flyEngine

Engine module: flyEngine

flyEngine DLL is the engine's main module. It represents an interface between plugins and the back-end modules. This DLL implements several classes and lots of useful methods that handle the per-frame update of the application state and coordinate the various plugins, giving each of them a chance to add its functionality to the simulation. It also includes the several offline phases required to load a scene, initialize plugins and objects and start the simulation from a valid initial state.

The engine module is characterized mainly by the flyEngine class, which encloses the most vital data and methods of the engine, like data loading, lighting calculus and BSP recursion functions, as well as the BSP tree itself, geometry data in the form of vertices and faces and all the simulation global parameters. We can access the data and use the methods in this class via its global instance, called g_flyengine and available throughout all the structure of the application. This object is declared in fly3d.h as follows:

// global flyEngine instance
extern FLY_ENGINE_API flyEngine *g_flyengine;

An important remark concerning the use of the g_flyengine object is the following: we must use the global functions fly_init_engine and fly_free_engine to initialise it before the simulation starts and to release it after everything is over, respectively. These functions will assure that all necessary resources are allocated to the engine prior to using it and free any resources it allocated in the past. The two functions are declared in fly3d.h as follows:

// global engine initialisation method
FLY_ENGINE_API void fly_init_engine(HWND hWnd,HINSTANCE hInst,int appid=FLY_APPID_NONE);

// global engine release method
FLY_ENGINE_API void fly_free_engine();

Besides the robust flyEngine class, there is a high number of other important classes exported by this DLL. The most important of them is the flyBspObject class, implementing a generic entity which exists in the BSP tree. This class derives from three other classes, using important attributes from them: from flyParticle, it inherits mass, position, velocity, bump factor and many other physical entities responsible for positioning and movement; from flyLocalSystem, it inherits an orthonormal coordinate system and rotation matrix to be used as its orientation relative to the world; and from flyBaseObject, it inherits name and other entity identification properties. Every object implemented in the plugins that exists in the BSP must derive from flyBspObject and re-implement its virtual functions. A complete list of the classes in this DLL can be found in the engine reference documentation.

The flyEngine module also implements some general-use utility classes, like flyString, flyArray and flyFile. flyString is a variable-size string class, which auto-manages its memory space, implements concatenation, automatic char pointer conversion, character and substring search, comparison with another string, and much more. flyArray is a template variable-size array class, which also auto-manages its memory space, implementing insertion, deletion and indexation. flyFile is a file management class which handles binary and text files, implementing string, integer and floating point reading, fast profile reads (%s=%s type data), and also handles zip compressed data files allowing direct access without the need of extracting the data packs.


Fly3D Guide - Plugins

Plugins

The Fly3D engine and SDK is fully plugin-oriented. Any extension of its functionality, being it a utility, a new frontend or an entire new game or application, can be implemented as an independent plugin, in the form of a DLL. This way, we do not need to re-compile the engine or any other piece of code that does not belong to our plugin.

A Fly3D plugin can be of three types: an object repository plugin, a processing plugin or a compound plugin. An object repository plugin enumerates any number of flyBspObject-derived classes, each of them implementing the flyBspObject virtual functions and exporting any number of parameters of predefined types. A processing plugin does not define any classes; instead, it implements its funcionality through the fly_message DLL-exported method, which the engine calls whenever it wants the plugins to run (for example, upon initialisation or closing of the scene, and to update and draw the state of the application on every frame). A compound plugin merges the two types described above into a single DLL. We can build an entire game in a single plugin, but it is advisable to divide it into different modules to reuse the code and facilitate maintenance and bug-catching.

Every Fly3D plugin must implement and export some functions to be used by the engine. One of them has already been mentioned:

The get_version function must return the version of Fly3D that the plugin belongs to and is optional (not including it will disable the plugin version check done by the engine and might crash when loading old plugins in newer enegine releases). Here is its implementation:
__declspec( dllexport )
int get_version()
{ return FLY_VERSION_NUM; }
The num_classes function must return the number of flyBspObject-derived classes implemented in the plugin. The following is an example for a plugin implementing a single class:
__declspec( dllexport )
int num_classes()
{ return 1; }
The get_class_desc function must return a pointer to a flyClassDesc derived object containing a description for each class implemented in the plugin. Here is an example for a simple object called myobject:
myobject_desc cd_myobject;

__declspec( dllexport )
flyClassDesc *get_class_desc(int i)
{
switch(i)
{
case 0: return &cd_myobject;
default: return 0;
}
}
The fly_message function is called by the engine during the simulation to notify the plugin of the initialisation of the scene, closing of the scene and also inform the plugins every frame to update it's state, draw itself in 3D and then in 2D. Follows a draft of the implementation with the predefined messages (custom plugins can define new message types):
__declspec( dllexport )
int fly_message(int msg,int param,void *data)
{
switch(msg)
{
case FLY_MESSAGE_INITSCENE:
...
break;
case FLY_MESSAGE_UPDATESCENE:
...
break;
case FLY_MESSAGE_DRAWSCENE:
...
break;
case FLY_MESSAGE_DRAWTEXT:
...
break;
case FLY_MESSAGE_CLOSESCENE:
...
break;
}
return 1;
}
The get_global_param_desc function must enumerate all global parameters in the plugin, filling a flyParamDesc object for each of them, all inside a switch block, and return the total number of global parameters (a plugin global parameter is one that is shared by all the classes in the plugin). Here is an example of a single global parameter called myint of type integer ('i' parameter type):
int myint=0;

__declspec( dllexport )
int get_global_param_desc(int i,flyParamDesc *pd)
{
if (pd!=0)
switch(i)
{
case 0:
pd->type='i';
pd->data=&myint;
pd->name="myint_name";
break;
}
return 1;
}


Fly3D Guide - Files and File Formats

Files and File Formats

Fly3D designers have defined a big number of file formats that enclose different types of useful data to be processed by the engine during scene loading and the simulation. A technical description of each file format, enumerating every piece of data inside them, is available in the 'util' folder in the Fly3D installation directory. Here is a list of all file types and a comprehensive description of each of them:

Map File (.fmp)

This is the raw scene information file type. It contains the 3D coordinates of all the vertices and faces that compose the geometry of the scene, and is the main data file used in the build process. A .fmp file should be produced by a 3D modelling application.

Entities File (.fen)

This file contains information on all the scene entities: their position and specific attributes. These 'entities' can be, for example, power-ups or light sources. The .fen file is generated by the 3D modelling tool, and used in the build process to generate the Fly3D scene file (.fly).

BSP File (.bsp)

This file format encloses the BSP tree itself. The data inside it is divided into nodes, where each node can be an internal node (defining a portal that divides the space between positive and negative) or a leaf node (which by definition is a convex volume). This file is generated by the build process and is loaded by the engine before the simulation starts.

Lightmaps File (.lmp)

This is the light maps data file. It encloses light map pictures that can have any number of lightmaps inside them, and the lightmaps themselves. Light map pictures must always be power of 2, and it is desired that they are square; light maps, however, can be of any size. These files are produced in the build process, and are loaded by the engine upon initialisation of a scene, to statically illuminate the environment.

Shaders File (.shr)

This is the shaders information file. It stores any number of shaders with its passes and the variable values for them. A .shr file is created by the build process, storing shaders information from the scene's faces. A shader file is also created upon exporting mesh files (.f3d and .k3d), defining shaders for the mesh's materials. The shader files are loaded by the engine whenever its corresponding scene or mesh object is loaded.

Visibility File (.pvs)

This is the visibility information file. It stores visibility flags between all pairs of leaf nodes in the BSP. This file makes PVS culling possible during the simulation. It is created by an algorithm inside the build process, and is loaded upon initialising its corresponding scene file.

Portals File (.fpt)

This is the portals information file. In this context, portals are polygons that link a pair of convex volumes (BSP leaf nodes). This data is needed by the path-finding algorithm, making it possible for an entity to move from a convex volume to another. The .fpt file is created by an algorithm inside the building program, and is loaded together with its corresponding BSP file.

Fly3D Scene File (.fly)

This is the scene information file. It includes values for all the variables of the engine, from global to plugin-specific data. Every entity present in the scene must be included in the .fly file, with all its parameters. The .fly file is created by the building process, from information in the .fen and .ctp files. It is the main file opened by the front-ends, and includes a field called 'bspfile', referencing the BSP that should be loaded.

Static and Vertex-Animated Mesh File (.f3d)

This is one of the two file types that represent Fly3D mesh objects. A .f3d file encloses a static (non-animated) or a vertex-animated mesh file, consisting of an array of vertices, an array of faces and an array of vertices for each animation key frame (if animated). This file is generated by a 3D modelling tool and is loaded when any object using the mesh is inserted in the simulation.

Bone-Animated Mesh File (.k3d)

This is the second file type that represents mesh objects. A .k3d file encloses a bone-animated mesh object, consisting of arrays of vertices, faces and bones, and an array of bones matrices for each animation key frame. This file is generated by a 3D modelling tool that supports skeletal animation, and is loaded when any object using the mesh is inserted in the simulation.

Class Templates File (.ctp)

This is a template file that enumerates entities as they are inserted in the scene by the 3D modelling tool. It is useful for mapping the tool's entites to Fly3D objects, such as lights, power-ups, etc. It must be generated manually when creating a new game template and is opened by the build program when converting the entities enumerated in the .fen file.


Fly3D Guide - flyBspObject virtual functions

flyBspObject virtual functions

Every object that exists in the BSP must derive from the flyBspObject class. This way, it inherits the flyParticle, flyLocalSystem and flyBaseObject properties, all of which are flyBspObject parent classes. Also, the object inherits all the flyBspObject methods, having to implement a default constructor and a copy-constructor, and re-implement some vitual functions that allow the object to update its state, draw itself whenever required, and much more. Below is a list of these functions and a description of what they should implement:

default constructor

my_class():
var1(0),
var2(0),...

The default constructor must assign initial values to the class' member variables. In the example above, the 0's must be replaced by the initial value of each variable. This constructor is necessary to assure that a recently instantiated object does not contain invalid data that could cause a crash in the system.

copy-constructor

my_class(const my_class &in):
flyBspObject(in),
var1(in.var1),
var2(in.var2),...

The copy-constructor must copy all the member variable values from the given source object. Also, it must call the copy-constructor of all the parent classes (in the example above, the flyBspObject class). Note that we must not copy pointers from the source object; instead, we should allocate additional memory for new pointers, and copy the data from the source's pointers.

init

void init()

Unlike the constructor, this function is called whenever the object is activated in the simulation (for more information on activating objects, see the stock and active objects section). It should implement the initialisation and validation of all the object's attributes, and any other measure that should be taken upon inserting an object in the simulation.

step

int step(int dt)

For all active objects, this function is called by the engine once per frame. It must implement whatever your object needs to do to update its state every frame. For example, an object that represents the player should check for input; one that moves around should update its position and velocity; and so on.

draw

void draw()

This function is called by the engine to require that the object draws itself. If we wants its object to show up whenever a camera is facing it, we should implement drawing with OpenGL in this function. It is important to observe that, unlike the step function, the draw function might be called more than once in the same frame, in the case that two different viewports or cameras are seeing the object. Therefore, we should not implement any state update in the draw function, leaving it in the step function, or that piece of code could run twice in a frame.

draw_shadow

void draw_shadow()

This function is called by the engine to require that the object draws its shadow. Like the draw function, it can eventually be called more than once per frame, in the case where two or more viewports are seeing the shadow. The draw_shadow function can use the draw_shadow_volume function of the object's mesh instance (a flyMesh object).

get_mesh

flyMesh *get_mesh()

This function must return a pointer to the object's mesh instance, if any. It is called by the engine whenever it needs information on the mesh's structure.

clone

flyBspObject *clone()
{ return new my_class(*this); }

This function is called by the engine whenever it needs to make a copy of the object. It should be implemented exactly like the example above, calling the copy-constructor of the object and returning the newly allocated pointer.

message

int message(const flyVector& p,float rad,int msg,int param,void *data)

This function is used for communication between objects in the simulation. Our object should implement it to be able to receive messages about events that occurred in the simulation. The engine can also send a message to an object via this function. An example of the use of message is dynamic lighting: the lights send a message to all the nearby objects; if an object wants to be lit, it must implement the message function and receive the FLY_OBJMESSAGE_ILLUM message.

get_custom_param_desc

int get_custom_param_desc(int i,flyParamDesc *pd)

This function is used by parameter-editing applications (like flyEditor). It should fill a parameter description object (an instance of the flyParamDesc class) for each user-editable parameter in the object. The function must do so by switching the i parameter value, and must always return the total number of editable parameters in the object (many examples of the implementation of get_custom_param_desc are given in the plugins available together with the engine).

ray_intersect

flyMesh *ray_intersect(const flyVector& ro,const flyVector& rd,flyVector& ip,float& dist,int &facenum)

This function should implement ray-intersection against the object. We may want to make the intersection with the object's mesh, or maybe just with its bounding box. This function must compute the intersection point and face, and return the intersected mesh (a pointer to a flyMesh object).

ray_intersect_test

int ray_intersect_test(const flyVector& ro,const flyVector& rd,float dist)

This function resembles the last one, but it is actually just a test for intersection; it should be quicker than ray_intersect, just testing if any intersection occurs and returning true or false, not computing intersection point or face.


Fly3D Guide - Stock and active objects

Stock and active objects

During the simulation process, many objects can be inserted in the scene; for example, when a shooter-game player fires his gun, a projectile must be added to the game, with its starting position and velocity given by the position of the gun and by characteristics of that projectile; once hitting a surface (an enemy or a wall), the projectile must be removed from the game, and maybe an explosion object should be inserted on the spot where the projectile collided. And of course, multiple copies of the same object (say, the gun's projectile) could exist in the simulation at the same time. Therefore, all this adding and removing of objects must be handled in a way that each copy of a given object has its own parameter values, and is controlled independently of the other copies. Also, when a copy of the object is inserted in the simulation, it must retain the original values for that kind of object, that is, the previously inserted objects cannot change the original values for that kind of object.

This coherence is achieved by always maintaining a stock object, which has the original properties and parameter values for that kind of object. Then, to add a new copy of that object into the simulation, the engine uses the clone function (see the virtual functions section) to make a copy of the stock object, and then inserts that copy into the environment. The added copy of the object is called an active object, as the act of inserting an object is called activation. This way, several active copies of the same object will each have its own parameter values changing over time, and the original stock object will remain unchanged, so that further activation of new copies of the object can occur by making a clone of the stock object.


Fly3D Guide - BSP recursion

BSP recursion

A BSP tree is the basic data structure onto which a Fly3D scene is built. It uses planes existent in the geometry of the environment to recursively split the 3D space into positive and negative sides. In the end, each leaf of the BSP tree represents a convex volume in the scene. A full-length explanation of the BSP technology and apparatus used in Fly3D 1.0 is available in

WATT, A. & POLICARPO, F. 3D Games, Vol. 1 - Real-Time Rendering and Software Technology. England: Addison-Wesley, 2000.

Fly3D 2.0 BSP technology and implementation is fully described in

WATT, A. & POLICARPO, F. 3D Games, Vol. 2 - Advanced Techniques. England: Addison-Wesley, 2001.

One of the main uses of the BSP is that it allows fast polling techniques. The BSP recursion functions offer a fast and accurate way of searching for objects or other entities in the scene 3D space. There are several kinds of recursion functions, but all of them fill up an array of selected BSP leaf nodes (selnodes) and an array of objects that are inside or clip at least one of these nodes (selobjs). The recursion functions and the arrays mentioned before are accessible via the global variable g_flyengine (more on this variable in the Engine module section).

The different flavours of recursion functions are described below:

void recurse_bsp(const flyVector& p,float rad,int elemtype,int pvsleaf)

This function recurses the scene searching for all objects or nodes inside the sphere centered at p with radius rad. The elemtype parameter can be used to restrict the search to a specific type of object; if set to -1, no restriction will be made. The pvsleaf parameter is the index of a PVS leaf that can be used to restrict the search to nodes that are visible from the specified leaf; ommit it if this option is unwanted.

void recurse_bsp(const flyVector& p1,const flyVector& p2,int elemtype,int pvsleaf)

This function recurses the scene selecting objects and nodes intersected by a ray casted from point p1 to p2. The remaining parameters are the same as in the above function.

void recurse_bsp(const flyVector *p,int np,int elemtype,int pvsleaf)

This function recurses the scene selecting objects and nodes clipped by the volume defined by the first np points in the p array. The remaining parameters are the same as in the above function.

void recurse_bsp_box(const flyVector& min,const flyVector& max,int elemtype,int pvsleaf)

This function recurses the scene selecting objects and nodes clipped by the box defined by the points min and max. The remaining parameters are the same as in the above function.


Fly3D Guide - Collision detection

Collision detection

Collision detection is the act of detecting that two objects intersect or "touch" each other. It is a crucial step in physically-based simulation. It is a separate task from collision response, which is the act of taking some providence given the fact that two objects collide, and is an application-dependant routine.

Fly3D engine offers 2 general-usage collision methods, accessed via the global variable g_flyengine:

collision_bsp

int collision_bsp(const flyVector& p1,const flyVector& p2,int elemtype)

This function computes the closest collision between the 3D-space points p1 and p2, assigning values to the engine variables hitobj (the object that was hit), hitmesh (the mesh that was hit), hitip (the exact 3D-space point of intersection), hitdist (the distance from p1 to the collision point), hitface (the face where the collision occured), hitsubface (triangular hit face, in the case that hitface is a compound face), hitnormal (the direction of reflection) and hitshader (shader applied to the hit face). The elemtype parameter can be used to restrict the collision to a given type of object, or can be ommited for no restriction. This function returns 0 for no collisions, 1 for collision.

collision_test

int collision_test(const flyVector& p1,const flyVector& p2,int elemtype)

This function returns once it finds a collision between p1 and p2. It is much quicker than collision_bsp, but serves just to test for collisions, not computing the variables mentioned in the above function. The elemtype parameter is the same as in collision_bsp. This function returns 0 for no collisions, 1 for collision.

For moving objects, Fly3D offers a different collision method in the flyBspObject class, and this function behaves differently depending on the value of the object's collide variable (inherited from flyBspObject):

box_collision

int box_collision(flyVector& destpos,flyVector& destvel,int maxcol)

The destpos and destvel parameters are vectors that contain the desired destination position and velocity of the moving object. maxcol is the maximum number of collisions to be computed, and the default value is 3. box_collision will automatically change the value of these parameters if it finds a collision, reflecting the object according to its bump and friction values (for more on these, see below). The basic behaviour of box_collision depends on the collide variable value: if 0, no collision is computed and the functions returns immediately; if 1, collision is computed using the object's axis-aligned bounding box, which is REALLY fast and acceptable in many applications; if 2, collision is computed using the object's mesh itself, which can be very expensive, depending on the mesh's complexity. This function returns 0 for no collisions, 1 for collision.

Fly3D also offers particle-like collision response, that is, an object can collide on walls and bump like a particle. To do so, we must assign proper values to the bump, friction and colflag variables of the object (it inherits them from the flyParticle class), in this manner:

bump is a floating point value between 0 and 1. It represents the bump factor of the object's surface material (0 for completely inelastic collision, 1 for perfectly elastic collision).

friction is also a floating point value between 0 and 1. It represents the friction factor of the object's surface material upon colliding with walls (0 for infinite friction, 1 for no friction).

colflag is an integer variable. Assign 0 for no collision or 1 for collision. It can also assume the special value 3, meaning that this object must die upon colliding for the first time.


Fly3D Guide - AI and path-finding

AI and path-finding

Artificial Intelligence plays a major role in a game. Intelligent opponents are no news to pc gamers, but AI is finding its way into other kinds of 3D applications as well. Therefore, Fly3D engine offers the basic structures and methods which we need to build an AI engine for our application.

The lowest level of 3D games' AI consists in the ability to find a path between two points in the 3D environment, or simply path-finding. Fly3D offers a path-finding routine in the flyEngine class (accessible via the g_flyengine global variable), described below:

find_path

int find_path(const flyVector &source,const flyVector &sourcedir,float sourceradius,const flyVector &dest,flyBezierCurve &curve)

This function finds a path from the position source to the position dest, given in 3D space. sourcedir is a normal vector indicating the direction which the object is facing, and sourceradius is the radius of the source object, used to build a path that does not make the object hit a wall. The resulting path is stored in the parameter curve, which is a Bezier curve in 3D space. The function uses the A* algorithm, with the convex volumes formed by the BSP as states. This way, the generated path does not hit any walls. Furthermore, the path is smoothed, by having unnecessary waypoints taken out and by applying a curve transformation to it. The find_path function returns 1 if there is a path between the two points, 0 otherwise.

At a higher level, AI must handle behaviours. In this phase, AI engineers often choose to use a structure called Finite State Machine (FSM). Fly3D offers a generic FSM class called flyStateMachine in the Engine module. It includes states, inputs, an array of transition rules, methods for transition, and much more.


Fly3D Guide - Lighting

Lighting

Lighting is one of the most useful resource of rendering, being crucial for the depth and realism of the environments. Therefore, Fly3D offers a handful of options for lighting a scene, from lightmaps to vertex lights. Also, shadowing is available through pre-calculated static shadows and stencil technology for dynamic shadows.

The first distinction that must be made is about lightmap-illuminated faces and vertex lights. A lightmap is a texture that represents the lighting that apply over the faces which it is mapped on, and are blended with the original texture of the face. It sure is the most used lighting technique for huge structures and surfaces. Vertex lighting is the technique of calculating the incidence of light on each vertex and interpolating between vertices to light the whole surface. It suits best for detailed triangular objects, as it is more expensive than having all the lighting pre-calculated and stored in a lightmap.

Fly3D features lighmap lighting for structural faces and detail large faces; detail triangular faces, curved surfaces and meshes pertaining to dynamic objects use vertex lighting.

Another important distinction concerns static and dynamic lights. Static lights are light sources with a fixed position, color and illumination radius, known at build time; these are pre-calculated and stored in the lightmaps, for faces with lightmaps applied to them; vertex light objects that do not move have their static lighting calculated at loading time; moving vertex light objects must calculate lighting from static light sources every frame during the simulation. Dynamic lights can move, change their color or illumination radius; lightmap pixels of faces with lightmaps applied must be sampled by dynamic lights every frame; vertex light objects must have a flyLightVertex member variable to store dynamic lights applying on them.

When implementing dynamic lighting, decision must be taken whether the light source should look around for objects inside its radius or the objects shuold look for nearby lights. This depends on various factors, one of the strongest of them being the number of lights and objects that exist: if there are far more lights than objects, then the objects should look for lights around them; if there are far more objects than lights, it would be faster to have the lights look for objects around them.

Fly3D scenes also feature automatic ambient lighting. Every BSP leaf node has a corresponding ambient light, which is calculated as the average of all lightmap pixels of the lightmaps applied to the node's faces. The ambient light applied to an object is then computed as the average of the ambient lights of all nodes clipped by the object.

Shadowing

Another important feature to provide depth and realism to the scene is shadowing. For faces that have lightmaps, shadows are pre-calculated at build time from static light sources; no shadows can be computed from dynamic light objects. For vertex light objects, stencil shadows can be used to cast a shadow from the closest light source, being it static or dynamic.


Fly3D Guide - Cameras and scene drawing

Cameras and scene drawing

Fly3D engine is a real-time rendering tool. It offers various options for rendering the scene from different angles. During the simulation, it renders the scene from a determined view point several times per second.

The point from which the scene will be drawn is defined by the cam engine variable. Any object derived from flyBspObject can be assigned to this variable, and the scene will be drawn according to the position of this object, and to the direction it is facing (which is the negation of the object's local system's Z axis).

Here are some methods related to cameras and scene drawing:

set_camera

void set_camera(flyBspObject *d)

This method is used to set the engine's current camera. The camera object set by this method is used in the draw_bsp method. Besides seting the cam variable, the set_camera methos also instantiates the model view and projection matrices and the viewport vector for the camera, and creates the corresponding view frustum.

draw_frame

void draw_frame()

This is a method for drawing the whole frame. The engine calls it whenever it is time to render the current simulation frame. draw_frame sends messages to all loaded plugins, telling them to draw themselves. This method also sends 2D drawing messages to the plugins.

draw_bsp

void draw_bsp()

This method draws the scene as viewed by the engine's current camera. The camera must be set using the set_camera method. The engine then renders the scene from the camera, using PVS and view frustum culling.

draw_frame_pic

int draw_frame_pic(flyPicture& p,flyBspObject *camera,float camangle,float aspect)

This method implements render-to-picture technology. It renders the scene viewed from the camera object in the camera parameter and stores the resulting image in a flyPicture object. The camangle and aspect parameters can be ommited, and in this case the value of the engine's variables of the same name will be used instead.

draw_frame_subpic

int draw_frame_subpic(flyPicture& p,int x,int y,int sizex,int sizey,flyBspObject *camera,float camangle,float aspect)

This method is a modified render-to-picture routine, where just a piece of the whole image is rendered. The x and y parameters are the position, and the sizex and sizey parameters are the offset of the render window inside the original image.

draw_frame_tex

int draw_frame_tex(int tex,flyBspObject *camera,float camangle,float aspect)

This method is similar to the draw_frame_pic function, but it implements render-to-texture instead. The rendered image is stored over a texture in the engine's texture cache. The texture over which the image will be saved is given by the index parameter tex. Rendering to textures is much faster than rendering to pictures, for in the first all operations are performed by the video card itself.

draw_frame_subtex

int draw_frame_subtex(int tex,int x,int y,int sizex,int sizey,flyBspObject *camera,float camangle,float aspect)

This method is similar to the draw_frame_subpic function, but it implements render-to-texture instead.


Fly3D Guide - Frontends

Front-ends

Besides the SDK itself, Fly3D also offers a great number of front-end applications, that serve inumerous purposes. There are fornt-ends for adding, deleting and editing entities, manipulating shader effects, configuring the system, and much more. A complete list of these applications and a description of each of them is found below:

flyFrontend.exe

This is the main front-end application of the engine. It consists of a rendering window, where simulation occurs, and a menu for opening .fly files. The full-screen mode is a great way to see exactly what your game or application looks like. By pressing F1 while in this front-end, we can run a menu where we can choose single or multi-player modes, load a .fly file and start a simulation, or play a pre-recorded demo file (for more information on .fly files, see the Files and File Formats section). FlyFrontend also features a huge list of options, like switching texture filtering modes, mip-mapping, wireframe mode, mute, turning the PVS culling on or off, taking a screenshot, and much more. Here is a list of all the options:

F1: Menu
F2: Mute
F3: Record Demo
F4: Take Screenshot
F5: Node-only Mode
F6: PVS Toggle
F7: Mip-Mapping Toggle
F8: Texture Filtering Toggle
F9: Multitexture Toggle
F10: Stencil Toggle
F11: Wireframe Toggle
F12: Clear Background

flyEditor.exe

This is the main editing tool in Fly3D. It consists of a tree-view, where all entities of the scene are displayed and categorized; a list-view, where parameters are shown and edited; and a rendering window, where we can see our game or application in action. flyEditor allows on-the-fly parameter change visualization, that is, we change a value in the list-view and see the results in the rendering view. We can also load additional plugins to use in our game or application, add and delete entities, modify existing ones, and save a .fly file with all these configurations.

flyShader.exe

This is the shader effects editing tool. With it, we can load the entire shaders list (a .shr file) of a given scene, edit the effects and see the shader in action in the rendering window. We can also load a .f3d mesh object, edit its shader and see it animating. For more information on .shr and .f3d files, see the Files and File Formats section. We can even apply vertex programs to the mesh, using a script file. flyShader features all the possible shader effects for a maximum of 8 shader passes, with alpha channel blending, RGB generation functions, animation maps consisting of various key-frames, scrolling, rotation and scaling of textures, environment mapping, texture clamping, and much more.

flyServer.exe

This is the stand-alone console multi-player server. We should call it from within flyFrontend, through the 'Multiplayer' menu option, to create a server for the desired scene. Then, players connect to the server using the 'connect' console command or from the flyFrontend menu.

fly3d.ocx

This is Fly3D ActiveX Control. With it, the whole Fly3D Engine is available for in-browse applications, such as Web 3D games, 3D browsing, 3D virtual shopping, 3D presentations, and much more. We just needs to build a HTML file with Fly3d.ocx inside it, and use the control's commands to load .fly files and start the 3D simulation. More about .fly files in the Files and File Formats page.


Fly3D Guide - Utilities

Utilities

Fly3D offers some useful utilities that extend its functionalities, properly configure Fly3D for the machine and make an interface with third-party software. Here is a complete list of these utilities and their respective description:

flyConfig.exe

This is the Fly3D configuration application. It enumerates all available video modes for us to choose from, and offers a great number of rendering, profile and keyboard customization options. It is run automatically upon installation of the SDK, but must be re-run whenever we change our video configuration.

flyBuilder.exe

This is the scene-building tool for Fly3D. From a .fmp file, it creates the corresponding BSP tree (.bsp file), saves the shaders of all the scene faces in a .shr file, statically illuminates the scene generating lightmaps (.lmp files), calculates visibility for PVS culling (.pvs file), generates portals information for the AI module (.fpt file) and builds a .fly file from a class template file (.ctp file). For more information on these file types, see the Files and File Formats section. It also includes a huge list of options for building the scene with different BSP grid sizes, lightmap and texture quality, lighting parameters, and much more. Actually, flyBuilder.exe is just a friendly interface for building scenes: internally, it calls the flyBuild.exe program, which is responsible for all the processes mentioned above.

flyFonts.exe

This is a font texture generation program. We should use it to generate font textures with given patterns and sizes, to use them in our application. The Render Module offers text drawing routines, where a font texture should be selected.

flyInstPlugins.exe

This is a plugins installation program. It install Fly3D Plugin Wizard for Visual C++ and the import and export plugins for 3D Studio MAX 3.x or 4.x. See details below.

flyPlugin.awx

This is the Fly3D Plugin Wizard for Visual C++ 6.0. Once installed, a new project option will be available in Visual C++, with a step-by-step plugin creation wizard. flyPlugin.awx should be installed through the flyInstPlugins.exe program.

flyExpFMPx.dle

This is the .fmp file exporter plugin for 3D Studio MAX. We can build our scenes in MAX and use this plugin to save a Fly3D Map file. See more about .fmp files in the Files and File Formats section. The 'x' in flyExpFMPx.dle means the version of MAX which this plugin was compiled to. flyExpFMPx.dle should be installed through the flyInstPlugins.exe program.

flyExpF3Dx.dle

This is the .f3d file exporter plugin for 3D Studio MAX. We can build our mesh object in MAX and use this plugin to save a Fly3D Object file, which supports static and vertex-animated models. See more about .f3d files in the Files and File Formats section. The 'x' in flyExpF3Dx.dle means the version of MAX which this plugin was compiled to. flyExpF3Dx.dle should be installed through the flyInstPlugins.exe program.

flyExpK3Dx.dle

This is the .k3d file exporter plugin for 3D Studio MAX. We can build our mesh object in MAX and use this plugin to save a Fly3D Skeletal Object file, which supports bone-animated models. See more about .k3d files in the Files and File Formats section. The 'x' in flyExpK3Dx.dle means the version of MAX which this plugin was compiled to. flyExpK3Dx.dle should be installed through the flyInstPlugins.exe program.

flyImpFMPx.dli

This is the .fmp file importer plugin for 3D Studio MAX. We can open our previously-created Fly3D Map file using this plugin. See more about .fmp files in the Files and File Formats section. The 'x' in flyImpFMPx.dli means the version of MAX which this plugin was compiled to. flyImpFMPx.dli should be installed through the flyInstPlugins.exe program.


Main Page

Fly3D SDK 2.0 Documentation

RC2

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


File Index

Fly3D SDK 2.0 File List

Here is a list of all documented files with brief descriptions:
  • fly3D.h
  • flyAI.h
  • flyAnimatedMesh.h
  • flyArray.h
  • flyBaseObject.h
  • flyBezier.h
  • flyBoundBox.h
  • flyBspNode.h
  • flyBspObject.h
  • flyConsole.h
  • flyDefine.h
  • flyDesc.h
  • flyDirectX.h
  • flyDll.h
  • flyEngine.h
  • flyFace.h
  • flyFile.h
  • flyFrustum.h
  • flyHashList.h
  • flyInputMap.h
  • flyLight.h
  • flyLocalSystem.h
  • flyMath.h
  • flyMesh.h
  • flyOcTree.h
  • flyParticle.h
  • flyPicture.h
  • flyPolygon.h
  • flyRender.h
  • flyShader.h
  • flySkeletonMesh.h
  • flySound.h
  • flyStaticMesh.h
  • flyString.h
  • flyTexCache.h
  • flyVideo.h


fly3D.h File Reference

#include <windows.h>
#include <mmsystem.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include "wglATI.h"
#include "glATI.h"
#include "glExtension.h"
#include "unzip.h"
#include "flyDefine.h"
#include "flyMath.h"
#include "flyDirectX.h"
#include "flyRender.h"
#include "flyArray.h"
#include "flyString.h"
#include "flyBoundBox.h"
#include "flyFrustum.h"
#include "flyLocalSystem.h"
#include "flyParticle.h"
#include "flyBaseObject.h"
#include "flyBspObject.h"
#include "flyBspNode.h"
#include "flyOcTree.h"
#include "flyBezier.h"
#include "flyPolygon.h"
#include "flyFace.h"
#include "flyMesh.h"
#include "flyAnimatedMesh.h"
#include "flySkeletonMesh.h"
#include "flyStaticMesh.h"
#include "flyLight.h"
#include "flyDesc.h"
#include "flyConsole.h"
#include "flySound.h"
#include "flyShader.h"
#include "flyInputMap.h"
#include "flyFile.h"
#include "flyDll.h"
#include "flyAI.h"
#include "flyHashList.h"
#include "flyEngine.h"

Functions

FLY_ENGINE_API void | fly_init_engine (HWND hWnd, HINSTANCE hInst, int appid=FLY_APPID_NONE)
global engine initialisation method.

FLY_ENGINE_API void | fly_set_engine (flyEngine *eng, HWND hWnd, HINSTANCE hInst, int appid=FLY_APPID_NONE)
global engine initialisation method from an alredy initialized pointer (used when subclassing flyEngine).

FLY_ENGINE_API void | fly_free_engine ()
global engine release method.

FLY_ENGINE_API void | fly_get_profile (LPTSTR section, LPTSTR key, LPBYTE lpData, DWORD cbData)
Read data from the Fly3D section in windows registry.

FLY_ENGINE_API void | fly_write_profile (LPTSTR section, LPCTSTR key, DWORD dwType, CONST BYTE *lpData, DWORD cbData)
Write data to the Fly3D section in windows registry.

Variables

FLY_ENGINE_API HWND | g_flyhwnd
Window handle used by the engine.

FLY_ENGINE_API HINSTANCE | g_flyhinst
Instance handle used by the engine.

FLY_ENGINE_API flyEngine* | g_flyengine = 0
global flyEngine instance.

FLY_ENGINE_API GUID | g_flyGUID
Fly3D GUID. More...

FLY_ENGINE_API int | g_processor_features = 0
Flags indicating processor features available like MMX,3DNow,SSE,SS2.

Detailed Description

Variable Documentation

FLY_ENGINE_API GUID g_flyGUID

Initial value:

 {
    0xe29ac960,
    0x09f8,
    0x11d2,
    {0x92, 0x62, 0x00, 0x00, 0x21, 0x79, 0x98, 0x71}
  }
Fly3D GUID.


flyAI.h File Reference

Compounds

class | flyStateMachine
Finite state machine class. More...

class | flyStateMachineRule
Transition rule class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyAnimatedMesh.h File Reference

Compounds

class flyAnimatedMesh
Vertex-animated mesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyArray.h File Reference

Compounds

class flyArray
Dynamic array template class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyBaseObject.h File Reference

Compounds

class flyBaseObject
The engine's basic object class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyBezier.h File Reference

Compounds

class | flyBezierCurve
Any-dimension Bezier curve. More...

class | flyBezierPatch
Cubic or quadratic bezier patch. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyBoundBox.h File Reference

Compounds

class flyBoundBox
Axis-aligned bounding box class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyBspNode.h File Reference

Compounds

class flyBspNode
Node of the BSP tree. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyBspObject.h File Reference

Compounds

class flyBspObject
Generic object class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyConsole.h File Reference

Compounds

class flyConsole
Console class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyDefine.h File Reference

Defines

#define | FLY_REGISTRYKEY_PRIMARY "Paralelo"
Fly3D main Registry folder.

#define | FLY_REGISTRYKEY_SECONDARY "Fly3D"
Fly3D Registry sub-folder.

#define | FLY_VERSION_STR "2.0"
Current version in string format.

#define | FLY_VERSION_NUM 230
Current version number.

#define | FLY_APPID_NONE 0
Application id: no application.

#define | FLY_APPID_FLYFRONTEND 1
Application id: flyFrontend.

#define | FLY_APPID_FLYEDITOR 2
Application id: flyEditor.

#define | FLY_APPID_FLYSERVER 4
Application id: flyServer.

#define | FLY_APPID_FLYOCX 5
Application id: flyActiveX.

#define | FLY_APPID_FLYSHADER 6
Application id: flyShader.

#define | FLY_APPID_FLYBUILD 7
Application id: flyBuild.

#define | FLY_FILEID_FMP 0xfaa
File id: FMP file.

#define | FLY_FILEID_BSP 0xfab
File id: BSP file.

#define | FLY_FILEID_PVS 0xfac
File id: PVS file.

#define | FLY_FILEID_LMP 0xfad
File id: lightmap file.

#define | FLY_FILEID_F3D 0xfae
File id: F3D file.

#define | FLY_FILEID_K3D 0xfaf
File id: K3D file.

#define | FLY_TYPE_NONE 0
Base object type: Undefined.

#define | FLY_TYPE_STATICMESH 1
Base object type: Static mesh.

#define | FLY_TYPE_MESH 2
Base object type: Standard mesh.

#define | FLY_TYPE_VERTEXMESH 3
Base object type: Vertex animated mesh.

#define | FLY_TYPE_SKELETONMESH 4
Base object type: Skeleton animated mesh.

#define | FLY_TYPE_SOUND 5
Base object type: Sound.

#define | FLY_TYPE_BEZIERCURVE 6
Base object type: Bezier curve.

#define | FLY_NUMDEFAULTPARAM 12
Number of the engine's default parameters.

#define | FLY_MAX_OBJDRAWLAYERS 8
Maximum number of drawing layers.

#define | FLY_MAX_BSPSTACK 64
Maximum number of entries in the BSP stack.

#define | FLY_MAX_MESHANIMS 256
Maximum number of animations in a mesh.

#define | FLY_MAX_MESHBONES 256
Maximum number of bones in a skeleton mesh.

#define | FLY_MAX_MESHSTRLEN 32
Maximum length of strings in the mesh file format.

#define | FLY_MAX_SHADERPASSES 8
Maximum number of passes in each shader.

#define | FLY_MAX_SHADERANIMFRAMES 16
Maximum number of shader animation map frames.

#define | FLY_MAX_HWLIGHTS 4
Maximum number of hardware lights.

#define | FLY_MESSAGE_INITSCENE 1000
Default message: Initialise scene.

#define | FLY_MESSAGE_UPDATESCENE 1001
Default message: Update scene.

#define | FLY_MESSAGE_DRAWSCENE 1002
Default message: Draw scene (3D drawing).

#define | FLY_MESSAGE_DRAWTEXT 1003
Default message: 2D drawing.

#define | FLY_MESSAGE_CLOSESCENE 1004
Default message: Close scene.

#define | FLY_MESSAGE_MPMESSAGE 1005
Default message: Multiplayer general.

#define | FLY_MESSAGE_MPUPDATE 1006
Default message: Multiplayer update.

#define | FLY_MESSAGE_DROPDATA 1007
Default message: Data drop into engine.

#define | FLY_MESSAGE_FULLSCREEN 1008
Default message: Inverts full screen state.

#define | FLY_OBJMESSAGE_CHANGEPARAM 2000
Object message: Parameter change.

#define | FLY_OBJMESSAGE_ILLUM 2001
Object message: Search for lights and self-illuminate.

#define | FLY_OBJMESSAGE_STATICILLUM 2002
Object message: Search for static lights and self-illuminate.

#define | FLY_OBJMESSAGE_DYNILLUM 2003
Object message: Search for dynamic lights and self-illuminate.

#define | FLY_OBJMESSAGE_DAMAGE 2004
Object message: Splash damage.

#define | FLY_OBJMESSAGE_DAMAGECONTACT 2005
Object message: Contact damage.

#define | FLY_OBJMESSAGE_LIGHT 2006
Object message: Illuminate (generate a light source on current position.

#define | FLY_OBJMESSAGE_TRIGGER 2007
Object message: Generic trigger.

#define | FLY_MESH_FACENORM 1
Mesh bitfield: face normal bit.

#define | FLY_MESH_VERTNORM 2
Mesh bitfield: vertex normal bit.

#define | FLY_MESH_BBOX 4
Mesh bitfield: bounding box bit.

#define | FLY_MESH_OCTREE 8
Mesh bitfield: octree bit.

#define | FLY_MESH_ALL 15
All bitfields set to one.

#define | FLY_PATCHEVAL_POINT 1
Patch evaluation bitfield: point bit.

#define | FLY_PATCHEVAL_TEXTCOORD 2
Patch evaluation bitfield: texture coordinates bit.

#define | FLY_PATCHEVAL_NORMAL 4
Patch evaluation bitfield: normal bit.

#define | FLY_FACETYPE_LARGE_POLYGON 0
Face type: Face is large convex polygon made of any number of edges.

#define | FLY_FACETYPE_BEZIER_PATCH 1
Face type: Face is a bi-quadratic Bezier patch.

#define | FLY_FACETYPE_TRIANGLE_MESH 2
Face type: Face is a generic triangle mesh.

#define | FLY_FACETYPE_TRIANGLE_STRIP 3
Face type: Face is a triangle strip.

#define | FLY_FACETYPE_TRIANGLE_FAN 4
Face type: Face is a triangle fan.

#define | FLY_FACEFLAG_DETAIL 0
Face flag: detail face.

#define | FLY_FACEFLAG_STRUCTURAL 1
Face flag: srtructural face.

#define | FLY_FACEFLAG_LANDSCAPE 2
Face flag: landscape face.

#define | FLY_CONSOLE_MAXLINES 512
Maximum number of lines in console.

#define | FLY_CONSOLE_COL 40
Console column width in screen pixels.

#define | FLY_CONSOLE_LINE 30
Console line width in screen pixels.

#define | FLY_PVS_TEST(from, to)
PVS testing. More...

#define | FLY_SHADER_NOCULL 1
Shader bitfield: No culling bit.

#define | FLY_SHADER_TRANSPARENT 2
Shader bitfield: Transparency bit.

#define | FLY_SHADER_NODEPTHWRITE 4
Shader bitfield: No depth buffer writing bit.

#define | FLY_SHADER_SKY 8
Shader bitfield: Sky bit.

#define | FLY_SHADER_NOCOLLIDE 16
Shader bitfield: No colliding bit.

#define | FLY_SHADER_NOSHADOWS 32
Shader bitfield: No shadows bit.

#define | FLY_SHADER_LIGHTMAP 1
Shader pass bitfield: Lightmap bit.

#define | FLY_SHADER_BLEND 2
Shader pass bitfield: Blending bit.

#define | FLY_SHADER_ALPHAFUNC 8
Shader pass bitfield: Alpha function bit.

#define | FLY_SHADER_TCMOD 16
Shader pass bitfield: Texture coordinates modifier bit.

#define | FLY_SHADER_ANIMMAP 32
Shader pass bitfield: Animation map bit.

#define | FLY_SHADER_TCGEN_ENV 64
Shader pass bitfield: Environment bit.

#define | FLY_SHADER_TEXCLAMP 128
Shader pass bitfield: Texture clamping bit.

#define | FLY_SHADER_INVERTCULLING 256
Shader pass bitfield: Invert backface culling bit.

#define | FLY_SHADERFUNC_SIN 1
Shader function: Sin.

#define | FLY_SHADERFUNC_TRIANGLE 2
Shader function: Triangle.

#define | FLY_SHADERFUNC_SQUARE 3
Shader function: Square.

#define | FLY_SHADERFUNC_SAWTOOTH 4
Shader function: Saw-tooth.

#define | FLY_SHADERFUNC_INVERSESAWTOOTH 5
Shader function: Inverse saw-tooth.

#define | FLY_SHADERGEN_DEFAULT -1
Shader RGB generation: Default.

#define | FLY_SHADERGEN_IDENTITY 0
Shader RGB generation: Identity.

#define | FLY_SHADERGEN_WAVE 1
Shader RGB generation: Wave function.

#define | FLY_SHADERGEN_VERTEX 2
Shader RGB generation: Vertex.

#define | FLY_SHADERGEN_REFLECTANCE 3
Shader RGB generation: Reflectance.

#define | FLY_SHADERGEN_REFLECTANCEWAVE 4
Shader RGB generation: Reflectance * Wave.

#define | FLY_SHADERTCMOD_SCALE 2
Shader texture coordinates modifier bitfield: Scaling.

#define | FLY_SHADERTCMOD_ROTATE 4
Shader texture coordinates modifier bitfield: Rotation.

#define | FLY_SHADERTCMOD_SCROLL 8
Shader texture coordinates modifier bitfield: Scrolling.

#define | FLY_SHADERTCMOD_STRETCH 64
Shader texture coordinates modifier bitfield: Stretching.

Detailed Description

Define Documentation

#define D3DRGB( r, g, b )

Value:

    (0xff000000L | ( ((DWORD)((r) * 255)) << 16) | (((DWORD)((g) * 255)) << 8) | (DWORD)((b) * 255))

#define D3DRGBA( r, g, b, a )

Value:

    (   (((DWORD)((a) * 255)) << 24) | (((DWORD)((r) * 255)) << 16) \
    |   (((DWORD)((g) * 255)) << 8) | (DWORD)((b) * 255) \
    )

#define FLY_GLOBAL_PVS_TEST( from, to )

Value:

        (*(g_flyengine->pvs + (from)*g_flyengine->pvsrowsize + ((to)>>3)) & (1 << ((to) & 7)))

#define FLY_PVS_TEST( from, to )

Value:

        (*(pvs + (from)*pvsrowsize + ((to)>>3)) & (1 << ((to) & 7)))
PVS testing.


flyDesc.h File Reference

Compounds

class | flyClassDesc
Class description meta-class. More...

class | flyParamDesc
Parameter description class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyDirectX.h File Reference

#include <windows.h>
#include <stdio.h>
#include "dinput.h"
#include "dsound.h"
#include "dplay.h"
#include "dplobby.h"

Compounds

class | flyDirectx
Interface with DirectInput, DirectSound and DirectPlay. More...

class | flyMPGames
Multiplayer games database. More...

class | flyMPMsg
Multiplayer message. More...

class | flyMPPlayerData
Multiplayer player data. More...

Defines

#define | DIRECTINPUT_VERSION 0x0500
DirectInput version 5 used.

#define | FLY_MP_BROWSETIME 2000
maximum browse time.

#define | FLY_MP_MAXPLAYERS 16
player data structure size.

#define | FLY_MP_MAXSERVICES 16
maximum number of services.

#define | FLY_MP_MAXGAMES 16
maximum number of simultaneous games.

#define | FLY_MP_GUARANTEED 0x80000000
flag for guaranteed message delivery.

#define | FLY_MP_MSG_JOIN 9171|FLY_MP_GUARANTEED
'join' multiplayer message.

#define | FLY_MP_MSG_QUIT 9172|FLY_MP_GUARANTEED
'quit' multiplayer message.

#define | FLY_MP_MSG_FLYFILE 9173|FLY_MP_GUARANTEED
'open .fly file' multiplayer message.

#define | FLY_MP_MSG_CHAT 9174|FLY_MP_GUARANTEED
multiplayer chat message.

#define | FLY_MP_NOMP 0
multiplayer mode: no multiplayer.

#define | FLY_MP_CLIENT 1
multiplayer mode: client.

#define | FLY_MP_SERVER 2
multiplayer mode: server.

#define | FLY_MOUSE_L 1
mouse left button.

#define | FLY_MOUSE_R 2
mouse right button.

#define | FLY_MOUSE_M 4
mouse middle button.

#define | FLY_AXIS_X 1
joystick X axis.

#define | FLY_AXIS_Y 2
joystick Y axis.

#define | FLY_AXIS_Z 4
joystick Z axis.

#define | FLY_AXIS_X_ROT 8
joystick X axis rotation.

#define | FLY_AXIS_Y_ROT 16
joystick Y axis rotation.

#define | FLY_AXIS_Z_ROT 32
joystick Z axis rotation.

#define | FLY_AXIS_SLIDER0 64
joystick first slider.

#define | FLY_AXIS_SLIDER1 128
joystick second slider.

#define | FLY_JOY_BUTTON_1 1
joystick button number 1.

#define | FLY_JOY_BUTTON_2 2
joystick button number 2.

#define | FLY_JOY_BUTTON_3 4
joystick button number 3.

#define | FLY_JOY_BUTTON_4 8
joystick button number 4.

#define | FLY_JOY_BUTTON_5 16
joystick button number 5.

#define | FLY_JOY_BUTTON_6 32
joystick button number 6.

#define | FLY_JOY_BUTTON_7 64
joystick button number 7.

#define | FLY_JOY_BUTTON_8 128
joystick button number 8.

#define | FLY_JOY_BUTTON_9 256
joystick button number 9.

#define | FLY_JOY_BUTTON_10 512
joystick button number 10.

Functions

FLY_DIRECTX_API void | fly_init_directx (HWND hwnd, HINSTANCE hinst)
global DirectX initialisation method.

FLY_DIRECTX_API void | fly_free_directx ()
global DirectX release method.

Variables

FLY_DIRECTX_API flyDirectx* | g_flydirectx
global flyDirectx instance.

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyDll.h File Reference

Compounds

class | flyDll
Fly3D plugin DLL class. More...

class | flyDllGroup
DLLs grouping class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyEngine.h File Reference

Compounds

class flyEngine
Fly3D engine class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyFace.h File Reference

Compounds

class flyFace
General face class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyFile.h File Reference

Compounds

class flyFile
Fly3D scene data file management class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyFrustum.h File Reference

Compounds

class flyFrustum
View frustum class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyHashList.h File Reference

Compounds

class flyHashList
Hash of flyBaseObject linked lists. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyInputMap.h File Reference

Compounds

class flyInputMap
Class representing input maps. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyLight.h File Reference

Compounds

class | flyLightMap
Light map class. More...

class | flyLightMapPic
Light map picture class. More...

class | flyLightVertex
Dynamic hardware lights class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyLocalSystem.h File Reference

Compounds

class flyLocalSystem
Local coordinates system class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyMath.h File Reference

#include <memory.h>
#include <math.h>

Compounds

class | flyMatrix
Matrix class compound of 4x4 floating point real numbers. More...

class | flyPlane
Plane representation class. More...

class | flyQuaternion
Quaternion representation class. More...

class | flyVector
Vector class compound of 4 floating point real numbers. More...

class | flyVertex
Vertex representation class. More...

Defines

#define | FLY_FRAND (((rand()%10000)-5000)/5000.0f)
random floating point number.

#define | FLY_FABSRAND ((rand()%10000)/10000.0f)
absolute random floating point number.

#define | FLY_VECDOT(v1, v2) ((v1).x*(v2).x+(v1).y*(v2).y+(v1).z*(v2).z)
two vectors dot product.

#define | FLY_SMALL 1.0e-4f
lower bound for overflow detection.

#define | FLY_BIG 1.0e+10f
upper bound for overflow detection.

#define | FLY_ISZERO(a) ((a)>-FLY_SMALL && (a)<FLY_SMALL)
underflow detection.

#define | FLY_2PI 6.28318530718f
represents the value of 2*pi.

#define | FLY_PI 3.14159265359f
represents the value of pi.

#define | FLY_PI2 1.57079632679f
represents the value of pi/2.

#define | FLY_PIOVER180 1.74532925199433E-002f
represents the value of pi/180.

#define | FLY_PIUNDER180 5.72957795130823E+001f
represents the value of 180/pi.

#define | FLY_COS45 0.7071067811865475244f
represents cos(45).

#define | FLY_SQRT3 1.7320508075688772935f
represents the square root of 3.

#define | FLY_FPBITS(fp) (*(int *)&(fp))
returns the bitwise representation of a floating point number.

#define | FLY_FPABSBITS(fp) (FLY_FPBITS(fp)&0x7FFFFFFF)
returns the absolute value of a floating point number in bitwise form.

#define | FLY_FPSIGNBIT(fp) (FLY_FPBITS(fp)&0x80000000)
returns the signal bit of a floating point number.

#define | FLY_FPABS(fp) (*((int *)&fp)=FLY_FPABSBITS(fp))
returns the absolute value of a floating point number.

#define | FLY_FPONEBITS 0x3F800000
returns the value of 1.0f in bitwise form.

Functions

void | operator *= (flyVector &v, float f)
Multiplies a vector by a floating point value.

void | operator/= (flyVector &v, float f)
Divides a vector by a floating point value.

void | operator-= (flyVector &v1, const flyVector &v2)
Subtracts vector 'v2' from the original vector.

void | operator+= (flyVector &v1, const flyVector &v2)
Adds the original vector with another.

void | operator *= (flyVector &v1, const flyVector &v2)
Multiplies the original vector with another.

void | operator/= (flyVector &v1, const flyVector &v2)
Divides the original vector by another.

flyVector | operator- (flyVector v1, const flyVector &v2)
Subtracts vector 'v2' from 'v1'.

flyVector | operator+ (flyVector v1, const flyVector &v2)
Adds two vectors.

flyVector | operator * (flyVector v1, const flyVector &v2)
Multiplication between vectors.

flyVector | operator/ (flyVector v1, const flyVector &v2)
Divides vector 'v1' by vector 'v2'.

flyVector | operator * (float f, flyVector v)
Multiply a floating point value by a vector.

flyVector | operator * (flyVector v, float f)
Multiply a vector by a floating point value.

flyVector | operator/ (flyVector v, float f)
Divide a vector by a floating point value.

flyVector | operator * (const flyVector &v, const flyMatrix &m)
Multiplies a vector by a matrix.

flyVector | operator * (const flyMatrix &m, const flyVector &v)
Multiplies a matrix by a vector.

Detailed Description

Define Documentation

#define INTEL_SIMD

Value:

Fly3D Game Engine ver 2.0 -
http://www.fly3d.com.br


flyMesh.h File Reference

Compounds

class flyMesh
Polygonal mesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyOcTree.h File Reference

Compounds

class | flyOcTree
OcTree class. More...

class | flyOcTreeNode
OcTree node class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyParticle.h File Reference

Compounds

class flyParticle
Single particle class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyPicture.h File Reference

Compounds

class flyPicture
Picture image class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyPolygon.h File Reference

Compounds

class flyPolygon
Polygon representation class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyRender.h File Reference

#include <windows.h>
#include <stdio.h>
#include <vfw.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include "wglATI.h"
#include "glATI.h"
#include "glExtension.h"
#include "flyPicture.h"
#include "flyVideo.h"
#include "flyTexCache.h"

Compounds

class | flyRender
Render management class. More...

Defines

#define | FLY_FONTS_NUM 16
Number of letters per line in font texture.

#define | FLY_FONTS_FACTOR 0.0625f
Number of letters per line in font texture.

Functions

FLY_RENDER_API void | fly_init_render (HWND hWnd, HINSTANCE hInst)
global render manager initialisation method.

FLY_RENDER_API void | fly_free_render ()
global render manager release method.

Variables

FLY_RENDER_API flyRender* | g_flyrender
global flyRender instance.

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyShader.h File Reference

Compounds

class | flyShader
Shader class. More...

class | flyShaderFunc
Shader function class. More...

class | flyShaderPass
Shader pass class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flySkeletonMesh.h File Reference

Compounds

class flySkeletonMesh
Bone-animated mesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flySound.h File Reference

Compounds

class flySound
Sound class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyStaticMesh.h File Reference

Compounds

class flyStaticMesh
Static mesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyString.h File Reference

Compounds

class | flyString
Fly3D in-house string class. More...

Defines

#define | FLY_STR_MINSIZE 16
flyString's minimum size in bytes.

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyTexCache.h File Reference

Compounds

class | flyTexCache
Texture manager class. More...

struct | flyTexInfo
texture info structure. More...

Defines

#define | FLY_MAXTEXUNITS 4
Maximum texture units.

#define | FLY_TEXFLAG_FILTER 1
Texture flags: texture filtering enabled.

#define | FLY_TEXFLAG_MIPMAP 2
Texture flags: mip-mapping enabled.

#define | FLY_TEXFLAG_TRUECOLOR 4
Texture flags: true color texture (24/32 bits/pixel).

#define | FLY_TEXFLAG_BGR 8
Texture flags: BGR texture format.

#define | FLY_TEXFLAG_COMPRESSION 16
Texture flags: ARB texture compression.

Variables

FLY_RENDER_API flyTexCache* | g_flytexcache
global flyTexCache instance.

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


flyVideo.h File Reference

Compounds

class flyVideo
Video class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


Annotated Index

Fly3D SDK 2.0 Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:
  • flyAnimatedMesh (Vertex-animated mesh class)
  • flyArray (Dynamic array template class)
  • flyBaseObject (The engine's basic object class)
  • flyBezierCurve (Any-dimension Bezier curve)
  • flyBezierPatch (Cubic or quadratic bezier patch)
  • flyBoundBox (Axis-aligned bounding box class)
  • flyBspNode (Node of the BSP tree)
  • flyBspObject (Generic object class)
  • flyClassDesc (Class description meta-class)
  • flyConsole (Console class)
  • flyDirectx (Interface with DirectInput, DirectSound and DirectPlay)
  • flyDll (Fly3D plugin DLL class)
  • flyDllGroup (DLLs grouping class)
  • flyEngine (Fly3D engine class)
  • flyFace (General face class)
  • flyFile (Fly3D scene data file management class)
  • flyFrustum (View frustum class)
  • flyHashList (Hash of flyBaseObject linked lists)
  • flyInputMap (Class representing input maps)
  • flyLightMap (Light map class)
  • flyLightMapPic (Light map picture class)
  • flyLightVertex (Dynamic hardware lights class)
  • flyLocalSystem (Local coordinates system class)
  • flyMatrix (Matrix class compound of 4x4 floating point real numbers)
  • flyMesh (Polygonal mesh class)
  • flyMPGames (Multiplayer games database)
  • flyMPMsg (Multiplayer message)
  • flyMPPlayerData (Multiplayer player data)
  • flyOcTree (OcTree class)
  • flyOcTreeNode (OcTree node class)
  • flyParamDesc (Parameter description class)
  • flyParticle (Single particle class)
  • flyPicture (Picture image class)
  • flyPlane (Plane representation class)
  • flyPolygon (Polygon representation class)
  • flyQuaternion (Quaternion representation class)
  • flyRender (Render management class)
  • flyShader (Shader class)
  • flyShaderFunc (Shader function class)
  • flyShaderPass (Shader pass class)
  • flySkeletonMesh (Bone-animated mesh class)
  • flySound (Sound class)
  • flyStateMachine (Finite state machine class)
  • flyStateMachineRule (Transition rule class)
  • flyStaticMesh (Static mesh class)
  • flyString (Fly3D in-house string class)
  • flyTexCache (Texture manager class)
  • flyTexInfo (Texture info structure)
  • flyVector (Vector class compound of 4 floating point real numbers)
  • flyVertex (Vertex representation class)
  • flyVideo (Video class)


flyAnimatedMesh Class Reference

Vertex-animated mesh class. More...

#include <flyAnimatedMesh.h>

Inheritance diagram for flyAnimatedMesh::

flyMesh flyBaseObject List of all members.

Public Methods

flyAnimatedMesh ()
Default constructor.

flyAnimatedMesh (const flyAnimatedMesh &in)
Copy-constructor.

void | operator= (const flyAnimatedMesh &in)
Atribuition operator.

virtual | ~flyAnimatedMesh ()
Default destructor, calls reset.

void | reset (void)
Free all data.

int | save (const char *file) const
Save the mesh to a file.

int | load (const char *file)
Load the mesh from a file.

void | set_state (int anim, int key)
Set the mesh to the desired animation and key.

void | set_state (int anim, float key_factor)
Set the mesh to the desired animation, interpolating between keys in function of key_factor.

void | set_state (int anim1, float key_factor1, int anim2, float key_factor2, float blend)
Set the mesh to an intermediate state (blending) between two animations/keys.

void | set_state_blendcur (int anim, int key, float blend)
Blend the given key/animation with the current one.

void | set_state_blendcur (int anim, float key_factor, float blend)
Blend the given animation (key given by key_factor) with the current one.

Public Attributes

int | nkeys
total number of keys (sum of animkeys).

int | animkeys [FLY_MAX_MESHANIMS]
number of keys in each animation.

int | animkeyspos [FLY_MAX_MESHANIMS]
start position of each key (accumulated animkeys).

char | animnames [FLY_MAX_MESHANIMS][FLY_MAX_MESHSTRLEN]
animation names.

flyVector* key_verts
vertices of every key in every animation (size: nkeys*nverts).

Detailed Description

Vertex-animated mesh class.

This class implements key-based vertex-animated meshes that can be read from a .f3d file. Its members are: the number of key-frames and an array of vectors that represent the position of every vertex of the model in every key-frame. The class also provides built-in blending methods for multi-animation blending, as well as routines for reading and saving .f3d files, setting the current state of the model in an animation and blend between animations.


TemplateflyArray class Reference

flyArray Class Template Reference

Dynamic array template class. More...

#include <flyArray.h>

List of all members.

Public Methods

flyArray ()
Default constructor.

flyArray (const flyArray< T > &in)
Copy-constructor.

virtual | ~flyArray ()
Default destructor.

void | operator= (const flyArray< T > &in)
Copy-constructor.

virtual void | operator+= (flyArray< T > &in)
Adds another array to the end of current array.

virtual void | reserve (int n)
Reserve the required amount of space for the array.

virtual void | free ()
Free all the space.

void | clear ()
Clear the whole array, but keep the memory space.

virtual void | add (const T elem)
Add a new element to the end of the array, automatically allocating more space, if needed.

void | remove (int i)
Remove the element in the given position.

void | remove (int i, int n)
Remove 'n' elements in the given position.

const T& | operator[] (int i) const
Indexing operator returing const.

T& | operator[] (int i)
Indexing operator.

Public Attributes

T* | buf
generic buffer.

int | num
number of entries.

int | arraysize
array size in bytes.

Detailed Description

template<class T> class flyArray

Dynamic array template class.

This template class implements an array allocated and expanded in execution time. It auto-manages its memory space and supplies methods for adding, removing and indexing items.


flyBaseObject Class Reference

The engine's basic object class. More...

#include <flyBaseObject.h>

Inheritance diagram for flyBaseObject::

flyBezierCurve flyBspObject flyMesh flyShader flySound flyStaticMesh flyAnimatedMesh flySkeletonMesh List of all members.

Public Methods

flyBaseObject ()
Default constructor.

flyBaseObject (const flyBaseObject &in)
Copy-constructor.

void | operator= (const flyBaseObject &in)
Atribuition operator.

virtual | ~flyBaseObject ()
Default destructor.

Public Attributes

flyString name
the object's name.

flyString long_name
the object's long name.

flyBaseObject* | next_obj
the next object in the linked list.

Detailed Description

The engine's basic object class.

This class is the base class for all objects. It holds the object's name, long name, type and pointer to the next object in the specific object linked list.


flyBezierCurve Class Reference

Any-dimension Bezier curve. More...

#include <flyBezier.h>

Inheritance diagram for flyBezierCurve::

flyBaseObject List of all members.

Public Methods

flyBezierCurve ()
Default constructor.

flyBezierCurve (const flyBezierCurve &in)
Copy-constructor.

virtual | ~flyBezierCurve ()
Destructor constructor.

void | operator= (const flyBezierCurve &in)
Atribuition operator.

void | reset ()
Reset all allocated data.

void | set_dim (int ndim)
Set the curve dimension from the given number (2: 2D, 3: 3D, ...).

void | add_point (const float *f)
Add a new point to the curve, the given array must have ndim floats.

void | evaluate (float u, float *f) const
Evaluate curve at point u (0..1), and store the resulting point in f (ndim floats).

void | evaluate_tangent (float u, float *f) const
Evaluate tangent of the curve at point u (0..1), and store the result in f (ndim floats).

int | load_bez (const char *file)
Load a bezier curve from a .bez file.

int | adaptative_subdiv (float maxerror, float *points, int maxpoints) const
Adaptively subdivide the curve using maxerror threshold and store the resulting u coordinates in the given array.

float | length () const
Get the length of the curve.

Public Attributes

float* | p
curve control points.

int | np
number of control points.

int | ns
number of bezier segments ((np-1)/3).

int | nd
curve dimensions (2->2D, 3->3D, etc...).

flyVector pivot
curve pivot position.

Detailed Description

Any-dimension Bezier curve.

This class implements a n-dimension Bezier curve. The curve and tangent can be evaluated at any point, and the curve can be adaptively subdivided until the curve error is less than a maximum error factor. The members in this class are: the control points, the number of segments in the curve, the curve's dimension and the curve's pivot position. Some of its methods include: adding a control point to the curve, evaluate the curve and the tangent at a given point, loading a .bez file which contains data about a curve, adaptive subdivision of the curve, and much more.


flyBezierPatch Class Reference

Cubic or quadratic bezier patch. More...

#include <flyBezier.h>

List of all members.

Public Methods

flyBezierPatch ()
Default constructor.

flyBezierPatch (const flyBezierPatch &in)
Copy-constructor.

void | operator= (const flyBezierPatch &in)
Atribuition operator.

virtual | ~flyBezierPatch ()
Default destructor.

void | reset ()
Reset all allocated data.

void | build_cp_loft (const flyBezierCurve *shape, const flyBezierCurve *path, float tileu, float tilev)
Build patch control points for a loft from 2 bezier curves (shape and path).

void | build_cp (int nu, int nv, const flyVertex *v)
Build patch control points from the given vertices.

void | evaluate (int evaltype, float u, float v, flyVector *dest) const
Evaluate curve data at point (u,v) ((0..1),(0..1)), and store the resulting vectors in dest (evaltype can specify point, normal or tangent).

void | build_surface ()
Build the highest resolution surface from the control points.

void | draw (int drawmode) const
Draw the patch faces using dynamic LOD.

void | set_detail (const flyVector &pos, const flyVector &campos)
Automatically set the patch's drop level, based on its distance from camera.

Public Attributes

int | mode
2 for quadratic and 3 for cubic.

flyVertex* p
surface control points.

int | np
num points.

int | npu
num points in u dir.

int | npv
num points in v dir.

int | nsu
num segments in u dir.

int | nsv
num segments in u dir.

int | levelu
subdivision level in u.

int | levelv
subdivision level in v.

int | nvertu
surface num vertices in u.

int | nvertv
surface num vertices in v.

flyVertex* surf
discretized surface.

int | numstrips
number of bezier curve strips.

int | dropu
drop level in u.

int | dropv
drop level in v.

int | dropu_inc
number of vertices to skip in u.

int | dropv_inc
number of vertices to skip in v.

Detailed Description

Cubic or quadratic bezier patch.

The patch can have any number of segments in u and v directions. It is made of several connected cubic or quadratic Bezier patches (nsu is the number of patches in the u dir and nsv in the v dir).

For quadratic patches: nsu=(spu-2)/2 nsv=(spv-2)/2

For cubic patches: nsu=(spu-1)/2 nsv=(spv-1)/2

The surface is discretized based on the subdivision level. The number of vertices in u and v dir are:

nvertu=(1<<levelu)*nsu+1 nvertv=(1<<levelv)*nsv+1

At run-time, the surface car be draw at any level of detail up to its current selected level. The set_detail method sets the desired level of detail. The numbrer of vertices skipped (col/row draw loop increment) on each direction is:

nvertskip=(1<<nleveldrop)


flyBoundBox Class Reference

Axis-aligned bounding box class. More...

#include <flyBoundBox.h>

List of all members.

Public Methods

flyBoundBox ()
Default constructor.

flyBoundBox (const flyVector &min, const flyVector &max)
Construct a bounding box given the minimum and maximum points.

flyBoundBox (const flyBoundBox &in)
Copy-constructor.

void | operator= (const flyBoundBox &in)
Atribuition operator.

flyVector | get_vert (int ind) const
Return the vertex corresponding to the given index.

float | get_plane_dist (int ind) const
Return the distance of the plane corresponding to the given index (0=min[x], 1=min[y], 2=min[z], 3=max[x], 4=max[y], 5=max[z]).

int | clip_bbox (const flyVector &bbmin, const flyVector &bbmax) const
Test for clipping between this and the bounding box whose minimum and maximum points are, respectively, bbmin and bbmax.

int | is_inside (const flyVector &p) const
Test if point p is inside this bounding box.

int | collide (const flyVector &p, const flyVector &dir, float &len)
Collide the bounding box moving in the direction dir with movement magnitude len and store its resulting position in p.

int | collide (flyMesh *mesh, const flyBoundBox &bbtemp, const flyVector &dir, float &len, flyVector &normal, flyVector &ip) const
Collide the bounding box moving in the direction dir with a static mesh.

int | collide (flyMesh *mesh, const flyVector &pos, const flyLocalSystem &ls, const flyBoundBox &bbtemp, const flyVector &dir, float &len, flyVector &normal, flyVector &ip) const
Collide the bounding box moving in the direction dir with a dynamic mesh at position pos and orientation ls.

int | collide (const flyBoundBox &bbox, const flyVector &dir, float &len, flyVector &normal, flyVector &ip) const
Collide the bounding box moving in the direction dir with movement magnitude len with another bounding box (bbox).

int | ray_intersect (const flyVector &ro, const flyVector &rd, float &tnear, float &tfar) const
Collide ray defined by ray origin (ro) and ray direction (rd) with the bounding box.

int | edge_collision (const flyVector &p1, const flyVector &p2, const flyVector &dir, const flyVector &p3, const flyVector &p4, float &dist, flyVector &ip) const
Collide edge (p1,p2) moving in direction dir with edge (p3,p4).

void | reset ()
Reset all data.

void | add_point (const flyVector &p)
Add a point to the bounding box (expand its boundaries if necessary).

void | draw () const
Draw the box.

flyMesh* | get_mesh () const
Return a mesh corresponding to the bounding box faces.

Public Attributes

flyVector min
bounding box minimum point.

flyVector max
bounding box maximum point.

Static Public Attributes

int | facevert [6][4]
indices of the corresponding vertices for each face. More...

int | edgevert [12][2]
indices of the corresponding vertices for each edge. More...

int | edgefaces [12][2]
indices of the corresponding faces for each edge. More...

flyVector | vertnorm [8]
normals of each vertex. More...

flyVector | edgenorm [12]
normals of each edge. More...

flyVector | facenorm [6]
normals of each face. More...

flyVector | edgedir [12]
edge directions normalized for each edge. More...

flyVector | edgedirth [12]
edgedir divided by 100 (used as thresholds for edge collisions). More...

Detailed Description

Axis-aligned bounding box class.

This class implements an axis-aligned bounding box (AABB), which every object in the scene must have. The bounding box is used in collision calculations, and for the engine's aggressive view culling. The AABB is defined by its minimum and maximum points, and this class provides methods for testing if a given point is inside the box, testing if two AABBs intersect, calculating collision and ray-intersection.

Member Data Documentation

flyVector flyBoundBox::edgedir [static]

Initial value:

        {   flyVector(0,1,0),flyVector(1,0,0),flyVector(0,-1,0),flyVector(-1,0,0),
            flyVector(-1,0,0),flyVector(0,-1,0),flyVector(1,0,0),flyVector(0,1,0),
            flyVector(0,0,1),flyVector(0,0,-1),flyVector(0,0,1),flyVector(0,0,-1)   }
edge directions normalized for each edge.

flyVector flyBoundBox::edgedirth [static]

Initial value:

        {   flyVector(0,0.01f,0),flyVector(0.01f,0,0),flyVector(0,-0.01f,0),flyVector(-0.01f,0,0),
            flyVector(-0.01f,0,0),flyVector(0,-0.01f,0),flyVector(0.01f,0,0),flyVector(0,0.01f,0),
            flyVector(0,0,0.01f),flyVector(0,0,-0.01f),flyVector(0,0,0.01f),flyVector(0,0,-0.01f)   }
edgedir divided by 100 (used as thresholds for edge collisions).

int flyBoundBox::edgefaces [static]

Initial value:

        {   {0,2},{4,2},{3,2},{1,2},
            {4,5},{0,5},{1,5},{3,5},
            {0,1},{0,4},{3,4},{1,3}     }
indices of the corresponding faces for each edge.

flyVector flyBoundBox::edgenorm [static]

Initial value:

        {   flyVector(-FLY_COS45,        0,-FLY_COS45),
            flyVector(        0, FLY_COS45,-FLY_COS45),
            flyVector( FLY_COS45,        0,-FLY_COS45),
            flyVector(        0,-FLY_COS45,-FLY_COS45),
            flyVector(        0, FLY_COS45, FLY_COS45),
            flyVector(-FLY_COS45,        0, FLY_COS45),
            flyVector(        0,-FLY_COS45, FLY_COS45),
            flyVector( FLY_COS45,        0, FLY_COS45),
            flyVector(-FLY_COS45,-FLY_COS45,        0),
            flyVector(-FLY_COS45, FLY_COS45,        0),
            flyVector( FLY_COS45, FLY_COS45,        0),
            flyVector( FLY_COS45,-FLY_COS45,        0)  }
normals of each edge.

int flyBoundBox::edgevert [static]

Initial value:

        {   {0,6},{6,4},{4,2},{2,0},
            {1,3},{3,5},{5,7},{7,1},
            {0,5},{3,6},{4,1},{7,2}     }
indices of the corresponding vertices for each edge.

flyVector flyBoundBox::facenorm [static]

Initial value:

        {   flyVector(1,0,0),
            flyVector(0,1,0),
            flyVector(0,0,1),
            flyVector(-1,0,0),
            flyVector(0,-1,0),
            flyVector(0,0,-1) }
normals of each face.

int flyBoundBox::facevert [static]

Initial value:

        {   {1,7,2,4},{1,4,6,3},{1,3,5,7},
            {0,5,3,6},{0,2,7,5},{0,6,4,2}   }
indices of the corresponding vertices for each face.

flyVector flyBoundBox::vertnorm [static]

Initial value:

        {   flyVector(-FLY_COS45,-FLY_COS45,-FLY_COS45),
            flyVector( FLY_COS45, FLY_COS45, FLY_COS45),
            flyVector( FLY_COS45,-FLY_COS45,-FLY_COS45),
            flyVector(-FLY_COS45, FLY_COS45, FLY_COS45),
            flyVector( FLY_COS45, FLY_COS45,-FLY_COS45),
            flyVector(-FLY_COS45,-FLY_COS45, FLY_COS45),
            flyVector(-FLY_COS45, FLY_COS45,-FLY_COS45),
            flyVector( FLY_COS45,-FLY_COS45, FLY_COS45) }
normals of each vertex.


flyBspNode Class Reference

Node of the BSP tree. More...

#include <flyBspNode.h>

Inheritance diagram for flyBspNode::

flyPlane List of all members.

Public Methods

flyBspNode ()
Default constructor.

flyBspNode (const flyBspNode &in)
Copy-constructor.

void | operator= (const flyBspNode &in)
Atribuition operator.

virtual | ~flyBspNode ()
Default destructor.

void | add_neighbor (const flyPolygon &p, flyBspNode *in)
Add a new neighbor node and its connecting portal polygon.

Public Attributes

flyBspNode* | child [2]
the node's children.

flyArray<flyBspObject *> elem
the clipping elements array (if this node is a leaf).

flyArray<flyBspNode *> | neighbors
the node's neighbors.

flyArray<flyPolygon> portals
linking polygons to the neighbors.

flyVector centre
the centre of the node (if this node is a leaf).

int | leaf
leaf index (-1 if not a leaf).

flyVector color
node's ambient light.

Detailed Description

Node of the BSP tree.

This class implements a node from the bsp tree. If it is a leaf node, then it defines a convex volume in 3D space. The class members are: pointers to children nodes, an array of flyBspObjects that clip the volume, an array of neighbouring nodes, the position of the center of the node and the node's natural ambient light color.


flyBspObject Class Reference

Generic object class. More...

#include <flyBspObject.h>

Inheritance diagram for flyBspObject::

flyBaseObject flyParticle flyLocalSystem flyStaticMesh List of all members.

Public Methods

flyBspObject ()
Default constructor.

flyBspObject (const flyBspObject &in)
Copy-constructor.

void | operator= (const flyBspObject &in)
Atribuition operator.

virtual | ~flyBspObject ()
Default destructor.

void | remove_from_bsp ()
Remove the object from the BSP tree.

virtual int | step (int dt)
Move the object dt miliseconds.

virtual flyBspObject* | clone ()
Get another instance similar to this.

virtual flyMesh* | get_mesh ()
Return the object's polygonal mesh.

virtual void | init ()
Initialisation method called for the stock and before each activation.

virtual void | post_step ()
Extra processing step called after all objects have alreayd done step(). Needs calling flyEngine::post_process() passing the object for utilization.

int | get_param_desc (int i, flyParamDesc *pd)
FlyEditor's parameters description routine for this class.

virtual int | get_custom_param_desc (int i, flyParamDesc *pd)
FlyEditor's parameters description routine for any class derived from this one.

virtual flyMesh* | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum)
Collide ray defined by ray origin (ro) and ray direction (rd) with the object.

virtual int | ray_intersect_test (const flyVector &ro, const flyVector &rd, float dist)
Test for ray-intersection form a ray defined by ray origin (ro) and ray direction (rd) with the object.

int | box_collision (flyVector &destpos, flyVector &destvel, int maxcol=3)
Collide using the object's bounding box.

virtual int | message (const flyVector &p, float rad, int msg, int param, void *data)
Send a message of type msg to all objects defined by the sphere centered on p with radius rad.

virtual void | draw ()
Draw the object in its actual position.

virtual void | draw_shadow ()
Draw the object's shadow.

void | load_default_params (flyFile *file, const char *sec)
Load default parameters from a file.

void | load_params (flyFile *file, const char *sec)
Load parameters from a file.

Public Attributes

int | id
object unique id.

flyBspObject* | source
original object kept as a reference after cloning, NULL if from stock.

flyBoundBox bbox
bounding box used for clipping and colliding.

flyArray<flyBspNode *> clipnodes
BSP nodes clipping the object.

int | latedraw
object's draw layer.

int | lastdraw
last BSP draw id.

int | lastbsprecurse
last BSP recursion id.

int | collide
desired collison style (0: no collision, 1: bounding box collision, 2: full mesh collision).

int | active
active at startup.

flyVector rot
rotation at startup.

Detailed Description

Generic object class.

This class implements an object that exists in the simulation (and therefore is positioned inside one or more BSP tree nodes). This is the parent class of all entities that participate in the simulation. flyBspObject derives from 3 classes: flyParticle, from which it inherits physical entities like position, velocity, mass, bump and friction factors, and more; flyLocalSystem, from which it inherits a coordinate system that represents the orientation of the object in the world; and flyBaseObject, from which it inherits name, type and other identification parameters. The flyBspObject class also features some virtual functions that should be overriden by the classes that inherit them; these methods implement initialization of the object, state update between the frames of the simulation, self-drawing, message receiving, and much more.


flyClassDesc Class Reference

Class description meta-class. More...

#include <flyDesc.h>

List of all members.

Public Methods

virtual flyBspObject* | create ()=0
Instantiate an object of this class.

virtual const char* | get_name ()=0
Get the class' name.

virtual int | get_type ()=0
Get the class' type.

virtual | ~flyClassDesc ()
Destructor.

Detailed Description

Class description meta-class.

This meta-class implements a class description for plugin management and objects instantiation and referencing. Any plugin class that wants to be recognized and referenced by the engine must have a child class from this one, implementing that class' description. It consists of three methods: one for creating a new instanmce of the described class; one for retrieving the class name; and one for retrieving the integer that represents the class type.


flyConsole Class Reference

Console class. More...

#include <flyConsole.h>

List of all members.

Public Methods

flyConsole ()
Default constructor.

virtual | ~flyConsole ()
Default destructor.

void | show ()
Show console.

void | hide ()
Hide console.

void | draw ()
Draw console.

void | step (int dt)
Update console status each frame.

float | draw_text (float x, float y, const char *text) const
Draw text of the current page and command line.

void | key_down (int vk)
Get input from navigation keys.

void | key_char (int vk)
Get input from ordinary text keys.

void | add_string (const char *fmt,...)
Add a string to the console.

int | command_tokens (char *str, char **token) const
Lexical analyser.

void | command_exec (const char *str)
Execute the command.

Public Attributes

int | mode
display mode (mode<0: hide, mode>0: show).

int | time
maximum idle display time before auto-hiding.

int | nlines
total number of strings in the buffer.

int | linecount
number of lines.

int | winlines
number of lines in the window.

int | lic
flag indicating console input lock.

char* | buf [FLY_CONSOLE_MAXLINES]
strings buffer.

char | cmd_line [1024]
input line to be written (command line).

int | cmd_pos
current cursor position.

int | cmd_len
command string length.

int | curr_line
current line index.

int | curr_page
current page index.

float | dx
x cursor position in screen pixels.

float | dy
y cursor position in screen pixels.

Detailed Description

Console class.

This class implements the console, consisting of a command line where you can execute commands. Runtime information can also be printed out on the console, and the navigation keys 'home', 'end', 'page up' and 'page down' can be used to scroll trough messages.


flyDirectx Class Reference

Interface with DirectInput, DirectSound and DirectPlay. More...

#include <flyDirectX.h>

List of all members.

Public Methods

void | Init ()
DirectX initialisation and member variables validation.

void | Release ()
Free the allocated resources and release the devices.

flyDirectx (HWND hwnd, HINSTANCE hinst)
Default constructor, gets the window and instance handlers.

virtual | ~flyDirectx ()
Default destructor.

void | get_input ()
get user input from input devices.

void | zero_input ()
reset all input.

int | load_wav_file (LONG cchBuffer, HPSTR pchBuffer, LPDIRECTSOUNDBUFFER *buf, LPDIRECTSOUND3DBUFFER *buf3d)
load .wav sound file.

LPDIRECTSOUNDBUFFER | clone_sound (LPDIRECTSOUNDBUFFER buf)
clone an existing sound.

void | set_listener (const float *pos, const float *vel, const float *Y, const float *Z)
sets position, velocity and alignment of a listener.

void | set_master_volume (int volume)
set master sound volume.

int | init_multiplayer (const char *netaddress=0)
initialise multiplayer session.

void | free_multiplayer ()
destroy multiplayer session.

flyMPGames* | enum_games (LPGUID app_guid)
get a pointer to the list of available games.

int | join_game (LPGUID game_guid, const char *player_name, unsigned color=0xFF808080)
join an existing game.

int | create_game (LPGUID app_guid, const char *game_name)
create (host) a new game.

char* | get_player_address (DWORD dpid)
get player IP address from its DirectPlay id.

void | send_message (const flyMPMsg *msg, int len, DWORD dpid=0)
send a message over the net.

int | get_num_messages ()
get total number of messages.

flyMPMsg* | get_message (DWORD *size)
get a message.

int | add_player (const char *name, DWORD dpid, void *data, unsigned color=0xFF808080)
add a new player to the environment.

void* | remove_player (int i)
remove a p´layer from the environment.

Public Attributes

HWND | hWnd
application window handle.

HINSTANCE | hInst
instance handle.

LPDIRECTINPUT | lpDI
pointer to DirectInput device.

LPDIRECTINPUTDEVICE | lpKeyboard
pointer to keyboard.

LPDIRECTINPUTDEVICE | lpMouse
pointer to mouse.

LPDIRECTINPUTDEVICE | lpJoystick
pointer to joystick.

LPDIRECTINPUTDEVICE2 | lpJoystickPoll
pointer to joystick poll device.

LPDIRECTSOUND | lpDSound
pointer to DirectSound device.

LPDIRECTSOUNDBUFFER | lpDS3dPrimBuf
pointer to 3D Primary Buffer.

LPDIRECTSOUND3DLISTENER | lpDS3dListener
pointer to 3D Listener.

LPDPSESSIONDESC2 | lpSD
pointer to DirectPlay session descriptor.

LPDIRECTPLAY3A | lpDP
pointer to DirectPlay device.

LPDIRECTPLAYLOBBY2A | lpDPL
pointer to DirectPlay lobby.

GUID | guidInstance
instance of the GUID.

int | mpmode
multiplayer mode.

int | nplayers
number of players.

flyMPPlayerData | players [FLY_MP_MAXPLAYERS]
array of players.

unsigned char | keys [256]
keyboard keys.

int | mouse_pos [2]
current mouse position in screen pixels.

float | mouse_delta [2]
mouse displacement.

float | mouse_smooth [2]
smooooooooooth movement position.

char | mouse_down
bitfield registering which mouse buttons are down.

char | mouse_click
bitfield registering which mouse buttons have been clicked.

int | joy_min_range
joy axis minium range.

int | joy_max_range
joy axis maxium range.

int | joy_dead_zone
joy stick dead zone (if the stick is in the dead zone the pos is returned as centered).

int | joy_axes
joysitck supported axis.

int | joy_down
bitfield registering which joysticks buttons are down.

float | joy_pos [2]
current joystick position.

DIDEVCAPS | joy_caps
joystick capabilities.

Static Public Attributes

float | s_mousespeed = 0.1f
mouse speed.

int | s_invertmousex = 0
flag to invert mouse input in x direction.

int | s_invertmousey = 1
flag to invert mouse input in y direction.

float | s_joyspeed = 2.0f
joystick speed.

int | s_invertjoyx = 0
flag to invert joystick input in x direction.

int | s_invertjoyy = 1
flag to invert joystick input in y direction.

Detailed Description

Interface with DirectInput, DirectSound and DirectPlay.

This class implements friendly methods that compound an interface with the DirectX modules used by Fly3D, namely DirectInput, DirectSound and DirectPlay. Among the member variables are pointers to the various DirectX devices, the total number of online players and an array of player data structures. Various interface methods are supplied for many operations, like: loading playable wave files, reading or zeroing the input buffer, initializing and finishing the multiplayer mode, creating a multiplayer game, adding and removing players from a game, and much more.


flyDll Class Reference

Fly3D plugin DLL class. More...

#include <flyDll.h>

List of all members.

Public Methods

flyDll ()
Default constructor.

virtual | ~flyDll ()
Default destructor.

Public Attributes

HINSTANCE | hdll
instance handle of the plugin DLL.

flyString dll_filename
file name of the plugin DLL.

int | nclasses
number of classes implemented in the plugin.

int (* | num_classes )()
Pointer to the 'num_classes' function of the plugin.

int (* | fly_message )(int msg, int param, void *data)
Pointer to the 'fly_message' function of the plugin.

int (* | get_version )()
Pointer to the 'get_version' function of the plugin.

flyClassDesc* (* | get_class_desc )(int i)
Pointer to the 'get_class_desc' function of the plugin.

int (* | get_global_param_desc )(int i, flyParamDesc *pd)
Pointer to the 'get_global_param_desc' function of the plugin.

Detailed Description

Fly3D plugin DLL class.

This class holds information for each Fly3D plugin DLL, including the number of classes implemented in the DLL, and the pointers to the DLL exported functions.


flyDllGroup Class Reference

DLLs grouping class. More...

#include <flyDll.h>

List of all members.

Public Methods

flyDllGroup ()
Default constructor.

virtual | ~flyDllGroup ()
Default destructor.

void | reset ()
Free all data.

int | add_dll (const char *filename)
Add a new DLL to the group, given its file name.

int | delete_dll (const char *filename)
Delete a DLL from the group, given its file name.

void | move_dll (const char *filename, int newrelpos)
Move a DLL inside the group to the desired new relative position 'newrelpos'.

int | send_message (int msg, int param, void *data) const
Send a message to all plugin DLLs in the group.

void | load_all_classes (flyFile *file)
Load all classes used by the given .fly file.

void | load_params (int d, flyFile *file)
Load global parameters from the plugin DLLs specified by 'd'.

void | load_classes (int d, flyFile *file)
Load all classes from the plugin DLLs specified by 'd'.

void | load_default_param (flyBspObject *o, const char *sec, flyFile *file)
Load all the default parameters for the specified object 'o'.

void | delete_class (flyBspObject *o)
Delete an object from the scene, along with all references to it.

void | delete_references (flyBspObject *o)
Delete all the references of the given object 'o'.

flyBspObject* | add_class (const char *name)
Create a new object from a plugin DLL through its class name.

Public Attributes

int | ndll
number of DLLs in the group.

flyDll** dll
list of DLLs in the group.

int | ncd
total number of classes implemented in all DLLs in the group.

flyClassDesc** cd
list of all classes from all the DLLs in the group.

Detailed Description

DLLs grouping class.

This class implements a group of Fly3D plugin DLLs. Each DLL can enumerate any number of flyBspObject derived classes.


flyEngine Class Reference

Fly3D engine class. More...

#include <flyEngine.h>

List of all members.

Public Methods

void | play_demo (const char *file)
starts playing a demo file (.fdm).

void | record_demo (const char *file)
starts recording a demo file (.fdm).

int | step ()
Update scene for elapsed time from last frame.

void | step (int dt)
Update scene for elapsed time dt in miliseconds.

void | step_init (int dt)
Update scene method initial commands.

void | step_objects (int dt)
Update scene method object commands.

void | step_end (int dt)
Update scene method final commands.

void | draw_bsp ()
Draw all scene viewed from the current camera.

void | draw_faces (int nfd, flyFace **fd, flyVertex *v, int sort=1)
Draw the given faces.

void | draw_frame ()
Send drawing messages to all objects and draw everything in the current frame.

int | collision_bsp (const flyVector &p1, const flyVector &p2, int elemtype=0)
Collision detection from p1 to p2, computes the closest collision.

int | collision_test (const flyVector &p1, const flyVector &p2, int elemtype=0)
Collision detection from p1 to p2, returns when finds the first collision.

void | recurse_bsp (const flyVector &p, float rad, int elemtype, int pvsleaf=-1)
Recurse the BSP selecting nodes and objects clipped by the sphere centered at p with radius rad.

void | recurse_bsp (const flyVector &p1, const flyVector &p2, int elemtype, int pvsleaf=-1)
Recurse the BSP selecting nodes and objects between p1 and p2.

void | recurse_bsp (const flyVector *p, int np, int elemtype, int pvsleaf=-1)
Recurse the BSP selecting nodes and objects clipped by the volume defined by the array of points p.

void | recurse_bsp_box (const flyVector &min, const flyVector &max, int elemtype, int pvsleaf=-1)
Recurse the BSP selecting nodes and objects clipped by the box defined by min and max.

void | send_bsp_message (const flyVector &p, float rad, int msg, int param, void *data, int elemtype=0, int pvsleaf=-1)
Recurse the BSP sending messages to all selected objects.

flyBspNode* | find_node (const flyVector &p) const
Recurse the BSP and return the node where the point p is located.

int | find_path (const flyVector &source, const flyVector &sourcedir, float sourceradius, const flyVector &dest, flyBezierCurve &curve)
Path finding.

void | add_to_bsp (flyBspObject *obj)
Add an object to the BSP tree.

int | open_fly_file (const char *file)
Open a .fly file.

void | close_fly_file ()
Close a .fly file.

int | save_fly_file (const char *file)
Save to a .fly file.

void | console_printf (const char *fmt,...)
Print a string out on the console.

int | get_picture (const char *file, int droplevel=0)
Load a picture to the texture cache or return its index if already loaded.

int | load_shaders (const char *file)
Load a shader file.

flyMesh* | get_model_object (const char *name)
Get a mesh object by its filename (tga,jpg).

flySound* | get_sound_object (const char *name)
Get a sound object by its filename (wav).

flyBezierCurve* | get_bezier_curve (const char *name)
Get a bezier curve by its filename (bez).

int | get_input_map (const char *name)
Get a input map.

int | check_input_map (int i, int clicked=0)
Checks the given input map for input.

int | set_obj_param (const char *objname, const char *param, const char *value)
Set an object's parameter value.

int | get_obj_param (const char *objname, const char *param, flyString &value) const
Get an object's parameter value.

int | set_global_param (const char *name, const char *value)
Set a global parameter value.

int | get_global_param_desc0 (int num, flyParamDesc *pd)
Get the value for a global parameter (scene, non-scene or from plugin).

int | get_global_param_desc1 (int i, flyParamDesc *pd)
Get the value of a non-scene dependant global parameter.

int | get_global_param_desc2 (int i, flyParamDesc *pd)
Get the value of a scene dependant global parameter.

void | activate (flyBspObject *d)
Activate an object from the stock.

void | set_camera (flyBspObject *d)
Sets the current camera to the given object.

virtual void | add_post_step (flyBspObject *o)
Adds object to post processing list (executed after all objects step() and before any draw).

int | join_multiplayer (const char *addr, int num=0)
Join a multiplayer game.

void | close_multiplayer ()
Remove the player form the server.

void | check_multiplayer ()
Check for multiplayer messages (should be called every frame in a multiplayer game).

void | process_multiplayer (int from, int size, const flyMPMsg *msg)
Process one multiplayer message.

void | load_default_tex (const char *path)
Load the default texture (fonts and console).

int | lock_input (int free=0)
Used to lock all input from game. Call with no parameters (0) to lock and pass the return value to unlock. Only one concurrent lock can exist so test return value for -1 (lock fail).

int | load_ini ()
Load Fly3D configuration file (Fly3D.ini).

int | save_ini ()
Save Fly3D configuration file (Fly3D.ini).

flyEngine ()
Default constructor.

virtual | ~flyEngine ()
Default destructor.

Public Attributes

HWND | hwnd
Window handle.

HINSTANCE | hinst
Instance handle.

int | cur_step
current step (each call to each object step function in each frame has an unique id).

int | cur_step_base
current step base (first step id for current frame).

int | cur_frame
current frame.

int | cur_frame_base
current frame base (multiple renders are possible in different viewports).

int | cur_bsprecurse
current BSP recursion (each call to each BSP recursion method from each object in each frame has an unique id).

int | cur_time
current time in ms.

int | cur_dt
current elapsed time from last frame in ms.

int | force_dt
current elapsed time from last frame in ms.

float | cur_time_float
current time in floating point format.

int | start_time
global start time.

int | level_start_time
level start time.

int | frame_rate
current frame rate (frames per second).

int | frame_count
total number of frames.

int | fraglimit
multiplayer game frag limit.

int | timelimit
multiplayer game time limit.

int | restarttime
multiplayer game restart time.

int | T0
last frame time.

int | T1
current frame time.

flyDllGroup dll
all plugin DLLs in current scene.

flyConsole con
console interface.

flyBspObject* player
current player.

flyBspObject* cam
current camera.

flyFrustum view
current view frustum.

double | cam_proj_mat [16]
camera projection matrix.

double | cam_model_mat [16]
camera model matrix.

int | cam_viewport [4]
camera viewport.

flyBspObject* excludecollision
object to exclude from collision.

int | nnodedraw
total number of drawn nodes.

int | ntotfacedraw
total number of drawn faces.

int | ntotelemdraw
total number of drawn elements.

flyArray<flyBspObject *> | objdraw [FLY_MAX_OBJDRAWLAYERS]
objects to draw in current render.

flyArray<flyFace *> facedraw
faces to draw in current render.

flyArray<flyFace *> facedrawtransp
transparent faces to draw in current render.

flyString flysdkpath
the sdk path (c:\flysdk\).

flyString flysdkdatapath
the sdk data path (c:\flysdk\data\).

flyString flysdkpluginpath
the sdk plugin path (c:\flysdk\plugin\).

flyString flyfile
the .fly file (ship\ship.fly).

flyString flyfilepath
the .fly path (c:\flysdk\data\ship\).

flyString flyfilename
the .fly full file name (c:\flysdk\data\ship\ship.fly).

flyString bspfile
the bsp file (ship).

flyString status_msg
last message.

flyString console_command
command(s) to exectue.

flyString playername
player name for multiplayer games.

flyVector playercolor
player color on multiplayer games.

unsigned | status_msg_time
time of the status string message.

flyBoundBox bbox
scene bounding box.

float | bboxdiag
scene bounding box diagonal.

float | geomdetail
level of geometric detail.

float | curveerr
level of curve error.

float | shadowdist
shadow distance from the object.

float | gravity
scene gravity.

flyVector bboxcenter
scene bounding box center.

flyVector filter
screen filter color.

flyVector shadercolor
current shader color.

flyVector shadowcolor
shadow color.

int | debug
debug mode (0: no debug, 1: debug).

int | appid
frontend application id.

int | pvsoff
PVS mode (0: PVS culling, 1: no PVS).

int | mpdelay
multiplayer message delay time.

int | antialias
antialiasing mode (0: no antialiasing, 1: antialiasing on).

int | shadows
shadow flags (bit0: backface cull, bit1: suqare attenuation, bit2: N dot L attenuation, bit3: bspfaces shadows).

int | collisionmode
bool to indicate current collision mode (1: pre-illumination, 2: pvs calculation).

int | noinput
block input (0: normal, 1: no input).

int | mute
mute flag (0: normal sound, 1: no sound).

int | mouse
display mouse flag (0: no mouse display, 1: mouse normal draw).

int | nodeonly
draw only the node containing the camera.

int | status
2D drawing flag (0: no 2D drawing, 1: normal 2D drawing).

int | crosshairpic
crosshair picture, leave blank for no crosshair.

int | crosshairsize
crosshair size in pixels.

int | loading
scene loading flag.

int | multitexture
multitexture mode (0: no multitexturing, 1: multitexturing on).

int | fogmap
fogmap flag (0: no fogmap, 1: fogmap on).

int | shadermask
bitfield for masking shader passes.

int | dynlight
dynamic lighting flag (0: off, 1: on).

int | mastervolume
master volume for all sounds (0:maximum, <0:lower).

int | picrender
flag to indicate rendeing to a picture or texture (0: normal render, 1: render to pictire, 2: render to texture).

int | sse
flag to switch the use of Intel Pentium3 SSE intructions on/off.

int | vertprog
flag to switch the use of NVidia vertex programs on/off.

int | octree
flag to switch the use of octrees for static and dynamic object.

int | bsppicflipy
flag to invert pictures from the bsp shader file (flip in y dir).

flyHashList active_objs
hash linked list of active objects.

flyHashList stock_objs
hash linked list of stock script objects.

flyHashList resource_objs
hash linked list of resource objects derived from flyBaseObject (flySound, flyBezierCurve, flyMesh, flyAnimatedMesh and flySkeletonMesh).

flyBspObject* hitobj
current hit object.

flyMesh* hitmesh
current hit mesh.

int | hitface
current hit face.

int | hitsubface
current hit subface.

int | hitshader
current hit face shader.

flyVector hitip
last collision intersection point.

flyVector hitnormal
last collision hit normal.

float | hitdist
last collision hit distance.

flyVertex* vert
vertex array for BSP faces.

int | nvert
total number of vertices in the 'vert' array.

flyFace* faces
face array for the BSP.

int | nfaces
total number of faces in the 'faces' array.

flyVector* en
edge array for BSP faces.

int | nen
total number of edges in the 'en' array.

flyArray<flyShader *> shaders
shaders dynamic array.

flyBspNode* bsp
the BSP tree root.

flyArray<flyBspNode *> selnodes
array of selected nodes from the last BSP recursion.

flyArray<flyBspObject *> selobjs
array of selected objects from the last BSP recursion.

flyArray<flyLightMap *> lm
individual light maps.

flyArray<flyLightMapPic *> lmpic
light map picture groups array.

int | lmbase
offset into texture array for light map pictures.

flyArray<int> | lmchanged
indices of all changed light maps.

flyArray<flyLightMap *> fm
individual fog maps.

flyArray<flyLightMapPic *> fmpic
fog map picture groups array.

int | fmbase
offset into texture array for fog map pictures.

flyArray<int> | fmchanged
indices of all changed fog maps.

flyArray<int> | facechanged
indices of all changed triangle mesh faces.

char* | pvs
pvs bit array.

flyBspNode** leaf
BSP tree leaf array.

int | nleaf
total number of leaves in the BSP tree.

int | pvssize
size of the PVS array in bytes.

int | pvsrowsize
size of each PVS row in bytes.

flyArray<flyInputMap> inputmaps
array of input maps.

flyArray<flyBspObject *> poststeps
array with post step needed objects.

int | timedemo
flag indicating timedemo mode.

int | timedemoframes
total timedemo frames already played.

FILE* | demo_file_out
file dor demo recording.

flyFile* demo_file_in
file for demo playback.

Protected Methods

int | smooth_path (const flyArray< flyVector > &path, flyArray< flyVector > &newpath)
Smooth the path by dropping unnecessary vertices.

Detailed Description

Fly3D engine class.

This is the interface class with the engine. Its members represent all the engine-related options available in Fly3D, and a few examples are: the current time, pointers to the current camera and player objects, the path where the engine was installed, the path for the resources, and much more. The methods provided by the flyEngine class vary from offline procedures like the load/save methods, BSP building and static lighting calculus functions to simulation-time methods like adding/removing objects from the scene, drawing the current frame viewed by the current active camera, recursing the BSP for calculus of any kind, and much, much more.


flyFace Class Reference

General face class. More...

#include <flyFace.h>

Inheritance diagram for flyFace::

flyPlane List of all members.

Public Methods

flyFace ()
Copy-constructor.

virtual | ~flyFace ()
Atribuition operator.

void | compute_normals (int flag)
Compute face and face edges normals.

int | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
Compute ray intersection with the face.

int | ray_intersect_test (const flyVector &ro, const flyVector &rd, float dist) const
Test for ray intersection with the face (faster but only a bool result with no intersection info).

int | ray_intersect_tri (int *facesindx, int facesnum, const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
Compute ray intersection with the triangle mesh faces specified in the facesindx list (used by octree ray_intersect).

int | ray_intersect_tri_test (int *facesindx, int facesnum, const flyVector &ro, const flyVector &rd, float dist) const
Test for ray intersection with the triangle mesh faces specified in the facesindx list (used by octree ray_intersect_test, faster but only a bool result with no intersection info).

void | inverse_map (const flyVector &p, float &u, float &v) const
Convert point p in face u,v coordinates.

void | forward_map (float u, float v, flyVector &p) const
Convert face u,v coordinates to point p.

void | set_ntrivert (int n3v)
Allocate vertices for a triangle mesh face.

Public Attributes

int | facetype
Face type.

int | flag
Face flags (0:detail, 1:structure).

int | nvert
number of vertices.

int | vertindx
index of the first vertex.

flyVertex* vert
pointer to the first vertex.

flyVector* en
edge normals pointer.

int | ntriface
Traingular surfaces: number of triangular faces.

int | ntrivert
Traingular surfaces: number of vertices.

int* | trivert
Traingular surfaces: pointer to the first of the triangular vertices.

int | patch_npu
Patches: number of points in u.

int | patch_npv
Patches: number of points in v.

flyBezierPatch* patch
Patches: pointer to the patch class.

flyVector pivot
Patches: the patch's pivot position.

int | sh
applied shader index.

int | lm
lightmap index.

int | indx
index into faces array.

int | sortkey
draw sort key.

int | lastbsprecurse
last BSP recursion id.

int | lastupdate
last vertex illumination step id.

flyBoundBox bbox
the face's bounding box.

flyOcTree* octree
Default constructor.

Detailed Description

General face class.

This class implements a face of any type supported by the engine, which are:

Large convex polygons Bi-quadratic Bezier patches Triangular surfaces Triangular strips Triangular fans

Its members are: the face type (an integer representing one of the types enumerated above), the number of vertices of the face, a pointer ti the first vertex in the engine's vertex array, and many other members specific to each type of face. Among the methods provided by this class are: computing the normal of the face and computing ray-intersection with the face.


flyFile Class Reference

Fly3D scene data file management class. More...

#include <flyFile.h>

List of all members.

Public Methods

flyFile ()
Default constructor.

virtual | ~flyFile ()
Default destructor.

void | build_ziplist (flyString path)
Build the zip list with all packed files.

void | build_table ()
Build a array or array of strings for fast text reads of fly files.

void | unzip (const char *)
Unzip a zipped file.

void | seek (int offset)
Seek a position in the file.

bool | open (const char *filename)
Open a file by its given file name.

void | close ()
Close the file.

int | read (void *dest, int size)
Read 'size' bytes from the file (beginning at the current position 'pos') into the 'dest' buffer.

int | get_profile_string (const char *section, const char *key, flyString &dest)
Get a string from the profile.

void | get_string (flyString &dest)
Get a string from the file.

int | get_int ()
Get an integer from the file.

float | get_float ()
Get an floating point from the file.

Public Attributes

unsigned char* | buf
the file data buffer.

int | pos
current position in the file.

int | len
length of the file.

flyStringArray2* | table
Table with text file itens as an array of array of strings Each group (named like '[groupname]') has an array of parameter strings (in the form 'param=data').

Static Public Attributes

flyStringArray2* | ziplist = 0
List of all files included in all zip packs inside the current data folder.

Detailed Description

Fly3D scene data file management class.

This class implements a manager and interface for Fly3D's scene data files (.fly files). Its members are a pointer to a data buffer containing the file load on memory, the current access position in the file and the total length of the file. Among the methods available in this class are: opening and closing a file, seeking a position in it, unzipping a zipped file, reading a certain amount of data from the file, and more.


flyFrustum Class Reference

View frustum class. More...

#include <flyFrustum.h>

List of all members.

Public Methods

flyFrustum ()
Default constructor.

flyFrustum (const flyFrustum &in)
Copy-constructor.

virtual | ~flyFrustum ()
Default destructor.

int | clip_bbox (const flyBoundBox &bbox) const
Test the given bounding box against the frustum for clipping.

void | build (const flyVector &pos, const flyVector &X, const flyVector &Y, const flyVector &Z, float camangle=flyRender::s_camangle, float aspect=flyRender::s_aspect, float farplane=flyRender::s_farplane)
Build the view frustum from position 'pos' and system given by (X,Y,Z).

void | draw () const
Draw the view frustum.

Public Attributes

flyVector | verts [5]
the frustum vertices.

flyVector | planes [5]
the frustum planes.

int | bboxindx [8][3]
the frustum bounding box's vertices index.

Detailed Description

View frustum class.

This class implements a view frustum, storing its vertices and planes. A frustum building method and an aggressively fast bounding box clipping test for view culling are also provided. The class stores the frustum vertices and planes as member variables.


flyHashList Class Reference

Hash of flyBaseObject linked lists. More...

#include <flyHashList.h>

List of all members.

Public Methods

flyHashList ()
Default constructor.

virtual | ~flyHashList ()
Default destructor.

void | reset ()
Resets the whole list.

void | add (flyBaseObject *obj)
Add an object to the list.

void | remove (flyBaseObject *obj)
Remove an object from the list.

flyBaseObject* | get_object_name (const char *name, int type=0) const
Retrieve an object with the given name.

flyBaseObject* | get_object_longname (const char *long_name, int type=0) const
Retrieve an object with the given long name.

flyBaseObject* | get_next_object (const flyBaseObject *o, int type=0) const
Get the object that follows the given one.

Public Attributes

flyArray<int> | m_hash
the primary hash list, ordered by object type.

flyArray<flyBaseObject *> m_list
the secondary hash lists.

flyArray<flyBaseObject *> m_last
the last objects of the lists.

Detailed Description

Hash of flyBaseObject linked lists.

This class implements a hash table of flyBaseObject derived classes. The hash is organized by class type and for each class type a list of flyBaseObject derived classes is available.


flyInputMap Class Reference

Class representing input maps. More...

#include <flyInputMap.h>

List of all members.

Public Methods

flyInputMap ()
Default constructor.

flyInputMap (const flyInputMap &in)
Copy-constructor.

void | operator= (const flyInputMap &in)
Atribuition operator.

virtual | ~flyInputMap ()
Default destructor.

Detailed Description

Class representing input maps.

This class implements a Input Map, i.e. a data structure that maps keyboard keys and mouse buttons into game actions. Its members are the name of the input map, the keyboard key and the mouse buttons assigned to it.


flyLightMap Class Reference

Light map class. More...

#include <flyLight.h>

List of all members.

Public Methods

void | set_base (const flyFace *f, const flyLightMapPic *lmp, const flyVector &pos=flyVector(0, 0, 0))
Precompute internal data required when mapping points from the light map space into world space and vice-versa.

void | map_point (float u, float v, flyVector &point) const
Map a point from the light_map (u,v) into world coordinates.

void | map_point_local (float u, float v, flyVector &p, flyVector &n) const
Map a point from the local light_map (u,v) into world coordinates.

virtual void | illum (const flyVector &pos, const flyVector &color, float radius, int shadows)
Dynamicaly illuminate the light map pixels based on the given parameters.

void | load (const flyLightMapPic *lmp)
Restore the light map pixels from flyLightMapPic.

void | save (flyLightMapPic *lmp) const
Save the light map to flyLightMapPic.

flyLightMap (int f, int p, int x, int y, int sx, int sy, int bp=3)
Default constructor.

virtual | ~flyLightMap ()
Default destructor.

Public Attributes

int | lastupdate
last frame in which this light map was changed.

int | pic
flyLightMapPic index.

int | offsetx
x offset into the light map picture.

int | offsety
y offset into the light map picture.

int | sizex
x size of the light map (no need for being power of 2).

int | sizey
y size of the light map (no need for being power of 2).

int | facenum
face index for one face using this light map.

unsigned char* | bmp
light map bitmap.

int | bytespixel
number of bytes per pixel (3: RGB, 4: RGBA).

int | bytesx
number of bytes per line (sizex*bytespixel).

int | bytesxy
total bytes of the bitmap (bytesx*sizey).

flyVector d0
base value used for illumination calculations.

flyVector d1
base value used for illumination calculations.

flyVector d2
base value used for illumination calculations.

Detailed Description

Light map class.

This class implements a light map. Several faces can share the same light map and many light maps can share the same light map picture.


flyLightMapPic Class Reference

Light map picture class. More...

#include <flyLight.h>

List of all members.

Public Methods

flyLightMapPic (int sx, int sy, int bp=3)
Default Counstructor, passing the size in x and y, and the number of bytes per pixel.

virtual | ~flyLightMapPic ()
Default destructor.

Public Attributes

unsigned char* | bmp
the light maps bitmap.

int | sizex
x size of the picture (power of 2).

int | sizey
y size of the picture (power of 2).

int | bytesx
number of bytes per line (sizex*bytespixel).

int | bytesxy
total bytes of the bitmap (bytesx*sizey).

int | bytespixel
the light map bytes per pixel (3: RGB, 4: RGBA).

Detailed Description

Light map picture class.

This class implements the light map texture used when drawing. This texture can have several light map pictures in it as many instances of the flyLightMap class will use a single flyLightMapPic.


flyLightVertex Class Reference

Dynamic hardware lights class. More...

#include <flyLight.h>

List of all members.

Public Methods

flyLightVertex ()
Default constructor.

flyLightVertex (const flyLightVertex &in)
Copy-constructor.

~flyLightVertex ()
Destructor.

void | operator= (const flyLightVertex &in)
Atribuition operator.

void | add_light (const flyVector &p, const flyVector &c, float r)
Add a new dynamic light.

void | add_light (const flyVector &p, const flyVector &c, float r, const flyVector &objpos)
Add a new dynamic light sorted by distance to objpos.

void | init_draw (const flyBspObject *obj) const
Initialise drawing.

int | get_closest (const flyVector &p) const
Get the closest light to the given point.

Public Attributes

int | nlights
number of lights.

int | frame
number of the frame the lights wore added.

flyVector | pos [FLY_MAX_HWLIGHTS]
position of each light.

flyVector | color [FLY_MAX_HWLIGHTS]
color of each light.

float | radius [FLY_MAX_HWLIGHTS]
radius of each light.

Detailed Description

Dynamic hardware lights class.

This class holds information on dynamic hardware lights. When a dynamic object receives a FLY_OBJMESSAGE_ILLUM message it adds the light parameters to this class with the 'add_light' method. When rendering, it calls the 'init_draw' method before drawing the mesh to get the hardware lights in place. After finishing the render it calls 'end_draw' to reset the hardware lights.


flyLocalSystem Class Reference

Local coordinates system class. More...

#include <flyLocalSystem.h>

Inheritance diagram for flyLocalSystem::

flyBspObject flyStaticMesh List of all members.

Public Methods

void | update_mat ()
Update the rotation matrices.

void | rotate (const flyVector &rot)
Rotate the local system axis by 'rot'.

void | rotate (float ang, const flyVector &v)
Rotate the local system axis of angle 'ang' around vector 'v'.

void | rotate (const flyVector &v, const flyVector &u, float maxang=360)
Rotate the local system axis from 'v' to 'u', in the plane defined by 'v' and 'u', at a maximum angle of 'maxang' degrees.

void | align_z (const flyVector &z)
Align the z axis of the local system with the given vector.

flyLocalSystem ()
Default constructor.

flyLocalSystem (const flyLocalSystem &in)
Copy-constructor.

void | operator= (const flyLocalSystem &in)
Atribuition operator.

virtual | ~flyLocalSystem ()
Default destructor.

Public Attributes

flyVector X
x vector in the base axis.

flyVector Y
y vector in the base axis.

flyVector Z
z vector in the base axis.

flyMatrix mat
rotation matrix.

flyMatrix mat_t
transpose of the rotation matrix.

Detailed Description

Local coordinates system class.

This class implements a local coordinates system defined by three perpendicular vectors (the base axis). The class members are the unitary vectors X, Y and Z that define the system, the rotation matrix that maps the system to world coordinates and the transpose of this matrix (stored for efficiency. The methods available include updating the rotation matrices, rotating the system and aligning the Z vector with a given direction.


flyMatrix Class Reference

Matrix class compound of 4x4 floating point real numbers. More...

#include <flyMath.h>

List of all members.

Public Methods

flyMatrix ()
Default constructor, sets the identity matrix.

flyMatrix (const flyMatrix &in)
Copy-constructor.

void | operator= (const flyMatrix &in)
Atribuition operator.

void | null (void)
Nullify all elements.

void | load_identity (void)
Load the identity matrix.

void | set_rotation (float ang, const flyVector &dir)
Set the matrix as the rotation matrix of angle given by 'ang' around direction 'dir'.

void | rotate (float ang, const flyVector &dir)
Multiply the matrix by another with rotation given by 'ang' around direction 'dir'.

void | lerp (const flyMatrix &m1, const flyMatrix &m2, float t)
Interpolate between two rotation matrices using quaternions.

flyMatrix | operator * (const flyMatrix &m1) const
Multiplication operator.

Public Attributes

float | m [4][4]
matrix elements.

Detailed Description

Matrix class compound of 4x4 floating point real numbers.

This class implements a 4x4 matrix. The matrix can represent any linear transformation and is used for rotation, translation, scaling, etc...


flyMesh Class Reference

Polygonal mesh class. More...

#include <flyMesh.h>

Inheritance diagram for flyMesh::

flyBaseObject flyAnimatedMesh flySkeletonMesh List of all members.

Public Methods

flyMesh ()
Default constructor.

flyMesh (const flyMesh &in)
Copy-constructor.

void | operator= (const flyMesh &in)
Atribuition operator.

virtual | ~flyMesh ()
Default destructor.

virtual void | reset ()
Free the object.

virtual void | draw ()
Draw all object's faces.

void | draw_shadow_volume (const flyVector &lightdir)
Draw stencil shadow volume.

void | draw_plain ()
Draw raw geometry only.

void | compute_normals (int flag=7)
Load the mesh normals.

int | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
Compute ray intersection with all object's faces.

int | ray_intersect_test (const flyVector &ro, const flyVector &rd, float dist)
Return on first ray intersection.

void | illum_faces (const flyVector &ip, float d_max, const flyVector &c, int shadows) const
Dynamicaly illuminate the object's faces.

virtual int | save (const char *file) const
Save the mesh to a file.

virtual int | load (const char *file)
Load the mesh from a file.

void | set_numverts (int nverts, int keep=0)
Set the number of vertices.

void | set_numfaces (int nfaces, int local, int keep=0)
Set the number of faces.

void | set_numen (int numen, int keep=0)
Set the number of edge normals.

Public Attributes

int | nf
number of faces.

int | nv
numver of vertices.

int | nen
number of edge normals.

flyFace** faces
the faces.

flyFace* localfaces
the local faces.

flyVertex* localvert
the local vertices.

flyVector* localen
the local edge normals.

flyVector pivotpos
pivot position.

flyBoundBox bbox
mesh bounding box.

flyVector color
color multiplier.

int | lastdraw
last frame in ehich the mesh was drawn.

int | nanims
number of animations.

int | lastintesectedface
index of last face intersected (-1 for none).

Detailed Description

Polygonal mesh class.

This class implements a 3D object polygonal mesh. Its faces may reference the local faces or the global engine BSP faces. The class members are the number of faces and vertices of the mesh, as well as pointers to the faces, vertices and edge normals. The methods supplied are for ray-intersection, normals computation, illumination, and much more.


flyMPGames Class Reference

Multiplayer games database. More...

#include <flyDirectX.h>

List of all members.

Public Methods

flyMPGames ()
Default constructor.

Public Attributes

int | num
number of games.

char | name [FLY_MP_MAXGAMES][128]
games' names.

int | num_players [FLY_MP_MAXGAMES]
number of players in each game.

GUID | guid [FLY_MP_MAXGAMES]
GUID of each game.

Detailed Description

Multiplayer games database.

This class implements a databse that holds all information concerning the currently online multiplayer game sessions, with information about the total number of sessions and the name and number of players in each session.


flyMPMsg Class Reference

Multiplayer message. More...

#include <flyDirectX.h>

List of all members.

Public Attributes

DWORD | type
message type.

DWORD | from
message sender player index.

char | data [500]
message data of 500 bytes maximum.

Detailed Description

Multiplayer message.

This class implements a minimized data structure for exchanging info in a multiplayer game. Among its members are a message type identifier, a sender identifier and the data buffer itself.


flyMPPlayerData Class Reference

Multiplayer player data. More...

#include <flyDirectX.h>

List of all members.

Public Methods

flyMPPlayerData ()
Default constructor.

Public Attributes

DWORD | type
player type.

DWORD | dpid
player's id in DirectPlay.

char | name [128]
player's name.

unsigned | color
player's color (ARGB).

void* | data
any additional data.

Detailed Description

Multiplayer player data.

This class implements a data structure for storing information concerning a player in the multiplayer environment. Among its members are the player's DirectPlay identification number, his name and characteristic color.


flyOcTree Class Reference

OcTree class. More...

#include <flyOcTree.h>

List of all members.

Public Methods

flyOcTree ()
Default constructor.

virtual | ~flyOcTree ()
Default destructor.

flyOcTree (flyOcTree &in)
Copy constructor.

void | operator= (flyOcTree &in)
Operator equal.

void | reset ()
Free the tree data.

void | build_tree (flyFace *f)
Builds the octree for the given triangle face or Bezier face.

int | ray_intersect_test (const flyVector &ro, const flyVector &rd, float dist) const
recurse octree and ray intersect test the triangles (just bool resoult with no intersection info).

int | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
recurse octree and ray intersect the triangles for the closest collision.

void | draw ()
draw the bbox as wireframe.

Public Attributes

flyOcTreeNode* root
Root node for octree.

flyFace* face
Face from where octree was created.

Detailed Description

OcTree class.

This class implements an octree and is used to subdivide the space for complex detail triangle meshes and Bezier curved faces speeding up collision detection with its triangles (used for point collision and bbox collision)


flyOcTreeNode Class Reference

OcTree node class. More...

#include <flyOcTree.h>

List of all members.

Public Methods

flyOcTreeNode ()
Default constructor.

virtual | ~flyOcTreeNode ()
Default destructor.

flyOcTreeNode (flyOcTreeNode &in)
Copy constructor.

void | build_node (int *triverts, flyVertex *verts)
Split faces into child nodes if a subdivison is need (used on the octree build process).

Public Attributes

flyBoundBox bbox
Node bound box.

flyArray<int> | faces
Node triangle faces.

flyOcTreeNode* | nodes [8]
Node childs.

Detailed Description

OcTree node class.

This class implements an octree node used to speed up collision detection with detail trinagle meshes or curved Bezier faces.


flyParamDesc Class Reference

Parameter description class. More...

#include <flyDesc.h>

List of all members.

Public Methods

const char* | get_string () const
Get a string.

void | set_string (const char *str)
Set a string.

virtual | ~flyParamDesc ()
Destructor.

Public Attributes

flyString name
parameter name.

int | type
parameter type.

void* | data
parameter value.

Detailed Description

Parameter description class.

This class holds information on Fly3D plugin object parameters. Each class defined in a Fly3D plugin (derived from flyBspObject) can have any number of parameters. Each parameter must have an associated flyParamDesc class describing its data. The flyParamDesc class encloses the parameter's name, type and value, and is very useful in parameter-editing front-ends, like flyEditor.


flyParticle Class Reference

Single particle class. More...

#include <flyParticle.h>

Inheritance diagram for flyParticle::

flyBspObject flyStaticMesh List of all members.

Public Methods

int | compute_collision (flyVector &p, flyVector &v)
Computes particle collision.

int | step (int dt)
Move the particle 'dt' miliseconds.

flyParticle ()
Default constructor.

flyParticle (const flyParticle &in)
Copy-constructor.

void | operator= (const flyParticle &in)
Atribuition operator.

virtual | ~flyParticle ()
Default destructor.

Public Attributes

flyVector pos
particle position.

flyVector vel
particle velocity.

flyVector force
particle force.

float | mass
particle mass.

float | bump
particle bump factor (0..1).

float | friction
particle friction factor (0..1).

int | life
particle life in miliseconds.

int | colflag
particle collision flag (0: no collision, 1: collide, 3: collide and die).

Detailed Description

Single particle class.

This class implements a single, invisible, particle. Its members are mainly physical entities like position, velocity, mass and bump and friction factors. Among the methods are collision computing and the step function, which moves the particle every frame.


flyPicture Class Reference

Picture image class. More...

#include <flyPicture.h>

List of all members.

Public Methods

flyPicture ()
Default constructor.

flyPicture (flyPicture &in)
Copy-constructor.

void | operator= (const flyPicture &in)
atribuition operator.

virtual | ~flyPicture ()
Default Destructor.

int | LoadJPG (const unsigned char *data, int len, int flipy=0)
Load a .jpg image.

int | LoadTGA (const unsigned char *data, int len, int flipy=0)
Load a .tga image. Only 24 or 32 bits/pixel images are supported, uncompressed or RLE compressed.

int | SaveTGA (const char *file)
Save a .tga image.

int | SaveJPG (const char *file, int quality=85)
Save a .jpg image at specified quality factor (0-100).

int | SaveJPG (FILE *fp, int quality=85)
Save a .jpg image at specified quality factor (0-100).

void | CreatePicture32 (int xd, int yd)
Allocate the memory required for the a 32-bit picture with the specified dimensions. The buffer allocated is xc*yd*4 bytes.

void | CreatePicture24 (int xd, int yd)
Allocate the memory required for the a 24-bit picture with the specified dimensions. The buffer allocated is xc*yd*3 bytes.

void | CheckSize (int maxlevel)
Resamples the image to the closest power of 2 dimensions.

void | FreePicture (void)
Free all data allocated by the picture.

void | FlipY ()
Flips picture in Y axis (first line turns to last line).

Public Attributes

char | name [256]
picture filename.

int | sx
x size in pixels.

int | sy
y size in pixels.

int | bytespixel
number of bytes per pixel (24 or 32).

int | size
size in bytes for the image (sx*sy*bytespixel).

unsigned char* | buf
image pixels.

Detailed Description

Picture image class.

This class implements a picture with 24 or 32 bits/pixel. The picture pixels are allocated in a single array of bytes (buf[0]) and the other variables are just shortcuts to the picture lines (buf[1] to buf[sy-1]).


flyPlane Class Reference

Plane representation class. More...

#include <flyMath.h>

Inheritance diagram for flyPlane::

flyBspNode flyFace flyPolygon List of all members.

Public Methods

flyPlane ()
Default constructor.

flyPlane (const flyVector &n, float dist)
Constructor from components.

flyPlane (const flyPlane &in)
Copy-constructor.

void | operator= (const flyPlane &in)
Atribuition operator.

float | distance (const flyVector &v) const
Compute the perpendicular distance from a point to the plane.

int | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist)
Intersect a ray (ro,rd) with the plane and return intersection point (ip) and distance to intersection (dist).

Public Attributes

flyVector normal
Plane normal.

float | d0
Perpendicular distance from the plane to the origin.

Detailed Description

Plane representation class.

This class implements a plane is 3D space. Classes like the bsp_node and face derive from a plane.


flyPolygon Class Reference

Polygon representation class. More...

#include <flyPolygon.h>

Inheritance diagram for flyPolygon::

flyPlane List of all members.

Public Methods

flyPolygon ()
Default constructor.

flyPolygon (const flyPolygon &in)
Copy-constructor.

virtual | ~flyPolygon ()
Default destructor.

void | operator= (const flyPolygon &in)
Atribuition operator.

void | order_verts ()
Properly order the polygon's vertices to front-face the given normal.

void | build_quad (const flyVector &pos, const flyVector &x, const flyVector &y, const flyVector &z)
Builds a quad.

void | clip_plane (const flyPlane &plane)
Cut the polygon with the given plane.

void | clip_edge (int i, const flyPlane &plane, flyVertex &v)
Cut the polygon edge.

void | draw ()
Draw the polygon.

int | intersect (flyPolygon &in, flyPolygon &out)
Intersect with another polygon, storing intersection in 'out' (if any).

float | area ()
Returns the area of the polygon.

int | random_point (flyVector &point, float threshold=0.1f)
Computes a rendom point within the polygon.

void | build_edgeplanes ()
Build a list of plane for each of the polygon edges.

void | build_normal ()
Compute polygon normal.

flyVector | get_center () const
Calculate the center of the polygon.

void | add (const flyVertex &v)
Add a vertex to the polygon.

void | clear ()
Remove all vertices from polygon (free all data).

Public Attributes

flyArray<flyVertex> verts
Dynamic array of polygon vertices.

flyArray<flyPlane> edgeplanes
Dynamic array of the planes defined by each edge.

Detailed Description

Polygon representation class.

This class implements a convex polygon with any number of vertices. Its members are an array of vertices and an array of planes defined by the polygon edges. Methods are availabe for cutting the polygon by custom generated planes and for ordering its vertices.


flyQuaternion Class Reference

Quaternion representation class. More...

#include <flyMath.h>

Inheritance diagram for flyQuaternion::

flyVector List of all members.

Public Methods

flyQuaternion (const flyQuaternion &in)
Copy-constructor.

flyQuaternion ()
Default constructor.

flyQuaternion (const flyMatrix &mat)
Construct the quaternion from a matrix.

flyQuaternion (float angle, const flyVector &axis)
Construct the quaternion from the angle and axis.

void | normalize ()
Normalize the quaternion.

void | get_mat (flyMatrix &mat) const
Converts the quaternion into a matrix.

void | get_rotate (float &angle, flyVector &axis) const
Get the rotation angle and axis.

void | lerp (const flyQuaternion &q1, const flyQuaternion &q2, float t)
Interpolate two quaternions.

flyQuaternion | operator * (const flyQuaternion &q)
Multiplication between quaternions.

flyQuaternion | operator+ (const flyQuaternion &q)
Addition between quaternions.

Detailed Description

Quaternion representation class.

This class implements a quaternion that represents a rotation of 'theta' degrees around an axis 'dir', where: x=dir.x*sin(theta/2), y=dir.y*sin(theta/2), z=dir.z*sin(theta/2), w=cos(theta/2)


flyRender Class Reference

Render management class. More...

#include <flyRender.h>

List of all members.

Public Methods

flyRender (HWND hWnd, HINSTANCE hInst)
Default constructor, gets the window and instance handlers.

virtual | ~flyRender ()
Default destructor.

int | create ()
Create the rendering manager.

void | destroy ()
Destroy the rendering manager.

void | init ()
Initialise the rendering manager.

void | resize (int sx, int sy)
Resize the rendering window.

void | set_full_screen ()
Change to fullscreen mode.

void | begin_draw ()
Enter drawing mode.

void | end_draw ()
Leave drawing mode.

void | begin_draw2d ()
Enter 2D drawing mode.

void | end_draw2d ()
Leave 2D drawing mode.

void | draw_text (int x, int y, const char *text, int size=16, int n=-1)
Draw text aligned to the left of the given position.

void | draw_text_center (int x, int y, const char *text, int size=16)
Draw text centralized on the given position.

int | get_text_size (const char *text, int size)
Calculates the horizontal size of a text string.

void | draw_progress (const char *text, int progress)
draws progress info (used on loading).

Public Attributes

HWND | m_hwnd
window handle.

HINSTANCE | m_hinst
instance handle.

HGLRC | m_hrc
OpenGL handle.

HDC | m_hdc
device context handle.

RECT | m_winrect
window rectangle.

int | m_numvideomodes
number of available video modes.

DEVMODE | m_videomodes [1024]
array of video modes.

int | m_numrendermodes
number of rendering modes.

PIXELFORMATDESCRIPTOR | m_rendermodes [1024]
array of rendering modes.

int | m_rendermodesindex [1024]
index of rendering modes.

int | m_colorbits
number of color bits.

int | m_stencilbits
number of stencil buffer bits (per pixel).

int | m_depthbits
number of depth buffer bits (per pixel).

int | m_accumbits
number of accumulation buffer bits.

int | m_alphabits
number of alpha buffer bits.

int | m_numtextureunits
number of texture units.

int | m_numhwlights
number of hardware lights.

int | m_cursorx
x position of the last written letter.

int | m_cursory
y position of the last written letter.

int | m_curtime
render current time.

Static Public Attributes

int | s_fontspic = -1
fonts texture index.

int | s_fontspicsize = 256
fonts texture size in pixels.

int | s_fontspiccharsize = 16
fonts char size in pixels.

int | s_consolepic = -1
console texture index.

int | s_screensizex = 0
screen width in pixels.

int | s_screensizey = 0
screen height in pixels.

int | s_fullscreen = 0
fullscreen flag.

int | s_selvideomode = 0
index of selected video mode.

int | s_selrendermode = 0
index of selected render mode.

int | s_clearbg = 1
background clear flag.

int | s_antialias = 0
anti-aliasing flag.

int | s_wireframe = 0
wireframe flag.

int | s_fog = 0
fog flag.

int | s_stencil = 0
stencil flag.

int | s_fontswidth [256]
width of each letter of the font.

int | s_texdroplevel = 0
texture level of detail (0 no drop, 1 drop half size, ...).

int | s_videores = 7
resolution for video files (0-novideo, 1-2x2, 2-4x4, ..., 8-256x256, ...).

float | s_brightness = 1.8f
brightness level.

float | s_ambient = 0.2f
ambient lighting level.

float | s_aspect = 1.0f
screen aspect ratio.

float | s_camangle = 60
camera angle.

float | s_nearplane = 10
near rendering plane.

float | s_farplane = 5000
far rendering plane.

float | s_background [4] = { 0,0,0,1 }
background color.

Detailed Description

Render management class.

This class implements the engine's rendering module and is an interface with the graphics API, OpenGL. It contains members related to the window where rendering will be performed, like the window and device context handlers. It also has members that store the rendering modes and options, like an array of available video modes, the color depth, the screen resolution, and many flags that signalize for turning on anti-aliasing, activating the full-screen mode, enabling the use of a stencil buffer, and so on. Among the various methods present in the class are those for initialising the render entities, changing to full-screen mode, resizing the render window, drawing text, and so on.


flyShader Class Reference

Shader class. More...

#include <flyShader.h>

Inheritance diagram for flyShader::

flyBaseObject List of all members.

Public Methods

flyShader ()
Default constructor.

virtual | ~flyShader ()
Default destructor.

int | set_state (int cp)
Set the shader state to pass 'cp'.

int | restore_state ()
Restore the shader original state.

void | load (flyFile *fp, const char *section)
Load the shader from a file.

void | save (const char *filename, int i) const
Save the shader to a file.

Public Attributes

int | flags
shader flags bitfield.

int | npass
number of passes.

flyShaderPass | pass [FLY_MAX_SHADERPASSES]
shader passes array.

flyVector color
face color for radiosity.

float | selfillum
face self illumination for radiosity.

Detailed Description

Shader class.

This class implements a multi-pass shader, that can be applied over any surface of the geometry.


flyShaderFunc Class Reference

Shader function class. More...

#include <flyShader.h>

List of all members.

Public Methods

float | eval () const
evaluate the function with the current arguments.

Public Attributes

int | type
function type (sin, triangle, square, saw-tooth or inverse saw-tooth).

float | args [4]
function arguments (offset, amplitude, phase offset and rate).

Detailed Description

Shader function class.

This class implements a shader typical function, whose type can be:

Sin Triangle Square Saw-tooth Inverse saw-tooth


flyShaderPass Class Reference

Shader pass class. More...

#include <flyShader.h>

List of all members.

Public Methods

flyShaderPass ()
Default constructor.

virtual | ~flyShaderPass ()
Default destructor.

void | set_vp (const char *file)
Set the pass vertex program.

void | load (flyFile *fp, const char *section, int i)
Load a shader pass from a shader file.

void | save (FILE *fp, int i) const
Save a shader pass to a shader file.

void | set_state_1 (const flyVector &color)
Set the shader pass states concerning depth, alpha and RGB generation functions.

void | set_state_2 ()
Set the shader pass states concerning animations, texture coordinates modifiers, texture clamping and environment mapping.

Public Attributes

int | flags
shader pass flags bitfield.

int | tex
shader pass texture index.

int | blendsrc
shader pass source blend factor (argument of blending function).

int | blenddst
shader pass destination blend factor (argument of blending function).

int | depthfunc
shader pass depth function.

int | alphafunc
shader pass alpha function.

float | alphafuncref
alpha function reference value.

int | rgbgen
shader pass RGB generation mode.

flyShaderFunc rgbgen_func
RGB wave generation function.

int | tcmod
shader pass texture coordinates modifier flag bitfield.

float | tcmod_rotate
texture cordinates rotation factor.

float | tcmod_scale [2]
texture cordinates scaling factor in u and v.

float | tcmod_scroll [2]
texture cordinates scrolling factor in u and v.

flyShaderFunc tcmod_stretch_func
texture cordinates stretching function.

float | anim_fps
shader pass animation frame rate.

int | anim_numframes
number of frames in the animation.

int | anim_frames [FLY_MAX_SHADERANIMFRAMES]
each animation frame.

flyString vp
vertex program file.

flyShaderFunc vpfunc
vertex program function.

unsigned | vpid
vertex program id.

Detailed Description

Shader pass class.

This class implements a shader pass, which can have a texture and various effeect applied to it. A shader consists of various shader passes.


flySkeletonMesh Class Reference

Bone-animated mesh class. More...

#include <flySkeletonMesh.h>

Inheritance diagram for flySkeletonMesh::

flyMesh flyBaseObject List of all members.

Public Methods

flySkeletonMesh ()
Default constructor.

flySkeletonMesh (const flySkeletonMesh &in)
Copy-constructor.

void | operator= (const flySkeletonMesh &in)
Atribuition operator.

virtual | ~flySkeletonMesh ()
Default destructor.

void | reset ()
Free all data.

int | get_key_factor (int anim, float &key_factor)
Get the key factor in the animation given by 'anim'.

int | save (const char *file) const
Save the mesh to a file.

int | load (const char *file)
Load the mesh from a file.

void | draw_skeleton () const
Draw the skeleton.

int | get_bone (const char *name) const
Get the index of a bone given its name.

void | set_skeleton (int anim, int key)
Set the skeleton to the desired animation and key.

void | set_skeleton (int anim, float key_factor)
Set the skeleton to the desired animation, interpolating between keys in function of key_factor.

void | set_skeleton (int anim1, float key_factor1, int anim2, float key_factor2, float blend)
Set the skeleton to an intermediate state (blending) between two animations/keys.

void | build_mesh ()
Build the mesh from current skeleton.

Public Attributes

int | nkeys
number of animation keys.

int | animkeys [FLY_MAX_MESHANIMS]
animation keys array.

int | animkeyspos [FLY_MAX_MESHANIMS]
start position of each key (accumulated animkeys).

char | animnames [FLY_MAX_MESHANIMS][FLY_MAX_MESHSTRLEN]
animation names.

char | bonenames [FLY_MAX_MESHBONES][FLY_MAX_MESHSTRLEN]
bone names.

int | nbones
number of bones.

int* | nvweights
list of numbers of vertex weights.

int* | vindex
list of vertex indices.

int* | parent
list of parent bones.

flyVector* vweight
vertex weights array.

flyMatrix* tm
list of all the bones matrices in all keys.

flyMatrix* m
list of the bones matrices in current skeleton.

int | root
root bone.

Detailed Description

Bone-animated mesh class.

This class implements skeletal animated meshes that can be read from a .k3d file. Some of its members are: the number of keys in all animations, the names of the animations, the total number of bones,the names of each bone, the root bone in the skeleton hierarchy and an array of vertex weights. The class also features methods for building the mesh from the current animation and skeleton state, blending between animations and skeleton states, drawing the skeleton for debug purposes and loading and saving .k3d files.


flySound Class Reference

Sound class. More...

#include <flySound.h>

Inheritance diagram for flySound::

flyBaseObject List of all members.

Public Methods

flySound ()
Default constructor.

virtual | ~flySound ()
Default destructor.

void | reset ()
Free all data.

int | load_wav (const char *filename)
Load a wave (.wav) file.

int | get_sound_instace (int flag3d)
Get an instance of the sound.

void | free_sound_instance (int i)
Free an instance of the sound.

Public Attributes

int | total_time
sound length in miliseconds.

LPDIRECTSOUNDBUFFER | file_buf
the DirectSound sound file buffer.

LPDIRECTSOUND3DBUFFER | file_buf3d
the DirectSound 3D sound file buffer.

LPDIRECTSOUNDBUFFER | file_buf2d
the DirectSound 2D sound file buffer.

flyArray<LPDIRECTSOUNDBUFFER> | buf
array of sound buffers.

flyArray<LPDIRECTSOUND3DBUFFER> | buf3d
array of 3D sound buffers.

Detailed Description

Sound class.

This class implements raw sound data that can be loaded from a .wav file. The class members are DirectSound buffers and the total length of the sound file. The methods include loading .wav files from the disk and instantiating and freeing a sound


flyStateMachine Class Reference

Finite state machine class. More...

#include <flyAI.h>

List of all members.

Public Methods

flyStateMachine ()
Default constructor.

flyStateMachine (const flyStateMachine &in)
Copy-constructor.

int | load_behaviour (const char *filename)
Loads a behaviour from a pre-made file.

int | transition (int input, float *factors)
Computes transition (if any), with the given inputs and factors.

int | get_current_state ()
Returns the current state.

Protected Attributes

int | nstates
the total number of states in the machine.

int | ninputs
the number of possible input flags.

int | nfactors
the number of factors for randomization.

flyArray<flyStateMachineRule> rules
an array of all the transition rules.

Detailed Description

Finite state machine class.

This class implements a finite state machine class, which is made of states, inputs and rules for transitions between states. Methods for loading a pre-made behaviour file, computing transition and retrieving the current state are provided.


flyStateMachineRule Class Reference

Transition rule class. More...

#include <flyAI.h>

List of all members.

Public Methods

void | operator= (const flyStateMachineRule &in)
Atribuition operator.

Public Attributes

int | output
the rule's output state.

int | state
the state over which the rule applies.

int | positive_input
a bitwise indicator of which input logical variables must be true for the transition to occur.

int | negative_input
a bitwise indicator of which input logical variables must be false for the transition to occur.

int | factorindex
the index of the factor (stored in the State Machine) that will be randomly evaluated.

Detailed Description

Transition rule class.

This class implements a rule that determines a given state transition in a state machine definition. The rule members are: the state over which the rule applies, the positive and negative necessary inputs, a factor for randomly evaluating the transition and the output state.


flyStaticMesh Class Reference

Static mesh class. More...

#include <flyStaticMesh.h>

Inheritance diagram for flyStaticMesh::

flyBspObject flyBaseObject flyParticle flyLocalSystem List of all members.

Public Methods

flyMesh* get_mesh ()
Return the mesh.

flyMesh* | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum) const
Ray intersection with leaf nodes faces.

int | ray_intersect_test (const flyVector &ro, const flyVector &rd, float dist) const
Ray intersection test with leaf nodes faces, returns after first intersection.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Process the messages sent to the BSP leaf nodes faces.

flyStaticMesh ()
Default constructor.

virtual | ~flyStaticMesh ()
Default destructor.

Public Attributes

flyMesh* objmesh
the mesh object.

Detailed Description

Static mesh class.

This class implements the group of geometry faces that define a convex volume, i.e. a BSP leaf node. The only member of the class is a flyMesh object representing the mesh. The methods available include one for retrievieng the mesh, two for ray-intersection and one for receiving messages.


flyString Class Reference

Fly3D in-house string class. More...

#include <flyString.h>

List of all members.

Public Methods

flyString ()
Default constructor.

flyString (const char *in)
Construct a string from a char pointe.

flyString (const flyString &in)
Copy-constructor.

flyString (const char *in, int p, int n)
Construct a string of length 'n' from a char pointer, beginning at position 'p'.

virtual | ~flyString ()
Default destructor.

operator const char * () const
Type cast to char pointer.

char | operator[] (int i) const
Indexing operator.

void | operator= (const char *in)
Char pointer atribuition operator.

void | operator= (const flyString &in)
Atribuition operator.

void | operator+= (const char *in)
Self-concatenation operator with a char pointer.

void | operator+= (const flyString &in)
Self-concatenation operator.

flyString | operator+ (const char *in)
Concatenation operator with a char pointer.

flyString | operator+ (const flyString &in)
Concatenation operator.

void | copy (const char *in, int p, int n)
Copy the 'n'-sized contents of a char pointer beginning at position 'p'.

int | find (const char *str) const
Find a sub-string in the string.

int | find (char c) const
Find the first occurrence of a character in the string.

int | find_reverse (char c) const
Find the last occurrence of a character in the string.

void | set_char (int i, char c)
Change the 'i'-th character of the string.

void | crop_begin (int n)
Crop the first 'n' characters of the string.

flyString | left (int n) const
Return a string consisting of the first 'n' characters of the original one.

flyString | right (int n) const
Return a string consisting of the last 'n' characters of the original one.

flyString | mid (int p, int n) const
Return a string consisting of the 'n' characters of the original one that follow position 'p', inclusive.

void | format (const char *fmt,...)
Format the string using a format template.

int | operator== (const char *str) const
equal compare operator.

int | compare (const char *str) const
Compare with a char pointer.

int | compare (const char *str, int n) const
Compare the first 'n' characters of the string with a char pointer.

int | compare_nocase (const char *str) const
Compare with a char pointer, case-insensitive flavour.

void | lower ()
Change all characters to lower-case.

void | upper ()
Change all characters to upper-case.

int | length () const
Return the length of the string in bytes.

Detailed Description

Fly3D in-house string class.

This class implements variable-size strings, and auto-manages its memory space, expanding the buffer whenever necessary. The class supplies methods for constructing a flyString from a char pointer, concatenating, copying and comparing strings, indexing a specific character and finding a sub-string.


flyTexCache Class Reference

Texture manager class. More...

#include <flyTexCache.h>

List of all members.

Public Methods

flyTexCache ()
Default constructor.

~flyTexCache ()
Default destructor.

void | reset ()
Reset the manager.

int | add_tex (const char *name, int sx, int sy, int bytespixel, const unsigned char *buf, int flags)
Dinamically add a new texture to the cache, passing all info.

int | add_tex (int np, flyPicture **pic, int flags)
Dinamically add a new texture to the cache, passing a picture pointer list.

int | add_tex (const char *name, flyVideo *video, int flags)
Dinamically add a new video to the cache (video will belong to cache... do not delete it aftre this call).

void | update_tex (int pic, int sx, int sy, int bytespixel, const unsigned char *buf)
Update the texture in the texture manager with a new pixel array.

void | update_subtex (int pic, int x, int y, int sx, int sy, int bytespixel, const unsigned char *buf)
Update a part of a texture in the texture manager. Only the sub-texture pixels are passed. If 'x' and 'y' are 0 and 'sx' and 'sy' the size of the image, it will work just like the update_picture function.

int | get_tex (int pic, unsigned char *buf)
Returns the index of the desired texture.

int | find_tex (const char *file)
Find a texture given its filename.

void | set_tex_flags ()
Sets the texture flags.

void | clear_tex_state ()
Clear the texture state.

void | build_mipmaps (int pic, int sx, int sy, int bytespixel, const unsigned char *buf)
Builds all mipmap levels for the given picture.

void | sel_unit (int u)
Select a texture unit.

void | sel_tex (int t)
Select a texture.

void | sel_tex (int t, int u)
Select a texture and unit.

Public Attributes

int | curtex [FLY_MAXTEXUNITS]
current texture.

int | curtexunit
current texture unit.

int | ntex
number of texture.

unsigned* | tex
OpenGL texture handles.

flyVideo** vid
video files.

flyTexInfo* texinfo
texture info array.

Static Public Attributes

int | s_texfilter = 1
texture filtering flag.

int | s_texmipmap = 1
texture mip-mapping flag.

int | s_textruecolor = 0
texture color depth flag: 0:high color (16 bits/pixel), 1:true color (24 bits/pixel).

int | s_texcompress = 0
texture compression flag.

Detailed Description

Texture manager class.

This class is a texture cache (texture manager). The supplied initialisation and release methods should be used to initialise and free the global variable g_flytexcache that is the interface to this class.


flyTexInfo Struct Reference

texture info structure. More...

#include <flyTexCache.h>

List of all members.

Public Attributes

char | name [240]
texture filename.

int | sx
x size in pixels.

int | sy
y size in pixels.

int | bytespixel
number of bytes per pixel (24 or 32).

int | flags
texture flags.

Detailed Description

texture info structure.


flyVector Class Reference

Vector class compound of 4 floating point real numbers. More...

#include <flyMath.h>

Inheritance diagram for flyVector::

flyQuaternion flyVertex List of all members.

Public Methods

flyVector ()
Default constructor.

flyVector (float f)
Constructor from a floating point value, sets x, y and z to this value, and w to 1.0f.

flyVector (const flyVector &v)
Copy-constructor.

flyVector (float x0, float y0, float z0)
Constructor from 3 floating point numbers, sets x, y and z to their respective values, and w to 1.0f.

flyVector (float x0, float y0, float z0, float w0)
Constructor from 4 floating point numbers.

void | operator= (const flyVector &in)
Atribuition operator.

void | null (void)
Nullifying function, sets x, y and z to zero, and w to 1.0f.

float | length (void)
Returns the length of the vector.

float | length2 (void)
Returns the square of the length.

float | distto (const flyVector &v) const
Returns the distance to another flyVector.

float | distto2 (const flyVector &v) const
Returns the square of the distance to another flyVector.

void | vec (float f)
Set all the components to the given floating point value.

void | vec (float x0, float y0, float z0)
Set components to the given floating point values, and set w=1.0f.

void | vec (float x0, float y0, float z0, float w0)
Set components to the given floating point values.

void | negate (void)
Negate the first 3 components.

void | cross (const flyVector &v1, const flyVector &v2)
Compute the cross-product of two given flyVectors.

void | normalize (void)
Normalize the vector.

float& | operator[] (int i)
Reference indexing operator.

float | operator[] (int i) const
Indexing operator.

flyVector | operator- () const
Negates the vector (unary operator-).

Public Attributes

float | x
the first component.

float | y
the second component.

float | z
the third component.

float | w
the fourth (of optional usage) component.

Detailed Description

Vector class compound of 4 floating point real numbers.

This is probably the most used class in the whole system. One can use flyVector with 3 or 4 floats, as in the first case the 4th value remains zero. One must address the components of flyVector by the letters x, y, z and w, or by indexes 0 to 3, and the operations of negation, normalization and cross product with another flyVector object are provided.


flyVertex Class Reference

Vertex representation class. More...

#include <flyMath.h>

Inheritance diagram for flyVertex::

flyVector List of all members.

Public Methods

flyVertex ()
Default constructor.

flyVertex (flyVector &p, flyVector &tx, flyVector &n, unsigned c)
Constructor from components.

flyVertex (const flyVertex &in)
Copy-constructor.

void | operator= (const flyVertex &in)
Atribuition operator.

Public Attributes

flyVector texcoord
(x,y): texture coordinates; (z,w): lightmap texture coordinates.

flyVector normal
the vertex's normal.

unsigned | color
the vertex's color.

unsigned | color_static
the vertex's color from static lighting.

Detailed Description

Vertex representation class.

This class holds all info about a vertex, including color, two sets of texture coordinates, position and normal.


flyVideo Class Reference

Video class. More...

#include <flyVideo.h>

List of all members.

Public Methods

flyVideo ()
default constructor.

virtual | ~flyVideo ()
destructor.

int | load_avi (const char *file)
loads an avi file.

void | set_frame (int frame)
set current frame.

void | update (int curtime)
apdate animation frame.

Public Attributes

int | curframe
current frame.

int | numframes
total number of frames in.

int | width
x size in pixels.

int | height
y size in pixels.

int | resolution
texture resolution (power of 2).

int | frametime
time in ms for each frame.

unsigned char* | data
current frame bitmap.

unsigned | texture
current frame texture id.

Detailed Description

Video class.

This class implements an avi video that plays to texture map. The video if converted from any format to a 256x256 texture that can be used to map any 3d mesh and is updated only when visible.


Hierarchical Index

Fly3D SDK 2.0 Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
  • flyArray
  • flyBaseObject
    • flyBezierCurve
    • flyBspObject
      • flyStaticMesh
    • flyMesh
      • flyAnimatedMesh
      • flySkeletonMesh
    • flyShader
    • flySound
  • flyBezierPatch
  • flyBoundBox
  • flyClassDesc
  • flyConsole
  • flyDirectx
  • flyDll
  • flyDllGroup
  • flyEngine
  • flyFile
  • flyFrustum
  • flyHashList
  • flyInputMap
  • flyLightMap
  • flyLightMapPic
  • flyLightVertex
  • flyLocalSystem
    • flyBspObject
  • flyMatrix
  • flyMPGames
  • flyMPMsg
  • flyMPPlayerData
  • flyOcTree
  • flyOcTreeNode
  • flyParamDesc
  • flyParticle
    • flyBspObject
  • flyPicture
  • flyPlane
    • flyBspNode
    • flyFace
    • flyPolygon
  • flyRender
  • flyShaderFunc
  • flyShaderPass
  • flyStateMachine
  • flyStateMachineRule
  • flyString
  • flyTexCache
  • flyTexInfo
  • flyVector
    • flyQuaternion
    • flyVertex
  • flyVideo


Compound Member Index

Fly3D SDK 2.0 Compound Members

a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | r | s | t | u | v | w | x | y | z | ~

Here is a list of all documented class members with links to the classes they belong to:

- a -

  • activate() : flyEngine
  • active : flyBspObject
  • active_objs : flyEngine
  • adaptative_subdiv() : flyBezierCurve
  • add() : flyPolygon, flyHashList, flyArray
  • add_class() : flyDllGroup
  • add_dll() : flyDllGroup
  • add_light() : flyLightVertex
  • add_neighbor() : flyBspNode
  • add_player() : flyDirectx
  • add_point() : flyBoundBox, flyBezierCurve
  • add_post_step() : flyEngine
  • add_string() : flyConsole
  • add_tex() : flyTexCache
  • add_to_bsp() : flyEngine
  • align_z() : flyLocalSystem
  • alphafunc : flyShaderPass
  • alphafuncref : flyShaderPass
  • anim_fps : flyShaderPass
  • anim_frames : flyShaderPass
  • anim_numframes : flyShaderPass
  • animkeys : flySkeletonMesh, flyAnimatedMesh
  • animkeyspos : flySkeletonMesh, flyAnimatedMesh
  • animnames : flySkeletonMesh, flyAnimatedMesh
  • antialias : flyEngine
  • appid : flyEngine
  • area() : flyPolygon
  • args : flyShaderFunc
  • arraysize : flyArray

- b -
  • bbox : flyOcTreeNode, flyMesh, flyFace, flyEngine, flyBspObject
  • bboxcenter : flyEngine
  • bboxdiag : flyEngine
  • bboxindx : flyFrustum
  • begin_draw() : flyRender
  • begin_draw2d() : flyRender
  • blenddst : flyShaderPass
  • blendsrc : flyShaderPass
  • bmp : flyLightMap, flyLightMapPic
  • bonenames : flySkeletonMesh
  • box_collision() : flyBspObject
  • bsp : flyEngine
  • bspfile : flyEngine
  • bsppicflipy : flyEngine
  • buf : flySound, flyPicture, flyFile, flyConsole, flyArray
  • buf3d : flySound
  • build() : flyFrustum
  • build_cp() : flyBezierPatch
  • build_cp_loft() : flyBezierPatch
  • build_edgeplanes() : flyPolygon
  • build_mesh() : flySkeletonMesh
  • build_mipmaps() : flyTexCache
  • build_node() : flyOcTreeNode
  • build_normal() : flyPolygon
  • build_quad() : flyPolygon
  • build_surface() : flyBezierPatch
  • build_table() : flyFile
  • build_tree() : flyOcTree
  • build_ziplist() : flyFile
  • bump : flyParticle
  • bytespixel : flyTexInfo, flyPicture, flyLightMap, flyLightMapPic
  • bytesx : flyLightMap, flyLightMapPic
  • bytesxy : flyLightMap, flyLightMapPic

- c -
  • cam : flyEngine
  • cam_model_mat : flyEngine
  • cam_proj_mat : flyEngine
  • cam_viewport : flyEngine
  • cd : flyDllGroup
  • centre : flyBspNode
  • check_input_map() : flyEngine
  • check_multiplayer() : flyEngine
  • CheckSize() : flyPicture
  • child : flyBspNode
  • clear() : flyPolygon, flyArray
  • clear_tex_state() : flyTexCache
  • clip_bbox() : flyFrustum, flyBoundBox
  • clip_edge() : flyPolygon
  • clip_plane() : flyPolygon
  • clipnodes : flyBspObject
  • clone() : flyBspObject
  • clone_sound() : flyDirectx
  • close() : flyFile
  • close_fly_file() : flyEngine
  • close_multiplayer() : flyEngine
  • cmd_len : flyConsole
  • cmd_line : flyConsole
  • cmd_pos : flyConsole
  • colflag : flyParticle
  • collide : flyBoundBox, flyBspObject
  • collision_bsp() : flyEngine
  • collision_test() : flyEngine
  • collisionmode : flyEngine
  • color : flyShader, flyMesh, flyVertex, flyLightVertex, flyMPPlayerData, flyBspNode
  • color_static : flyVertex
  • command_exec() : flyConsole
  • command_tokens() : flyConsole
  • compare() : flyString
  • compare_nocase() : flyString
  • compute_collision() : flyParticle
  • compute_normals() : flyMesh, flyFace
  • con : flyEngine
  • console_command : flyEngine
  • console_printf() : flyEngine
  • copy() : flyString
  • create() : flyRender, flyClassDesc
  • create_game() : flyDirectx
  • CreatePicture24() : flyPicture
  • CreatePicture32() : flyPicture
  • crop_begin() : flyString
  • cross() : flyVector
  • crosshairpic : flyEngine
  • crosshairsize : flyEngine
  • cur_bsprecurse : flyEngine
  • cur_dt : flyEngine
  • cur_frame : flyEngine
  • cur_frame_base : flyEngine
  • cur_step : flyEngine
  • cur_step_base : flyEngine
  • cur_time : flyEngine
  • cur_time_float : flyEngine
  • curframe : flyVideo
  • curr_line : flyConsole
  • curr_page : flyConsole
  • curtex : flyTexCache
  • curtexunit : flyTexCache
  • curveerr : flyEngine

- d -
  • d0 : flyPlane, flyLightMap
  • d1 : flyLightMap
  • d2 : flyLightMap
  • data : flyVideo, flyMPPlayerData, flyMPMsg, flyParamDesc
  • debug : flyEngine
  • delete_class() : flyDllGroup
  • delete_dll() : flyDllGroup
  • delete_references() : flyDllGroup
  • demo_file_in : flyEngine
  • demo_file_out : flyEngine
  • depthfunc : flyShaderPass
  • destroy() : flyRender
  • distance() : flyPlane
  • distto() : flyVector
  • distto2() : flyVector
  • dll : flyEngine, flyDllGroup
  • dll_filename : flyDll
  • dpid : flyMPPlayerData
  • draw() : flyPolygon, flyOcTree, flyMesh, flyFrustum, flyConsole, flyBspObject, flyBoundBox, flyBezierPatch
  • draw_bsp() : flyEngine
  • draw_faces() : flyEngine
  • draw_frame() : flyEngine
  • draw_plain() : flyMesh
  • draw_progress() : flyRender
  • draw_shadow() : flyBspObject
  • draw_shadow_volume() : flyMesh
  • draw_skeleton() : flySkeletonMesh
  • draw_text() : flyRender, flyConsole
  • draw_text_center() : flyRender
  • dropu : flyBezierPatch
  • dropu_inc : flyBezierPatch
  • dropv : flyBezierPatch
  • dropv_inc : flyBezierPatch
  • dx : flyConsole
  • dy : flyConsole
  • dynlight : flyEngine

- e -
  • edge_collision() : flyBoundBox
  • edgedir : flyBoundBox
  • edgedirth : flyBoundBox
  • edgefaces : flyBoundBox
  • edgenorm : flyBoundBox
  • edgeplanes : flyPolygon
  • edgevert : flyBoundBox
  • elem : flyBspNode
  • en : flyFace, flyEngine
  • end_draw() : flyRender
  • end_draw2d() : flyRender
  • enum_games() : flyDirectx
  • eval() : flyShaderFunc
  • evaluate() : flyBezierPatch, flyBezierCurve
  • evaluate_tangent() : flyBezierCurve
  • excludecollision : flyEngine

- f -
  • face : flyOcTree
  • facechanged : flyEngine
  • facedraw : flyEngine
  • facedrawtransp : flyEngine
  • facenorm : flyBoundBox
  • facenum : flyLightMap
  • faces : flyOcTreeNode, flyMesh, flyEngine
  • facetype : flyFace
  • facevert : flyBoundBox
  • factorindex : flyStateMachineRule
  • file_buf : flySound
  • file_buf2d : flySound
  • file_buf3d : flySound
  • filter : flyEngine
  • find() : flyString
  • find_node() : flyEngine
  • find_path() : flyEngine
  • find_reverse() : flyString
  • find_tex() : flyTexCache
  • flag : flyFace
  • flags : flyTexInfo, flyShader, flyShaderPass
  • FlipY() : flyPicture
  • fly_message : flyDll
  • flyAnimatedMesh() : flyAnimatedMesh
  • flyArray() : flyArray
  • flyBaseObject() : flyBaseObject
  • flyBezierCurve() : flyBezierCurve
  • flyBezierPatch() : flyBezierPatch
  • flyBoundBox() : flyBoundBox
  • flyBspNode() : flyBspNode
  • flyBspObject() : flyBspObject
  • flyConsole() : flyConsole
  • flyDirectx() : flyDirectx
  • flyDll() : flyDll
  • flyDllGroup() : flyDllGroup
  • flyEngine() : flyEngine
  • flyFace() : flyFace
  • flyfile : flyEngine
  • flyFile() : flyFile
  • flyfilename : flyEngine
  • flyfilepath : flyEngine
  • flyFrustum() : flyFrustum
  • flyHashList() : flyHashList
  • flyInputMap() : flyInputMap
  • flyLightMap() : flyLightMap
  • flyLightMapPic() : flyLightMapPic
  • flyLightVertex() : flyLightVertex
  • flyLocalSystem() : flyLocalSystem
  • flyMatrix() : flyMatrix
  • flyMesh() : flyMesh
  • flyMPGames() : flyMPGames
  • flyMPPlayerData() : flyMPPlayerData
  • flyOcTree() : flyOcTree
  • flyOcTreeNode() : flyOcTreeNode
  • flyParticle() : flyParticle
  • flyPicture() : flyPicture
  • flyPlane() : flyPlane
  • flyPolygon() : flyPolygon
  • flyQuaternion() : flyQuaternion
  • flyRender() : flyRender
  • flysdkdatapath : flyEngine
  • flysdkpath : flyEngine
  • flysdkpluginpath : flyEngine
  • flyShader() : flyShader
  • flyShaderPass() : flyShaderPass
  • flySkeletonMesh() : flySkeletonMesh
  • flySound() : flySound
  • flyStateMachine() : flyStateMachine
  • flyStaticMesh() : flyStaticMesh
  • flyString() : flyString
  • flyTexCache() : flyTexCache
  • flyVector() : flyVector
  • flyVertex() : flyVertex
  • flyVideo() : flyVideo
  • fm : flyEngine
  • fmbase : flyEngine
  • fmchanged : flyEngine
  • fmpic : flyEngine
  • fogmap : flyEngine
  • force : flyParticle
  • force_dt : flyEngine
  • format() : flyString
  • forward_map() : flyFace
  • fraglimit : flyEngine
  • frame : flyLightVertex
  • frame_count : flyEngine
  • frame_rate : flyEngine
  • frametime : flyVideo
  • free() : flyArray
  • free_multiplayer() : flyDirectx
  • free_sound_instance() : flySound
  • FreePicture() : flyPicture
  • friction : flyParticle
  • from : flyMPMsg

- g -
  • geomdetail : flyEngine
  • get_bezier_curve() : flyEngine
  • get_bone() : flySkeletonMesh
  • get_center() : flyPolygon
  • get_class_desc : flyDll
  • get_closest() : flyLightVertex
  • get_current_state() : flyStateMachine
  • get_custom_param_desc() : flyBspObject
  • get_float() : flyFile
  • get_global_param_desc : flyDll
  • get_global_param_desc0() : flyEngine
  • get_global_param_desc1() : flyEngine
  • get_global_param_desc2() : flyEngine
  • get_input() : flyDirectx
  • get_input_map() : flyEngine
  • get_int() : flyFile
  • get_key_factor() : flySkeletonMesh
  • get_mat() : flyQuaternion
  • get_mesh() : flyStaticMesh, flyBspObject, flyBoundBox
  • get_message() : flyDirectx
  • get_model_object() : flyEngine
  • get_name() : flyClassDesc
  • get_next_object() : flyHashList
  • get_num_messages() : flyDirectx
  • get_obj_param() : flyEngine
  • get_object_longname() : flyHashList
  • get_object_name() : flyHashList
  • get_param_desc() : flyBspObject
  • get_picture() : flyEngine
  • get_plane_dist() : flyBoundBox
  • get_player_address() : flyDirectx
  • get_profile_string() : flyFile
  • get_rotate() : flyQuaternion
  • get_sound_instace() : flySound
  • get_sound_object() : flyEngine
  • get_string() : flyFile, flyParamDesc
  • get_tex() : flyTexCache
  • get_text_size() : flyRender
  • get_type() : flyClassDesc
  • get_version : flyDll
  • get_vert() : flyBoundBox
  • gravity : flyEngine
  • guid : flyMPGames
  • guidInstance : flyDirectx

- h -
  • hdll : flyDll
  • height : flyVideo
  • hide() : flyConsole
  • hinst : flyEngine
  • hInst : flyDirectx
  • hitdist : flyEngine
  • hitface : flyEngine
  • hitip : flyEngine
  • hitmesh : flyEngine
  • hitnormal : flyEngine
  • hitobj : flyEngine
  • hitshader : flyEngine
  • hitsubface : flyEngine
  • hwnd : flyEngine
  • hWnd : flyDirectx

- i -
  • id : flyBspObject
  • illum() : flyLightMap
  • illum_faces() : flyMesh
  • indx : flyFace
  • init() : flyRender, flyBspObject
  • Init() : flyDirectx
  • init_draw() : flyLightVertex
  • init_multiplayer() : flyDirectx
  • inputmaps : flyEngine
  • intersect() : flyPolygon
  • inverse_map() : flyFace
  • is_inside() : flyBoundBox

- j -
  • join_game() : flyDirectx
  • join_multiplayer() : flyEngine
  • joy_axes : flyDirectx
  • joy_caps : flyDirectx
  • joy_dead_zone : flyDirectx
  • joy_down : flyDirectx
  • joy_max_range : flyDirectx
  • joy_min_range : flyDirectx
  • joy_pos : flyDirectx

- k -
  • key_char() : flyConsole
  • key_down() : flyConsole
  • key_verts : flyAnimatedMesh
  • keys : flyDirectx

- l -
  • lastbsprecurse : flyFace, flyBspObject
  • lastdraw : flyMesh, flyBspObject
  • lastintesectedface : flyMesh
  • lastupdate : flyLightMap, flyFace
  • latedraw : flyBspObject
  • leaf : flyEngine, flyBspNode
  • left() : flyString
  • len : flyFile
  • length() : flyString, flyVector, flyBezierCurve
  • length2() : flyVector
  • lerp() : flyQuaternion, flyMatrix
  • level_start_time : flyEngine
  • levelu : flyBezierPatch
  • levelv : flyBezierPatch
  • lic : flyConsole
  • life : flyParticle
  • linecount : flyConsole
  • lm : flyFace, flyEngine
  • lmbase : flyEngine
  • lmchanged : flyEngine
  • lmpic : flyEngine
  • load() : flySkeletonMesh, flyShader, flyShaderPass, flyMesh, flyLightMap, flyAnimatedMesh
  • load_all_classes() : flyDllGroup
  • load_avi() : flyVideo
  • load_behaviour() : flyStateMachine
  • load_bez() : flyBezierCurve
  • load_classes() : flyDllGroup
  • load_default_param() : flyDllGroup
  • load_default_params() : flyBspObject
  • load_default_tex() : flyEngine
  • load_identity() : flyMatrix
  • load_ini() : flyEngine
  • load_params() : flyDllGroup, flyBspObject
  • load_shaders() : flyEngine
  • load_wav() : flySound
  • load_wav_file() : flyDirectx
  • loading : flyEngine
  • LoadJPG() : flyPicture
  • LoadTGA() : flyPicture
  • localen : flyMesh
  • localfaces : flyMesh
  • localvert : flyMesh
  • lock_input() : flyEngine
  • long_name : flyBaseObject
  • lower() : flyString
  • lpDI : flyDirectx
  • lpDP : flyDirectx
  • lpDPL : flyDirectx
  • lpDS3dListener : flyDirectx
  • lpDS3dPrimBuf : flyDirectx
  • lpDSound : flyDirectx
  • lpJoystick : flyDirectx
  • lpJoystickPoll : flyDirectx
  • lpKeyboard : flyDirectx
  • lpMouse : flyDirectx
  • lpSD : flyDirectx

- m -
  • m : flySkeletonMesh, flyMatrix
  • m_accumbits : flyRender
  • m_alphabits : flyRender
  • m_colorbits : flyRender
  • m_cursorx : flyRender
  • m_cursory : flyRender
  • m_curtime : flyRender
  • m_depthbits : flyRender
  • m_hash : flyHashList
  • m_hdc : flyRender
  • m_hinst : flyRender
  • m_hrc : flyRender
  • m_hwnd : flyRender
  • m_last : flyHashList
  • m_list : flyHashList
  • m_numhwlights : flyRender
  • m_numrendermodes : flyRender
  • m_numtextureunits : flyRender
  • m_numvideomodes : flyRender
  • m_rendermodes : flyRender
  • m_rendermodesindex : flyRender
  • m_stencilbits : flyRender
  • m_videomodes : flyRender
  • m_winrect : flyRender
  • map_point() : flyLightMap
  • map_point_local() : flyLightMap
  • mass : flyParticle
  • mastervolume : flyEngine
  • mat : flyLocalSystem
  • mat_t : flyLocalSystem
  • max : flyBoundBox
  • message() : flyStaticMesh, flyBspObject
  • mid() : flyString
  • min : flyBoundBox
  • mode : flyConsole, flyBezierPatch
  • mouse : flyEngine
  • mouse_click : flyDirectx
  • mouse_delta : flyDirectx
  • mouse_down : flyDirectx
  • mouse_pos : flyDirectx
  • mouse_smooth : flyDirectx
  • move_dll() : flyDllGroup
  • mpdelay : flyEngine
  • mpmode : flyDirectx
  • multitexture : flyEngine
  • mute : flyEngine

- n -
  • name : flyTexInfo, flyPicture, flyMPPlayerData, flyMPGames, flyParamDesc, flyBaseObject
  • nanims : flyMesh
  • nbones : flySkeletonMesh
  • ncd : flyDllGroup
  • nclasses : flyDll
  • nd : flyBezierCurve
  • ndll : flyDllGroup
  • negate() : flyVector
  • negative_input : flyStateMachineRule
  • neighbors : flyBspNode
  • nen : flyMesh, flyEngine
  • next_obj : flyBaseObject
  • nf : flyMesh
  • nfaces : flyEngine
  • nfactors : flyStateMachine
  • ninputs : flyStateMachine
  • nkeys : flySkeletonMesh, flyAnimatedMesh
  • nleaf : flyEngine
  • nlights : flyLightVertex
  • nlines : flyConsole
  • nnodedraw : flyEngine
  • nodeonly : flyEngine
  • nodes : flyOcTreeNode
  • noinput : flyEngine
  • normal : flyVertex, flyPlane
  • normalize() : flyQuaternion, flyVector
  • np : flyBezierPatch, flyBezierCurve
  • npass : flyShader
  • nplayers : flyDirectx
  • npu : flyBezierPatch
  • npv : flyBezierPatch
  • ns : flyBezierCurve
  • nstates : flyStateMachine
  • nsu : flyBezierPatch
  • nsv : flyBezierPatch
  • ntex : flyTexCache
  • ntotelemdraw : flyEngine
  • ntotfacedraw : flyEngine
  • ntriface : flyFace
  • ntrivert : flyFace
  • null() : flyMatrix, flyVector
  • num : flyMPGames, flyArray
  • num_classes : flyDll
  • num_players : flyMPGames
  • numframes : flyVideo
  • numstrips : flyBezierPatch
  • nv : flyMesh
  • nvert : flyFace, flyEngine
  • nvertu : flyBezierPatch
  • nvertv : flyBezierPatch
  • nvweights : flySkeletonMesh

- o -
  • objdraw : flyEngine
  • objmesh : flyStaticMesh
  • octree : flyFace, flyEngine
  • offsetx : flyLightMap
  • offsety : flyLightMap
  • open() : flyFile
  • open_fly_file() : flyEngine
  • operator *() : flyQuaternion, flyMatrix
  • operator const char *() : flyString
  • operator+() : flyString, flyQuaternion
  • operator+=() : flyString, flyArray
  • operator-() : flyVector
  • operator=() : flyString, flySkeletonMesh, flyPolygon, flyPicture, flyParticle, flyOcTree, flyMesh, flyVertex, flyPlane, flyMatrix, flyVector, flyLocalSystem, flyLightVertex, flyInputMap, flyBspObject, flyBspNode, flyBoundBox, flyBezierPatch, flyBezierCurve, flyBaseObject, flyArray, flyAnimatedMesh, flyStateMachineRule
  • operator==() : flyString
  • operator[]() : flyString, flyVector, flyArray
  • order_verts() : flyPolygon
  • output : flyStateMachineRule

- p -
  • p : flyBezierPatch, flyBezierCurve
  • parent : flySkeletonMesh
  • pass : flyShader
  • patch : flyFace
  • patch_npu : flyFace
  • patch_npv : flyFace
  • pic : flyLightMap
  • picrender : flyEngine
  • pivot : flyFace, flyBezierCurve
  • pivotpos : flyMesh
  • planes : flyFrustum
  • play_demo() : flyEngine
  • player : flyEngine
  • playercolor : flyEngine
  • playername : flyEngine
  • players : flyDirectx
  • portals : flyBspNode
  • pos : flyParticle, flyLightVertex, flyFile
  • positive_input : flyStateMachineRule
  • post_step() : flyBspObject
  • poststeps : flyEngine
  • process_multiplayer() : flyEngine
  • pvs : flyEngine
  • pvsoff : flyEngine
  • pvsrowsize : flyEngine
  • pvssize : flyEngine

- r -
  • radius : flyLightVertex
  • random_point() : flyPolygon
  • ray_intersect() : flyStaticMesh, flyOcTree, flyMesh, flyPlane, flyFace, flyBspObject, flyBoundBox
  • ray_intersect_test() : flyStaticMesh, flyOcTree, flyMesh, flyFace, flyBspObject
  • ray_intersect_tri() : flyFace
  • ray_intersect_tri_test() : flyFace
  • read() : flyFile
  • record_demo() : flyEngine
  • recurse_bsp() : flyEngine
  • recurse_bsp_box() : flyEngine
  • Release() : flyDirectx
  • remove() : flyHashList, flyArray
  • remove_from_bsp() : flyBspObject
  • remove_player() : flyDirectx
  • reserve() : flyArray
  • reset() : flyTexCache, flySound, flySkeletonMesh, flyOcTree, flyMesh, flyHashList, flyDllGroup, flyBoundBox, flyBezierPatch, flyBezierCurve, flyAnimatedMesh
  • resize() : flyRender
  • resolution : flyVideo
  • resource_objs : flyEngine
  • restarttime : flyEngine
  • restore_state() : flyShader
  • rgbgen : flyShaderPass
  • rgbgen_func : flyShaderPass
  • right() : flyString
  • root : flySkeletonMesh, flyOcTree
  • rot : flyBspObject
  • rotate() : flyMatrix, flyLocalSystem
  • rules : flyStateMachine

- s -
  • s_ambient : flyRender
  • s_antialias : flyRender
  • s_aspect : flyRender
  • s_background : flyRender
  • s_brightness : flyRender
  • s_camangle : flyRender
  • s_clearbg : flyRender
  • s_consolepic : flyRender
  • s_farplane : flyRender
  • s_fog : flyRender
  • s_fontspic : flyRender
  • s_fontspiccharsize : flyRender
  • s_fontspicsize : flyRender
  • s_fontswidth : flyRender
  • s_fullscreen : flyRender
  • s_invertjoyx : flyDirectx
  • s_invertjoyy : flyDirectx
  • s_invertmousex : flyDirectx
  • s_invertmousey : flyDirectx
  • s_joyspeed : flyDirectx
  • s_mousespeed : flyDirectx
  • s_nearplane : flyRender
  • s_screensizex : flyRender
  • s_screensizey : flyRender
  • s_selrendermode : flyRender
  • s_selvideomode : flyRender
  • s_stencil : flyRender
  • s_texcompress : flyTexCache
  • s_texdroplevel : flyRender
  • s_texfilter : flyTexCache
  • s_texmipmap : flyTexCache
  • s_textruecolor : flyTexCache
  • s_videores : flyRender
  • s_wireframe : flyRender
  • save() : flySkeletonMesh, flyShader, flyShaderPass, flyMesh, flyLightMap, flyAnimatedMesh
  • save_fly_file() : flyEngine
  • save_ini() : flyEngine
  • SaveJPG() : flyPicture
  • SaveTGA() : flyPicture
  • seek() : flyFile
  • sel_tex() : flyTexCache
  • sel_unit() : flyTexCache
  • selfillum : flyShader
  • selnodes : flyEngine
  • selobjs : flyEngine
  • send_bsp_message() : flyEngine
  • send_message() : flyDllGroup, flyDirectx
  • set_base() : flyLightMap
  • set_camera() : flyEngine
  • set_char() : flyString
  • set_detail() : flyBezierPatch
  • set_dim() : flyBezierCurve
  • set_frame() : flyVideo
  • set_full_screen() : flyRender
  • set_global_param() : flyEngine
  • set_listener() : flyDirectx
  • set_master_volume() : flyDirectx
  • set_ntrivert() : flyFace
  • set_numen() : flyMesh
  • set_numfaces() : flyMesh
  • set_numverts() : flyMesh
  • set_obj_param() : flyEngine
  • set_rotation() : flyMatrix
  • set_skeleton() : flySkeletonMesh
  • set_state() : flyShader, flyAnimatedMesh
  • set_state_1() : flyShaderPass
  • set_state_2() : flyShaderPass
  • set_state_blendcur() : flyAnimatedMesh
  • set_string() : flyParamDesc
  • set_tex_flags() : flyTexCache
  • set_vp() : flyShaderPass
  • sh : flyFace
  • shadercolor : flyEngine
  • shadermask : flyEngine
  • shaders : flyEngine
  • shadowcolor : flyEngine
  • shadowdist : flyEngine
  • shadows : flyEngine
  • show() : flyConsole
  • size : flyPicture
  • sizex : flyLightMap, flyLightMapPic
  • sizey : flyLightMap, flyLightMapPic
  • smooth_path() : flyEngine
  • sortkey : flyFace
  • source : flyBspObject
  • sse : flyEngine
  • start_time : flyEngine
  • state : flyStateMachineRule
  • status : flyEngine
  • status_msg : flyEngine
  • status_msg_time : flyEngine
  • step() : flyParticle, flyEngine, flyConsole, flyBspObject
  • step_end() : flyEngine
  • step_init() : flyEngine
  • step_objects() : flyEngine
  • stock_objs : flyEngine
  • surf : flyBezierPatch
  • sx : flyTexInfo, flyPicture
  • sy : flyTexInfo, flyPicture

- t -
  • T0 : flyEngine
  • T1 : flyEngine
  • table : flyFile
  • tcmod : flyShaderPass
  • tcmod_rotate : flyShaderPass
  • tcmod_scale : flyShaderPass
  • tcmod_scroll : flyShaderPass
  • tcmod_stretch_func : flyShaderPass
  • tex : flyTexCache, flyShaderPass
  • texcoord : flyVertex
  • texinfo : flyTexCache
  • texture : flyVideo
  • time : flyConsole
  • timedemo : flyEngine
  • timedemoframes : flyEngine
  • timelimit : flyEngine
  • tm : flySkeletonMesh
  • total_time : flySound
  • transition() : flyStateMachine
  • trivert : flyFace
  • type : flyShaderFunc, flyMPPlayerData, flyMPMsg, flyParamDesc

- u -
  • unzip() : flyFile
  • update() : flyVideo
  • update_mat() : flyLocalSystem
  • update_subtex() : flyTexCache
  • update_tex() : flyTexCache
  • upper() : flyString

- v -
  • vec() : flyVector
  • vel : flyParticle
  • vert : flyFace, flyEngine
  • vertindx : flyFace
  • vertnorm : flyBoundBox
  • vertprog : flyEngine
  • verts : flyPolygon, flyFrustum
  • vid : flyTexCache
  • view : flyEngine
  • vindex : flySkeletonMesh
  • vp : flyShaderPass
  • vpfunc : flyShaderPass
  • vpid : flyShaderPass
  • vweight : flySkeletonMesh

- w -
  • w : flyVector
  • width : flyVideo
  • winlines : flyConsole

- x -
  • x : flyVector
  • X : flyLocalSystem

- y -
  • y : flyVector
  • Y : flyLocalSystem

- z -
  • z : flyVector
  • Z : flyLocalSystem
  • zero_input() : flyDirectx
  • ziplist : flyFile

- ~ -
  • ~flyAnimatedMesh() : flyAnimatedMesh
  • ~flyArray() : flyArray
  • ~flyBaseObject() : flyBaseObject
  • ~flyBezierCurve() : flyBezierCurve
  • ~flyBezierPatch() : flyBezierPatch
  • ~flyBspNode() : flyBspNode
  • ~flyBspObject() : flyBspObject
  • ~flyClassDesc() : flyClassDesc
  • ~flyConsole() : flyConsole
  • ~flyDirectx() : flyDirectx
  • ~flyDll() : flyDll
  • ~flyDllGroup() : flyDllGroup
  • ~flyEngine() : flyEngine
  • ~flyFace() : flyFace
  • ~flyFile() : flyFile
  • ~flyFrustum() : flyFrustum
  • ~flyHashList() : flyHashList
  • ~flyInputMap() : flyInputMap
  • ~flyLightMap() : flyLightMap
  • ~flyLightMapPic() : flyLightMapPic
  • ~flyLightVertex() : flyLightVertex
  • ~flyLocalSystem() : flyLocalSystem
  • ~flyMesh() : flyMesh
  • ~flyOcTree() : flyOcTree
  • ~flyOcTreeNode() : flyOcTreeNode
  • ~flyParamDesc() : flyParamDesc
  • ~flyParticle() : flyParticle
  • ~flyPicture() : flyPicture
  • ~flyPolygon() : flyPolygon
  • ~flyRender() : flyRender
  • ~flyShader() : flyShader
  • ~flyShaderPass() : flyShaderPass
  • ~flySkeletonMesh() : flySkeletonMesh
  • ~flySound() : flySound
  • ~flyStaticMesh() : flyStaticMesh
  • ~flyString() : flyString
  • ~flyTexCache() : flyTexCache
  • ~flyVideo() : flyVideo


File Member Index

Fly3D SDK 2.0 File Members

d | f | g | o

Here is a list of all documented file members with links to the documentation:

- d -

  • DIRECTINPUT_VERSION : flyDirectX.h

- f -
  • FLY_2PI : flyMath.h
  • FLY_APPID_FLYBUILD : flyDefine.h
  • FLY_APPID_FLYEDITOR : flyDefine.h
  • FLY_APPID_FLYFRONTEND : flyDefine.h
  • FLY_APPID_FLYOCX : flyDefine.h
  • FLY_APPID_FLYSERVER : flyDefine.h
  • FLY_APPID_FLYSHADER : flyDefine.h
  • FLY_APPID_NONE : flyDefine.h
  • FLY_AXIS_SLIDER0 : flyDirectX.h
  • FLY_AXIS_SLIDER1 : flyDirectX.h
  • FLY_AXIS_X : flyDirectX.h
  • FLY_AXIS_X_ROT : flyDirectX.h
  • FLY_AXIS_Y : flyDirectX.h
  • FLY_AXIS_Y_ROT : flyDirectX.h
  • FLY_AXIS_Z : flyDirectX.h
  • FLY_AXIS_Z_ROT : flyDirectX.h
  • FLY_BIG : flyMath.h
  • FLY_CONSOLE_COL : flyDefine.h
  • FLY_CONSOLE_LINE : flyDefine.h
  • FLY_CONSOLE_MAXLINES : flyDefine.h
  • FLY_COS45 : flyMath.h
  • FLY_FABSRAND : flyMath.h
  • FLY_FACEFLAG_DETAIL : flyDefine.h
  • FLY_FACEFLAG_LANDSCAPE : flyDefine.h
  • FLY_FACEFLAG_STRUCTURAL : flyDefine.h
  • FLY_FACETYPE_BEZIER_PATCH : flyDefine.h
  • FLY_FACETYPE_LARGE_POLYGON : flyDefine.h
  • FLY_FACETYPE_TRIANGLE_FAN : flyDefine.h
  • FLY_FACETYPE_TRIANGLE_MESH : flyDefine.h
  • FLY_FACETYPE_TRIANGLE_STRIP : flyDefine.h
  • FLY_FILEID_BSP : flyDefine.h
  • FLY_FILEID_F3D : flyDefine.h
  • FLY_FILEID_FMP : flyDefine.h
  • FLY_FILEID_K3D : flyDefine.h
  • FLY_FILEID_LMP : flyDefine.h
  • FLY_FILEID_PVS : flyDefine.h
  • FLY_FONTS_FACTOR : flyRender.h
  • FLY_FONTS_NUM : flyRender.h
  • FLY_FPABS : flyMath.h
  • FLY_FPABSBITS : flyMath.h
  • FLY_FPBITS : flyMath.h
  • FLY_FPONEBITS : flyMath.h
  • FLY_FPSIGNBIT : flyMath.h
  • FLY_FRAND : flyMath.h
  • fly_free_directx() : flyDirectX.h
  • fly_free_engine() : fly3D.h
  • fly_free_render() : flyRender.h
  • fly_get_profile() : fly3D.h
  • fly_init_directx() : flyDirectX.h
  • fly_init_engine() : fly3D.h
  • fly_init_render() : flyRender.h
  • FLY_ISZERO : flyMath.h
  • FLY_JOY_BUTTON_1 : flyDirectX.h
  • FLY_JOY_BUTTON_10 : flyDirectX.h
  • FLY_JOY_BUTTON_2 : flyDirectX.h
  • FLY_JOY_BUTTON_3 : flyDirectX.h
  • FLY_JOY_BUTTON_4 : flyDirectX.h
  • FLY_JOY_BUTTON_5 : flyDirectX.h
  • FLY_JOY_BUTTON_6 : flyDirectX.h
  • FLY_JOY_BUTTON_7 : flyDirectX.h
  • FLY_JOY_BUTTON_8 : flyDirectX.h
  • FLY_JOY_BUTTON_9 : flyDirectX.h
  • FLY_MAX_BSPSTACK : flyDefine.h
  • FLY_MAX_HWLIGHTS : flyDefine.h
  • FLY_MAX_MESHANIMS : flyDefine.h
  • FLY_MAX_MESHBONES : flyDefine.h
  • FLY_MAX_MESHSTRLEN : flyDefine.h
  • FLY_MAX_OBJDRAWLAYERS : flyDefine.h
  • FLY_MAX_SHADERANIMFRAMES : flyDefine.h
  • FLY_MAX_SHADERPASSES : flyDefine.h
  • FLY_MAXTEXUNITS : flyTexCache.h
  • FLY_MESH_ALL : flyDefine.h
  • FLY_MESH_BBOX : flyDefine.h
  • FLY_MESH_FACENORM : flyDefine.h
  • FLY_MESH_OCTREE : flyDefine.h
  • FLY_MESH_VERTNORM : flyDefine.h
  • FLY_MESSAGE_CLOSESCENE : flyDefine.h
  • FLY_MESSAGE_DRAWSCENE : flyDefine.h
  • FLY_MESSAGE_DRAWTEXT : flyDefine.h
  • FLY_MESSAGE_DROPDATA : flyDefine.h
  • FLY_MESSAGE_FULLSCREEN : flyDefine.h
  • FLY_MESSAGE_INITSCENE : flyDefine.h
  • FLY_MESSAGE_MPMESSAGE : flyDefine.h
  • FLY_MESSAGE_MPUPDATE : flyDefine.h
  • FLY_MESSAGE_UPDATESCENE : flyDefine.h
  • FLY_MOUSE_L : flyDirectX.h
  • FLY_MOUSE_M : flyDirectX.h
  • FLY_MOUSE_R : flyDirectX.h
  • FLY_MP_BROWSETIME : flyDirectX.h
  • FLY_MP_CLIENT : flyDirectX.h
  • FLY_MP_GUARANTEED : flyDirectX.h
  • FLY_MP_MAXGAMES : flyDirectX.h
  • FLY_MP_MAXPLAYERS : flyDirectX.h
  • FLY_MP_MAXSERVICES : flyDirectX.h
  • FLY_MP_MSG_CHAT : flyDirectX.h
  • FLY_MP_MSG_FLYFILE : flyDirectX.h
  • FLY_MP_MSG_JOIN : flyDirectX.h
  • FLY_MP_MSG_QUIT : flyDirectX.h
  • FLY_MP_NOMP : flyDirectX.h
  • FLY_MP_SERVER : flyDirectX.h
  • FLY_NUMDEFAULTPARAM : flyDefine.h
  • FLY_OBJMESSAGE_CHANGEPARAM : flyDefine.h
  • FLY_OBJMESSAGE_DAMAGE : flyDefine.h
  • FLY_OBJMESSAGE_DAMAGECONTACT : flyDefine.h
  • FLY_OBJMESSAGE_DYNILLUM : flyDefine.h
  • FLY_OBJMESSAGE_ILLUM : flyDefine.h
  • FLY_OBJMESSAGE_LIGHT : flyDefine.h
  • FLY_OBJMESSAGE_STATICILLUM : flyDefine.h
  • FLY_OBJMESSAGE_TRIGGER : flyDefine.h
  • FLY_PATCHEVAL_NORMAL : flyDefine.h
  • FLY_PATCHEVAL_POINT : flyDefine.h
  • FLY_PATCHEVAL_TEXTCOORD : flyDefine.h
  • FLY_PI : flyMath.h
  • FLY_PI2 : flyMath.h
  • FLY_PIOVER180 : flyMath.h
  • FLY_PIUNDER180 : flyMath.h
  • FLY_PVS_TEST : flyDefine.h
  • FLY_REGISTRYKEY_PRIMARY : flyDefine.h
  • FLY_REGISTRYKEY_SECONDARY : flyDefine.h
  • fly_set_engine() : fly3D.h
  • FLY_SHADER_ALPHAFUNC : flyDefine.h
  • FLY_SHADER_ANIMMAP : flyDefine.h
  • FLY_SHADER_BLEND : flyDefine.h
  • FLY_SHADER_INVERTCULLING : flyDefine.h
  • FLY_SHADER_LIGHTMAP : flyDefine.h
  • FLY_SHADER_NOCOLLIDE : flyDefine.h
  • FLY_SHADER_NOCULL : flyDefine.h
  • FLY_SHADER_NODEPTHWRITE : flyDefine.h
  • FLY_SHADER_NOSHADOWS : flyDefine.h
  • FLY_SHADER_SKY : flyDefine.h
  • FLY_SHADER_TCGEN_ENV : flyDefine.h
  • FLY_SHADER_TCMOD : flyDefine.h
  • FLY_SHADER_TEXCLAMP : flyDefine.h
  • FLY_SHADER_TRANSPARENT : flyDefine.h
  • FLY_SHADERFUNC_INVERSESAWTOOTH : flyDefine.h
  • FLY_SHADERFUNC_SAWTOOTH : flyDefine.h
  • FLY_SHADERFUNC_SIN : flyDefine.h
  • FLY_SHADERFUNC_SQUARE : flyDefine.h
  • FLY_SHADERFUNC_TRIANGLE : flyDefine.h
  • FLY_SHADERGEN_DEFAULT : flyDefine.h
  • FLY_SHADERGEN_IDENTITY : flyDefine.h
  • FLY_SHADERGEN_REFLECTANCE : flyDefine.h
  • FLY_SHADERGEN_REFLECTANCEWAVE : flyDefine.h
  • FLY_SHADERGEN_VERTEX : flyDefine.h
  • FLY_SHADERGEN_WAVE : flyDefine.h
  • FLY_SHADERTCMOD_ROTATE : flyDefine.h
  • FLY_SHADERTCMOD_SCALE : flyDefine.h
  • FLY_SHADERTCMOD_SCROLL : flyDefine.h
  • FLY_SHADERTCMOD_STRETCH : flyDefine.h
  • FLY_SMALL : flyMath.h
  • FLY_SQRT3 : flyMath.h
  • FLY_STR_MINSIZE : flyString.h
  • FLY_TEXFLAG_BGR : flyTexCache.h
  • FLY_TEXFLAG_COMPRESSION : flyTexCache.h
  • FLY_TEXFLAG_FILTER : flyTexCache.h
  • FLY_TEXFLAG_MIPMAP : flyTexCache.h
  • FLY_TEXFLAG_TRUECOLOR : flyTexCache.h
  • FLY_TYPE_BEZIERCURVE : flyDefine.h
  • FLY_TYPE_MESH : flyDefine.h
  • FLY_TYPE_NONE : flyDefine.h
  • FLY_TYPE_SKELETONMESH : flyDefine.h
  • FLY_TYPE_SOUND : flyDefine.h
  • FLY_TYPE_STATICMESH : flyDefine.h
  • FLY_TYPE_VERTEXMESH : flyDefine.h
  • FLY_VECDOT : flyMath.h
  • FLY_VERSION_NUM : flyDefine.h
  • FLY_VERSION_STR : flyDefine.h
  • fly_write_profile() : fly3D.h

- g -
  • g_flydirectx : flyDirectX.h
  • g_flyengine : fly3D.h
  • g_flyGUID : fly3D.h
  • g_flyhinst : fly3D.h
  • g_flyhwnd : fly3D.h
  • g_flyrender : flyRender.h
  • g_flytexcache : flyTexCache.h
  • g_processor_features : fly3D.h

- o -
  • operator *() : flyMath.h
  • operator *=() : flyMath.h
  • operator+() : flyMath.h
  • operator+=() : flyMath.h
  • operator-() : flyMath.h
  • operator-=() : flyMath.h
  • operator/() : flyMath.h
  • operator/=() : flyMath.h


Main Page

Fly3D SDK 2.0 Plugins Documentation

RC2

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


File Index

Fly3D SDK 2.0 Plugins File List

Here is a list of all documented files with brief descriptions:
  • bspmesh.h
  • color_particle.h
  • cubemap.h
  • explode.h
  • f3dmesh.h
  • followpath.h
  • game.h
  • gamelib.h
  • gamemenu.h
  • lights.h
  • menu.h
  • multimedia.h
  • observer.h
  • panorama.h
  • portal.h
  • ps.h
  • robots.h
  • shadow.h
  • sound.h
  • trigger.h
  • viewport.h
  • volfog.h
  • walk.h
  • weapon.h


bspmesh.h File Reference

Compounds

class | bspmesh
Generic BSP mesh class. More...

class | bspmesh_desc
Description class for the bspmesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


color_particle.h File Reference

Compounds

class color_particle
Coloured particle class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


cubemap.h File Reference

Compounds

class | cubemap
Cube map class for precise environment mapping. More...

class | cubemap_desc
Description class for the cubemap class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


explode.h File Reference

Compounds

class | explode
Explosion class. More...

class | explode_desc
Description class for the explode class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


f3dmesh.h File Reference

Compounds

class | f3dmesh
Generic F3D mesh class. More...

class | f3dmesh_desc
Description class for the f3dmesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


followpath.h File Reference

Compounds

class | followpath
A path of sprites. More...

class | followpath_desc
Description class for the followpath class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


game.h File Reference

#include "..\..\lib\Fly3D.h"
#include "..\weapon\weapon.h"

Compounds

class | birthpad
Birth place for the ship. More...

class | birthpad_desc
Description class for the birthpad class. More...

class | camera
3rd person perspective camera class. More...

class | camera_desc
Description class for the camera class. More...

class | forcebox
Force box class. More...

class | forcebox_desc
Description class for the forcebox class. More...

class | powerup
Power-up class for the ship game. More...

class | powerup_desc
Description class for the powerup class. More...

class | ship
Ship class. More...

class | ship_control
Ship input class. More...

class | ship_desc
Description class for the ship class. More...

class | ship_draw
Ship drawing class. More...

class | ship_move
Ship movement class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


gamelib.h File Reference

#include "..\lights\lights.h"
#include "..\viewport\viewport.h"
#include "color_particle.h"
#include "ps.h"
#include "sound.h"
#include "explode.h"
#include "shadow.h"
#include "bspmesh.h"
#include "f3dmesh.h"
#include "followpath.h"
#include "portal.h"
#include "cubemap.h"
#include "trigger.h"

Variables

int portals
a flag for turning portals and mirrors on/off.

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


gamemenu.h File Reference

Compounds

class | menu_base
Game menu bar class. More...

class | menu_button
Button game menu item class. More...

class | menu_checkbox
Check box button game menu item class. More...

class | menu_editinputmap
Input map edit game menu item class. More...

class | menu_editoptionlist
Options list game menu item class. More...

class | menu_editstring
Text edit box game menu item class. More...

class | menu_group
Game menu group class. More...

class | menu_item
Generic game menu item class. More...

class | menu_scrollbar
Scroll bar game menu item class. More...

class | menu_separator
Separator game menu item class. More...

class | menu_showvalue
Value display game menu item class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


lights.h File Reference

Compounds

class | light
Light class. More...

class | light_desc
Description class for the light class. More...

class | scene_light
Scene light class. More...

class | scene_light_desc
Description class for the scene_light class. More...

class | spot_light
Spotlight class. More...

class | spot_light_desc
Description class for the spot_light class. More...

class | sprite_light
Sprite class. More...

class | sprite_light_desc
Description class for the sprite_light class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


menu.h File Reference

Compounds

class | menucamera
Camera class for browsing the menu. More...

class | menucamera_desc
Description class for the menucamera class. More...

class | menugroup
Group of menu items class. More...

class | menugroup_desc
Description class for the menugroup class. More...

class | menuitem
Selectable menu item class. More...

class | menuitem_desc
Description class for the menuitem class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


multimedia.h File Reference

Variables

flyString | video
name of a video file to be played.

flyString | command
console command to be executed.

int | audio_flag
flag indicating the number of the audio track to be played.

int | volume
audio volume.

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


observer.h File Reference

Compounds

class | observer
Freely-flying observer class. More...

class | observer_desc
Description class for the observer class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


panorama.h File Reference

Compounds

class | panorama
Background panorama class. More...

class | panorama_desc
Description class for the panorama class. More...

class | sky
Background sky class. More...

class | sky_desc
Description class for the sky class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


portal.h File Reference

Compounds

class | portal
Portal and mirror class. More...

class | portal_desc
Description class for the portal class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


ps.h File Reference

Compounds

class | particle_system
Particle system class. More...

class | ps_desc
Description class for the ps class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


robots.h File Reference

#include "..\..\lib\Fly3D.h"
#include "..\ship\game.h"

Compounds

class | door
Door class. More...

class | door_desc
Description class for the door class. More...

class | generator
Robot generator class. More...

class | generator_desc
Description class for the generator class. More...

class | robot
Enemy robot class. More...

class | robot_desc
Description class for the robot class. More...

Detailed Description

Define Documentation

#define PVS_TEST( from, to )

Value:

        (*(g_flyengine->pvs + (from)*g_flyengine->pvsrowsize + ((to)>>3)) & (1 << ((to) & 7)))


shadow.h File Reference

Compounds

class | shadow
Shadow class. More...

class | shadow_desc
Description class for the f3dmesh class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


sound.h File Reference

Compounds

class | sound
Sound class. More...

class | sound_desc
Description class for the sound class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


trigger.h File Reference

Compounds

class | trigger
Generic trigger class. More...

class | trigger_desc
Description class for the trigger class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


viewport.h File Reference

Compounds

class | viewport
Viewport class. More...

class | viewport_desc
Description class for the viewport class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


volfog.h File Reference

Compounds

class | fogbox
Box fog class. More...

class | fogbox_desc
Description class for the fogbox class. More...

class | fogsphere
Spherical fog class. More...

class | fogsphere_desc
Description class for the fogsphere class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


walk.h File Reference

#include "..\..\lib\Fly3D.h"
#include "..\weapon\weapon.h"

Compounds

class | birthpad
Birth place for the ship. More...

class | birthpad_desc
Description class for the birthpad class. More...

class | diemesh
Death animation mesh class. More...

class | diemesh_desc
Description class for the diemesh class. More...

class | gib
Person gib class. More...

class | gib_desc
Description class for the gib class. More...

class | jumppad
Jump pad class. More...

class | jumppad_desc
Description class for the jumppad class. More...

class | person
Person class. More...

class | person_anim
Person animation class. More...

class | person_control
Person input class. More...

class | person_desc
Description class for the person class. More...

class | person_move
Person movement class. More...

class | powerup
Power-up class for the ship game. More...

class | powerup_desc
Description class for the powerup class. More...

class | teleport
Teleport volume class. More...

class | teleport_desc
Description class for the teleport class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


weapon.h File Reference

#include "..\gamelib\gamelib.h"

Compounds

class | gun
Gun class. More...

class | gun_desc
Description class for the gun class. More...

class | gun_projectile
Gun projectile class. More...

class | hitmark
Hitmark class. More...

class | hitmark_desc
Description class for the hitmark class. More...

class | laser
Laser projectile class. More...

class | laser_desc
Description class for the laser class. More...

class | mine
Mine projectile class. More...

class | mine_desc
Description class for the mine class. More...

class | missile
Missile projectile class. More...

class | missile_desc
Description class for the missile class. More...

Detailed Description

Fly3D Game Engine ver 2.0 - http://www.fly3d.com.br
Copyright, 2000 Pararelo Computação Ltda.


Annotated Index

Fly3D SDK 2.0 Plugins Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:
  • birthpad (Birth place for the ship)
  • birthpad_desc (Description class for the birthpad class)
  • bspmesh (Generic BSP mesh class)
  • bspmesh_desc (Description class for the bspmesh class)
  • camera (3rd person perspective camera class)
  • camera_desc (Description class for the camera class)
  • color_particle (Coloured particle class)
  • cubemap (Cube map class for precise environment mapping)
  • cubemap_desc (Description class for the cubemap class)
  • diemesh (Death animation mesh class)
  • diemesh_desc (Description class for the diemesh class)
  • door (Door class)
  • door_desc (Description class for the door class)
  • explode (Explosion class)
  • explode_desc (Description class for the explode class)
  • f3dmesh (Generic F3D mesh class)
  • f3dmesh_desc (Description class for the f3dmesh class)
  • fogbox (Box fog class)
  • fogbox_desc (Description class for the fogbox class)
  • fogsphere (Spherical fog class)
  • fogsphere_desc (Description class for the fogsphere class)
  • followpath (A path of sprites)
  • followpath_desc (Description class for the followpath class)
  • forcebox (Force box class)
  • forcebox_desc (Description class for the forcebox class)
  • generator (Robot generator class)
  • generator_desc (Description class for the generator class)
  • gib (Person gib class)
  • gib_desc (Description class for the gib class)
  • gun (Gun class)
  • gun_desc (Description class for the gun class)
  • gun_projectile (Gun projectile class)
  • hitmark (Hitmark class)
  • hitmark_desc (Description class for the hitmark class)
  • jumppad (Jump pad class)
  • jumppad_desc (Description class for the jumppad class)
  • laser (Laser projectile class)
  • laser_desc (Description class for the laser class)
  • light (Light class)
  • light_desc (Description class for the light class)
  • menu_base (Game menu bar class)
  • menu_button (Button game menu item class)
  • menu_checkbox (Check box button game menu item class)
  • menu_editinputmap (Input map edit game menu item class)
  • menu_editoptionlist (Options list game menu item class)
  • menu_editstring (Text edit box game menu item class)
  • menu_group (Game menu group class)
  • menu_item (Generic game menu item class)
  • menu_scrollbar (Scroll bar game menu item class)
  • menu_separator (Separator game menu item class)
  • menu_showvalue (Value display game menu item class)
  • menucamera (Camera class for browsing the menu)
  • menucamera_desc (Description class for the menucamera class)
  • menugroup (Group of menu items class)
  • menugroup_desc (Description class for the menugroup class)
  • menuitem (Selectable menu item class)
  • menuitem_desc (Description class for the menuitem class)
  • mine (Mine projectile class)
  • mine_desc (Description class for the mine class)
  • missile (Missile projectile class)
  • missile_desc (Description class for the missile class)
  • observer (Freely-flying observer class)
  • observer_desc (Description class for the observer class)
  • panorama (Background panorama class)
  • panorama_desc (Description class for the panorama class)
  • particle_system (Particle system class)
  • person (Person class)
  • person_anim (Person animation class)
  • person_control (Person input class)
  • person_desc (Description class for the person class)
  • person_move (Person movement class)
  • portal (Portal and mirror class)
  • portal_desc (Description class for the portal class)
  • powerup (Power-up class for the ship game)
  • powerup_desc (Description class for the powerup class)
  • ps_desc (Description class for the ps class)
  • robot (Enemy robot class)
  • robot_desc (Description class for the robot class)
  • scene_light (Scene light class)
  • scene_light_desc (Description class for the scene_light class)
  • shadow (Shadow class)
  • shadow_desc (Description class for the f3dmesh class)
  • ship (Ship class)
  • ship_control (Ship input class)
  • ship_desc (Description class for the ship class)
  • ship_draw (Ship drawing class)
  • ship_move (Ship movement class)
  • sky (Background sky class)
  • sky_desc (Description class for the sky class)
  • sound (Sound class)
  • sound_desc (Description class for the sound class)
  • spot_light (Spotlight class)
  • spot_light_desc (Description class for the spot_light class)
  • sprite_light (Sprite class)
  • sprite_light_desc (Description class for the sprite_light class)
  • teleport (Teleport volume class)
  • teleport_desc (Description class for the teleport class)
  • trigger (Generic trigger class)
  • trigger_desc (Description class for the trigger class)
  • viewport (Viewport class)
  • viewport_desc (Description class for the viewport class)


birthpad Class Reference

Birth place for the ship. More...

#include <game.h>

List of all members.

Public Methods

birthpad ()
Default constructor.

birthpad (const birthpad &in)
Copy-constructor.

virtual | ~birthpad ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mesh.

int | step (int dt)
State update function, is called once per frame, animates.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

birthpad ()
Default constructor.

virtual | ~birthpad ()
Default destructor.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

Public Attributes

float | anim_size
size of the animation.

flyMesh* | anim_mesh
animated mesh to be activated when a ship spawns on the birth pad.

particle_system* ps
a particle emmiter to be activated when a ship spawns on the birth pad.

Detailed Description

Birth place for the ship.

This class implements a birth pad where the ship can spawn.


birthpad_desc Class Reference

Description class for the birthpad class. More...

#include <game.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the birthpad class.


bspmesh Class Reference

Generic BSP mesh class. More...

#include <bspmesh.h>

List of all members.

Public Methods

bspmesh ()
Default constructor.

bspmesh (const bspmesh &in)
Copy-constructor.

virtual | ~bspmesh ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mesh.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

flyMesh* | ray_intersect (const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum)
Computes ray-intersection with the object.

int | ray_intersect_test (const flyVector &ro, const flyVector &rd, float dist)
Tests for ray-intersection with the object, returning true or false.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

int | firstface
the index of the first face of the mesh in the engine's global array of faces.

int | numfaces
the number of faces that for the mesh.

flyMesh* | objmesh
a flyMesh object representing the mesh.

Detailed Description

Generic BSP mesh class.

This class implements a mesh formed by structural faces, i.e. faces that are part of the levels's structure and are used for BSP building.


bspmesh_desc Class Reference

Description class for the bspmesh class. More...

#include <bspmesh.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the bspmesh class.


camera Class Reference

3rd person perspective camera class. More...

#include <game.h>

List of all members.

Public Methods

camera ()
Default constructor.

camera (const camera &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the camera following the target.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

camera ()
Default constructor.

camera (const camera &in)
Copy-constructor.

int | step (int dt)
State update function, is called once per frame, moves the camera following the target.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

void | init (void)
Members initialisation function, is called upon activating the object.

Public Attributes

float | radius
the camera's radius.

float | dist
the desired distance to the target.

float | height
the desired height from the target's position.

flyBspObject* | target
the object that the camera will follow.

Detailed Description

3rd person perspective camera class.

This class implements a camera that follows a given object, and is used for 3rd person view of the ship game.


camera_desc Class Reference

Description class for the camera class. More...

#include <game.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the camera class.


color_particle Class Reference

Coloured particle class. More...

#include <color_particle.h>

List of all members.

Public Methods

int | step (int dt)
State update function, is called once per frame, moves the particle for the time elapsed since the last frame.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

color_particle ()
Default constructor.

virtual | ~color_particle ()
Default destructor.

Public Attributes

flyVector | color
the particle color.

int | texture
the texture applied over the face that represents the particle.

float | size
the particle size.

Detailed Description

Coloured particle class.

This class implements a particle that has colour and transparency.


cubemap Class Reference

Cube map class for precise environment mapping. More...

#include <cubemap.h>

List of all members.

Public Methods

cubemap ()
Default constructor.

cubemap (const cubemap &in)
Copy-constructor.

virtual | ~cubemap ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mapped mesh.

int | step (int dt)
State update function, is called once per frame.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyMesh* | objmesh
the mesh over which the maps will be applied.

int | img [6]
an array of six image indexes referencing the maps.

Detailed Description

Cube map class for precise environment mapping.

This class implements more precise environment mapping, taking advantage of the GL_TEXTURE_CUBE_MAP_ARB extension to avoid the discontinuity observed in standard environment mapping. The class members are the mesh over which the cube map will be applied and an array with six images.


cubemap_desc Class Reference

Description class for the cubemap class. More...

#include <cubemap.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the cubemap class.


diemesh Class Reference

Death animation mesh class. More...

#include <walk.h>

List of all members.

Public Methods

diemesh ()
Default constructor.

diemesh (const diemesh &in)
Copy-constructor.

virtual | ~diemesh ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | move (int dt)
Moves the diemesh.

void | explode (const flyVector &hitpos)
Explodes the diemesh and releases gibs.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the diemesh.

void | draw_shadow ()
Shadow drawing function.

int | step (int dt)
State update function, is called once per frame.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyAnimatedMesh* | objmesh
the animated mesh object.

int | fadetime
amount of time of the fading effect.

float | radius
the object's radius.

float | health
the diemesh's health (for exploding in gibs when destroyed).

float | gibforce
the force with which the gibs are thrown.

gib* | gb [5]
array of gibs.

Detailed Description

Death animation mesh class.

This class implements a mesh with a death animation for the person.


diemesh_desc Class Reference

Description class for the diemesh class. More...

#include <walk.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the diemesh class.


door Class Reference

Door class. More...

#include <robots.h>

List of all members.

Public Methods

door ()
Default constructor.

door (const door &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, animates the door.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the door.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyAnimatedMesh* | objmesh
the door's mesh.

int | animtime
the time in which the door opens.

int | ntriggers
the number of signals the door must receive to open.

birthpad* bp
birthpad object to be activated when the door is opened.

Detailed Description

Door class.

This class implements a door that is signaled to open by the robot generators.


door_desc Class Reference

Description class for the door class. More...

#include <robots.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the door class.


explode Class Reference

Explosion class. More...

#include <explode.h>

List of all members.

Public Methods

explode ()
Default constructor.

virtual | ~explode ()
Default destructor.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

virtual void | do_explode (flyVector &pos, flyVector &z, int fromplayer)
Carries out the explosion.

Public Attributes

sprite_light* s
a sprite object attached to the explosion.

light* l
the explosion light.

sound* snd
the explosion sound.

particle_system* ps
the explosion particle system.

float | damage
the explosion damage value.

float | damageradius
the explosion damage radius.

flyBspObject* | obj
the BSP object that will explode.

Detailed Description

Explosion class.

This class implements an explosion with a sprite, a light, a sound, a particle system and a damage attached to it


explode_desc Class Reference

Description class for the explode class. More...

#include <explode.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the explode class.


f3dmesh Class Reference

Generic F3D mesh class. More...

#include <f3dmesh.h>

List of all members.

Public Methods

f3dmesh ()
Default constructor.

f3dmesh (const f3dmesh &in)
Copy-constructor.

virtual | ~f3dmesh ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mesh.

int | step (int dt)
State update function, is called once per frame.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyMesh* | objmesh
a flyMesh object representing the mesh itself.

flyVector | color
the mesh's attached color.

int | flag
indicates if the object has its own 3D orientation (flag==0) or is always camera-aligned (otherwise).

float | scale
the mesh's scaling factor.

Detailed Description

Generic F3D mesh class.

This class implements a generic mesh that is not part of the level structure, but exists on its own in the scene, and can be moved during the simulation.


f3dmesh_desc Class Reference

Description class for the f3dmesh class. More...

#include <f3dmesh.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the f3dmesh class.


fogbox Class Reference

Box fog class. More...

#include <volfog.h>

List of all members.

Public Methods

fogbox ()
Default constructor.

fogbox (const fogbox &in)
Copy-constructor.

virtual | ~fogbox ()
Default destructor.

void | fog_map (flyLightMap *fm)
Computes the fog map.

int | fog_intersect (flyVector &point)
Calculates the fog intensity on a given point.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | fogsizex
x-edge size of the box.

float | fogsizey
y-edge size of the box.

float | fogsizez
z-edge size of the box.

float | fogdepth
the fog's depth factor.

flyVector | fogcolor
the fog's color.

int | fogmode
flag for debug purposes (0: normal fog, 1: light map pixels affected by the fog are painted).

Detailed Description

Box fog class.

This class implements a fog box with given depth and color.


fogbox_desc Class Reference

Description class for the fogbox class. More...

#include <volfog.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the fogbox class.


fogsphere Class Reference

Spherical fog class. More...

#include <volfog.h>

List of all members.

Public Methods

fogsphere ()
Default constructor.

fogsphere (const fogsphere &in)
Copy-constructor.

virtual | ~fogsphere ()
Default destructor.

void | fog_map (flyLightMap *fm)
Computes the fog map.

int | fog_intersect (flyVector &point)
Calculates the fog intensity on a given point.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | fogradius
the sphere's radius.

float | fogdepth
the fog's depth factor.

flyVector | fogcolor
the fog's color.

int | fogmode
flag for debug purposes (0: normal fog, 1: light map pixels affected by the fog are painted).

Detailed Description

Spherical fog class.

This class implements a fog sphere with given depth and color.


fogsphere_desc Class Reference

Description class for the fogsphere class. More...

#include <volfog.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the fogsphere class.


followpath Class Reference

A path of sprites. More...

#include <followpath.h>

List of all members.

Public Methods

followpath ()
Default constructor.

followpath (const followpath &in)
Copy-constructor.

virtual | ~followpath ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the path with its segments.

int | step (int dt)
State update function, is called once per frame.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | width
the path width.

flyVector | color
the path color.

int | texture
the texture applied to the path.

int | fade
the fade time for each path segment.

int | duration
the duration of each path segment.

int | delay
delay of time between the generation of segments.

Detailed Description

A path of sprites.

This class implements a path made of a stretched texture. It can be used to follow an object and produce some beautiful visual effects, like the ship afterburner.


followpath_desc Class Reference

Description class for the followpath class. More...

#include <followpath.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the followpath class.


forcebox Class Reference

Force box class. More...

#include <game.h>

List of all members.

Public Methods

forcebox ()
Default constructor.

forcebox (const forcebox &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, animates.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mesh.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | radius
the box radius.

float | forcefactor
the factor with which the box applies force on the ship.

flyVector | forcedir
the direction which the box drags or boosts the ship.

int | animdelay
the delay between animations in the animation cycle.

flyMesh* | objmesh
animated object representing the forcebox.

int | meshbox
flag indicating that the mesh should not be drawn.

sound* snd
sound for dragging or boosting the ship.

Detailed Description

Force box class.

This class implements a force box that boosts or drags the ship.


forcebox_desc Class Reference

Description class for the forcebox class. More...

#include <game.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the forcebox class.


generator Class Reference

Robot generator class. More...

#include <robots.h>

List of all members.

Public Methods

generator ()
Default constructor.

generator (const generator &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, animates.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the generator.

void | draw_shadow ()
Shadow drawing function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

void | generate ()
Generates a new robot randomly chosen from the types available.

Public Attributes

int | count
the total number of robots that will be generated.

flyMesh* | objmesh
the generator's mesh.

flyMesh* | anim_mesh
an animated mesh that is activated when a robot is generated.

particle_system* anim_ps
a particle emmiter that is activated when a robot is generated.

int | animtime
the amount of time that the generation animation plays.

float | anim_size
size of the animating object.

flyArray<flyBspObject*> | gen_types
enumeration of the types of robots that the generator can activate.

int | gen_delay
the amount of time between two robot activations.

float | gen_angle
the random angle in which robots are generated.

sound* gen_sound
sound for activating a new robot.

flyVector | birthpos
relative position on which the generated robots will show up.

flyArray<flyBspObject *> | objs
an array of objects that are signaled when all the robots activated by the generator are killed.

Detailed Description

Robot generator class.

This class implements a generator that periodically adds robots to the game.


generator_desc Class Reference

Description class for the generator class. More...

#include <robots.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the generator class.


gib Class Reference

Person gib class. More...

#include <walk.h>

List of all members.

Public Methods

gib ()
Default constructor.

gib (const gib &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the gib and trail.

void | draw_shadow ()
Shadow drawing function.

int | step (int dt)
State update function, is called once per frame, moves the gib.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyMesh* | objmesh
the gib's mesh.

hitmark* hm
hitmark layed by the gib when it hits a surface.

int | fadetime
amount of time of the fading effect.

int | numbounces
the gib's maximum number of bounces.

int | traildelay
delay time for the blood trail.

Detailed Description

Person gib class.

This class implements a person's gibs for exploding.


gib_desc Class Reference

Description class for the gib class. More...

#include <walk.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the gib class.


gun Class Reference

Gun class. More...

#include <weapon.h>

List of all members.

Public Methods

gun ()
Default constructor.

gun (const gun &in)
Copy-constructor.

virtual | ~gun ()
Default destructor.

virtual flyBspObject* | fire (flyBspObject *obj, int player)
Fires a projectile.

virtual int | fire_status ()
Checks if it is possible to fire in a given moment (if the gun still has ammo and the fire delay is observed).

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

sound* sndfire
sound for firing the gun.

gun_projectile* p
gun_projectile object fired by the gun.

int | firecount
amount of ammo the gun has in a given moment.

int | delay
the gun's delay of fire (time between two firings).

int | nfire
number of projectiles thrown at once when firing.

float | firevel
the projectile's initial velocity.

float | randomangle
the gun's angle of imprecision.

flyArray<flyVector> | firepos
an array of positions from which the projectiles are fired (relative to the gun's position).

flyMesh* | objmesh
the gun's mesh.

light* l
a light to be light in the moment of firing.

Detailed Description

Gun class.

This class implements a gun that has a certain ammount of ammo and fires its projectiles.


gun_desc Class Reference

Description class for the gun class. More...

#include <weapon.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the gun class.


gun_projectile Class Reference

Gun projectile class. More...

#include <weapon.h>

Inheritance diagram for gun_projectile::

laser mine missile List of all members.

Public Methods

gun_projectile ()
Default constructor.

gun_projectile (const gun_projectile &in)
Copy-constructor.

virtual | ~gun_projectile ()
Default destructor.

virtual flyBspObject* | fire (flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0)=0
Fires the projectile from the given position with the given direction and velocity.

Public Attributes

float | damage
the amount of damage inflicted by the projectile.

explode* exp
explosion thrown when the projectile collides and dies.

Detailed Description

Gun projectile class.

This class implements the gun projectiles interface.


hitmark Class Reference

Hitmark class. More...

#include <weapon.h>

List of all members.

Public Methods

hitmark ()
Default constructor.

hitmark (const hitmark &in)
Copy-constructor.

virtual | ~hitmark ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mark.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

void | clip (flyFace *face)
Clips the mark on the edges of the face over which it is applied.

Public Attributes

int | texture
texture left on the surface.

float | size
size of the mark.

int | fadetime
amount of time of the fading effect.

flyVector | color
the hitmark's color.

Detailed Description

Hitmark class.

This class implements a mark left on walls and other surfaces by projectiles that hit them.


hitmark_desc Class Reference

Description class for the hitmark class. More...

#include <weapon.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the hitmark class.


jumppad Class Reference

Jump pad class. More...

#include <walk.h>

List of all members.

Public Methods

jumppad ()
Default constructor.

jumppad (const jumppad &in)
Copy-constructor.

int | clip_bbox (const flyVector &min, const flyVector &max)
Determines if the given box clips the pad volume.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyVector | targetpos
position of the highest point of the jump.

flyVector* | sound
sound for jumping on the pad.

flyArray<flyVector> | planes
the planes that define the jump pad volume.

Detailed Description

Jump pad class.

This class implements a volume that applies vertical force on the person.


jumppad_desc Class Reference

Description class for the jumppad class. More...

#include <walk.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the jumppad class.


laser Class Reference

Laser projectile class. More...

#include <weapon.h>

Inheritance diagram for laser::

gun_projectile List of all members.

Public Methods

laser ()
Default constructor.

laser (const laser &in)
Copy-constructor.

virtual | ~laser ()
Default destructor.

virtual flyBspObject* | fire (flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0)
Fires the laser from the given position with the given direction and velocity.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the laser projectile, releases sprites and animates them.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the laser projectile.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | sizetexture
the size of the largest texture between the side and front textures.

int | sidetexture
texture for viewing the projectile from the side.

int | fronttexture
texture for viewing the projectile by front.

hitmark* hm
hitmark layed on walls by the projectile.

light* l
light carried with the projectile.

sprite_light* s
a sprite released periodically by the projectile when flying.

float | sfact
frequence in which the sprite is released.

float | srfact
variation in the sprite's scale (for growing or shrinking sprites).

float | srvel
radial velocity of the sprite (for spiraling sprites).

int | numbounces
the number of times the laser projectile can bounce on walls and surfaces.

followpath* path
a followpath object that follows the flying laser.

Detailed Description

Laser projectile class.

This class implements a laser projectile, i.e. a projectile made of energy and implemented with sprites.


laser_desc Class Reference

Description class for the laser class. More...

#include <weapon.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the laser class.


light Class Reference

Light class. More...

#include <lights.h>

List of all members.

Public Methods

light ()
Default constructor.

light (const light &in)
Copy-constructor.

virtual | ~light ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, illuminates.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the halo.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyVector | color
the light color.

float | illum_radius
the light illumination radius.

sprite_light* s
the light's halo sprite.

float | grow
radius variation per milisecond.

Detailed Description

Light class.

This class implements a generic light.


light_desc Class Reference

Description class for the light class. More...

#include <lights.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the light class.


menu_base Class Reference

Game menu bar class. More...

#include <gamemenu.h>

List of all members.

Public Methods

menu_base ()
Default constructor.

virtual | ~menu_base ()
Default destructor.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu bar.

void | draw_back (int x, int y, int sx, int sy, float f)
Draw the bar background.

void | step (int dt)
State update function, is called once per frame.

menu_group* | add_group (const char *t)
Add a group to the menu.

Private Attributes

int | locked
flag for locking focus used by menu itens with internal input.

int | visible
flag that signalizes that the menu bar is visible.

int | sel_group
index of the currently selected group.

flyArray<menu_group *> | groups
array of active menu groups.

Detailed Description

Game menu bar class.

This class implements an in-game menu bar that is called by pressing a given key on the keyboard, and works as a base for the menu groups. The class members include the array of menu groups and the currently selected group.


menu_button Class Reference

Button game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_button::

menu_item List of all members.

Public Methods

menu_button (const char *label, void callback())
Default constructor.

virtual | ~menu_button ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

void | on_select ()
Actions performed upon pressing the button.

int | get_width ()
Retrieves the item width in screen pixels.

Detailed Description

Button game menu item class.

This class implements a game menu item that works as a button, i.e. an item that performs a given action when pressed.


menu_checkbox Class Reference

Check box button game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_checkbox::

menu_item List of all members.

Public Methods

menu_checkbox (const char *label, int *val)
Default constructor.

virtual | ~menu_checkbox ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

void | on_select ()
Actions performed upon pressing the button.

int | get_width ()
Retrieves the item width in screen pixels.

Detailed Description

Check box button game menu item class.

This class implements a game menu item that works as a check box button, i.e. an item that changes its on/off state when pressed.


menu_editinputmap Class Reference

Input map edit game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_editinputmap::

menu_item List of all members.

Public Methods

menu_editinputmap (const char *label, int im, int tab=0)
Default constructor.

virtual | ~menu_editinputmap ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

void | step (int dt, int x, int y, int sx, int sy)
State update function, is called once per frame.

void | on_select ()
Actions performed upon editing the text.

int | get_width ()
Retrieves the item width in screen pixels.

Public Attributes

int | tabwidth
distance in pixels from the menu border to the left of the item.

int | editing
flag indicating that the value is being edited.

Detailed Description

Input map edit game menu item class.

This class implements a game menu item that displays an input option and the key or mouse button assigned to it. It also allows changing the key or button.


menu_editoptionlist Class Reference

Options list game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_editoptionlist::

menu_item List of all members.

Public Methods

menu_editoptionlist (const char *label, int num, char **names, int *val, int bias=0, void *callback=0)
Default constructor.

virtual | ~menu_editoptionlist ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

void | step (int dt, int x, int y, int sx, int sy)
State update function, is called once per frame.

void | on_select ()
Actions performed upon editing the text.

int | get_width ()
Retrieves the item width in screen pixels.

Public Attributes

int | val_bias
values list index offset.

int | num_options
number of options in the list.

char** | option_names
array of strings containing the options.

int | sel_option
index of the currently selected option.

int | editing
flag indicating that the value is being edited (the user is browsing the list to choose a value).

void (* | onchange_callback )()
Callback function called when the option is changed.

Detailed Description

Options list game menu item class.

This class implements a game menu item that displays a list of values and allows the user to choose a value from the list.


menu_editstring Class Reference

Text edit box game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_editstring::

menu_item List of all members.

Public Methods

menu_editstring (const char *label, flyString *val)
Default constructor.

virtual | ~menu_editstring ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

void | step (int dt, int x, int y, int sx, int sy)
State update function, is called once per frame.

void | on_select ()
Actions performed upon editing the text.

int | get_width ()
Retrieves the item width in screen pixels.

Detailed Description

Text edit box game menu item class.

This class implements a game menu item that works as a text edit box, i.e. an item that features a space where text can be edited.


menu_group Class Reference

Game menu group class. More...

#include <gamemenu.h>

List of all members.

Public Methods

menu_group ()
Default constructor.

virtual | ~menu_group ()
Default destructor.

void | draw (int x, int y)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu group.

void | step (int dt, int x, int y)
State update function, is called once per frame.

void | add_item (menu_item *item)
Add an item to the menu group.

Public Attributes

int | visible
flag that signalizes that the menu group is visible.

int | sel_item
index of the currently selected menu item.

flyString | text
the menu group's text label.

flyArray<menu_item *> | itens
the array of items pertaining to this menu group.

float | factor
factor used for menu fading on open.

Detailed Description

Game menu group class.

This class implements a group of menu items for the in-game menu The class members include an array of menu items, a text label for the menu group and the currently selected item.


menu_item Class Reference

Generic game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_item::

menu_button menu_checkbox menu_editinputmap menu_editoptionlist menu_editstring menu_scrollbar menu_separator menu_showvalue List of all members.

Public Methods

menu_item ()
Default constructor.

virtual | ~menu_item ()
Default destructor.

virtual void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

virtual void | step (int dt, int x, int y, int sx, int sy)
State update function, is called once per frame.

virtual void | on_select ()
Actions performed upon selecting the item.

virtual int | get_height ()
Retrieves the item height in screen pixels.

virtual int | get_width ()
Retrieves the item width in screen pixels.

Public Attributes

int | type
the item's type.

void* | data
generic data buffer for the item's data.

flyString | text
a label to be displayed by the item.

Detailed Description

Generic game menu item class.

This class implements a generic menu item object. It is inherited by all the types of menu items available. Among the class members are the item type, a text label to be displayed over or before the item, and a generic data buffer.


menu_scrollbar Class Reference

Scroll bar game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_scrollbar::

menu_item List of all members.

Public Methods

menu_scrollbar (const char *label, int *val, int minvalue, int maxvalue, int modulo=0, int tab=0)
Integer constructor.

menu_scrollbar (const char *label, float *val, float minvalue, float maxvalue, float modulo=0, int tab=0)
Float constructor.

virtual | ~menu_scrollbar ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

void | step (int dt, int x, int y, int sx, int sy)
State update function, is called once per frame.

Public Attributes

int | tabwidth
distance in pixels from the menu border to the left of the item.

Detailed Description

Scroll bar game menu item class.

This class implements a scroll bar menu item useful for editing numeric values. It can be combined with a value display menu item for displaying a number and editing it with the scroll bar.


menu_separator Class Reference

Separator game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_separator::

menu_item List of all members.

Public Methods

menu_separator ()
Default constructor.

virtual | ~menu_separator ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

int | get_height ()
Retrieves the item height in screen pixels.

Detailed Description

Separator game menu item class.

This class implements a separator that helps organizing various items is a menu. It consists of a single line drawn in the menu window.


menu_showvalue Class Reference

Value display game menu item class. More...

#include <gamemenu.h>

Inheritance diagram for menu_showvalue::

menu_item List of all members.

Public Methods

menu_showvalue (const char *label)
Default constructor.

menu_showvalue (const char *label, int *val)
Integer display constructor.

menu_showvalue (const char *label, float *val)
Float display constructor.

menu_showvalue (const char *label, flyVector *val)
Color display constructor.

menu_showvalue (const char *label, flyString *val)
flyString string display constructor.

menu_showvalue (const char *label, char *val)
Char pointer string display constructor.

virtual | ~menu_showvalue ()
Default destructor.

void | draw (int x, int y, int sx, int sy)
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the menu item.

int | get_width ()
Retrieves the item width in screen pixels.

Detailed Description

Value display game menu item class.

This class implements a game menu item that displays a value or color. It can display integer or floating point numbers, colors or strings.


menucamera Class Reference

Camera class for browsing the menu. More...

#include <menu.h>

List of all members.

Public Methods

menucamera ()
Default constructor.

menucamera (const menucamera &in)
Copy-constructor.

~menucamera ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, moves the camera and rotates towards the target.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyBspObject* | target
the camera's target, which it will be facing.

float | rotvel
the camera's maximum rotation velocity.

light* l
the camera's light.

sound* sndchangesel
sound for changing the currently selected item.

sound* sndselect
sound for activating the currently selected item.

Detailed Description

Camera class for browsing the menu.

This class implements a camera that is always facing a certain menu group. It is used for browsing the menu.


menucamera_desc Class Reference

Description class for the menucamera class. More...

#include <menu.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the menucamera class.


menugroup Class Reference

Group of menu items class. More...

#include <menu.h>

List of all members.

Public Methods

menugroup ()
Default constructor.

menugroup (const menugroup &in)
Copy-constructor.

virtual | ~menugroup ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the items, checks for input and selects/de-selects items.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

int | nitem
number of items in the group.

menuitem* | item [8]
array of items.

float | height1
height of non-selected items.

float | height2
height of selected items.

float | wave_speed
items' wave-like movement speed.

float | wave_size
items' wave-like movement size.

Detailed Description

Group of menu items class.

This class implements a group of selectable menu items.


menugroup_desc Class Reference

Description class for the menugroup class. More...

#include <menu.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the menugroup class.


menuitem Class Reference

Selectable menu item class. More...

#include <menu.h>

List of all members.

Public Methods

menuitem ()
Default constructor.

menuitem (const menuitem &in)
Copy-constructor.

virtual | ~menuitem ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, checks for input.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the item.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

int | mapbrowse
flag indicating if the menu item is a map browsing item or standard button item.

int | texture
menu item texture.

flyVector | color
menu item color.

flyString | command
console command to be executed upon activating the menu item.

Detailed Description

Selectable menu item class.

This class implements a selectable menu item.


menuitem_desc Class Reference

Description class for the menuitem class. More...

#include <menu.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the menuitem class.


mine Class Reference

Mine projectile class. More...

#include <weapon.h>

Inheritance diagram for mine::

gun_projectile List of all members.

Public Methods

mine ()
Default constructor.

mine (const mine &in)
Copy-constructor.

virtual | ~mine ()
Default destructor.

virtual flyBspObject* | fire (flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0)
Fires the mine from the given position with the given direction and velocity.

void | send_mine_data (int flag)
Sends the mine data to the server in a multiplayer game.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, looks for enemies around the mine, turretmines shoot on enemies.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mine.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | lookrange
the distance in which the mine explodes with the presence of an enemy.

float | turnvel
the turretmine's maximum rotation velocity.

light* l
a glowing light on the mine.

sound* snd_bounce
sound for bouncing on surfaces.

flyMesh* | objmesh
the mine's mesh.

int | delay
the amount of time before the mine is activated (when it is released).

float | shield
the mine's amount of shield (for destroying it).

int | numbounces
the number of times the thrown mine can bounce on walls and surfaces.

gun* turretgun
the turretmine's gun.

float | turretrange
the distance in which the turretmine can look for enemies.

float | turretfireangle
the minimum angle in which the turretmine fires on the enemy.

Detailed Description

Mine projectile class.

This class implements a mine, i.e. a projectile that explodes with proximity. It also implements a special kind of mine, the 'turretmine', that fires a gun on any nearby enemy.


mine_desc Class Reference

Description class for the mine class. More...

#include <weapon.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the mine class.


missile Class Reference

Missile projectile class. More...

#include <weapon.h>

Inheritance diagram for missile::

gun_projectile List of all members.

Public Methods

missile ()
Default constructor.

missile (const missile &in)
Copy-constructor.

virtual | ~missile ()
Default destructor.

virtual flyBspObject* | fire (flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0)
Fires the missile from the given position with the given direction and velocity.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the missile, releases sprites and animates them.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the missile.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyMesh* | objmesh
the missile's mesh.

float | rotvel
the missile's maximum z-axis rotation velocity.

light* l
light carried with the missile.

float | lightzpos
the relative position of the light over the missile's local z axis.

sound* snd_travel
sound carried by the missile when flying around.

viewport* | viewport
viewport that renders the missile view on a window.

sprite_light* s
a sprite released periodically by the projectile when flying.

float | sfact
frequence in which the sprite is released.

hitmark* hm
hitmark layed on walls by the projectile.

float | lookangle
maximum angle in which a homing missile looks for enemies.

float | lookdist
maximum distance in which a homing missile looks for enemies.

float | turnvel
homing and guided missiles' turning velocity.

followpath* path
a followpath object that follows the flying missile.

Detailed Description

Missile projectile class.

This class implements a missile fired by missile guns.


missile_desc Class Reference

Description class for the missile class. More...

#include <weapon.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the missile class.


observer Class Reference

Freely-flying observer class. More...

#include <observer.h>

List of all members.

Public Methods

observer ()
Default constructor.

observer (const observer &in)
Copy-constructor.

virtual | ~observer ()
Default destructor.

void | check_keys (int dt)
Check for input from the keyboard and mouse.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the observer.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | radius
the observer's radius.

float | rotvel
the observer's maximum rotation velocity.

float | mousevel
the observer's maximum mouse rotation velocity.

float | moveforce
the observer's maximum movement force.

float | maxvel
the observer's maximum movement velocity.

float | veldamp
the velocity damping value.

Detailed Description

Freely-flying observer class.

This class implements a flying observer entity that moves freely in 3D space. It is useful as a user-controlled camera for visualization of the scene.


observer_desc Class Reference

Description class for the observer class. More...

#include <observer.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the observer class.


panorama Class Reference

Background panorama class. More...

#include <panorama.h>

List of all members.

Public Methods

panorama ()
Default constructor.

virtual | ~panorama ()
Default destructor.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the panorama.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

Public Attributes

int | img [6]
array of images that compose the panorama (in order: up, down, left, right, front, back).

float | size
size of each image.

flyVector | color
color applied to the images.

Detailed Description

Background panorama class.

This class implements a panorama made of six images that form a background box surrounding the level.


panorama_desc Class Reference

Description class for the panorama class. More...

#include <panorama.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the panorama class.


particle_system Class Reference

Particle system class. More...

#include <ps.h>

List of all members.

Public Methods

particle_system ()
Default constructor.

particle_system (const particle_system &in)
Copy-constructor.

virtual | ~particle_system ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, instantiates and emmits the particles.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyVector | partcolor
the emmited particles' color.

flyVector | partcolorvar
variation of the emmited particles' color.

float | partbump
the emmited particles' bump factor.

float | partfriction
the emmited particles' friction factor.

float | partradius
the emmited particles' radius.

float | partmass
the emmited particles' mass.

float | partspeed
the emmited particles' speed.

float | partspeedvar
variation of the emmited particles' speed.

float | ax
maximum random emmition angle in x.

float | ay
maximum random emmition angle in y.

int | partcolflag
the emmited particles' collision flag (0: no collision, 1: collide, 3: collide and die).

int | texture
the emmited particles' applied texture.

int | emmtime
total emmition time.

int | totpart
total number os particles to be emmited.

int | fadetime
fading time for the particles.

int | drawflag
particles drawing flag (0: draws the particles only, 1: draws a sprite from the emmiter to each particle).

Detailed Description

Particle system class.

This class implements a particle emmition system.


person Class Reference

Person class. More...

#include <walk.h>

Inheritance diagram for person::

person_anim person_move person_control List of all members.

Public Methods

person ()
Default constructor.

person (const person &in)
Copy-constructor.

virtual | ~person ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, checks for input, moves the person, fires the guns.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the person.

void | draw_shadow ()
Shadow drawing function.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

void | move (int dt)
Moves the person around.

void | do_input (int dt)
Checks for input form the keyboard and mouse.

void | mp_send_pos (int msgtype, int msgflag)
Multiplayer message function, sends the person's position.

void | mp_send_kill (int killer, int pad, const flyVector &hitpoint)
Multiplayer message function, sends the person's death data.

void | mp_send_damage (int from, const flyVector &pushvec, float value)
Multiplayer message function, sends the person's damage data.

void | die (int killer, const flyVector &hitpos, int padindx)
Kills the person and prepares it for respawning.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

spot_light* spot
the person's headlight.

shadow* playershadow
the person's shadow.

diemesh* die_person
a mesh with the person's death animations.

gun* | g [9]
the person's arsenal, i.e. an array of guns.

sound* snd_noammo
sound for trying to fire an out-of-ammo gun.

sound* snd_change
sound for changing the selected gun.

sound* snd_wearoff
sound for power-up wear off.

sound* snd_damage
sound for damaging an enemy.

sound* snd_jump
sound for jumping.

sound* snd_land
sound for landing on the ground.

sound* snd_jumppad
sound for stepping on a jump pad.

sound* snd_teleport
sound for teleporting.

sound* snd_crater
sound for taking fall damage.

Detailed Description

Person class.

This class implements a person, which is used as a player in the walk game. The person reads input from the keyboard and mouse, moves, animates, fires guns and much more.


person_anim Class Reference

Person animation class. More...

#include <walk.h>

Inheritance diagram for person_anim::

person List of all members.

Public Methods

person_anim ()
Default constructor.

person_anim (const person_anim &in)
Copy-constructor.

virtual | ~person_anim ()
Default destructor.

void | calc_anim (const flyVector &walkvec, const flyVector &Z)
Computes the current state of the animation.

void | calc_anim_hit (const flyVector &dir, const flyVector &Z)
Computes hit animation modifier.

void | set_anim ()
Sets the mesh's current state based on animations.

Public Attributes

flyAnimatedMesh* | playermesh
mesh for the person.

flyAnimatedMesh* | weaponmesh
mesh for the weapon.

Detailed Description

Person animation class.

This class implements the animation module for the person class.


person_control Class Reference

Person input class. More...

#include <walk.h>

Inheritance diagram for person_control::

person List of all members.

Public Methods

person_control ()
Default constructor.

person_control (const person_control &in)
Copy-constructor.

virtual | ~person_control ()
Default destructor.

Public Attributes

int | zoomtime
time for zooming in.

float | zoomangle1
normal view camera angle.

float | zoomangle2
zoom view camera angle.

float | health
the person's health (up to 2.0f).

float | armor
the person's armor (up to 2.0f).

float | getradius
power-ups in the getradius distance from the person will be picked.

float | falldamagevel
falling velocity with which fall damage is applied.

float | falldamagefactor
fall damage intensity.

Detailed Description

Person input class.

This class implements the input module for the person class.


person_desc Class Reference

Description class for the person class. More...

#include <walk.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the person class.


person_move Class Reference

Person movement class. More...

#include <walk.h>

Inheritance diagram for person_move::

person List of all members.

Public Methods

person_move ()
Default constructor.

person_move (const person_move &in)
Copy-constructor.

virtual | ~person_move ()
Default destructor.

Public Attributes

float | radius
the person's radius.

float | height
the person's height.

float | headheight
distance from the person's height to the eyes.

float | rotvel
the person's maximum rotation velocity.

float | mousespeed
mouse rotation speed.

float | jumpheight
maximum jump height.

float | walkvel
the person's maximum walk velocity.

float | stepheight
the maximum height of a stairs step which the person can climb.

float | stepmaxvel
the maximum velocity for going upstairs/downstairs.

Detailed Description

Person movement class.

This class implements the movement module for the person class.


portal Class Reference

Portal and mirror class. More...

#include <portal.h>

List of all members.

Public Methods

portal ()
Default constructor.

portal (const portal &in)
Copy-constructor.

virtual | ~portal ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object, builds the bounding box and creates the portal texture.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the portal's geometry.

void | post_step ()
After-step function, is called after every object has updated its state in the frame, renders the scene from the portal camera into the portal texture.

int | step (int dt)
State update function, is called once per frame, computes the portal camera and the portal geometry LOD.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

int | invert
look direction inversion flag.

int | mode
portal mode (0: camera, 1: portal, 2: mirror).

int | resolution
portal texture resolution (power of 2).

int | nsegx
max number of segments (for LOD) in x.

int | nsegy
max number of segments (for LOD) in y.

float | width
portal geometry width.

float | height
portal geometry height.

flyVector | color
portal color (RGBA).

float | maxviewdist
maximum viewing distance.

Detailed Description

Portal and mirror class.

This class implements a portal or mirror, and can also be used as a remote camera.


portal_desc Class Reference

Description class for the portal class. More...

#include <portal.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the portal class.


powerup Class Reference

Power-up class for the ship game. More...

#include <game.h>

List of all members.

Public Methods

powerup ()
Default constructor.

powerup (const powerup &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the power-up.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the power-up.

void | draw_shadow ()
Shadow drawing function.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

void | powerup_get (ship *p)
Pick up the power-up.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

powerup ()
Default constructor.

powerup (const powerup &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the power-up.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the power-up.

void | draw_shadow ()
Shadow drawing function.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

void | powerup_get (person *p)
Pick up the power-up.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

int | valuetype
power-up type (-1: life, -2: armor, -3: quaddamage, -4: invisibility, n>=0 && n<=10: ammo for weapon n, n>=10: weapon n-10).

int | value
the amount of ammo, life, armor, etc. given by the power-up.

flyVector | colorget
color that fills the screen when the power-up is picked.

int | fadetime
amount of time in miliseconds for the fade-in effect when the power-up respawns.

int | spawntime
amount of time in miliseconds for the power-up to respawn after being picked.

sound* sndget
array of sounds for picking the power-up.

sound* sndspawn
sound for respawning.

flyMesh* | objmesh_item
mesh of the power-up itself.

flyMesh* | objmesh_box
optional mesh for a box that encloses the power-up.

int | zrot_time
time of the z-axis rotation movement of the power-up.

float | updowndist
distance of the up/down power-up movement.

int | updowntime
time of the up/down power-up movement.

float | veldamp
power-up velocity damping factor.

int | gettime
delay of time for getting the power-up after right sfter it is dropped.

int | nsndget
number of sounds for picking the power-up.

flyMesh* | objmesh
mesh of the power-up itself.

Detailed Description

Power-up class for the ship game.

This class implements power-ups that are pickable by the ships.


powerup_desc Class Reference

Description class for the powerup class. More...

#include <game.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the powerup class.


ps_desc Class Reference

Description class for the ps class. More...

#include <ps.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the ps class.


robot Class Reference

Enemy robot class. More...

#include <robots.h>

List of all members.

Public Methods

robot ()
Default constructor.

robot (const robot &in)
Copy-constructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, moves the robot and fires its gun.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the robot.

void | draw_shadow ()
Shadow drawing function.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyMesh* | objmesh
the robot's mesh.

float | shield
the robot's shield, i.e. the amount of damage it can take before dying.

float | rotvel
the robot's maximum rotation velocity.

float | movevel
the robot's maximum movement velocity.

float | fireangle
the minimum angle (with the player) in which the robots fires its gun.

float | movedist
the minimum distance the robot keeps from the player.

float | explodedist
the distance within which the robots explodes in presence of the player.

flyArray<gun *> | guns
the robots arsenal, i.e. an array of guns.

sound* snd_travel
sound carried by the robot when flying around.

int | gunrefreshtime
the robot's gun delay of fire.

explode* e
explosion thrown by the robot upon dying.

Detailed Description

Enemy robot class.

This class implements an AI-controlled enemy robot for the ship game.


robot_desc Class Reference

Description class for the robot class. More...

#include <robots.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the robot class.


scene_light Class Reference

Scene light class. More...

#include <lights.h>

List of all members.

Public Methods

scene_light ()
Default constructor.

scene_light (const scene_light &in)
Copy-constructor.

virtual | ~scene_light ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, illuminates.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the halo.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

scene_light ()
Default constructor.

scene_light (const scene_light &in)
Copy-constructor.

virtual | ~scene_light ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, illuminates.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the halo.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyVector | color
the light's color.

float | illumradius
the light's illumination radius.

sprite_light* s
the light's halo sprite.

Detailed Description

Scene light class.

This class implements a light petaining to the scene that illuminates nearby objects and geometry.


scene_light_desc Class Reference

Description class for the scene_light class. More...

#include <lights.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the scene_light class.


shadow Class Reference

Shadow class. More...

#include <shadow.h>

List of all members.

Public Methods

shadow ()
Default constructor.

shadow (const shadow &in)
Copy-constructor.

virtual | ~shadow ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the shadow.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

void | draw_simple_shadow ()
Draw a simpler version of the shadow.

virtual void | reposition (flyBspObject *obj)
Reposition the object's shadow.

Public Attributes

int | texture
the shadow texture.

float | size
the shadow size.

Detailed Description

Shadow class.

This class implements a shadow cast by an object of the scene.


shadow_desc Class Reference

Description class for the f3dmesh class. More...

#include <shadow.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the f3dmesh class.


ship Class Reference

Ship class. More...

#include <game.h>

Inheritance diagram for ship::

ship_move ship_control ship_draw List of all members.

Public Methods

ship ()
Default constructor.

ship (const ship &in)
Copy-constructor.

virtual | ~ship ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the ship and shield.

void | draw_shadow ()
Shadow drawing function.

int | step (int dt)
State update function, is called once per frame, checks for input, moves the ship, fires the guns.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

void | check_keys (int dt)
Checks for input form the keyboard and mouse.

void | mp_send_pos (int msgtype, int msgflag)
Multiplayer message function, sends the ship's position.

void | mp_send_kill (int killer, int pad, const flyVector &hitpoint)
Multiplayer message function, sends the ship's death data.

void | mp_send_damage (int from, const flyVector &pushvec, float value)
Multiplayer message function, sends the ship's damage data.

virtual void | die (int killer, const flyVector &hitpos, int padindx)
Kills the ships and prepares it for respawning.

void | draw_game_status ()
Draws information about the game on the heads-up display.

void | create_powerups (int flag)
Creates power-ups that will be dropped, after being hit by a Disruptor Missile.

void | drop_powerups ()
Drops power-ups after being hit by a Disruptor Missile.

void | reset ()
Resets the ship for respawning.

void | get_foes ()
Searches the space right in front of the ship, looking for enemy ships.

void | sort_players_by_score (int *a)
Sorts the array of players by their score.

Public Attributes

explode* exp
the ship's dying explosion.

sound* snd_teleport
sound for teleporting.

sound * snd_damage
sound for taking damage.

sound * snd_noammo
sound for trying to fire an out-of-ammo gun.

sound * snd_ab_start
sound for turning the afterburner on.

sound * snd_ab_loop
sound for keeping the afterburner on.

gun* | guns [16]
the ship's arsenal, an array of guns.

float | foeangle
the angle in which a visible foe will have its name displayed on the screen.

float | powerup_dropvel
movement maximum velocity of the dropped power-ups.

float | powerup_veldamp
velocity damping factor for the dropped power-ups.

int | powerup_gettime
amount of time in miliseconds that a ship cannot take power-ups after being hit by a Disruptor Missile.

int | waittime
amount of time in miliseconds that a dead ship must wait to respawn.

int | busypic
picture to represent that the player is using the console or game menu.

followpath* abpath
followpath object activated when the afterburner is used.

flyMesh* | panel
mesh object for the ship's heads-up display.

birthpad* bp
birthpad object where the ship should respawn.

Detailed Description

Ship class.

This is the main class for the ship. It integrates the movement, input and draw modules, and implements many features, special effects and other characteristics of the ship.


ship_control Class Reference

Ship input class. More...

#include <game.h>

Inheritance diagram for ship_control::

ship List of all members.

Public Methods

ship_control ()
Default constructor.

ship_control (const ship_control &in)
Copy-constructor.

virtual | ~ship_control ()
Default destructor.

Public Attributes

float | shield
the ship's shield value, up to 2.0f.

flyVector | shieldcolor
the color applied over the ship's shield mesh.

flyVector | invensiblecolor
the color applied to the shield mesh when the ship is invisible.

flyVector | quadcolor
the color applied to the shield mesh when the ship has the PowerDamage power-up.

Detailed Description

Ship input class.

This class implements the input module of the ship.


ship_desc Class Reference

Description class for the ship class. More...

#include <game.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the ship class.


ship_draw Class Reference

Ship drawing class. More...

#include <game.h>

Inheritance diagram for ship_draw::

ship List of all members.

Public Methods

ship_draw ()
Default constructor.

ship_draw (const ship_draw &in)
Copy-constructor.

virtual | ~ship_draw ()
Default destructor.

Public Attributes

sprite_light* enghalo
a sprite representing the ship's engine halo.

light* englight
a light object representing the ship's engine light.

float | engpos
the position of the engine relative to the ship's position (only the Z coordinate).

flyMesh* | objmesh
the ship's mesh.

flyMesh* | shieldmesh
the ship's shield mesh.

spot_light* spot
the ship's spotlight.

Detailed Description

Ship drawing class.

This class implements the drawing module of the ship.


ship_move Class Reference

Ship movement class. More...

#include <game.h>

Inheritance diagram for ship_move::

ship List of all members.

Public Methods

ship_move ()
Default constructor.

ship_move (const ship_move &in)
Copy-constructor.

virtual | ~ship_move ()
Default destructor.

void | move (int dt)
Moves the ship and computes collision.

Public Attributes

float | radius
the ship's radius.

float | veldamp
the ship's velocity damping factor.

float | maxvel
the ship's maximum movement velocity.

float | speedboost
the ship's speed boost when using the afterburner.

float | mousespeed
mouse rotation speed.

float | forcefactor
factor with which input from the keyboard applies force over the ship.

flyVector | angularmaxvel
the ship's maximum angular velocity.

flyVector | angulardamp
the ship's angular velocity damping factor.

Detailed Description

Ship movement class.

This class implements the movement module of the ship.


sky Class Reference

Background sky class. More...

#include <panorama.h>

List of all members.

Public Methods

sky ()
Default constructor.

virtual | ~sky ()
Default destructor.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the sky dome.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

Public Attributes

flyMesh* | objmesh
the object that represents the sky dome.

Detailed Description

Background sky class.

This class implements a sky represented by a flyBspObject, therefore enabling procedural textures (shaders) and many other effects.


sky_desc Class Reference

Description class for the sky class. More...

#include <panorama.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the sky class.


sound Class Reference

Sound class. More...

#include <sound.h>

List of all members.

Public Methods

sound ()
Default constructor.

sound (const sound &in)
Copy-constructor.

virtual | ~sound ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, computes position and intensity, and plays the sound.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

virtual void | play ()
Play the sound.

virtual flyBspObject* | add_sound_clone (flyVector *lock_pos, flyVector *lock_vel)
Add a sound instance on a given position, moving with a given velocity.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

sound ()
Default constructor.

sound (const sound &in)
Copy-constructor.

virtual | ~sound ()
Default destructor.

int | step (int dt)
State update function, is called once per frame, computes position and intensity, and plays the sound.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

virtual void | play ()
Play the sound.

virtual void | add_sound_clone (flyVector *lock_pos, flyVector *lock_vel)
Add a sound instance on a given position, moving with a given velocity.

Public Attributes

int | volume
the sound volume.

int | loop
loop flag.

float | mindist
distance in which the sound intensity is dropped by half.

float | maxdist
distance in which the sound intensity is dropped to 0.

flySound* | snd
a flySound pointer of the wave file in memory.

Detailed Description

Sound class.

This class implements a sound that can be attached to a scene object or event.


sound_desc Class Reference

Description class for the sound class. More...

#include <sound.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the sound class.


spot_light Class Reference

Spotlight class. More...

#include <lights.h>

List of all members.

Public Methods

spot_light ()
Default constructor.

spot_light (const spot_light &in)
Copy-constructor.

virtual | ~spot_light ()
Default destructor.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

virtual void | reposition (flyBspObject *obj)
Reposition the object in the scene.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

float | maxdist
the maximum distance where the spotlight will be cast.

flyVector | color
the spotlight's color.

light* l
pointer to the light object.

Detailed Description

Spotlight class.

This class implements a spotlight consisting of a lighting sphere.


spot_light_desc Class Reference

Description class for the spot_light class. More...

#include <lights.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the spot_light class.


sprite_light Class Reference

Sprite class. More...

#include <lights.h>

List of all members.

Public Methods

sprite_light ()
Default constructor.

sprite_light (const sprite_light &in)
Copy-constructor.

virtual | ~sprite_light ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame, animates the sprite.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the sprite.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

int | texture
the texture to be applied on the face.

int | mode
bitfield flag (&1: use face orientation instead of aligning to the camera, &2: animate and die, &4: fade away, &8: enable alpha, &16: move as a particle, &32: disable depth writing).

flyVector | color
the sprite color.

float | size
the sprite size.

float | grow
radius variation per milisecond.

Detailed Description

Sprite class.

This class implements a simple sprite, i.e. a texture over a face.


sprite_light_desc Class Reference

Description class for the sprite_light class. More...

#include <lights.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the sprite_light class.


teleport Class Reference

Teleport volume class. More...

#include <walk.h>

List of all members.

Public Methods

teleport ()
Default constructor.

teleport (const teleport &in)
Copy-constructor.

int | clip_bbox (const flyVector &min, const flyVector &max)
Determines if the given box clips the teleport volume.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

Public Attributes

flyVector | targetpos
the target teleport spot.

flyVector | targetangle
the angle which the person will be facing after teleporting.

sound* | sound
sound for teleporting.

flyArray<flyVector> | planes
the planes that define the teleporting volume.

Detailed Description

Teleport volume class.

This class implements a teleport volume that teleports the person to another spot in the scene.


teleport_desc Class Reference

Description class for the teleport class. More...

#include <walk.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the teleport class.


trigger Class Reference

Generic trigger class. More...

#include <trigger.h>

List of all members.

Public Methods

trigger ()
Default constructor.

trigger (const trigger &in)
Copy-constructor.

virtual | ~trigger ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mesh.

int | step (int dt)
State update function, is called once per frame.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

void | draw_shadow ()
Shadow drawing function.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

trigger ()
Default constructor.

trigger (const trigger &in)
Copy-constructor.

virtual | ~trigger ()
Default destructor.

void | init ()
Members initialisation function, is called upon activating the object.

int | step (int dt)
State update function, is called once per frame.

void | draw ()
OpenGL drawing function, is called whenever the engine's camera can see the object, draws the mesh.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

flyBspObject* | clone ()
Creates another instance of the object similar to this one.

int | message (const flyVector &p, float rad, int msg, int param, void *data)
Message receiving function, is used for communication between objects.

flyMesh* | get_mesh ()
Returns the object's mesh in a flyMesh object.

Public Attributes

flyMesh* | objmesh
a flyMesh object representing the mesh itself.

flyString | command
the console command to be executed when the trigger is activated.

int | visible
indicates that the trigger's mesh is visible and should be drawn.

int | enabled
indicates that the trigger is enabled.

flyArray<flyBspObject *> | objs
array of objects to be signalized.

Detailed Description

Generic trigger class.

This class implements a generic trigger that runs a console command whenever the player's bounding box clips the trigger's mesh bounding box.


trigger_desc Class Reference

Description class for the trigger class. More...

#include <trigger.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the trigger class.


viewport Class Reference

Viewport class. More...

#include <viewport.h>

List of all members.

Public Methods

viewport ()
Default constructor.

virtual | ~viewport ()
Default destructor.

int | get_custom_param_desc (int i, flyParamDesc *pd)
Parameter information retrieval function.

Public Attributes

flyBspObject* | target
the viewport's target, i.e. an object whose view will be rendered.

float | xf
relative position of the window in x.

float | yf
relative position of the window in y.

float | sxf
relative size of the window in x.

float | syf
relative size of the window in y.

int | dirflag
view direction flag (0: target's Z, 1: target's -Z).

int | key
keyboard key that activates the viewport.

Detailed Description

Viewport class.

This class implements a viewport for rendering the scene from an alternative view on a given window.


viewport_desc Class Reference

Description class for the viewport class. More...

#include <viewport.h>

List of all members.

Public Methods

flyBspObject* | create ()
Creates a new object of the described class.

const char* | get_name ()
Retrieves the name of the described class.

int | get_type ()
Retrieves the integer value that represents the type of the described class.

Detailed Description

Description class for the viewport class.


Hierarchical Index

Fly3D SDK 2.0 Plugins Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
  • birthpad
  • birthpad_desc
  • bspmesh
  • bspmesh_desc
  • camera
  • camera_desc
  • color_particle
  • cubemap
  • cubemap_desc
  • diemesh
  • diemesh_desc
  • door
  • door_desc
  • explode
  • explode_desc
  • f3dmesh
  • f3dmesh_desc
  • fogbox
  • fogbox_desc
  • fogsphere
  • fogsphere_desc
  • followpath
  • followpath_desc
  • forcebox
  • forcebox_desc
  • generator
  • generator_desc
  • gib
  • gib_desc
  • gun
  • gun_desc
  • gun_projectile
    • laser
    • mine
    • missile
  • hitmark
  • hitmark_desc
  • jumppad
  • jumppad_desc
  • laser_desc
  • light
  • light_desc
  • menu_base
  • menu_group
  • menu_item
    • menu_button
    • menu_checkbox
    • menu_editinputmap
    • menu_editoptionlist
    • menu_editstring
    • menu_scrollbar
    • menu_separator
    • menu_showvalue
  • menucamera
  • menucamera_desc
  • menugroup
  • menugroup_desc
  • menuitem
  • menuitem_desc
  • mine_desc
  • missile_desc
  • observer
  • observer_desc
  • panorama
  • panorama_desc
  • particle_system
  • person_anim
    • person
  • person_control
    • person
  • person_desc
  • person_move
    • person
  • portal
  • portal_desc
  • powerup
  • powerup_desc
  • ps_desc
  • robot
  • robot_desc
  • scene_light
  • scene_light_desc
  • shadow
  • shadow_desc
  • ship_control
    • ship
  • ship_desc
  • ship_draw
    • ship
  • ship_move
    • ship
  • sky
  • sky_desc
  • sound
  • sound_desc
  • spot_light
  • spot_light_desc
  • sprite_light
  • sprite_light_desc
  • teleport
  • teleport_desc
  • trigger
  • trigger_desc
  • viewport
  • viewport_desc


Compound Member Index

Fly3D SDK 2.0 Plugins Compound Members

a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z | ~

Here is a list of all documented class members with links to the classes they belong to:

- a -

  • abpath : ship
  • add_group() : menu_base
  • add_item() : menu_group
  • add_sound_clone() : sound
  • angulardamp : ship_move
  • angularmaxvel : ship_move
  • anim_mesh : birthpad, generator
  • anim_ps : generator
  • anim_size : birthpad, generator
  • animdelay : forcebox
  • animtime : door, generator
  • armor : person_control
  • ax : particle_system
  • ay : particle_system

- b -
  • birthpad() : birthpad
  • birthpos : generator
  • bp : ship, door
  • bspmesh() : bspmesh
  • busypic : ship

- c -
  • calc_anim() : person_anim
  • calc_anim_hit() : person_anim
  • camera() : camera
  • check_keys() : ship, observer
  • clip() : hitmark
  • clip_bbox() : jumppad, teleport
  • clone() : missile, laser, mine, gun, hitmark, jumppad, teleport, powerup, gib, diemesh, person, fogbox, fogsphere, trigger, scene_light, sound, camera, birthpad, forcebox, powerup, ship, camera, door, generator, robot, observer, menucamera, menuitem, menugroup, scene_light, sprite_light, spot_light, light, trigger, sound, shadow, particle_system, portal, followpath, f3dmesh, cubemap, bspmesh
  • color : hitmark, panorama, menuitem, scene_light, sprite_light, spot_light, light, portal, followpath, f3dmesh, color_particle
  • color_particle() : color_particle
  • colorget : powerup
  • command : menuitem, trigger
  • count : generator
  • create() : missile_desc, laser_desc, mine_desc, hitmark_desc, gun_desc, jumppad_desc, teleport_desc, powerup_desc, diemesh_desc, gib_desc, birthpad_desc, person_desc, fogbox_desc, fogsphere_desc, viewport_desc, trigger_desc, scene_light_desc, sound_desc, camera_desc, birthpad_desc, forcebox_desc, powerup_desc, ship_desc, door_desc, generator_desc, robot_desc, sky_desc, panorama_desc, observer_desc, menucamera_desc, menuitem_desc, menugroup_desc, scene_light_desc, sprite_light_desc, spot_light_desc, light_desc, trigger_desc, sound_desc, shadow_desc, ps_desc, portal_desc, followpath_desc, f3dmesh_desc, explode_desc, cubemap_desc, bspmesh_desc
  • create_powerups() : ship
  • cubemap() : cubemap

- d -
  • damage : gun_projectile, explode
  • damageradius : explode
  • data : menu_item
  • delay : mine, gun, followpath
  • die() : person, ship
  • die_person : person
  • diemesh() : diemesh
  • dirflag : viewport
  • dist : camera
  • do_explode() : explode
  • do_input() : person
  • door() : door
  • draw() : missile, laser, mine, hitmark, powerup, gib, diemesh, person, fogbox, fogsphere, trigger, scene_light, camera, birthpad, forcebox, powerup, ship, camera, door, generator, robot, sky, panorama, observer, menuitem, menugroup, scene_light, sprite_light, light, menu_scrollbar, menu_separator, menu_editoptionlist, menu_editinputmap, menu_showvalue, menu_editstring, menu_checkbox, menu_button, menu_item, menu_group, menu_base, trigger, shadow, particle_system, portal, followpath, f3dmesh, cubemap, color_particle, bspmesh
  • draw_back() : menu_base
  • draw_game_status() : ship
  • draw_shadow() : powerup, gib, diemesh, person, powerup, ship, generator, robot, trigger
  • draw_simple_shadow() : shadow
  • drawflag : particle_system
  • drop_powerups() : ship
  • duration : followpath

- e -
  • e : robot
  • editing : menu_editoptionlist, menu_editinputmap
  • emmtime : particle_system
  • enabled : trigger
  • enghalo : ship_draw
  • englight : ship_draw
  • engpos : ship_draw
  • exp : gun_projectile, ship
  • explode() : diemesh, explode
  • explodedist : robot

- f -
  • f3dmesh() : f3dmesh
  • factor : menu_group
  • fade : followpath
  • fadetime : hitmark, gib, diemesh, powerup, particle_system
  • falldamagefactor : person_control
  • falldamagevel : person_control
  • fire() : missile, laser, mine, gun, gun_projectile
  • fire_status() : gun
  • fireangle : robot
  • firecount : gun
  • firepos : gun
  • firevel : gun
  • firstface : bspmesh
  • flag : f3dmesh
  • foeangle : ship
  • fog_intersect() : fogbox, fogsphere
  • fog_map() : fogbox, fogsphere
  • fogbox() : fogbox
  • fogcolor : fogbox, fogsphere
  • fogdepth : fogbox, fogsphere
  • fogmode : fogbox, fogsphere
  • fogradius : fogsphere
  • fogsizex : fogbox
  • fogsizey : fogbox
  • fogsizez : fogbox
  • fogsphere() : fogsphere
  • followpath() : followpath
  • forcebox() : forcebox
  • forcedir : forcebox
  • forcefactor : forcebox, ship_move
  • fronttexture : laser

- g -
  • g : person
  • gb : diemesh
  • gen_angle : generator
  • gen_delay : generator
  • gen_sound : generator
  • gen_types : generator
  • generate() : generator
  • generator() : generator
  • get_custom_param_desc() : missile, laser, mine, gun, hitmark, jumppad, teleport, powerup, gib, birthpad, diemesh, person, fogbox, fogsphere, viewport, trigger, scene_light, sound, camera, birthpad, forcebox, powerup, ship, camera, door, generator, robot, sky, panorama, observer, menucamera, menuitem, menugroup, scene_light, sprite_light, spot_light, light, trigger, sound, shadow, particle_system, portal, followpath, f3dmesh, explode, cubemap, bspmesh
  • get_foes() : ship
  • get_height() : menu_separator, menu_item
  • get_mesh() : mine, diemesh, trigger, ship, door, generator, robot, trigger, f3dmesh, bspmesh
  • get_name() : missile_desc, laser_desc, mine_desc, hitmark_desc, gun_desc, jumppad_desc, teleport_desc, powerup_desc, diemesh_desc, gib_desc, birthpad_desc, person_desc, fogbox_desc, fogsphere_desc, viewport_desc, trigger_desc, scene_light_desc, sound_desc, camera_desc, birthpad_desc, forcebox_desc, powerup_desc, ship_desc, door_desc, generator_desc, robot_desc, sky_desc, panorama_desc, observer_desc, menucamera_desc, menuitem_desc, menugroup_desc, scene_light_desc, sprite_light_desc, spot_light_desc, light_desc, trigger_desc, sound_desc, shadow_desc, ps_desc, portal_desc, followpath_desc, f3dmesh_desc, explode_desc, cubemap_desc, bspmesh_desc
  • get_type() : missile_desc, laser_desc, mine_desc, hitmark_desc, gun_desc, jumppad_desc, teleport_desc, powerup_desc, diemesh_desc, gib_desc, birthpad_desc, person_desc, fogbox_desc, fogsphere_desc, viewport_desc, trigger_desc, scene_light_desc, sound_desc, camera_desc, birthpad_desc, forcebox_desc, powerup_desc, ship_desc, door_desc, generator_desc, robot_desc, sky_desc, panorama_desc, observer_desc, menucamera_desc, menuitem_desc, menugroup_desc, scene_light_desc, sprite_light_desc, spot_light_desc, light_desc, trigger_desc, sound_desc, shadow_desc, ps_desc, portal_desc, followpath_desc, f3dmesh_desc, explode_desc, cubemap_desc, bspmesh_desc
  • get_width() : menu_editoptionlist, menu_editinputmap, menu_showvalue, menu_editstring, menu_checkbox, menu_button, menu_item
  • getradius : person_control
  • gettime : powerup
  • gib() : gib
  • gibforce : diemesh
  • groups : menu_base
  • grow : sprite_light, light
  • gun() : gun
  • gun_projectile() : gun_projectile
  • gunrefreshtime : robot
  • guns : ship, robot

- h -
  • headheight : person_move
  • health : diemesh, person_control
  • height : person_move, camera, portal
  • height1 : menugroup
  • height2 : menugroup
  • hitmark() : hitmark
  • hm : missile, laser, gib

- i -
  • illum_radius : light
  • illumradius : scene_light
  • img : panorama, cubemap
  • init() : missile, laser, mine, hitmark, powerup, gib, diemesh, person, fogbox, fogsphere, trigger, camera, birthpad, forcebox, powerup, ship, camera, door, generator, robot, observer, menugroup, scene_light, sprite_light, trigger, shadow, portal, followpath, f3dmesh, cubemap, bspmesh
  • invensiblecolor : ship_control
  • invert : portal
  • item : menugroup
  • itens : menu_group

- j -
  • jumpheight : person_move
  • jumppad() : jumppad

- k -
  • key : viewport

- l -
  • l : missile, laser, mine, gun, menucamera, spot_light, explode
  • laser() : laser
  • light() : light
  • lightzpos : missile
  • locked : menu_base
  • lookangle : missile
  • lookdist : missile
  • lookrange : mine
  • loop : sound

- m -
  • mapbrowse : menuitem
  • maxdist : spot_light, sound
  • maxvel : ship_move, observer
  • maxviewdist : portal
  • menu_base() : menu_base
  • menu_button() : menu_button
  • menu_checkbox() : menu_checkbox
  • menu_editinputmap() : menu_editinputmap
  • menu_editoptionlist() : menu_editoptionlist
  • menu_editstring() : menu_editstring
  • menu_group() : menu_group
  • menu_item() : menu_item
  • menu_scrollbar() : menu_scrollbar
  • menu_separator() : menu_separator
  • menu_showvalue() : menu_showvalue
  • menucamera() : menucamera
  • menugroup() : menugroup
  • menuitem() : menuitem
  • meshbox : forcebox
  • message() : missile, mine, hitmark, powerup, gib, diemesh, person, trigger, powerup, ship, door, generator, robot, trigger
  • mindist : sound
  • mine() : mine
  • missile() : missile
  • mode : sprite_light, portal
  • mousespeed : person_move, ship_move
  • mousevel : observer
  • move() : diemesh, person, ship_move
  • movedist : robot
  • moveforce : observer
  • movevel : robot
  • mp_send_damage() : person, ship
  • mp_send_kill() : person, ship
  • mp_send_pos() : person, ship

- n -
  • nfire : gun
  • nitem : menugroup
  • nsegx : portal
  • nsegy : portal
  • nsndget : powerup
  • ntriggers : door
  • num_options : menu_editoptionlist
  • numbounces : laser, mine, gib
  • numfaces : bspmesh

- o -
  • obj : explode
  • objmesh : missile, mine, gun, powerup, gib, diemesh, forcebox, ship_draw, door, generator, robot, sky, trigger, f3dmesh, cubemap, bspmesh
  • objmesh_box : powerup
  • objmesh_item : powerup
  • objs : generator, trigger
  • observer() : observer
  • on_select() : menu_editoptionlist, menu_editinputmap, menu_editstring, menu_checkbox, menu_button, menu_item
  • onchange_callback : menu_editoptionlist
  • option_names : menu_editoptionlist

- p -
  • p : gun
  • panel : ship
  • panorama() : panorama
  • partbump : particle_system
  • partcolflag : particle_system
  • partcolor : particle_system
  • partcolorvar : particle_system
  • partfriction : particle_system
  • particle_system() : particle_system
  • partmass : particle_system
  • partradius : particle_system
  • partspeed : particle_system
  • partspeedvar : particle_system
  • path : missile, laser
  • person() : person
  • person_anim() : person_anim
  • person_control() : person_control
  • person_move() : person_move
  • planes : jumppad, teleport
  • play() : sound
  • playermesh : person_anim
  • playershadow : person
  • portal() : portal
  • post_step() : portal
  • powerup() : powerup
  • powerup_dropvel : ship
  • powerup_get() : powerup
  • powerup_gettime : ship
  • powerup_veldamp : ship
  • ps : birthpad, explode

- q -
  • quadcolor : ship_control

- r -
  • radius : diemesh, person_move, forcebox, ship_move, camera, observer
  • randomangle : gun
  • ray_intersect() : bspmesh
  • ray_intersect_test() : bspmesh
  • reposition() : spot_light, shadow
  • reset() : ship
  • resolution : portal
  • robot() : robot
  • rotvel : missile, person_move, robot, observer, menucamera

- s -
  • s : missile, laser, scene_light, light, explode
  • scale : f3dmesh
  • scene_light() : scene_light
  • sel_group : menu_base
  • sel_item : menu_group
  • sel_option : menu_editoptionlist
  • send_mine_data() : mine
  • set_anim() : person_anim
  • sfact : missile, laser
  • shadow() : shadow
  • shield : mine, ship_control, robot
  • shieldcolor : ship_control
  • shieldmesh : ship_draw
  • ship() : ship
  • ship_control() : ship_control
  • ship_draw() : ship_draw
  • ship_move() : ship_move
  • sidetexture : laser
  • size : hitmark, panorama, sprite_light, shadow, color_particle
  • sizetexture : laser
  • sky() : sky
  • snd : forcebox, sound, explode
  • snd_ab_loop : ship
  • snd_ab_start : ship
  • snd_bounce : mine
  • snd_change : person
  • snd_crater : person
  • snd_damage : person, ship
  • snd_jump : person
  • snd_jumppad : person
  • snd_land : person
  • snd_noammo : person, ship
  • snd_teleport : person, ship
  • snd_travel : missile, robot
  • snd_wearoff : person
  • sndchangesel : menucamera
  • sndfire : gun
  • sndget : powerup
  • sndselect : menucamera
  • sndspawn : powerup
  • sort_players_by_score() : ship
  • sound : sound, jumppad, teleport
  • spawntime : powerup
  • speedboost : ship_move
  • spot : person, ship_draw
  • spot_light() : spot_light
  • sprite_light() : sprite_light
  • srfact : laser
  • srvel : laser
  • step() : missile, laser, mine, hitmark, powerup, gib, diemesh, person, fogbox, fogsphere, trigger, scene_light, sound, camera, birthpad, forcebox, powerup, ship, camera, door, generator, robot, observer, menucamera, menuitem, menugroup, scene_light, sprite_light, light, menu_scrollbar, menu_editoptionlist, menu_editinputmap, menu_editstring, menu_item, menu_group, menu_base, trigger, sound, particle_system, portal, followpath, f3dmesh, cubemap, color_particle
  • stepheight : person_move
  • stepmaxvel : person_move
  • sxf : viewport
  • syf : viewport

- t -
  • tabwidth : menu_scrollbar, menu_editinputmap
  • target : viewport, camera, menucamera
  • targetangle : teleport
  • targetpos : jumppad, teleport
  • teleport() : teleport
  • text : menu_item, menu_group
  • texture : hitmark, menuitem, sprite_light, shadow, particle_system, followpath, color_particle
  • totpart : particle_system
  • traildelay : gib
  • trigger() : trigger
  • turnvel : missile, mine
  • turretfireangle : mine
  • turretgun : mine
  • turretrange : mine
  • type : menu_item

- u -
  • updowndist : powerup
  • updowntime : powerup

- v -
  • val_bias : menu_editoptionlist
  • value : powerup
  • valuetype : powerup
  • veldamp : powerup, ship_move, observer
  • viewport : viewport, missile
  • visible : menu_group, menu_base, trigger
  • volume : sound

- w -
  • waittime : ship
  • walkvel : person_move
  • wave_size : menugroup
  • wave_speed : menugroup
  • weaponmesh : person_anim
  • width : portal, followpath

- x -
  • xf : viewport

- y -
  • yf : viewport

- z -
  • zoomangle1 : person_control
  • zoomangle2 : person_control
  • zoomtime : person_control
  • zrot_time : powerup

- ~ -
  • ~birthpad() : birthpad
  • ~bspmesh() : bspmesh
  • ~color_particle() : color_particle
  • ~cubemap() : cubemap
  • ~diemesh() : diemesh
  • ~explode() : explode
  • ~f3dmesh() : f3dmesh
  • ~fogbox() : fogbox
  • ~fogsphere() : fogsphere
  • ~followpath() : followpath
  • ~gun() : gun
  • ~gun_projectile() : gun_projectile
  • ~hitmark() : hitmark
  • ~laser() : laser
  • ~light() : light
  • ~menu_base() : menu_base
  • ~menu_button() : menu_button
  • ~menu_checkbox() : menu_checkbox
  • ~menu_editinputmap() : menu_editinputmap
  • ~menu_editoptionlist() : menu_editoptionlist
  • ~menu_editstring() : menu_editstring
  • ~menu_group() : menu_group
  • ~menu_item() : menu_item
  • ~menu_scrollbar() : menu_scrollbar
  • ~menu_separator() : menu_separator
  • ~menu_showvalue() : menu_showvalue
  • ~menucamera() : menucamera
  • ~menugroup() : menugroup
  • ~menuitem() : menuitem
  • ~mine() : mine
  • ~missile() : missile
  • ~observer() : observer
  • ~panorama() : panorama
  • ~particle_system() : particle_system
  • ~person() : person
  • ~person_anim() : person_anim
  • ~person_control() : person_control
  • ~person_move() : person_move
  • ~portal() : portal
  • ~scene_light() : scene_light
  • ~shadow() : shadow
  • ~ship() : ship
  • ~ship_control() : ship_control
  • ~ship_draw() : ship_draw
  • ~ship_move() : ship_move
  • ~sky() : sky
  • ~sound() : sound
  • ~spot_light() : spot_light
  • ~sprite_light() : sprite_light
  • ~trigger() : trigger
  • ~viewport() : viewport


File Member Index

Fly3D SDK 2.0 Plugins File Members

a | c | p | v

Here is a list of all documented file members with links to the documentation:

- a -

  • audio_flag : multimedia.h

- c -
  • command : multimedia.h

- p -
  • portals : gamelib.h

- v -
  • video : multimedia.h
  • volume : multimedia.h


Fly3D Frontends Guide

Fly3D SDK is a real-time 3D games and applications development tool. Therefore, it provides several development and production applications, forming the front-end layer of the SDK. This guide has the goal of introducing these applications, explaining and exemplifying their use and functionalities.

Below are the frontends covered in this guide:

Main Frontend: flyFrontend.exe
Parameter Editor: flyEditor.exe
Build Frontend: flyBuilder.exe
Shaders Editor: flyShader.exe
Multiplayer Server: flyServer.exe
ActiveX Control: fly3d.ocx


Main Frontend: flyFrontend.exe

flyFrontend.exe is the main frontend application used in the engine. It is composed by a single window where the simulation images are rendered, and a menu with all the options available in Fly3D. It can switch between windowed and fullscreen modes, and serves for viewing demos and final versions of games/apps in action.

This frontend works with Fly3D scene files (.fly), which contain all information needed to start running a given level. Upon opening an existing .fly file, the frontend calls the engine's level initialization methods, which initializes all plugin DLLs needed in the level. The BSP is then loaded, and the objects and entities are created and initialized, and the simulation begins.

The following sections deal with all the options available in flyFrontend.exe menus.

The Window Menu

flyFrontend.exe features a simple window menu, with basic options, like loading a .fly file, quitting the application and changing a great number of rendering options, which are also available through the functinos keys on the keyboard.

The File submenu has only 4 items: Open, for opening a scene file (*.fly); Close, for closing the currently open file and leaving the screen blank (like in the figure above); About, for information concerning the application developers; and Exit, for quitting flyFrontend.exe.

The View submenu has 14 items:

  • Toggle Full-Screen (Alt+Enter) does what its caption implies: switches between windowed and fullscreen modes;
  • Menu (F1) loads a special level called menu.fly, which is actually a menu level for browsing the other .fly files present in the system, creating a multiplayer game starting the server, and playing pre-recorded demos;
  • Mute (F2) turns off all sound in the simulation;
  • Save Panorama (F3) saves a panoramic screenshot centered at the current camera position, to be viewed with Paralelo's Pan3D Control;
  • Save Screen (F4) saves a screenshot in Targa format, and places it in the 'data' folder inside Fly3D installation;
  • Node Only (F5) tells the engine to draw only the BSP node(s) which the camera is inside or clips (for debugging purposes);
  • PVS (F6) toggles PVS culling on/off;
  • Mipmap (F7) toggles Mip-mapping on/off;
  • Filtering (F8) toggles texture filtering on/off;
  • Multitexture (F9) toggles Multexturing on/off;
  • Stencil (F10) toggles the use of stencil buffer for dynamic shadows on/off;
  • Wireframe (F11) toggles the wireframe mode on/off;
  • Clear Background (F12) toggles filling the background in black on/off (useful together with the wireframe mode);
  • Status (Tab) toggles drawing the 2D layer and text layer on/off.

The In-Game Menu

flyFrontend.exe also has a cool in-game menu with several options, including some of the ones found in the window menu. It is called by pressing the 'Esc' key. The in-game menu consists of four sub-menus: File, Render, Sound and About.

The File submenu includes the following options: Close, which closes the currently loaded .fly file; Menu, which loads the menu.fly level, consisting of a room where it is possible to browse for available .fly files, create and join a multiplayer game, and run a pre-recorded demo; and Exit, which quits flyFrontend.exe.

The Render submenu includes some items also available in the window menu. Refer to the previous section for explanations on the Multitexture, Texture Filter, Texture Mip-Map, Stencil Shadows, Clear Background , Draw Wireframe, Draw No PVS and Draw BSP CamNode Only options. The additional options are Dynamic Lighting, which turns all dynamic light sources on/off, and Draw Portals and Mirrors, which turns the drawing of portals and mirrors on/off.

The Sound submenu includes the Effects Volume item, which shows the sound volume for special effects, and the Mute Game Sounds item, which turns off all sounds in the simulation (just like the Mute option of flyFrontend window menu.

Finally, the About submenu shows 3 labels which are not actually menu items; they just display, respectively, the current Fly3D version that is running, the currently loaded .fly file, and the currently loaded .bsp file.

The Console

flyFrontend.exe also features a console for entering commands, that can be called by pressing the '`' key. Almost all operations with plugins and objects, like loading a DLL or activating an object, can be performed through console commands.

Below is an enumeration of all the available commands, with their correct sintax and a brief explanation of each of them:

  • get <varname> | get <objname.objparam>: queries the value of a global variable or an object parameter and shows it in the console screen;
  • set <varname> <value> | set <objname.objparam> <value>: sets the value of a global variable or object parameter to the given value;
  • map <path/level>.fly | map none: loads the given map or unloads the current map (map none);
  • save: saves the currently loaded .fly file with any modifications made during the simulation;
  • listgames | listgames <ipaddress>: lists all the multiplayer games currently online in the local network (listgames) or on the given machine (listgames <ipaddress>);'
  • connect | connect <ipaddress> | connect <ipaddress> <gamenum>: joins the first multiplayer game in the local network (connect) or on the given machine (connect <ipaddress>), or the given multiplayer game (connect <ipaddress> <gamenum>); the game number can be queried with the listgames command;
  • disconnect: disconnects from the multiplayer game to which the client is currently connected;
  • list plugins | list classes | list <classname> | list <objname>: queries the list of all plugins (list plugins) or classes(list classes), the list of instances of a given class (list <classname>), or the list of parameter and their values from a given object (list <objname>), and shows it on the console screen;
  • activate <objname>: clones the given instance of an object and inserts it into the simulation;
  • destroy <objname>: destroys the given active object, removing it from the simulation;
  • insert <plugin>.dll: loads the given plugin DLL and all of its classes;
  • remove <plugin>.dll: unloads the given plugin DLL and all of its classes;
  • playdemo <demofile>.fdm: plays the given pre-recorded demo file;
  • timedemo <demofile>.fdm: plays the given pre-recorded demo file as a time demo, without the time delay of messages;
  • exec <commandline>: executes a generic Windows command;
  • quit: exits flyFrontend.exe.


Parameter Editor: flyEditor.exe

As a software development kit, Fly3D 2.0 offers frontends and utilities that work as development tools to facilitate content creation and integration of the art material with the game or application executables. flyEditor.exe is one of the most important and useful tools of these. It can create a new .fly file or open an existing one, and serves for editing global or engine variables, loading plugins, creating objects, activating them, editing parameters in any object, be it active or not, and much more. flyEditor.exe also features a rendering window where the simulation of the currently open .fly file is executed and viewed, making it possible to modify parameters and see the results on-the-fly.

flyEditor.exe has a window menu with various options, and its window is divided in three parts: the tree view, the list view and the render view. All these items are discussed in the following sessions:

The Window Menu

flyEditor.exe features a complete window menu, with useful options like creating or loading a .fly file, copying and pasting of objects and parameter values, simulation options, and much more. Most commands, specially in the Edit submenu, are also available by right-clicking the desired object.

The File submenu has several items: New creates a new .fly file from scratch; Open opens a previously created .fly file; Save and Save As save the currently loaded file; Revert to Saved throws away all modifications made to the currently loaded .fly file and re-opens the previously saved version of the file; Restart restarts the simulation; Save Fly3D.ini saves the initialization variable values on the 'Fly3D.ini' file; a list of recently loaded .fly files for quick opening; and the Exit option, which closes the application.

The Edit submenu includes menu items for dealing with objects, like the Cut, Copy and Paste commands; the Duplicate item makes a copy of the currently selected object in the tree view, and pastes it in the same hierarchical position of the original object; Insert can be used in two ways: to insert a new plugin, .f3d object or texture (if any of these three tree view root items is selected) or to create a new instance of a class (if a class inside a plugin is selected instead); Delete/Clear can be used to delete all instances of the selected class or to remove the selected plugin from the scene; Rename can be used to rename any class instance in the simulation.

The View submenu has 4 options related to viewing and rendering: Object Only focuses the camera on the selected object and draws it as seen in the simulation; Simulate turns the simulation on/off; Toolbar and Status Bar toggle the respective controls on/off.

And finally, the Help submenu has only one item: About flyEditor, which displays information concerning the development of the application and copyright issues.

The Toolbar Menu

Right below the window menu is a toolbar with useful buttons for quick access to some functions of flyEditor.exe. Most of them are also accessible through the window menu.

The complete list of buttons and the action each of them perform, in the correspponding order that they are placed in the toolbar, from left to right, can be found below:

  • the New, Open and Save buttons correspond to the options with the same name found in the File submenu of the window menu;
  • SR (Save and Restart) saves the current .fly file and reloads it right after, restarting the simulation;
  • RV (Revert to Saved) matches the option with the same name in the File submenu of the window menu;
  • Cut, Copy, Paste and Duplicate work the same way as their counterparts in the Edit submenu of the window menu;
  • The Arrow Up and Arrow Down buttons are used to change the order in which the classes are displayed below the corresponding DLL item in the tree view;
  • The Object Only and Simulate buttons are switches, in the same way as the options with the same name in the View submenu of the window menu;
  • The About button displays information about the development of flyEditor.exe and its copyright.

The Tree View

The leftmost part of the flyEditor.exe window is the tree view. A tree view is a Windows control that displays items organized as a hierarchy. flyEditor.exe's tree view displays several basic items (the "root-items"), that can be expanded to show subitems. Upon selecting an item on the tree view, the list view beside it is updated, displaying a list of parameters corresponding to the selected item. Each of the root items, as well as the subitems appliable to them, are discussed below.

The Global root item represents Fly3D global and flyEngine's variables. When this item is selected, all the variables and their values are displayed in the list view, making it possible to modify them.

The Plugins root item represents all the plugin DLLs, classes and instances that exist in the currently loaded .fly file. After selecting the Plugins root item, it is possible to insert a new plugin DLL to the simulation. Any DLLs present in the current file are displayed one level inside the Plugins root item. One level further are the classes implemented in each plugin DLL. These can be selected for creating a new instance of the class, as a stock object. The existing instances of a given class are represented by subitems below the class item in the hierarchy, and can be selected for modifying their parameters, which appear in the list view.

The Objects root item represents all the .f3d and .k3d objects existing in the currently loaded .fly file. Upon selecting it, all the .f3d and .k3d objects in the file are displayed in the list view, together with some parameters for them, like name, number of animations, etc.

The Sounds root item represents all the sound files existing in the currently loaded .fly file. Upon selecting it, all the sound files are displayed in the list view, together with some parameters for them, like name, length, format, etc.

The Textures root item represents the whole set of textures applied to the faces in the currently loaded level. Upon selecting it, all the textures and lightmaps are displayed in the list view, together with some of their parameters, like name, size, etc.

The Shaders root item represents all shaders applied to the faces in the currently loaded level. Upon selecting it, all the shaders are displayed in the list view, together with some of their parameters, like name, number of passes, etc.

The List View

The central part of the flyEditor.exe window houses the list-view. A list view is a Windows control that displays a table, where the lines represent items of data and the columns represent fields in which items' parameters are represented.

Depending on the item selected in the tree view, the list view can display parameters relative to a given instance of a class, as an active or stock object; a list of textures, shaders, sounds or .f3d and .k3d mesh objects; or a list of global variables.

When displaying a list of object parameters, the list view enumerates them and displays their values; by double-clicking the left mouse button on a parameter, the corresponding value edition dialog box is displayed, and the parameter's value can be changed.

When displaying a list of textures, shaders or .f3d and .k3d files, selecting an item displays the corresponding texture or shader or mesh in the render view to the right. These entities can be rotated by dragging the left mouse button in the render view; zooming can also be performed, by dragging the right mouse button on the render view.

When displaying a list of sounds, double-clicking the left mouse button on a sound plays the corresponding .wav file.

The Stock/Active Objects Menu

Finally, on the upper rightmost part of flyEditor.exe is located the Stock and Active Objects menu. Here, it is possible to create active objects from stock objects, inserting them into the simulation. Also, this menu allows the selection of active objects created from a given stock object. It is also possible to destroy an active object, removing it from the simulation immediately.

When an instance of a class is selected in the tree-view, the list view displays a list of parameters corresponding to the respective stock object. If the Active Objects check box in the Stock and Active Objects menu is checked, then the list view will display the list of parameters of the first active instance of the object. With the arrow buttons, the current active object can be changed. The Activate button creates a new active object as a clone of the selected stock object; the Destroy button removes the currently selected active object from the simulation.


Build Frontend: flyBuilder.exe

The export module generates only raw data in the form of vertices and faces. This information needs further processing to generate the files used by the Fly3D Engine during the simulation. The flyBuilder.exe frontend is an application that loads vertices and faces data, together with a shaders file, and generates all the scene-related files necessary for Fly3D to play a level.

Below is a figure of the application's main window:

flyBuilder.exe has several options for building different parts of a Fly3D level data:

  • Map File is the .fmp file where the vertices and faces data for the level is stored. The Browse button opens a dialog box for selecting an existing .fmp file;
  • Build BSP enables building the .bsp file of the level. BSP stands for Binary Space Partitioning, an algorithm for dividing the scene space into convex volumes defined by the geometry faces. It is necessary to build a BSP file for the level to be viewable in Fly3D. But if you already have built a BSP before, and just wants to change, say, the illumination data, you do not need to build the BSP again. The BSP is divided into two parts, described below;
  • Phase 1: Axis-Aligned performs axis-aligned space partitioning, which can be in one of two styles: Landscape or Freespace; can be disabled if your level is a closed one;
  • Landscape (2D) performs axis-aligned space partition which considers only the X and Y axes. This makes the BSP building algorithm treat the scene as a landscape level, dividing the space with planes orthogonal to the landscape surface;
  • Freespace (3D) performs axis-aligned space partition which considers the X, Y and Z axes. This makes the BSP building algorithm treat the scene as a freespace level, dividing the space like a cube being sliced in the 3 dimensions;
  • Phase 2: Face-Aligned performs face-aligned space partitioning, which partitions the 3D space using planes defined by the scene's structural faces. This option must be disabled for Landscape or Freespace levels;
  • Remove Negative Nodes enables the deletion of negative (invalid) BSP nodes and any faces inside them. A well-modelled level should have no negative nodes, so in this case this option is inocuos. It must not be enabled for landscape levels;
  • Compute Visibility (PVS) enables the building of visibility data files, such as .pvs and .fpt files. The .pvs file hold information about PVS culling, which critically optimizes the rendenring phase of the simulation. The .fpt file stores the portals that connect each pair of BSP nodes, and enables the use of Fly3D built-in path-finding methods;
  • Build Lighting enabled the computation of vertex lighting and the building of lightmap files (.lmp), which store lighting information for all the faces in the scene;
  • Illuminate tells the lighting algorithm to take the lights in the scene into consideration. Without this option, the lighmaps are generated with only the ambient light;
  • Radiosity enables radiosity lighting computation, where the light sources can have an area (they do not need to be punctual). Light emmition is treated as energy, and all the faces filter and re-emmit the energy they receive, creating a far more real lighting effect;
  • Build FLY File enables the building of Fly3D scene files (.fly), which store all the attributes of all the entities in the scene;
  • Class Template is an option for choosing the pre-created entity template scheme that best suits the kind of scene you want to build. For example, "ship" templates already include the ship and power-up entities, while "walk" templates include person and weapon entities, etc.;
  • Run Frontend tells flyBuilder.exe to run flyFrontend.exe after building the scene files, automatically opening the generated .fly file;
  • Pause After Build tells flyBuilder.exe to pause after building, for the user to be able to see the reports of the build process in the build window;

The Options button opens the Advanced Options Dialog Box, which contains several options for further customizing the build process. It is thoroughly described in the next section. The Build button initiates the build process, opening the build window. The Exit button closes the application without buiding.

The Advanced Options Dialog Box

Additional building options are available in the Advanced Options Dialog Box, shown below:

Here is a description of each option:

  • Ambient Light defines the amount of ambient lighting in the scene as a whole;
  • Backface Culling enables excluding faces that are opposed to the light ray direction from the lighting calculation;
  • Square Attenuation enables the light to be attenuated with the square of the distance to the light source, as in the real world. Disabling this options makes light to attenuate with the distance alone;
  • LightDir dot Normal enables the amount of light on a pixel to be multiplied by the dot product of the light direction and face normal vectors;
  • Max Passes defines the maximum number of radiosity passes, i. e. the maximum number of times the whole scene will be scanned for emitting energy;
  • Min Energy defines the minimum amount of total energy that needs to exist in the scene for a new radiosity pass to be performed. This means that, if at some point between passes in the radiosity calculation, the total amount of energy in the scene gets below this value, the process will end, not considering the little amount of energy left;
  • BSP Grid Size represents the maximum size of a BSP sector. This enables the automatic splitting of volumes with dimensions bigger than this value.
  • PVS Grid Size defines the maximum size of a PVS sector. Small PVS grid sizes provide more accurate PVS calculations at the cost of build speed;
  • Shadows enable shadowing calculations;
  • Hard Shadows creates jaggered shadows with sharp outlines;
  • Soft Shadows creates better-looking shadows with rounded outlines and penumbra;
  • Light Samples defines the number of penumbra levels, including the total shadow level;
  • Light Jittering defines the distance between the light samples, and determines the width of each penumbra layer;
  • Lightmap Size defines the light map texture size in pixels;
  • Lightmap Pixel Size determine how many scene units are represented in a light map pixel;
  • Exposure determines the exposure time of the lightmap to the light sources; the more, the brigther;
  • Compress Lightmaps enables light maps JPEG compression, gaining in light maps size with loss in quality;
  • Lightmap Quality defines the quality of the compressed lightmap, as a percent value relative to the original light map.


Shaders Editor: flyShader.exe

Fly3D SDK also offers an application for editing the shaders applied to the faces of the geometry or objects: flyShader.exe. This frontend can open shader files (.shr) or static and animated mesh object files (.f3d or .k3d), allowing the edition of shader effects and immediate visualization of changes in the render window.

Below is a figure of the application's main window:

flyShader.exe has several options for editing the shader effects, viewing a face or object with the shader applied, and much more. Viewing the desired shader is quite easy: just select it from the shader list on the leftmost side of the application window, and it will be drawn and will animate in the render window beside it.

Most of the options are available through the window menu and the Shader Properties Dialog Box, which are.discussed in the sections that follow.

The Window Menu

The window menu is shown below:

The Open item opens a shader file (.shr) or a static or animated object file (.f3d or .k3d) for edition and visualization; the Close item closes the currently loaded file, be it a shader file or an object file; the Save item saves the currently loaded file to the disk; the Properties item opens the Shader Properties Dialog Box for the currently selected shader in the shader list; the Background item opens a color dialog box for changing the background color of the render window; the Data Path item changes the folder where resources should be looked for; and finally, the Exit item, which quits flyShader.exe.

The Shader Properties Dialog Box

The Shader Properties Dialog Box displays all the information regarding a particular shader (selected previously in the shader list), and allows edition of all its variables. The dialog is divided in two parts: the shader properties section (the topmost one), which consists of options related to the shader as a whole, and the shader passes properties section (the bottommost one), consisting of information about each of the shader passes separately.

In the shader properties section, the shader's name can be changed; the number of passes is also displayed, and there are some flag parameters available for the shader as a whole:

  • No Culling disables backface culling of all faces where this shader is applied, forcing them to be two-sided;
  • No Depth Writing disables the writing of all faces where this shader is applied to the depth buffer;
  • No Colliding disables collision of objects against the faces where the selected shader is applied;
  • No Shadows disables shadow casting by the faces where the shader is applied (the faces cast no shadows, but shadows of other objects are still cast on them);
  • Sky is a special flag determining that the faces where the shader is applied should act as sky (the shader animates in a particular way, and objects do not explode or bounce on the face);
  • Transparent enables seeing through the alpha channel of textures applied on the faces associated with the selected shader;
  • Reflectance Color is the face's color; it is used by the radiosity algorithm as the color of te energy emitted and filtered by the face;
  • Transparency acts as an alpha value for the whole face; setting it to a value less than 1.0 make the face transparent by this factor;
  • Self-Illumination is the amount of energy emitted by the face, when radiosity is used.

In the shader passes properties section, all the shader passes are displayed in the shader passes list to the left. It is possible to add or remove passes, and to change the order of the passes, using the four buttons above the list. And by clicking on the check boxes beside each shader pass, it is possible to enable or disable the drawing of that specific pass. This allows for better visualization of the effects applied to each pass.

To the right of the shader passes list is an array of shader effects parameters, which allow the customization of each shader pass. These parameters are explained in detail below:

  • Depth Function defines a function determining in which cases the pass will be drawn, relative to the depth buffer current configuration;
  • Color Mode defines a RGB coordinates generation method, that can even be a wave-like function, in which case the function must be selected and customized by clicking on the Color Function button just beside the Color Mode combo-box (see below for the Function Dialog Box);
  • Blend defines the blending method applied to the selected pass; the two combo-boxes represent the factor multiplied by the front color and the one multiplied by the background color, respectively;
  • Alpha Func defines a function that determines in which interval the alpha channel of the pass should be considered; the combo-box represents the function and the number in the edit box is the value for comparison;
  • Light Map determines if the currently selected pass represents a light map pass os a normal texture pass; if Light Map is unchecked, a texture can be selected for the pass with the Texture button, which opens a browsing dialog box for selecting the texture file;
  • Anim Map adds an animation map to the selected pass. The anbimation frames can be opened in the Anim Map Dialog Box (see below), which is called by pressing the Maps button;
  • TC Mod adds a Texture Coordinates Modifier effect to the selected pass, which can be a scrolling, rotating, scaling or stretching effect; the Modifiers button opens the TC Mod Dialog Box, described in a section below.
  • Environment adds the environment mapping effect to the pass, since an approppriated texture is used;
  • if Texture Clamping is on, the texture is prevented from undesirable tiling, i.e. the texture is only applied in the [0..1] interval;
  • Invert Culling enables inverted culling (frontface culling) on the selected shader pass;
  • Vertex Prog opens a browse dialog box where a vertex program file (.vp) can be selected;
  • Vertex Prog Function opens the Function Dialog Box (see below), where a function can be set and its value will be evaluated every frame and passed to the program.

The vertex programs must follow the NVidia Vertex Programs Specification document. The programs can access the video card constant registers; a list of the values stored in them is shown in the following table:

Constant register | Contents
0-3 | Concatenated modelview and projection matrices
4-7 | Modelview matrix
8-11 | Inverse transpose of modelview matrix
12-15 | Inverse of modelview matrix
20 | (0,0.5,1,2) - general constants which can be swizzled and replicated
21 | Sin/cos helper constants
22 | Cos Taylor series coefficients
23 | Sin Taylor series coefficients
24 | Program function arguments (offset, amplitude, phase and rate)
25 | Program function (f,f,f,0)
26 | Time (t,t,t,0)
30 | Nearest light position in eye coordinates
31 | Light colour
32 | Light attenuation
33 | L light vector
34 | H halfway vector
35 | Ambient colour

The Function Dialog Box

The Function Dialog Box is a pratical way of defining a RGB generation function or a Stretch function for the Texture Coordinates Modifier effect. A function template can be chosen from the combo box, and the Offset, Amplitude, Phase and Rate function arguments can be set. The function applied to the interval between 0 and 1000 miliseconds can be seen in the frame beside;

The Anim Map Dialog Box

This dialog box enables the addition of an animation map to the selected shader pass, by defining the number of frames per second on the animation, and the frames themselves, which are loaded as pictures.

The FPS edit box represents the number of frames per second of the animation; the Add, Remove, Up and Down buttons manipulate the frames of the animation, forming the animation map.

The TC Mod Dialog Box

This dialog box allows the configuration of the Texture Coordinates Modifier effect, which applies on the currently selected shader pass. This effect can include scaling, rotating, scrolling or stretching the texture coordinates.

If Scale is enabled, the amount of scaling in the U and V directions must be informed in the respective edit boxes; the same occurs for the Scroll modifier; upon enabling Rotation, the rotation factor must be defined in the edit box, representing the amount of cyclic rotation applied; the Stretch modifier works with a stretch function; clicking on the Function button brings up the Function Dialog Box, already described above.


Multiplayer Server: flyServer.exe

Fly3D Engine implements multiplayer gaming in a client/server architecture, using DirectPlay as a low-level messaging module. The engine provides a specific application for creating a multiplayer games server in the local machine: flyServer.exe. It is a simple command line program, which receives a .fly file name as a parameter, and creates a multiplayer server running the scene defined by the specified .fly file. The application's functionalities include listening for clients who want to join the game, receiving multiplayer game messages, synchronizing the game and re-sending acknowledgement messages and game state messages to the clients, besides logging any in-game special events and maintaining coherence among the clients' games.

flyServer.exe usage is as simple as shown below:

flyServer.exe flyfile gamename

In this example, flyfile should be replaced by the complete or relative path and name of the .fly file containing the scene that will run on the server and clients as well; gamename is simply a string naming the game created, for other players to recognize it.


ActiveX Control: fly3d.ocx

Fly3D SDK 2.0 also features an ActiveX control with the whole engine functionality that can be inserted into web pages, running in an Internet browser. fly3d.ocx is powerful and easy to use, providing methods for loading the desired scene file, downloading additional data or resource files, and much more.

The methods provided by the control are the following:

Open(VT_BSTR fly_file)
OpenURL(VT_BSTR zip_url)
Run()
Stop()
Exec(VT_BSTR command)
AboutBox()

The Open method loads a scene file (.fly) found in the current ocx data folder (usually '\program files\fly3d\data\'). The fly_file parameter is the name of the file, relative to the data folder.

The OpenURL method receives an URL for a .zip file to be downloaded and executed. The URL can be relative or absolute, using http or ftp. It can also be a local file. The zip file is downloaded and extracted to the ocx installation path for execution.

The Run and Stop methods tell the control to start and stop the simulation, respectively. These methods need no parameters at all and will load/unload the currect selected .fly file.

The Exec method can execute a generic command, given by its string parameter.

Finally, the AboutBox method displays a dialog box with information regarding the ActiveX control.

fly3d.ocx also features a message system for Fly3D plugins to ask for the download of resources they need. The plugin just needs to call the SendMessage Windows function, as exemplified below:

char str[256];
strcpy(str,name);
strcat(str,",");
strcat(str,file);

SendMessage(g_flyengine->hwnd,WM_USER+1,0,(LPARAM)str);

In this example, str is a concatenation of the object's name, a comma, and the file name of the resource to be downloaded. The ActiveX control will search for the specified resource file in the download path URL provided by the Open method executed most recently. The first parameter of SendMessage is the handle of Fly3D current window, which is the handler to the ActiveX when it is running. The second parameter is the message identifier, which was defined in the ActiveX control code as WM_USER + 1.


Fly3D Tutorials

Programming

  1. Introduction
  2. Installing Fly3D, 3DSMax plugins and Visual C++ Wizard
  3. Creating a Fly3D plugin with the Visual C++ Wizard implementing two classes: camera and object
  4. Creating a .fly file with flyEditor including the new plugin
  5. Processing the engine's global messages
  6. Implementing the object's methods
  7. Implementing the camera's methods
  8. Adding new member variables to the plugin classes
  9. Adding movement and collision detection to the object class
  10. Adding a new class to the plugin: light
  11. Adding dynamic lighting and dynamic shadows to the object

3D Modelling

  1. Creating models for dynamic objects
  2. Importing and Exporting a .f3d file
  3. Modelling, exporting and building the simplest level ever
  4. Modelling, exporting and building a more complex level
  5. Modelling with curves

Special Effects

  1. Afterburner
  2. Gravtor
  3. Pulsar

Resources

  1. tutorial.zip


Programming Tutorial - Step 1

1. Introduction

This programming tutorial intends to introduce Fly3D plugins development for newbie users. It serves as a good example of a simple plugin that uses some of the engine's functionalities and shows typical techniques for working with Fly3D.

The steps include: installation of the necessary tools, a simplistic starting plugin and the incremental enhancement of this simple module, making it more complex and complete.

This tutorial requires intermediate skill in C++, as well as basic knowledge of Visual C++ 6.0.


Programming Tutorial - Step 2

2. Installing Fly3D, 3DSMax plugins and Visual C++ Wizard

Fly3D installation is as simple as follows: run the installation executable and follow the instructions on choosing the installation folder, etc.

After the copy of all the files, flyConfig.exe will run automatically, for the user to choose a graphics renderer, set some rendering options, configure profile and keyboard mappings, and much more. For the renderer, an accelerated mode should be selected.

After configurations are saved and flyConfig.exe is closed, the plugins installation program (flyInstPlugins.exe) will also run automatically. This software lets the user install Fly3D import and export plugins for 3D Studio MAX 3.x or 4.x and the Visual C++ Plugin Wizard. For the installation of the MAX plugins, the correct 3DSMax version and installation path must be selected. For the Plugin Wizard, just the Visual C++ path is needed.

After installing everything, the user may be prompted about rebooting the system, which he must do for the installation proccess to be finally complete.


Programming Tutorial - Step 3

3. Creating a Fly3D plugin with the Visual C++ Wizard implementing two classes: camera and object

In this step, a new Fly3D plugin will be created from scratch, using the Visual C++ Plugin Wizard.

First of all, Visual C++ must be run. In the 'File' menu, the 'New' sub-menu will open a window for choosing the kind of document to be created. Fly3D Plugin Wizard should be enumerated in the 'Projects' tab. It must be selected, a name must be given to the new project (in this case, 'Tutorial 1') and a folder must be chosen for the project to be saved in it. If Fly3D Plugin Wizard is not included in the list, the plugins installation program can be run again for the proper installation of the Wizard. flyInstPlugins.exe can be found inside the 'util' folder in the Fly3D installation directory. Refer back to step 2 for more info on installing the Plugin Wizard.

In the first step of the Plugin Wizard, the classes must be named and added to the plugin. In this tutorial, two classes will be created: 'object' and 'camera'.

In the second step, all parameters exported by the classes in the plugin must be enumerated: their name, type and default value must be specified. Every parameter must be of one of Fly3D predefined types, enumerated in the correspondent combo-box.

In our tutorial, the 'camera' class will have 2 parameters: 'mousevel' (a floating point number that defines the velocity of mouse-look) and 'movevel' (another floating point defining the velocity of camera movement). The 'object' class will have only 1 parameter, 'objmesh', of type 'f3d static mesh', that will be the triangular mesh of the object.

The third and last step of the wizard consists simply of selecting the Fly3D installation path.

After all this, Fly3D Plugin Wizard must have created 3 files in your project: 'Tutorial1.h', 'Tutorial1.cpp' and 'Tutorial1.def'. The header file now contains all the information enumerated in the steps 1 and 2 of the Plugin Wizard: the classes and their parameters.


Programming Tutorial - Step 4

4. Creating a .fly file with flyEditor including the new plugin

Now that the plugin has been successfully created, this step consists of creating a new .fly file and including the plugin in it with the flyEditor front-end.

First of all, flyEditor.exe must be run. It is located in the Fly3D installation folder. In the 'File' menu, the 'Save' sub-menu option must be used to save a new .fly file. Saving is necessary for loading a BSP file to the scene.

After saving the .fly file, a BSP must be loaded. This is achieved by editing the 'bspfile' parameter in the 'Global' group (select the 'Global' item in the tree-view on the left, then look for the 'bspfile' in the list-view on the center).

Now, the DLL generated by the 'Tutorial1' plugin must be inserted in the .fly file. The plugin must be compiled and its resulting DLL file copied to the 'plugin' folder in the Fly3D installation path. Then it can be inserted in the .fly file by right-clicking on the 'Plugins' item in the tree-view on the left, and selecting 'Insert'. A dialog-box will appear and the DLL file must be chosen. The final look of the file in flyEditor must be like this:


Programming Tutorial - Step 5

5. Processing the engine's global messages

Among many global methods created by the Plugin Wizard in the tutorial's .cpp file, one deserves special attention: the fly_message function. This function is used by the engine to notify the plugins of events like scene initialisation, between-frames update time, draw time, scene closing, etc. Any plugin that wishes to respond to these events must implement the response in this function.

During the simulation, Fly3D engine sends the FLY_MESSAGE_UPDATESCENE and FLY_MESSAGE_DRAWSCENE messages to the plugins whenever it is time to update the state or to draw between frames. Tipically, one of the plugins must receive and respond to the FLY_MESSAGE_DRAWSCENE message, drawing a view of the simulation from some point, or nothing will be drawn (or seen).

In this tutorial example, the FLY_MESSAGE_INITSCENE message does not need to be implemented, as the plugin has nothing to do upon scene initialisation; the same occurs with the FLY_MESSAGE_UPDATESCENE, FLY_MESSAGE_DRAWTEXT and FLY_MESSAGE_CLOSESCENE messages. The only message that must be implemented by the plugin is the FLY_MESSAGE_DRAWSCENE message, where it must set the engine's camera to the desired camera object, and tell the engine to draw the scene from that camera. The code for the fly_message function that implements this is as follows:

__declspec( dllexport )
int fly_message(int msg,int param,void *data)
{
switch(msg)
{
case FLY_MESSAGE_INITSCENE:
break;
case FLY_MESSAGE_UPDATESCENE:
break;
case FLY_MESSAGE_DRAWSCENE:
{
g_flyengine->set_camera(g_flyengine->cam);
g_flyengine->draw_bsp();
}
break;
case FLY_MESSAGE_DRAWTEXT:
break;
case FLY_MESSAGE_CLOSESCENE:
break;
}

return 1;
}


Programming Tutorial - Step 6

6. Implementing the object's methods

In this step, the object class' methods willl be implemented. These methods are, basically, the virtual functions inherited from the flyBspObject class.

Init

void object::init()

This is the object's initialisation funtion. For our small example, it just has to initialise the object's axis-aligned bounding box (every Fly3D entity must have one). And since the object has a mesh asociated to it, the object's AABB should be the mesh's. Then we have the following code for the init function:

void object::init()
{
if(objmesh)
bbox=objmesh->bbox;
}

Refer to step 8 for a small addition to the object's init method.

Step

int object::step(int dt)

This is the per-frame update function. Every entity must update its state in this function, as it will be called once per frame during the simulation. In this example, the object will just stay still (for now). So, there is no need to implement anything in this function: just returning a valid value (1, for the object is still alive) will do. Refer to step 9 and step 11 for modifications in the object's step function.

int object::step(int dt)
{
return 1;
}

Draw

void object::draw()

This is the drawing function. It must be used to draw the object using OpenGL calls. In this tutorial example, a simple drawing is implemented: the object is translated to its position in 3D space (given by the pos variable), rotated to its current orientation (given by the mat variable), and its mesh is drawn. The code is as follows:

void object::draw()
{
if(objmesh)
{
glPushMatrix();
glTranslatef(pos.x,pos.y,pos.z);
glMultMatrixf((float *)&mat);
objmesh->draw();
glPopMatrix();
}
}

Message

int object::message(const flyVector& p,float rad,int msg,int param,void *data)

This is the message receiving function. It must test the value of the msg parameter, treating the known message types. For now, this example's simple object will not receive any messages, returning the value 1 as an indication of normal function termination. Refer to step 11, which adds a message treatment in the object's message function.

int object::message(const flyVector& p,float rad,int msg,int
  param,void *data)
{
return 1;
}

Get Custom Parameters Description

int object::get_custom_param_desc(int i,flyParamDesc *pd)

This is a function used by the front-ends to obtain information regarding the plugins' classes' exported variables. It should always return the total number of exported variables in the class (in this case, 1), and switch the i parameter, filling the pd flyParamDesc instance with the desired type, data pointer and name. type must be a character representing one of Fly3D default parameter types (described in the class_typeid.txt document located in the 'util' folder inside Fly3D directory); data must be a pointer to the variable itself; name must be a string with the parameter's friendly name, to be used by the front-ends. The code is as follows:

int object::get_custom_param_desc(int i,flyParamDesc *pd)
{
if (pd!=0)
switch(i)
{
case
  0:
pd->type='m';
pd->data=&objmesh;
pd->name="objmesh";
break;
}

return 1;
}

Refer to step 8 for an addition to the object's get_custom_param_desc method.


Programming Tutorial - Step 7

7. Implementing the camera's methods

In this step, the camera class' methods willl be implemented. These methods are, basically, the virtual functions inherited from the flyBspObject class.

Init

void camera::init()

This is the camera's initialisation funtion. As with the object class, all we have to do is initialise the camera's axis-aligned bounding box. But since the camera does not have a mesh associated to it, an AABB must be created. In the following code, the camera's AABB is initialised with side 50:

void camera::init()
{
bbox.min.vec(-25,-25,-25);
bbox.max.vec(25,25,25);
}

Step

int camera::step(int dt)

This is the per-frame update function. The camera must test for input and update its position (move dt miliseconds) in this method. In this example, the camera should move like this: the left mouse button will act as an accelerator (when pressed, the camera will move forward), and the mouse axes will be used for rotation (pitching and yawing). The following code can be divided in 3 parts:

Firstly, the mouse_down variable of the flyDirectX class is accessed, and a test is made using the constant value FLY_MOUSE_L to check if the left mouse button has been pressed since the last frame; if the test succeeds, the camera's velocity must be increased by a value that depends on the direction the camera is facing (Z negative), the move velocity and the elapsed time since the last frame (dt); if the test fails, the velocity of the camera must be nullified.

After that, the mouse axes are tested through the mouse_smooth variable in flyDirectX (for smooth mouse movement). Note that this variable is an array of two positions, corresponding to the X and Y mouse axes, respectively. If a test succeeds, the camera must be rotated over the other axis, by a value given by the mouse movement velocity and the displacement of the mouse pointer position since the last frame. The negation in the Y-axis rotation refers to inverted mouse rotation.

At last, the camera must move. This part of the code is explained in step 9 , as the camera's movement and collision avoidance works the same way as the object's.

int camera::step(int dt)
{
if (g_flydirectx->mouse_down&FLY_MOUSE_L)
vel=Z*movevel*(float)(-dt);
else
vel.null();

if (g_flydirectx->mouse_smooth[0]) // mouse X
rotate(-g_flydirectx->mouse_smooth[0]*mousevel,Y);

if (g_flydirectx->mouse_smooth[1]) // mouse Y
rotate(g_flydirectx->mouse_smooth[1]*mousevel,X);

flyVector p,v;
p=pos+vel*(float)dt;
v=vel+force*((float)dt/mass);
box_collision(p,v);
pos = p;
vel = v;

return 1;
}

Draw

void camera::draw()

This is the drawing function. Since tha camera will not appear in the simulation, no drawing needs to be made here, and the method is left blank.

Message

int camera::message(const flyVector& p,float rad,int msg,int param,void *data)

This is the message receiving function. Just like the object, the camera will not receive any messages, and this method must just return 1 for normal termination.

int camera::message(const flyVector& p,float rad,int msg,int
  param,void *data)
{
return 1;
}

Get Custom Parameters Description

int camera::get_custom_param_desc(int i,flyParamDesc *pd)

This is a function used by the front-ends to obtain information regarding the plugins' classes' exported variables. It is similar to the object's methos of the same name, and a complete explanation can be found in the last step. The code is as follows:

int camera::get_custom_param_desc(int i,flyParamDesc *pd)
{
if (pd!=0)
switch(i)
{
case
  0:
pd->type='f';
pd->data=&movevel;
pd->name="movevel";
break;
case
  1:
pd->type='f';
pd->data=&mousevel;
pd->name="mousevel";
break;
}
return 2;
}


Programming Tutorial - Step 8

8. Adding new member variables to the plugin classes

In this step, the addition of members to existing classes in the plugin will be exemplified. A new variable will be added to the 'object' class: the mesh color.`

Firstly, the variable must be added to the 'object' class definition in the .h file. The following line should be inserted:

flyVector color;

The flyVector class defines a 4-component vector of floating point numbers. Our color will be represented by the x, y and z components of the vector, while the w component will be used to represent transparency (0..1, 0 for fully transparent, 1 for fully opaque).

For these values to be exported and edited in the front-ends, the variables must be enumerated in the get_custom_param_desc method. The code for this method, after these additions, is as follows:

int object::get_custom_param_desc(int i,flyParamDesc *pd)
{
if (pd!=0)
switch(i)
{
case
  0:
pd->type='m';
pd->data=&objmesh;
pd->name="objmesh";
break;
case
  1:
pd->type='c';
pd->data=&color;
pd->name="color";
break;
case
  2:
pd->type='f';
pd->data=&color.w;
pd->name="transp";
break;
}

return 3;
}

Note that the 'c' data type represents colors; flyEditor will open a color browsing dialog box upon editing this type of parameter. For the transparency variable, a standard floating point editing box will be used.

Now that the mesh color can be edited outside the plugin, it must be assigned to the object's mesh color. The flyMesh class has a color member variable to which the color parameter of the object will be set. This will be done in the object's init method, as seen below:

void object::init()
{
if(objmesh)
{
bbox=objmesh->bbox;
objmesh->color=color;
}
}


Programming Tutorial - Step 9

9. Adding movement and collision detection to the object class

This step exemplifies movement simulation and collision detection for the 'object' class. The object will move with constant acceleration and bounce at walls, and its velocity vector will be represented by the variable vel, inherited from flyParticle (through flyBspObject). Collision will be handled by the box_collision method inherited from flyBspObject, which implements collision detection and response for the object's axis-aligned bounding box.

The code is like this: firstly, the object's position and velocity are updated: position depends on velocity and time, and velocity depends on force, mass and time. Then, the box_collision method is called, and it handles collision detection and bouncing automatically (bouncing depends on the object's bump and friction parameters, inherited from flyBspObject), updating the position and velocity parameters passed to it. Finally, these values must be assigned to the object's original position and velocity. This is all inserted in the object's step method, like this:

int object::step(int dt)
{
flyVector p,v;
p=pos+vel*(float)dt;
v=vel+force*((float)dt/mass);
box_collision(p,v);
pos = p;
vel = v;

return 1;
}


Programming Tutorial - Step 10

10. Adding a new class to the plugin: light

In this step, a new class will be added to the tutorial plugin. And since the next step is about adding lighting to the simulation, the new class will be a light source.

Firstly, a new type must be added to the enumerated at the top of the .h file. It will be called TYPE_LIGHT. Every class in the plugin must have a corresponding type. The enumerated should now look like this:

enum
{
TYPE_OBJECT=100000,
TYPE_CAMERA,
TYPE_LIGHT,
};

Now for the definition of the light class. Like all other classes that exist in the scene, it must derive from the flyBspObject class. The light class will have two member variables, color and illumradius, representing the color and the light radius of the light, respectively. Also, a constructor and a copy-constructor must be created. The constructor must assign initial values to the member variables and set the type variable (inherited from flyBspObject) to the constant defined before; the copy-constructor must call flyBspObject's copy-constructor, and assign the member variables to the values given by the source object that is being copied. All the flyBspObject pure virtual functions must also be implemented, and the entire definition of the light class should look like this:

class light : public flyBspObject
{
public:
flyVector color;
float illumradius;

light() :
color(1),
illumradius(100)
{ type=TYPE_LIGHT; }

light(const light& in) :
flyBspObject(in),
color(in.color),
illumradius(in.illumradius)
{ }

virtual ~light()
{ }

void init();
int step(int dt);
void draw();
int get_custom_param_desc(int i,flyParamDesc *pd);

flyBspObject *clone()
{ return new light(*this); }
};

Another important step is to create a description class for the new light class. Description classes allow external modules to see what classes exist in the plugin and what members they export. All description classes are very alike, so the light's description class will be similar to the camera's or the object's:

class light_desc : public flyClassDesc
{
public:
flyBspObject *create() { return new light; };
const char *get_name() { return "light"; };
int get_type() { return TYPE_LIGHT; };
};

In the above class, the create method must return a new instance of the described class; the get_name method must return a string containing the friendly name of the class; and the get_type method must return the type that defines that class.

Now that the description class is created, the plugin's exported methods must be modified to include the new light class. Two methods must be modified: the num_classes method, which must return the total number of classes in the plugin, and the get_class_desc, which must return a pointer to a description class for each class in the plugin. They should look like this:

__declspec( dllexport )
int num_classes()
{
return 3;
}

__declspec( dllexport )
flyClassDesc *get_class_desc(int i)
{
switch(i)
{
case 0:
return
  &cd_object;
case 1:
return
  &cd_camera;
case 2:
return
  &cd_light;
}

return 0;
}

Finally, the light class methods must be implemented. They are quite simple: the init method must create an axis-aligned bounding box for the light; the step and draw methods will do nothing (for now); the get_custom_param_desc method must enumerate the two member variables in the class. They should be implemented this way:

void light::init()
{
bbox.max.vec(-10,-10,-10);
bbox.min.vec(10,10,10);
}

int light::step(int dt)
{
return 0;
}

void light::draw()
{

}

int light::get_custom_param_desc(int i,flyParamDesc *pd)
{
if (pd!=0)
switch(i)
{
case
  0:
pd->type='c';
pd->data=&color;
pd->name="color";
break;
case
  1:
pd->type='f';
pd->data=&illumradius;
pd->name="illumradius";
break;
}

return 2;
}

The next step is about adding lighting and shadows to the simulation, and will use the newly created light class to represent light sources.


Programming Tutorial - Step 11

11. Adding dynamic lighting and dynamic shadows to the object

For the last step of the tutorial, lighting and shadowing will be implemented for the object class, so that the object's mesh is lit and casts shadows.

Firstly, a flyLightVertex member variable must be added to the object class. flyLightVertex is a class from inside Fly3D engine, which implements an array of dynamic lights. It shuold be declared in the object class definition like this:

flyLightVertex dynlights;

Now the object must search the environment around it, looking for light sources that will light it. This is done in the object's step function through the engine method recurse_bsp:

int object::step(int dt)
{
flyVector p,v;
p=pos+vel*(float)dt;
v=vel+force*((float)dt/mass);
box_collision(p,v);
pos = p;
vel = v;

g_flyengine->recurse_bsp(pos,2048,TYPE_LIGHT);
for(int i=0;i<g_flyengine->selobjs.num;i++ )
{
light *l=(light *)g_flyengine->selobjs[i];

if (g_flyengine->collision_test(pos,l->pos,FLY_TYPE_STATICMESH)==0)
dynlights.add_light(l->pos,l->color,l->illumradius);
}

return 1;
}

Note that the collision_test call tests if there is a wall (FLY_TYPE_STATICMESH) between the light and the object.

Now that the object can already find light sources around it, it must be lit by them. This is done in the object's draw function, using the flyLightVertex method init_draw:

void object::draw()
{
if(objmesh)
{
dynlights.init_draw(this);

glPushMatrix();
glTranslatef(pos.x,pos.y,pos.z);
glMultMatrixf((float *)&mat);
objmesh->draw();
glPopMatrix();

glDisable(GL_LIGHTING);
}
}

The two lines of code added above are enough for the object to be lit by the dynamic lights stored in the dynlights variable. As a last task, shadow casting will now be implemented in the object class. It will be done through overriding the fyBspObject virtual function draw_shadow:

void object::draw_shadow()
{
int i=dynlights.get_closest(pos);
if (i!=-1)
{
glPushMatrix();
glTranslatef(pos.x,pos.y,pos.z);
glMultMatrixf((float *)&mat);
flyVector v=dynlights.pos[i]-pos;
v.normalize();
objmesh->draw_shadow_volume(v*mat_t);
glPopMatrix();
}
}

The get_closest method finds the closest light in the array; the draw_shadow_volume method draws a shadow of the mesh in a given position and orientation.

Finally, a useful note is about the object searching for lights around it. There is another way of determining which lights will apply which objects: the lights themselves could send messages to every object within the sphere defined by its position and radius. This option suits better in a situation where the number of lights is less than the number of objects to be lit. If this is not the case, the way it was implemented in this tutorial will do, with the objects themselves looking for light sources around them.


Modelling Tutorial - Creating Models for Dynamic Objects

Creating Models for Dynamic Objects

How to model a dynamic object:

The most important factor that distinguishes a dynamic object from a static object is the texture map. It is important that one texture map be derived for the complete object for run time efficiency.

The steps in buiding up a dynamic object are:

1) Build a polygon mesh model.

2) Render orthographic views of the object (front, side, top, back, etc). The numbers of view that will be required depends on the object complexity. All parts of the object must be visible and of sufficient projected area in 2D space.

3) Use a painting package to paint the textures on the views.

4) Create a single texture and copy/paste the required parts of the orthographic painted views into it. Notice that symmetric objects that have reflected textures should have both regions mapped onto the same area of the texture map. It is important for efficiency not to duplicate textures in the texture map.

5) Use 3D Studio MAX's Unwrap UVW modifier to precisely position the tetxure coordinates for each of the model faces into the desired position in the texture map.


Importing and Exporting a .f3d file

F3D Export Tutorial

Introduction

The goal of this tutorial is to show how to use the F3D mesh export plugin for 3D Studio MAX, featured in the Fly3D 2.0 engine. The example F3D mesh will contain 1 static frame and 2 animations of the same object, one of them done by use of fundamental operations (like translation, rotation and scaling), and the other done by moving the vertices of the object. It is necessary to have 3D Studio MAX versions 3.x or 4.x up and running, with the Fly3D MAX plugins properly installed, for the development of this tutorial and for the use of the F3D export plugin.

Step 1: Creating an Object

- In this step, a new object must be created from scratch (in this case a simple box);

- Since there will be no animation in the first object, it is almost ready for exporting.

Step 2: Mapping the Object

- A texture is applied and the object is mapped. When exporting, the mapping will be saved and a shader file (.shr) will be created.

Step 3: Exporting the Static Object

- In the File/Export menu option, save the file in the data/objects/ folder inside Fly3D installation path and the following dialog box will be shown:

- In it, check the Save Shader File (.shr) check box, which will save a shaders file that can be edited later in the FlyShader program. In this step, since the object has no animations, the Save animation option must be off.

Step 4: Editing the Shaders

- In this step, the object's shader is edited as desired, so that we do not need to save it again later (doing that would overwrite the modified .shr file, and all edition would be lost);
- In the Shader Editor (flyShader.exe), a chrome is applied over the object (as seen below), using envoironment mapping and a chrome texture.

Step 5: Linear Animation

- In this step, linear transformations are added to the object, like translations and rotations;
- The number of animation keys is the same as the number of frames defined in MAX. For example, for a simple door object, just two frames would be needed (open and closed), since the engine automatically interpolates between these two frames during the simulation.
- In this case, the animation features a little more frames (10) for better visualization, as seen below:

(Frame 0) (Frame 3)

(Frame 7) (Frame 10)

- In the File/Export option again, we will add this animation to the existing file, selecting the Append to existing file option; this way, more than one animation can fit a single .F3D file;
- Also, the Save Animation option must be turned on, and a name must be given to the animation (in the Anim Name edit box); we called our animation linear;
- In the export dialog box, you can see information like the number of vertices, materials, the number of frames in each animation and the total number of keys in all animations;
- It is not necesary to save a new shader file, unles you wish to overwrite the old one.

Step 6: Animating Vertices

- In this step, another animation will be built, but this time the vertices will be moved. This animation will be appended to the old .f3d file;

(Frame 0) (Frame 3)

(Frame 7) (Frame 10)

- After moving the vertices in the 10 frames and calling the export option, the animation must be added to the existing file by turning on the Append to existing file option;
- Turn on the Save Animation option and name the animation (we called this one vertex);
- Remeber not to save a shader file unless you want to overwrite the old one;

- All done! Now the object is ready to be used in Fly3D;
- To see your object animating, open the saved .f3d file in the Shader Editor. If more than one animation exists in the file (like in our simple example), double click with the right mouse button to change the animation.

F3D Import Tutorial

Introduction

The goal of this tutorial is to show how to use the F3D mesh export plugin for 3D Studio MAX, featured in the Fly3D 2.0 engine. A F3D file containing an animated mesh object will be imported to 3D Studio MAX 3.x or 4.x.

Importing Animations as Separated Meshes

- Use the File/Import menu option in 3D Studio MAX and choose the F3D file to be imported. The following dialog box will show up:

- There are two import options: one for importing each animation into a separate object, and another to import all animations into a single object. The first one is the default option.
- This tutorial uses the soldier.f3d object from Fly3D Walk Demo (walk.zip). This mesh consists of a series of animations featuring the Bronto character walking, jumping, swimming, etc.;
- When it is imported with the default option, all animations will be separated into different objects, generating a smaller number of frames, where this number will be given by the frames of the longest animation. All the objects are centralized on the same point, making it difficult to visualize:

- Here the objects are separated:

- Each mesh animates separately, and if there is any static object in the file, it will also be imported as a separated 1-frame mesh

Importing Several Animations into a Single Mesh

- The soldier.f3d file will be imported again, but this time the second import option will be used, and all animations will be imported to a single object;

- In this option, the number of frames will be much bigger, since the animations will be appended together as a sequence in the single object created;
- When import to a single object is performed, some parameters are added to the object's User-Defined Properties, informing the number of frames and the name of each animation, formatted as follows:

subanim = n0:animname0,n1:animname1,n2:animname2,n3:animname3...

- subanim is the name of the parameter; ni is the number of frames in the i-th animation; and animnamei is the name of the i-th animation. This parameter can be viewed in the mesh properties box (right-click on the object and select Properties/User Defined):

- If the object is re-exported, the plugin will detect these settings and save the F3D file with separate animations again;
- The Save Animation option is disabled as the animations will be automatically saved;

- All done! Now you can re-import a pre-made object to MAX, modify it and re-export it.


Modelling, exporting and building the simplest level ever

This tutorial explains how to build a structure that is the most basic possible, and to include one example of each detail object types supported by Fly3D (vertex-lightened triangular objects, lightmap-lightened polygonal objects and curve objects). 3D Studio MAX 3.x or 4.x can be used as modelling tools. The user must have basic knowledge of this software. Fly3D export/import plugins and curve plugin for the corresponding MAX version must be installed through the Fly3D Plugins Installation Program (flyInstPlugins.exe) application.

Building the Level's Structural Faces

- Structural faces are the ones that define the geometry of the scene, dividing the space between "in" and "out" of the environment, like walls, ceilings, floors, etc.

- The structure built in this example is the simplest possible: a box with coordinates 500x500x200.

- It is necessary to invert these faces' normals so that they are turned to inside the level, like in the figure below.

- The next step is setting the created mesh as structural. Fly3D uses a prefix tag system for recognizing the various types of meshes and faces. To set the mesh's faces as structural faces, just rename it, placing a "*" (asterisk) character before its name. For example, a mesh named "structure" must be renamed to "*structure".

Adding detail objects

- In this step, triangular and polygonal detail objects will be created.

- Detail objects follow the same prefix tag pattern. Therefore, a "^" must be added to the beginning of the object's name, if the object is made of triangular faces, or a "&", if the object is made of faces with more than three vertices.

- Boxes will be created and renamed with a "&" tag prefix, informing that they should be exported as polygonal objects. Their sizes are 70x60x40.

- Another object will also be created, but this time a Teapot will be used. It must be renamed with the addition of a "^" (circumflex) tag prefix, indicating that it is a triangular object.

Adding lights

- In this step, lights will be added to the scene. Lights must always be of the Omni type, and their color and illumination radius must be defined in the far attenuation submenu. Lights do not need a prefix tag before their names.

- 5 lights will be created, 4 of them with different colors on each corner of the room, and a white one on the center for ambient.

Adding a curve

- The flyCurve plugin can be found in the Create/Geometry/Paralelo menu.

- A flyCurve object will be added to the scene. A full cylinder should be selected, created and positioned in the room with coordinates 30x30x100.

Adding Entities

- The last step in building the level is inserting entities in it. Entites can be power-ups, birthpads, portals, mirrors, etc. In this tutorial example, a birthpad and a power-up entities were added to the scene. The entities names must match the names of classes that exist in a Fly3D plugin, and they are represented by simple meshes, like boxes. The image below shows the birthpad and power-up entities (highlighted in red):

- Entities must have a "$" prefix tag before their names.

- A birthpad (an entity that marks a place in the level for the player to appear on start-up) will be added to the scene. A sphere will be created and renamed to $birthpad.

Exporting the level

- In this step, it is mandatory that the export plugins have been installed through the Fly3D Plugins Installation Program (flyInstPlugins.exe). Refer to the Programming Tutorial, Step 2 for information on how to use flyInstPlugins.exe.

- In the 3D Studio MAX menu, select File/Export. Then choose "Fly3D 2.0 Map (*.fmp)" from the file type list. The file must be saved in the 'data' folder inside the Fly3D installation directory.

Building the level

- Now that the map file (.fmp) is saved, the scene must be built for Fly3D frontends to be able to open and run it. In the 'util' folder inside the Fly3D installation directory, the flyBuilder.exe application must be run.

- The previously exported .fmp file must be selected. The build options can be changed, but for this example the default settings will do. A class template must also be chosen, and for this tutorial the fly_observer template will be used.

- The building options used in this example are shown below with the final level running in the engine:

Build BSP
Build Lightmaps
Build FLY file
Class Template: fly_observer

Options:
Backface Culling
Light x Normal Dot product
Shadows / Soft Shadows
Light Samples : 4
Light Jittering : 4.0000
Ambient Light: 16 (Default)
Light Map size: 64
Light Map pixel size: 32.0000
BSP Grid size: 50000.0000
PVS Grid size: 50000.0000

- After clicking on the Build button and waiting a little while, the scene will be ready for use in Fly3D.


Modelling, exporting and building a more complex level

This tutorial explains how to model and illuminate a complex level, build the structure, build detail objects, build curves, texturize and export it to be used as a Fly3D scene environment. 3D Studio MAX 3.x or 4.x can be used as modelling tools. The user must have basic knowledge of this software. Fly3D export/import plugins and curve plugin for the corresponding MAX version must be installed through the flyInstPlugins.exe application.

The Concept of a New Level

- The very first step when building a new level is to design structures and details as in an architectural project, where decisions about measurements, type of materials used, textures, etc. must be made.

- The following drawings are conceptual sketches of this tutorial's example level and detail objects, made before the construction of the environment:

Building the Level's Structural Faces

- Structural faces are the ones that define the geometry of the scene, dividing the space between "in" and "out" of the environment, like walls, ceilings, floors, etc.

- It is of great importance that some properties are maintained by the structural model, specially when modelling more complex environments: the whole set of structural faces must define a closed concave volume. This is achieved by having two and only two faces sharing a given edge, for all edges that compound the model. If these properties are kept, the BSP building routine will generate only positive (valid) leaf nodes, making it possible to use PVS culling and portals technology for path-finding.

- The structure of the scene in this tutorial was built in 3D Studio MAX, where it is important to assure that the Snap to Grid option is turned on. A level's structure can also be built using AutoCAD, and then exported as a .3ds file to be imported in MAX.

- It is necessary to invert these faces' normals so that they are turned to inside the level, like in the figure below:

- The next step is to texturize the structural faces using UVW mapping. The Planar, Box or Cylindrical mapping templates can be used, as well as Face Map

- To make the task of mapping the structural faces easier, the Detach procedure can be used to separate the faces, making it possible to map each face in a unique way.

- The next step is setting the created mesh as structural. Fly3D uses a prefix tag system for recognizing the various types of meshes and faces. To set the mesh's faces as structural faces, just rename it, placing a "*" (asterisk) character before its name. For example, a mesh named "structure" must be renamed to "*structure".

Adding detail objects

- In this step, detail objects will be added to the scene, making it more realistic. Typical detail objects are picture frames, pilars, tables, boxes, stairs etc. The images below shows pilars and stairs added to the original scene:

- Detail objects follow the same prefix tag pattern. Therefore, a "^" must be added to the beginning of the object's name, if the object is made of triangular faces, or a "&", if the object is made of faces with more than three vertices.

- The following figures show examples of a triangular detail object (on the left) and a polygonal detail object (on the right):

- Special care must be taken when adding detail objects to the level. Their volumes must be located all inside the concave volume defined by the structural model. However, detail faces do not have the same limitations of structural ones: edges and vertices can be shared by any number of faces in any fashion.

- It is also important to note that detail objects made of large faces (faces with more than three vertices) will have lighmaps applied to them for static (pre-calculated) illumination, while objects made of triangular faces will be illuminated with vertex lights technology.

Adding lights

- In this step, lights will be added to the scene. Lights must always be of the Omni type, and its color and illumination radius must be defined in the far attenuation submenu. Lights do not need a prefix tag before their names.

- In the lights Far Attenuation submenu, the default lighting radius are set: Start=80 and End=500.

- Lighting is a major feature that adds ambience and depth to a level. It is probable that the level designer will want to test several light configurations before the intended visual impressions are achieved.

Adding Entities

- The last step in building the level is inserting entities in it. Entities can be power-ups, birthpads, portals, mirrors, etc. In this tutorial example, birthpad and power-up entities were added to the scene. The entities names must match the names of classes that exist in a Fly3D plugin, and they are represented by simple meshes, like boxes.

- Entities must have a "$" prefix tag before their names.

- There exists pre-defined entities for game templates like the Walk and Ship games, like power-ups for each of the games.

- What follows is a list of entities already defined in the Walk and Ship games.

SHIP | WALK
$ship_birthpad | $item_health_small
$ship_shield_small | $item_health
$ship_shield_medium | $item_health_large
$ship_shield_large | $item_health_mega
$ship_cloak | $ammo_bullets
$ship_powershield | $ammo_shells
$ship_powerdamage | $ammo_rockets
$ship_pulsar | $ammo_slugs
$ship_laser | $weapon_shotgun
$ship_bumper | $weapon_rocketlauncher
$ship_railgun | $weapon_railgun
$ship_plasma | $item_quad
$ship_fusion | $item_invis
$ship_mine |
$ship_turretmine |
$ship_concussion |
$ship_velos |
$ship_homing |
$ship_guided |
$ship_disruptor |
$ship_gravtor |
$ship_atom |

Exporting the level

- In this step, it is mandatory that the export plugins have been installed through flyInstPlugins.exe. Refer to the Programming Tutorial, Step 2 for information on how to use flyInstPlugins.exe.

- In the 3D Studio MAX menu, select File/Export. Then choose "Fly3D 2.0 Map (*.fmp)" from the file type list. The file must be saved in the 'data' folder inside Fly3D installation directory.

- Make sure that the proper prefix tags are added to the names of entities and meshes, or the export module will not recognize them.

Building the level

- Now that the map file (.fmp) is saved, the scene must be built for Fly3D frontends to be able to open and run it. In the 'util' folder inside Fly3D installation directory, the flyBuilder.exe application must be run.

- The previously exported .fmp file must be selected. The build options can be changed, but for this example the default settings will do. A class template must also be chosen, and for this tutorial the fly_observer template will be used.

- The build options used in this example are shown below:

Build BSP
Compute visibility
Build Lightmaps
Build FLY file
Class Template: Observer

Options:
Backface Culling
Light x Normal Dot product
Shadows Soft Shadows
Light Samples : 4
Light Jittering : 4.0000
Ambient Light: 20
Light Map size: 64
Light Map pixel size: 32.0000
BSP Grid size: 50000.0000
PVS Grid size: 50000.0000

- The texture files applied to the scene's materials must be copied into a directory with the scene name (same name as the .fmp file) inside the 'data' folder in Fly3D installation directory.

- After clicking on the Build button and waiting a little while, the scene will be ready for use in Fly3D.


Modelling with curves

This tutorial explains how to build curves in 3D Studio MAX for Fly3D. These are special types of curves, and the curve object plugin was created specifically for making curves that integrate with Fly3D and take advantage of the engine's dynamic LOD algorithms and other optimizations.

Step 1: Creating a structure

- In this step, a big box will be created and used as structure, which will represent the level itself and will contain the curves to be exported on the end of the tutorial.
- A box is created in our simple example with dimensions 1000x1000x400, as seen below:

Step 2: Inverting the normals

- Now the box's normals should be inverted, making the inside space valid, and the outside, invalid. Also, a '*' (asterisk) character must be added to the beginning of the box's name (in our case, structure), so that the export plugin will later recognize it as the level's structure.

Step 3: Mapping

- In this step, the box will be texturized for a better look, which is completely optional.

Step 4: Creating curves

- The Fly3D curve creation plugin is found inside the Create/Geometry menu, in the Paralelo category.
- Clicking on the flycurve button, various curve types will will be available, like cylinders, cones, spheres, caps, etc. Also, some options are available like the dimensions and number os segments of the curve.
- Firstly, a cylinder will be created as a Full one (4x1 segments), positioned at the center of the room, with dimensions set at 50x50x200.

- Now a quarter-sphere will be created, positioned anywhere in the room. A quarter-sphere is created by selecting hemisphere in the type menu, and then Quarter (1x1) in the Segments menu. Its dimensions will be 200x200x100, as seen in the figure below:

- This time, another kind of curve will be created. In the type menu, the Cone option will be selected, and a Full (4x1) cone will be created, with dimensions 50x50x100 and posicioned against the wall, as seen in the figure below:

- The next step is to make a capped thin half-cylinder. First, the body of a half-cylinder must be created with dimensions set to 200x200x20.

- Now the cylinder must be cloned and placed on the same position, but this time the Cap Up option of the Part menu must be used to make a cap for the cylinder, as seen below:

Step 5: Editing the curves

- In this step, another cylinder will be created, and the Edit Mesh modifier will be applied to it afterwards, making it possible to move the curve's vetices. A Full (4x1) cylinder will be created, and the Part menu must be set to Body.
- The Edit Mesh modifier is then applied, and the vertices are edited to make it for a curved cylinder. Note that, once the modifier is applied, the curve is no more visible; its control points appear instead. The vertices we move are actually the curve's control points, but in Fly3D it will still be seen as a curve.

- This last curve will be another cylinder (a quarter-cylinder, actually), but this time we will set the Invert Normals option to make a rounded corner. This quarter-cylinder will have dimensions of 200x200x200.

Step 6: Illuminating, adding entities and exporting

- In this last step, lights and a birthpad are positioned in the level.

- Export it as a Fly3D Map file (.fmp), build the level with flyBuilder and run one of the engine's front-ends to see the level. Here are some screenshots from the level in Fly3D:


Afterburner

The faces are drawn from point P0 (the ship's turbine) to Pn, where n is the number of points generated during the time when the afterburner key remained pressed on. The texures (see below) are applied on the faces, and are wrapped until the afterburner stops, always followed by a fading effect (fig. 1).

(fig. 1)

The halo texture (fig. 2) remains at P0, always aligned orthogonally to the observer. The texture is mapped on a face whose color is set in the ship variable spritelight color, and the result of this mapping is that the two colors (the face's and the texture's) are multiplied. The texture color is also modified by the speed of the ship, to further enhance the sense of movement. When the ship is stopped, the texture is almost invisible.

(fig. 2)

The below picture (fig. 3) is the alpha channel of the afterburner's texture.

(fig. 3)

The below picture (fig. 4) displays the RGB channels of the afterburner's texture.

(fig. 4)


Gravtor

This effect consists of a sphere that constantly scales down. When it reaches 1/3 of its original size, another one appears with the initial size. Besides, there is a modified particle emmitting system, where a polygon is drawn from the center of the gravtor object to each particle, wrapping a texture over this polygon, making for the feeling of a energy ray (fig. 1).

(fig. 1)

Below is the texture used in making the gravtor (fig. 2).

Below are some gravtor screenshots (fig. 3 and 4)

(fig. 3)

(fig. 4)

Gravtor missile (fig. 5).

(fig. 5)


Pulsar

Just a half of the texture is created (fig. 1), and a mirror effect is applied to generate the other half (fig. 2).
Then the dashed line marked on fig. 2 is rotated around itself vertically, and the texture representing the frontal view of the shot is generated (fig. 3). Now the horizontal and vertical textures are positioned like in fig. 4.
* Ps.: The textures are all summed with the back, through a 1-1 blend function, set in the Shader Editor.

The figure below shows the pulsar shot objects always orthogonal to the observer (fig. 5).

(fig. 5)

The below figures show our pulsar shot effect in action (fig. 6 and 7).

(fig.6)

(fig. 7)


Member List

birthpad Member List

This is the complete list of members for birthpad, including all inherited members.
  • anim_mesh
  • anim_size
  • birthpad() [inline]
  • birthpad(const birthpad &in) [inline]
  • birthpad() [inline]
  • clone() [inline]
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd) [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd) [inline]
  • init()
  • ps
  • step(int dt)
  • ~birthpad() [inline, virtual]
  • ~birthpad() [inline, virtual]


Member List

birthpad_desc Member List

This is the complete list of members for birthpad_desc, including all inherited members.
  • create() [inline]
  • create() [inline]
  • get_name() [inline]
  • get_name() [inline]
  • get_type() [inline]
  • get_type() [inline]


Member List

bspmesh Member List

This is the complete list of members for bspmesh, including all inherited members.
  • bspmesh() [inline]
  • bspmesh(const bspmesh &in) [inline]
  • clone() [inline]
  • draw()
  • firstface
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • init()
  • numfaces
  • objmesh
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum)
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist)
  • ~bspmesh() [virtual]


Member List

bspmesh_desc Member List

This is the complete list of members for bspmesh_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

camera Member List

This is the complete list of members for camera, including all inherited members.
  • camera() [inline]
  • camera(const camera &in) [inline]
  • camera() [inline]
  • camera(const camera &in) [inline]
  • clone() [inline]
  • clone() [inline]
  • dist
  • draw()
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • height
  • init()
  • init(void)
  • radius
  • step(int dt)
  • step(int dt)
  • target


Member List

camera_desc Member List

This is the complete list of members for camera_desc, including all inherited members.
  • create() [inline]
  • create() [inline]
  • get_name() [inline]
  • get_name() [inline]
  • get_type() [inline]
  • get_type() [inline]


Member List

color_particle Member List

This is the complete list of members for color_particle, including all inherited members.
  • color
  • color_particle() [inline]
  • draw()
  • size
  • step(int dt)
  • texture
  • ~color_particle() [inline, virtual]


Member List

cubemap Member List

This is the complete list of members for cubemap, including all inherited members.
  • clone() [inline]
  • cubemap() [inline]
  • cubemap(const cubemap &in) [inline]
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • img
  • init()
  • objmesh
  • step(int dt)
  • ~cubemap() [inline, virtual]


Member List

cubemap_desc Member List

This is the complete list of members for cubemap_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

diemesh Member List

This is the complete list of members for diemesh, including all inherited members.
  • clone() [inline]
  • diemesh() [inline]
  • diemesh(const diemesh &in) [inline]
  • draw()
  • draw_shadow()
  • explode(const flyVector &hitpos)
  • fadetime
  • gb
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • gibforce
  • health
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • move(int dt)
  • objmesh
  • radius
  • step(int dt)
  • ~diemesh() [virtual]


Member List

diemesh_desc Member List

This is the complete list of members for diemesh_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

door Member List

This is the complete list of members for door, including all inherited members.
  • animtime
  • bp
  • clone() [inline]
  • door() [inline]
  • door(const door &in) [inline]
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • ntriggers
  • objmesh
  • step(int dt)


Member List

door_desc Member List

This is the complete list of members for door_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

explode Member List

This is the complete list of members for explode, including all inherited members.
  • damage
  • damageradius
  • do_explode(flyVector &pos, flyVector &z, int fromplayer) [virtual]
  • explode() [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • l
  • obj
  • ps
  • s
  • snd
  • ~explode() [inline, virtual]


Member List

explode_desc Member List

This is the complete list of members for explode_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

f3dmesh Member List

This is the complete list of members for f3dmesh, including all inherited members.
  • clone() [inline]
  • color
  • draw()
  • f3dmesh() [inline]
  • f3dmesh(const f3dmesh &in) [inline]
  • flag
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • init()
  • objmesh
  • scale
  • step(int dt)
  • ~f3dmesh() [inline, virtual]


Member List

f3dmesh_desc Member List

This is the complete list of members for f3dmesh_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

fogbox Member List

This is the complete list of members for fogbox, including all inherited members.
  • clone() [inline]
  • draw() [inline]
  • fog_intersect(flyVector &point)
  • fog_map(flyLightMap *fm)
  • fogbox() [inline]
  • fogbox(const fogbox &in) [inline]
  • fogcolor
  • fogdepth
  • fogmode
  • fogsizex
  • fogsizey
  • fogsizez
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • init()
  • step(int dt)
  • ~fogbox() [inline, virtual]


Member List

fogbox_desc Member List

This is the complete list of members for fogbox_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

fogsphere Member List

This is the complete list of members for fogsphere, including all inherited members.
  • clone() [inline]
  • draw() [inline]
  • fog_intersect(flyVector &point)
  • fog_map(flyLightMap *fm)
  • fogcolor
  • fogdepth
  • fogmode
  • fogradius
  • fogsphere() [inline]
  • fogsphere(const fogsphere &in) [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • init()
  • step(int dt)
  • ~fogsphere() [inline, virtual]


Member List

fogsphere_desc Member List

This is the complete list of members for fogsphere_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

followpath Member List

This is the complete list of members for followpath, including all inherited members.
  • clone() [inline]
  • color
  • delay
  • draw()
  • duration
  • fade
  • followpath() [inline]
  • followpath(const followpath &in) [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • init()
  • step(int dt)
  • texture
  • width
  • ~followpath() [inline, virtual]


Member List

followpath_desc Member List

This is the complete list of members for followpath_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

forcebox Member List

This is the complete list of members for forcebox, including all inherited members.
  • animdelay
  • clone() [inline]
  • draw()
  • forcebox() [inline]
  • forcebox(const forcebox &in) [inline]
  • forcedir
  • forcefactor
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • init()
  • meshbox
  • objmesh
  • radius
  • snd
  • step(int dt)


Member List

forcebox_desc Member List

This is the complete list of members for forcebox_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

generator Member List

This is the complete list of members for generator, including all inherited members.
  • anim_mesh
  • anim_ps
  • anim_size
  • animtime
  • birthpos
  • clone() [inline]
  • count
  • draw()
  • draw_shadow()
  • gen_angle
  • gen_delay
  • gen_sound
  • gen_types
  • generate()
  • generator() [inline]
  • generator(const generator &in) [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • objmesh
  • objs
  • step(int dt)


Member List

generator_desc Member List

This is the complete list of members for generator_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

gib Member List

This is the complete list of members for gib, including all inherited members.
  • clone() [inline]
  • draw()
  • draw_shadow()
  • fadetime
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • gib() [inline]
  • gib(const gib &in) [inline]
  • hm
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • numbounces
  • objmesh
  • step(int dt)
  • traildelay


Member List

gib_desc Member List

This is the complete list of members for gib_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

gun Member List

This is the complete list of members for gun, including all inherited members.
  • clone() [inline]
  • delay
  • fire(flyBspObject *obj, int player) [virtual]
  • fire_status() [virtual]
  • firecount
  • firepos
  • firevel
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • gun() [inline]
  • gun(const gun &in) [inline]
  • l
  • nfire
  • objmesh
  • p
  • randomangle
  • sndfire
  • ~gun() [inline, virtual]


Member List

gun_desc Member List

This is the complete list of members for gun_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

gun_projectile Member List

This is the complete list of members for gun_projectile, including all inherited members.
  • damage
  • exp
  • fire(flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0)=0 [pure virtual]
  • gun_projectile() [inline]
  • gun_projectile(const gun_projectile &in) [inline]
  • ~gun_projectile() [inline, virtual]


Member List

hitmark Member List

This is the complete list of members for hitmark, including all inherited members.
  • clip(flyFace *face)
  • clone() [inline]
  • color
  • draw()
  • fadetime
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • hitmark() [inline]
  • hitmark(const hitmark &in) [inline]
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • size
  • step(int dt)
  • texture
  • ~hitmark() [inline, virtual]


Member List

hitmark_desc Member List

This is the complete list of members for hitmark_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

jumppad Member List

This is the complete list of members for jumppad, including all inherited members.
  • clip_bbox(const flyVector &min, const flyVector &max)
  • clone() [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • jumppad() [inline]
  • jumppad(const jumppad &in) [inline]
  • planes
  • sound
  • targetpos


Member List

jumppad_desc Member List

This is the complete list of members for jumppad_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

laser Member List

This is the complete list of members for laser, including all inherited members.
  • clone() [inline]
  • damage
  • draw()
  • exp
  • fire(flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0) [virtual]
  • fronttexture
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • gun_projectile() [inline]
  • gun_projectile(const gun_projectile &in) [inline]
  • hm
  • init()
  • l
  • laser() [inline]
  • laser(const laser &in) [inline]
  • numbounces
  • path
  • s
  • sfact
  • sidetexture
  • sizetexture
  • srfact
  • srvel
  • step(int dt)
  • ~gun_projectile() [inline, virtual]
  • ~laser() [inline, virtual]


Member List

laser_desc Member List

This is the complete list of members for laser_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

light Member List

This is the complete list of members for light, including all inherited members.
  • clone() [inline]
  • color
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • grow
  • illum_radius
  • light() [inline]
  • light(const light &in) [inline]
  • s
  • step(int dt)
  • ~light() [inline, virtual]


Member List

light_desc Member List

This is the complete list of members for light_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

menu_base Member List

This is the complete list of members for menu_base, including all inherited members.
  • add_group(const char *t)
  • draw()
  • draw_back(int x, int y, int sx, int sy, float f)
  • groups [private]
  • locked [private]
  • menu_base()
  • sel_group [private]
  • step(int dt)
  • visible [private]
  • ~menu_base() [virtual]


Member List

menu_button Member List

This is the complete list of members for menu_button, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • get_height() [inline, virtual]
  • get_width() [virtual]
  • menu_button(const char *label, void callback()) [inline]
  • menu_item() [inline]
  • on_select() [virtual]
  • step(int dt, int x, int y, int sx, int sy) [inline, virtual]
  • text
  • type
  • ~menu_button() [inline, virtual]
  • ~menu_item() [inline, virtual]


Member List

menu_checkbox Member List

This is the complete list of members for menu_checkbox, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • get_height() [inline, virtual]
  • get_width() [virtual]
  • menu_checkbox(const char *label, int *val) [inline]
  • menu_item() [inline]
  • on_select() [virtual]
  • step(int dt, int x, int y, int sx, int sy) [inline, virtual]
  • text
  • type
  • ~menu_checkbox() [inline, virtual]
  • ~menu_item() [inline, virtual]


Member List

menu_editinputmap Member List

This is the complete list of members for menu_editinputmap, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • editing
  • get_height() [inline, virtual]
  • get_width() [virtual]
  • menu_editinputmap(const char *label, int im, int tab=0) [inline]
  • menu_item() [inline]
  • on_select() [virtual]
  • step(int dt, int x, int y, int sx, int sy) [virtual]
  • tabwidth
  • text
  • type
  • ~menu_editinputmap() [inline, virtual]
  • ~menu_item() [inline, virtual]


Member List

menu_editoptionlist Member List

This is the complete list of members for menu_editoptionlist, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • editing
  • get_height() [inline, virtual]
  • get_width() [virtual]
  • menu_editoptionlist(const char *label, int num, char **names, int *val, int bias=0, void *callback=0) [inline]
  • menu_item() [inline]
  • num_options
  • on_select() [virtual]
  • onchange_callback
  • option_names
  • sel_option
  • step(int dt, int x, int y, int sx, int sy) [virtual]
  • text
  • type
  • val_bias
  • ~menu_editoptionlist() [inline, virtual]
  • ~menu_item() [inline, virtual]


Member List

menu_editstring Member List

This is the complete list of members for menu_editstring, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • get_height() [inline, virtual]
  • get_width() [virtual]
  • menu_editstring(const char *label, flyString *val) [inline]
  • menu_item() [inline]
  • on_select() [virtual]
  • step(int dt, int x, int y, int sx, int sy) [virtual]
  • text
  • type
  • ~menu_editstring() [inline, virtual]
  • ~menu_item() [inline, virtual]


Member List

menu_group Member List

This is the complete list of members for menu_group, including all inherited members.
  • add_item(menu_item *item) [inline]
  • draw(int x, int y)
  • factor
  • itens
  • menu_group()
  • sel_item
  • step(int dt, int x, int y)
  • text
  • visible
  • ~menu_group() [virtual]


Member List

menu_item Member List

This is the complete list of members for menu_item, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [inline, virtual]
  • get_height() [inline, virtual]
  • get_width() [inline, virtual]
  • menu_item() [inline]
  • on_select() [inline, virtual]
  • step(int dt, int x, int y, int sx, int sy) [inline, virtual]
  • text
  • type
  • ~menu_item() [inline, virtual]


Member List

menu_scrollbar Member List

This is the complete list of members for menu_scrollbar, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • get_height() [inline, virtual]
  • get_width() [inline, virtual]
  • menu_item() [inline]
  • menu_scrollbar(const char *label, int *val, int minvalue, int maxvalue, int modulo=0, int tab=0) [inline]
  • menu_scrollbar(const char *label, float *val, float minvalue, float maxvalue, float modulo=0, int tab=0) [inline]
  • on_select() [inline, virtual]
  • step(int dt, int x, int y, int sx, int sy) [virtual]
  • tabwidth
  • text
  • type
  • ~menu_item() [inline, virtual]
  • ~menu_scrollbar() [inline, virtual]


Member List

menu_separator Member List

This is the complete list of members for menu_separator, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • get_height() [inline, virtual]
  • get_width() [inline, virtual]
  • menu_item() [inline]
  • menu_separator() [inline]
  • on_select() [inline, virtual]
  • step(int dt, int x, int y, int sx, int sy) [inline, virtual]
  • text
  • type
  • ~menu_item() [inline, virtual]
  • ~menu_separator() [inline, virtual]


Member List

menu_showvalue Member List

This is the complete list of members for menu_showvalue, including all inherited members.
  • data
  • draw(int x, int y, int sx, int sy) [virtual]
  • get_height() [inline, virtual]
  • get_width() [virtual]
  • menu_item() [inline]
  • menu_showvalue(const char *label) [inline]
  • menu_showvalue(const char *label, int *val) [inline]
  • menu_showvalue(const char *label, float *val) [inline]
  • menu_showvalue(const char *label, flyVector *val) [inline]
  • menu_showvalue(const char *label, flyString *val) [inline]
  • menu_showvalue(const char *label, char *val) [inline]
  • on_select() [inline, virtual]
  • step(int dt, int x, int y, int sx, int sy) [inline, virtual]
  • text
  • type
  • ~menu_item() [inline, virtual]
  • ~menu_showvalue() [inline, virtual]


Member List

menucamera Member List

This is the complete list of members for menucamera, including all inherited members.
  • clone() [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • l
  • menucamera() [inline]
  • menucamera(const menucamera &in) [inline]
  • rotvel
  • sndchangesel
  • sndselect
  • step(int dt)
  • target
  • ~menucamera() [inline]


Member List

menucamera_desc Member List

This is the complete list of members for menucamera_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

menugroup Member List

This is the complete list of members for menugroup, including all inherited members.
  • clone() [inline]
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • height1
  • height2
  • init()
  • item
  • menugroup() [inline]
  • menugroup(const menugroup &in) [inline]
  • nitem
  • step(int dt)
  • wave_size
  • wave_speed
  • ~menugroup() [inline, virtual]


Member List

menugroup_desc Member List

This is the complete list of members for menugroup_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

menuitem Member List

This is the complete list of members for menuitem, including all inherited members.
  • clone() [inline]
  • color
  • command
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • mapbrowse
  • menuitem() [inline]
  • menuitem(const menuitem &in) [inline]
  • step(int dt)
  • texture
  • ~menuitem() [inline, virtual]


Member List

menuitem_desc Member List

This is the complete list of members for menuitem_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

mine Member List

This is the complete list of members for mine, including all inherited members.
  • clone() [inline]
  • damage
  • delay
  • draw()
  • exp
  • fire(flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0) [virtual]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • gun_projectile() [inline]
  • gun_projectile(const gun_projectile &in) [inline]
  • init()
  • l
  • lookrange
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • mine() [inline]
  • mine(const mine &in) [inline]
  • numbounces
  • objmesh
  • send_mine_data(int flag)
  • shield
  • snd_bounce
  • step(int dt)
  • turnvel
  • turretfireangle
  • turretgun
  • turretrange
  • ~gun_projectile() [inline, virtual]
  • ~mine() [inline, virtual]


Member List

mine_desc Member List

This is the complete list of members for mine_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

missile Member List

This is the complete list of members for missile, including all inherited members.
  • clone() [inline]
  • damage
  • draw()
  • exp
  • fire(flyVector &p, flyVector &dir, float v, int playerid, flyBspObject *o=0) [virtual]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • gun_projectile() [inline]
  • gun_projectile(const gun_projectile &in) [inline]
  • hm
  • init()
  • l
  • lightzpos
  • lookangle
  • lookdist
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • missile() [inline]
  • missile(const missile &in) [inline]
  • objmesh
  • path
  • rotvel
  • s
  • sfact
  • snd_travel
  • step(int dt)
  • turnvel
  • viewport
  • ~gun_projectile() [inline, virtual]
  • ~missile() [inline, virtual]


Member List

missile_desc Member List

This is the complete list of members for missile_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

observer Member List

This is the complete list of members for observer, including all inherited members.
  • check_keys(int dt)
  • clone() [inline]
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • init()
  • maxvel
  • mousevel
  • moveforce
  • observer() [inline]
  • observer(const observer &in) [inline]
  • radius
  • rotvel
  • step(int dt)
  • veldamp
  • ~observer() [inline, virtual]


Member List

observer_desc Member List

This is the complete list of members for observer_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

panorama Member List

This is the complete list of members for panorama, including all inherited members.
  • color
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • img
  • panorama() [inline]
  • size
  • ~panorama() [inline, virtual]


Member List

panorama_desc Member List

This is the complete list of members for panorama_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

particle_system Member List

This is the complete list of members for particle_system, including all inherited members.
  • ax
  • ay
  • clone() [inline]
  • draw()
  • drawflag
  • emmtime
  • fadetime
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • partbump
  • partcolflag
  • partcolor
  • partcolorvar
  • partfriction
  • particle_system() [inline]
  • particle_system(const particle_system &in) [inline]
  • partmass
  • partradius
  • partspeed
  • partspeedvar
  • step(int dt)
  • texture
  • totpart
  • ~particle_system() [virtual]


Member List

person Member List

This is the complete list of members for person, including all inherited members.
  • armor
  • calc_anim(const flyVector &walkvec, const flyVector &Z)
  • calc_anim_hit(const flyVector &dir, const flyVector &Z)
  • clone() [inline]
  • die(int killer, const flyVector &hitpos, int padindx)
  • die_person
  • do_input(int dt)
  • draw()
  • draw_shadow()
  • falldamagefactor
  • falldamagevel
  • g
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • getradius
  • headheight
  • health
  • height
  • init()
  • jumpheight
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • mousespeed
  • move(int dt)
  • mp_send_damage(int from, const flyVector &pushvec, float value)
  • mp_send_kill(int killer, int pad, const flyVector &hitpoint)
  • mp_send_pos(int msgtype, int msgflag)
  • person() [inline]
  • person(const person &in) [inline]
  • person_anim() [inline]
  • person_anim(const person_anim &in) [inline]
  • person_control() [inline]
  • person_control(const person_control &in) [inline]
  • person_move() [inline]
  • person_move(const person_move &in) [inline]
  • playermesh
  • playershadow
  • radius
  • rotvel
  • set_anim()
  • snd_change
  • snd_crater
  • snd_damage
  • snd_jump
  • snd_jumppad
  • snd_land
  • snd_noammo
  • snd_teleport
  • snd_wearoff
  • spot
  • step(int dt)
  • stepheight
  • stepmaxvel
  • walkvel
  • weaponmesh
  • zoomangle1
  • zoomangle2
  • zoomtime
  • ~person() [virtual]
  • ~person_anim() [inline, virtual]
  • ~person_control() [inline, virtual]
  • ~person_move() [inline, virtual]


Member List

person_anim Member List

This is the complete list of members for person_anim, including all inherited members.
  • calc_anim(const flyVector &walkvec, const flyVector &Z)
  • calc_anim_hit(const flyVector &dir, const flyVector &Z)
  • person_anim() [inline]
  • person_anim(const person_anim &in) [inline]
  • playermesh
  • set_anim()
  • weaponmesh
  • ~person_anim() [inline, virtual]


Member List

person_control Member List

This is the complete list of members for person_control, including all inherited members.
  • armor
  • falldamagefactor
  • falldamagevel
  • getradius
  • health
  • person_control() [inline]
  • person_control(const person_control &in) [inline]
  • zoomangle1
  • zoomangle2
  • zoomtime
  • ~person_control() [inline, virtual]


Member List

person_desc Member List

This is the complete list of members for person_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

person_move Member List

This is the complete list of members for person_move, including all inherited members.
  • headheight
  • height
  • jumpheight
  • mousespeed
  • person_move() [inline]
  • person_move(const person_move &in) [inline]
  • radius
  • rotvel
  • stepheight
  • stepmaxvel
  • walkvel
  • ~person_move() [inline, virtual]


Member List

portal Member List

This is the complete list of members for portal, including all inherited members.
  • clone() [inline]
  • color
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • height
  • init()
  • invert
  • maxviewdist
  • mode
  • nsegx
  • nsegy
  • portal() [inline]
  • portal(const portal &in) [inline]
  • post_step()
  • resolution
  • step(int dt)
  • width
  • ~portal() [inline, virtual]


Member List

portal_desc Member List

This is the complete list of members for portal_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

powerup Member List

This is the complete list of members for powerup, including all inherited members.
  • clone() [inline]
  • clone() [inline]
  • colorget
  • draw()
  • draw()
  • draw_shadow()
  • draw_shadow()
  • fadetime
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • gettime
  • init()
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • nsndget
  • objmesh
  • objmesh_box
  • objmesh_item
  • powerup() [inline]
  • powerup(const powerup &in) [inline]
  • powerup() [inline]
  • powerup(const powerup &in) [inline]
  • powerup_get(ship *p)
  • powerup_get(person *p)
  • sndget
  • sndspawn
  • spawntime
  • step(int dt)
  • step(int dt)
  • updowndist
  • updowntime
  • value
  • valuetype
  • veldamp
  • zrot_time


Member List

powerup_desc Member List

This is the complete list of members for powerup_desc, including all inherited members.
  • create() [inline]
  • create() [inline]
  • get_name() [inline]
  • get_name() [inline]
  • get_type() [inline]
  • get_type() [inline]


Member List

ps_desc Member List

This is the complete list of members for ps_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

robot Member List

This is the complete list of members for robot, including all inherited members.
  • clone() [inline]
  • draw()
  • draw_shadow()
  • e
  • explodedist
  • fireangle
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • gunrefreshtime
  • guns
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • movedist
  • movevel
  • objmesh
  • robot() [inline]
  • robot(const robot &in) [inline]
  • rotvel
  • shield
  • snd_travel
  • step(int dt)


Member List

robot_desc Member List

This is the complete list of members for robot_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

scene_light Member List

This is the complete list of members for scene_light, including all inherited members.
  • clone() [inline]
  • clone() [inline]
  • color
  • draw()
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • illumradius
  • init()
  • s
  • scene_light() [inline]
  • scene_light(const scene_light &in) [inline]
  • scene_light() [inline]
  • scene_light(const scene_light &in) [inline]
  • step(int dt)
  • step(int dt)
  • ~scene_light() [inline, virtual]
  • ~scene_light() [inline, virtual]


Member List

scene_light_desc Member List

This is the complete list of members for scene_light_desc, including all inherited members.
  • create() [inline]
  • create() [inline]
  • get_name() [inline]
  • get_name() [inline]
  • get_type() [inline]
  • get_type() [inline]


Member List

shadow Member List

This is the complete list of members for shadow, including all inherited members.
  • clone() [inline]
  • draw()
  • draw_simple_shadow()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • init()
  • reposition(flyBspObject *obj) [virtual]
  • shadow() [inline]
  • shadow(const shadow &in) [inline]
  • size
  • texture
  • ~shadow() [inline, virtual]


Member List

shadow_desc Member List

This is the complete list of members for shadow_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

ship Member List

This is the complete list of members for ship, including all inherited members.
  • abpath
  • angulardamp
  • angularmaxvel
  • bp
  • busypic
  • check_keys(int dt)
  • clone() [inline]
  • create_powerups(int flag)
  • die(int killer, const flyVector &hitpos, int padindx) [virtual]
  • draw()
  • draw_game_status()
  • draw_shadow()
  • drop_powerups()
  • enghalo
  • englight
  • engpos
  • exp
  • foeangle
  • forcefactor
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_foes()
  • get_mesh() [inline]
  • guns
  • init()
  • invensiblecolor
  • maxvel
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • mousespeed
  • move(int dt)
  • mp_send_damage(int from, const flyVector &pushvec, float value)
  • mp_send_kill(int killer, int pad, const flyVector &hitpoint)
  • mp_send_pos(int msgtype, int msgflag)
  • objmesh
  • panel
  • powerup_dropvel
  • powerup_gettime
  • powerup_veldamp
  • quadcolor
  • radius
  • reset()
  • shield
  • shieldcolor
  • shieldmesh
  • ship() [inline]
  • ship(const ship &in) [inline]
  • ship_control() [inline]
  • ship_control(const ship_control &in) [inline]
  • ship_draw() [inline]
  • ship_draw(const ship_draw &in) [inline]
  • ship_move() [inline]
  • ship_move(const ship_move &in) [inline]
  • snd_ab_loop
  • snd_ab_start
  • snd_damage
  • snd_noammo
  • snd_teleport
  • sort_players_by_score(int *a)
  • speedboost
  • spot
  • step(int dt)
  • veldamp
  • waittime
  • ~ship() [virtual]
  • ~ship_control() [inline, virtual]
  • ~ship_draw() [inline, virtual]
  • ~ship_move() [inline, virtual]


Member List

ship_control Member List

This is the complete list of members for ship_control, including all inherited members.
  • invensiblecolor
  • quadcolor
  • shield
  • shieldcolor
  • ship_control() [inline]
  • ship_control(const ship_control &in) [inline]
  • ~ship_control() [inline, virtual]


Member List

ship_desc Member List

This is the complete list of members for ship_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

ship_draw Member List

This is the complete list of members for ship_draw, including all inherited members.
  • enghalo
  • englight
  • engpos
  • objmesh
  • shieldmesh
  • ship_draw() [inline]
  • ship_draw(const ship_draw &in) [inline]
  • spot
  • ~ship_draw() [inline, virtual]


Member List

ship_move Member List

This is the complete list of members for ship_move, including all inherited members.
  • angulardamp
  • angularmaxvel
  • forcefactor
  • maxvel
  • mousespeed
  • move(int dt)
  • radius
  • ship_move() [inline]
  • ship_move(const ship_move &in) [inline]
  • speedboost
  • veldamp
  • ~ship_move() [inline, virtual]


Member List

sky Member List

This is the complete list of members for sky, including all inherited members.
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • objmesh
  • sky() [inline]
  • ~sky() [inline, virtual]


Member List

sky_desc Member List

This is the complete list of members for sky_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

sound Member List

This is the complete list of members for sound, including all inherited members.
  • add_sound_clone(flyVector *lock_pos, flyVector *lock_vel) [virtual]
  • add_sound_clone(flyVector *lock_pos, flyVector *lock_vel) [virtual]
  • clone() [inline]
  • clone() [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • loop
  • maxdist
  • mindist
  • play() [virtual]
  • play() [virtual]
  • snd
  • sound() [inline]
  • sound(const sound &in) [inline]
  • sound() [inline]
  • sound(const sound &in) [inline]
  • step(int dt)
  • step(int dt)
  • volume
  • ~sound() [inline, virtual]
  • ~sound() [inline, virtual]


Member List

sound_desc Member List

This is the complete list of members for sound_desc, including all inherited members.
  • create() [inline]
  • create() [inline]
  • get_name() [inline]
  • get_name() [inline]
  • get_type() [inline]
  • get_type() [inline]


Member List

spot_light Member List

This is the complete list of members for spot_light, including all inherited members.
  • clone() [inline]
  • color
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • l
  • maxdist
  • reposition(flyBspObject *obj) [virtual]
  • spot_light() [inline]
  • spot_light(const spot_light &in) [inline]
  • ~spot_light() [inline, virtual]


Member List

spot_light_desc Member List

This is the complete list of members for spot_light_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

sprite_light Member List

This is the complete list of members for sprite_light, including all inherited members.
  • clone() [inline]
  • color
  • draw()
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • grow
  • init()
  • mode
  • size
  • sprite_light() [inline]
  • sprite_light(const sprite_light &in) [inline]
  • step(int dt)
  • texture
  • ~sprite_light() [inline, virtual]


Member List

sprite_light_desc Member List

This is the complete list of members for sprite_light_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

teleport Member List

This is the complete list of members for teleport, including all inherited members.
  • clip_bbox(const flyVector &min, const flyVector &max)
  • clone() [inline]
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • planes
  • sound
  • targetangle
  • targetpos
  • teleport() [inline]
  • teleport(const teleport &in) [inline]


Member List

teleport_desc Member List

This is the complete list of members for teleport_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Member List

trigger Member List

This is the complete list of members for trigger, including all inherited members.
  • clone() [inline]
  • clone() [inline]
  • command
  • draw()
  • draw()
  • draw_shadow()
  • enabled
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • get_mesh() [inline]
  • get_mesh() [inline]
  • init()
  • init()
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • message(const flyVector &p, float rad, int msg, int param, void *data)
  • objmesh
  • objs
  • step(int dt)
  • step(int dt)
  • trigger() [inline]
  • trigger(const trigger &in) [inline]
  • trigger() [inline]
  • trigger(const trigger &in) [inline]
  • visible
  • ~trigger() [inline, virtual]
  • ~trigger() [inline, virtual]


Member List

trigger_desc Member List

This is the complete list of members for trigger_desc, including all inherited members.
  • create() [inline]
  • create() [inline]
  • get_name() [inline]
  • get_name() [inline]
  • get_type() [inline]
  • get_type() [inline]


Member List

viewport Member List

This is the complete list of members for viewport, including all inherited members.
  • dirflag
  • get_custom_param_desc(int i, flyParamDesc *pd)
  • key
  • sxf
  • syf
  • target
  • viewport() [inline]
  • xf
  • yf
  • ~viewport() [inline, virtual]


Member List

viewport_desc Member List

This is the complete list of members for viewport_desc, including all inherited members.
  • create() [inline]
  • get_name() [inline]
  • get_type() [inline]


Fly3D Standard Plugins Guide

Fly3D SDK 2.0 features various standard plugins that offer a great variety of classes, implementing useful entities and special effects that can be easily re-used in a new game or application. The goal of this guide is to discuss and exemplify the use of some of these plugins and classes, and to uncover some particularities of the classes. Examples on how the standard plugins can be linked to a new plugin or application are also provided.

It is important to notice that this guide focus on the programming tasks needed to deal with the covered classes. The objects' parameter values must be set in the flyEditor.exe program, and many of the examples featured in the pages below rely on the fact that these parameters are already assigned with a valid value.

These are the topics covered by this guide:

Linking a standard plugin to a new plugin or application
Lights on: using the 'light' class
How does it sound? Using the 'sound' class
Time to blow things up: using the 'explode' class
Leaving a trail behind: using the 'followpath' class
Target, aim, fire! Shooting with 'gun', 'gun_projectile' and its derived classes
A matter of points-of-view: using the 'viewport' class


Time to blow things up: using the 'explode' class

Explosions are an important visual effect in vehicle and shooting simulations. They are also a nice and discreet way of taking a destroyed entity away from the scene without making it simply vanish before the eyes of the player or spectator.

Fly3D standard plugin gamelib.dll provides the explode class, representing an explosion. Actually, the explode class is a repository for the explosion effects: it features a particle emitting system, a sound object, a light object, a sprite and a flyBspObject object that can animate and have shaders.

Using the explode class is very simple: firstly, a pointer to an object of that class must be declared in the new class' definition. See the example below:

#include "c:\fly3d\plugin\gamelib\explode.h"

class myclass : public flyBspObject
{
explode *e;

myclass();

int step(int dt);
};

Next, the step function must be used to set the explosion when the object's life reaches under 0. The explosion is set by calling the explode class virtual method do_explode. This method receives three parameters: a flyVector object containing the position of the explosion (typically, the same position of the exploding object), another flyVector object representing the direction of the explosion (typically the Z axis of the exploding object's local system) and an integer number as the index of the player that caused the explosion, used in multiplayer simulations and games (can be -1 for 'no player'). An excerpt exemplifying a call to do_explode is found below:

int myclass::step(int dt)
{
if(life<0)
e->do_explode(pos,Z,-1);

return 1;
}

The explode class does not implement a BSP active object at all; instead, when the do_explode method is called, the explosion objects are activated (the light, the sound, the particle system, etc.). The explode object itself never appears in the simulation, serving only for triggering the explosion effects.


Leaving a trail behind: using the 'followpath' class

The follow path is an astonishing effect that amplifies the feeling of rapid movement and adds dynamics to the simulation. It was used, for example, as a trail effect in the ship object's afterburner and in some of the ship's laser guns.

The gamelib.dll standard plugin includes the followpath class which implements the trail effect. It has member variables like a color, a texture to be applied on the trail, fade time, duration and delay between segments.

Using the followpath class in a custom class is simple. First of all, two pointers to followpath objects must be declared in the custom class definition: one to keep the original settings for the path and another to maintain the current path being used. An example of these declarations in a single class is as follows:

#include "c:\fly3d\plugin\gamelib\followpath.h"

class myclass : public flyBspObject
{
followpath *path, *cur_path;

myclass();

int step(int dt);
};

In the class' step function, the trail is put into action. Firstly, it is needed to check if the original path is valid and if it is to be placed in the simulation in the current frame (the current path pointer is null) or is already simulating (the current path pointer is valid). If it does not exist yet, the original path is cloned and the new object is assigned to the 'current path' pointer. The current path is then positioned and activated (being added to the BSP tree and the simulation). All of this is exemplified in the code excerpt below:

if(path)
if(cur_path==0)
{
cur_path=(followpath *)path->clone();
cur_path->pos=pos;
g_flyengine->activate(cur_path);
}

Next, it is needed to check if the elapsed time since the last path segment was released is above the followpath segment delay value: if it is so, a new segment must be added to the trail, the 'current path' variables must be updated; if not, the position of the current active segment must be updated with the new position of the carrier object (the one that is generating the trail). An example is as follows:

if(g_flyengine->cur_time-cur_path->last_time>cur_path->delay)
{
cur_path->last_time=g_flyengine->cur_time;
cur_path->time.add(g_flyengine->cur_time);
cur_path->path.add(pos);
}
else if(cur_path->path.num)
cur_path->path[cur_path->path.num-1]=pos;

Finally, the step function of the custom class, as a whole, should look like this:

int myclass::step(int dt)
{
if(path)
{
if(cur_path==0)
{
cur_path=(followpath
  *)path->clone();
cur_path->pos=pos;
g_flyengine->activate(cur_path);
}

if(g_flyengine->cur_time-cur_path->last_time>cur_path->delay)
{
cur_path->last_time=g_flyengine->cur_time;
cur_path->time.add(g_flyengine->cur_time);
cur_path->path.add(pos);
}
else if(cur_path->path.num)
cur_path->path[cur_path->path.num-1]=pos;
}

return 1;
}


Target, aim, fire! Shooting with 'gun', 'gun_projectile' and its derived classes

Fly3D provides a weapons standard plugin, weapon.dll, which consists of classes that implement guns and different types of projectiles. A new plugin or applcation might implement a class representing some kind of weapon-carrying entity, like a person or a war vehicle, and use the weapon.dll classes to add guns to these entities. It is also possible to create new types of projectiles, making a new projectile class derived from gun_projectile (a class from weapon.dll). The types of projectile implemented in the weapons plugin are laser, missile and mine.

Using the gun class in a custom plugin or application works as follows: a pointer to a gun object is added to the definition of the weapon-carrying entity class. See the example below:

#include "c:\fly3d\plugin\weapon\weapon.h"

class myclass : public flyBspObject
{
gun *g;

myclass();

int step(int dt);
}

Whenever the entity intends to fire, it must call the fire_status method of the gun object and test if the result is positive; a result of 0 means that the delay of fire has not been reached since the last time the gun was fired; a negative result means the gun is out of ammo.

Once the fire status for the gun has been checked, the fire method can be called. It expects two parameters: the first one is a pointer to the flyBspObject that is firing the gun (typically, the this pointer of the weapon-carrying entity); the second is an integer number representing the index of the player that is firing the gun, used in multiplayer simulations and games (can be -1 for 'no player'). Below is a piece of code showing the firing procedure for our simple class:

int myclass::step(int dt)
{
if(g && g->fire_status()>0)
g->fire(this,-1);
}

Creating a new kind of gun projectile is also simple: a new class must be created, deriving from the gun_projectile class found in weapon.dll. The class then must implement the virtual method fire, which returns a pointer to the activated projectile, and receives the following parameters: a flyVector object representing the initial position of the projectile; a normalized flyVector object representing the direction to which the projectile will move; a floating point value representing the initial velocity intensity of the projectile; an integer value representing the index of the player that is firing the projectile, used in multiplayer simulations and games (can be -1 for 'no player'); and a pointer to a flyBspObject object that represents the entity that is firing. An example class deriving from gun_projectile is given below:

#include "c:\fly3d\plugin\weapon\weapon.h"

class myotherclass : public gun_projectile
{
myotherclass();

flyBspObject *fire(flyVector& p,flyVector& dir,float
  v,int playerid,flyBspObject *o=0);
}

flyBspObject *myotherclass::fire(flyVector& p,flyVector& dir,float v,int
  playerid,flyBspObject *o)
{
myotherclass *copy=(myotherclass *)clone();
copy->pos=p;
copy->vel=dir*v;
copy->align_z(dir);
copy->player=playerid;
copy->owner=o;
g_flyengine->activate(copy);
return copy;
}


Lights on: using the 'light' class

Lights and lighting effects undoubtedly add depth and ambience to a graphic presentation. And it is often desired that an object has or deals with a light emmiter, be it a missile that carries a light spot or a lamp that illuminates a room.

Fly3D provides a pre-made class that allows an object to carry a light spot: the light class in the lights.dll standard plugin. It implements a basic light emmiting entity that draws itself and illuminates the space around it and inside its illumination radius. The light object can be of any color and can also have a halo texture.

Using the light class in a custom plugin or application is very simple: firstly, add a pointer to a light object in the desired class. Note that this light object is a stock object, not an active one. An example is given below:

#include "c:\fly3d\plugin\lights\lights.h"

class myclass : public flyBspObject
{
light *l;

myclass();

int step(int dt);
void draw();
};

Next, the step function of the class must be written as to position the light object, change its parameters if desired (maybe for making the light glow or change colors) and call the light object's step function, which will make it illuminate everything around it and in its radius. A simple example is shown below:

int myclass::step(int dt)
{
l->pos=pos;
l->step(dt);

return 1;
}

Finally, the draw function, which is called when the engine requires the object to draw itself, should reposition the light and re-set the parameters, calling the light object's draw function afterwards. This will make the light actually be seen on screen as a halo, if a texture is set to it. An example of a simple class' draw function is below:

void myclass::draw()
{
l->pos=pos;
l->draw();
}

An important note must be considered: since a pointer to a light object is added to the class as a member variable, all instances of the class will share the same light object. That is the reason why the light should be repositioned and re-set in the draw function: because the step function of all the objects are called by the engine before the draw function is called.


Linking a standard plugin to a new plugin or application

Fly3D Engine was designed in a way to make it as easiest as possible to extend its functionalities. Pratically speaking, this was achieved by making the engine fully plugin-oriented. A Fly3D plugin is built as a DLL and is linked to the engine. It must implement some DLL-exported functions that allow the engine to know what classes it implements. Pugin-building is explained in the Plugins section of Fly3D Engine Guide.

When developing a new plugin or application, it may be desired to use a class that is included in one of the standard plugins featured in the engine. For example: one certain class in the new plugin implements an object that carries a light spot. The light iteself does not need to be implemented, since the lights.dll plugin already has a class that implements a dynamic light. The new plugin just needs to be connected with the existing standard plugin, and the given class can add a member variable that is an instance of the light class.

The first step is to include the standard plugin's header file (.h) that contains the desired class in the new plugin or application's .h file. Some plugins, like lights.dll and viewport.dll, implement one or a few classes, and therefore have a single .h file; others, like gamelib.dll, implement several classes, each of them in a separate .h file. Anyway, the desired class' .h file must be recognized and included in the new plugin or application's .h file.

An important note must be added here about object types: Fly3D needs that an integer value is assigned to each class that will be present in the simulation, representing the type of any object that is an instance of the class. This is necessary for the engine to distinguish each object from others that are not like it, and to group objects of the same type so that the access to them in sequence is optimized. This charateristic brings up an important consequence: two different classes cannot have the same integer value for the type, or its objects would be mixed together and treated as if they were of the same class. Therefore, special care must be taken not to assign the same type number to two different classes that will have instances present in the simulation at the same time. All the standard plugins enumerate, on top of their main header file, the types that they use for their classes, and all other plugins should do the same, making it almost instantaneous to recognize the values used by that plugin.

Calling a method from a class that is inside another plugin DLL brings another important note: if the method is a virtual one, the new plugin (that calls it) should compile and link fine; however, if it is not virtual, the Library file (.lib) of the plugin containing the class whose method is called must be added to the caller plugin's project, or it will not link.


How does it sound? Using the 'sound' class

Sound plays a major role in adding depth and feeling to a simulation. Below are described the different methods of using the sound class provided in the Fly3D standard plugin called gamelib.dll.

First of all, a pointer to a sound object must be added to the class definition. It will point to a stock object that must be cloned and activated when the sound is to be played. An example in a simple class is below:

#include "c:\fly3d\plugin\gamelib\sound.h"

class myclass : public flyBspObject
{
sound *s;

myclass();
};

Playing the sound is as simple as a single function call: the add_sound_clone method provided by the sound class makes a copy of the original sound object and activates it, telling it to play immediately. The active sound object lives for the duration of the sound file (if not set to loop) or until some object deletes it (if set to loop). The add_sound_clone methods receives two pointers to floats as parameters: the first pointer must contain 3 floats representing the initial position of the sound; the second must contain other 3 floats representing the velocity with which the sound will move. If both pointers are set to 0, then the sound plays in 2D; if position is valid and velocity is 0, the sound plays in 3D but does not move; if both pointers are valid, the sound plays in 3D starting from the given position and moving with the given velocity. Below are examples of these 3 ways of calling the method:

s->add_sound_clone(0,0); //Play the sound in 2D

s->add_sound_clone(&pos.x,0); //Play the sound on the object's position

s->add_sound_clone(&pos.x,&vel.x); //Play the sound from the object's position, moving with the object's velocity

The third way of calling the add_sound_clone function obligates the sound to automatically reccalculate its position every frame until it finishes playing or is deleted. Therefore, the second pointer (the one representing velocity) must remain valid until the sound dies, for it will access it every frame.

Finally, if the object containing the sound has constant velocity, it can carry the sound along when moving. Simply set the sound to loop and call the add_sound_clone function passing the object's current position and velocity as parameters, and the sound will move exactly like the object. The only remark is that the object must delete the sound before dying.


A matter of points-of-view: using the 'viewport' class

A viewport is a window that renders the simulation viewed from a point diverse of the default camera view. It can be used as a rear view mirror in vehicle simulations or to render the view of any BSP object in a window on the screen.

The viewport.dll standard plugin provides the viewport class, which implements everything needed for using a viewport in a custom plugin or application. The class has member variables to store the relative position and size of the window inside the screen space, as well as a on/off flag.

Adding a viewport to a custom class is simple. Firstly, a pointer to a viewport object must be added to the class definition, like in the following example:

#include "c:\fly3d\plugin\viewport\viewport.h"

class myclass : public flyBspObject
{
viewport *vp;

myclass();

void init();
int step(int dt);
};

When the object is activated, its corresponding viewport must be initialized and set to render the view of the object; it must also be turned on. In this simple example, these tasks are performed in the custom class' init method, which is called by the engine when activating the object:

void myclass::init()
{
if(vp)
{
vp->target=this;
vp->on=1;
}
}

When the object is destroyed or dies, and has to be taken out of the simulation, it must first turn off its viewport instance. In this example, this is done in the custom class' step function:

int myclass::step(int dt)
{
if(life<0 && vp && vp->target==this)
{
vp->target=0;
vp->on=0;
}
}


Member List

flyAnimatedMesh Member List

This is the complete list of members for flyAnimatedMesh, including all inherited members.
  • animkeys
  • animkeyspos
  • animnames
  • bbox
  • color
  • compute_normals(int flag=7)
  • draw() [virtual]
  • draw_plain()
  • draw_shadow_volume(const flyVector &lightdir)
  • faces
  • flyAnimatedMesh()
  • flyAnimatedMesh(const flyAnimatedMesh &in)
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyMesh() [inline]
  • flyMesh(const flyMesh &in)
  • illum_faces(const flyVector &ip, float d_max, const flyVector &c, int shadows) const
  • key_verts
  • lastdraw
  • lastintesectedface
  • load(const char *file) [virtual]
  • localen
  • localfaces
  • localvert
  • long_name
  • name
  • nanims
  • nen
  • next_obj
  • nf
  • nkeys
  • nv
  • operator=(const flyAnimatedMesh &in)
  • flyMesh::operator=(const flyMesh &in)
  • flyBaseObject::operator=(const flyBaseObject &in)
  • pivotpos
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist)
  • reset(void) [virtual]
  • save(const char *file) const [virtual]
  • set_numen(int numen, int keep=0)
  • set_numfaces(int nfaces, int local, int keep=0)
  • set_numverts(int nverts, int keep=0)
  • set_state(int anim, int key)
  • set_state(int anim, float key_factor)
  • set_state(int anim1, float key_factor1, int anim2, float key_factor2, float blend)
  • set_state_blendcur(int anim, int key, float blend)
  • set_state_blendcur(int anim, float key_factor, float blend)
  • ~flyAnimatedMesh() [virtual]
  • ~flyBaseObject() [virtual]
  • ~flyMesh() [inline, virtual]


Member List

flyArray Member List

This is the complete list of members for flyArray, including all inherited members.
  • add(const T elem) [inline, virtual]
  • arraysize
  • buf
  • clear() [inline]
  • flyArray() [inline]
  • flyArray(const flyArray< T > &in) [inline]
  • free() [inline, virtual]
  • num
  • operator+=(flyArray< T > &in) [inline, virtual]
  • operator=(const flyArray< T > &in) [inline]
  • operator[](int i) const [inline]
  • operator[](int i) [inline]
  • remove(int i) [inline]
  • remove(int i, int n) [inline]
  • reserve(int n) [inline, virtual]
  • ~flyArray() [inline, virtual]


Member List

flyBaseObject Member List

This is the complete list of members for flyBaseObject, including all inherited members.
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • long_name
  • name
  • next_obj
  • operator=(const flyBaseObject &in)
  • ~flyBaseObject() [virtual]


Member List

flyBezierCurve Member List

This is the complete list of members for flyBezierCurve, including all inherited members.
  • adaptative_subdiv(float maxerror, float *points, int maxpoints) const
  • add_point(const float *f)
  • evaluate(float u, float *f) const
  • evaluate_tangent(float u, float *f) const
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyBezierCurve()
  • flyBezierCurve(const flyBezierCurve &in)
  • length() const
  • load_bez(const char *file)
  • long_name
  • name
  • nd
  • next_obj
  • np
  • ns
  • operator=(const flyBezierCurve &in)
  • flyBaseObject::operator=(const flyBaseObject &in)
  • p
  • pivot
  • reset()
  • set_dim(int ndim)
  • ~flyBaseObject() [virtual]
  • ~flyBezierCurve() [virtual]


Member List

flyBezierPatch Member List

This is the complete list of members for flyBezierPatch, including all inherited members.
  • build_cp(int nu, int nv, const flyVertex *v)
  • build_cp_loft(const flyBezierCurve *shape, const flyBezierCurve *path, float tileu, float tilev)
  • build_surface()
  • draw(int drawmode) const
  • dropu
  • dropu_inc
  • dropv
  • dropv_inc
  • evaluate(int evaltype, float u, float v, flyVector *dest) const
  • flyBezierPatch()
  • flyBezierPatch(const flyBezierPatch &in)
  • levelu
  • levelv
  • mode
  • np
  • npu
  • npv
  • nsu
  • nsv
  • numstrips
  • nvertu
  • nvertv
  • operator=(const flyBezierPatch &in)
  • p
  • reset()
  • set_detail(const flyVector &pos, const flyVector &campos)
  • surf
  • ~flyBezierPatch() [virtual]


Member List

flyBoundBox Member List

This is the complete list of members for flyBoundBox, including all inherited members.
  • add_point(const flyVector &p)
  • clip_bbox(const flyVector &bbmin, const flyVector &bbmax) const [inline]
  • collide(const flyVector &p, const flyVector &dir, float &len)
  • collide(flyMesh *mesh, const flyBoundBox &bbtemp, const flyVector &dir, float &len, flyVector &normal, flyVector &ip) const
  • collide(flyMesh *mesh, const flyVector &pos, const flyLocalSystem &ls, const flyBoundBox &bbtemp, const flyVector &dir, float &len, flyVector &normal, flyVector &ip) const
  • collide(const flyBoundBox &bbox, const flyVector &dir, float &len, flyVector &normal, flyVector &ip) const
  • draw() const
  • edge_collision(const flyVector &p1, const flyVector &p2, const flyVector &dir, const flyVector &p3, const flyVector &p4, float &dist, flyVector &ip) const
  • edgedir [static]
  • edgedirth [static]
  • edgefaces [static]
  • edgenorm [static]
  • edgevert [static]
  • facenorm [static]
  • facevert [static]
  • flyBoundBox() [inline]
  • flyBoundBox(const flyVector &min, const flyVector &max) [inline]
  • flyBoundBox(const flyBoundBox &in) [inline]
  • get_mesh() const
  • get_plane_dist(int ind) const [inline]
  • get_vert(int ind) const [inline]
  • is_inside(const flyVector &p) const [inline]
  • max
  • min
  • operator=(const flyBoundBox &in) [inline]
  • ray_intersect(const flyVector &ro, const flyVector &rd, float &tnear, float &tfar) const
  • reset() [inline]
  • vertnorm [static]


Member List

flyBspNode Member List

This is the complete list of members for flyBspNode, including all inherited members.
  • add_neighbor(const flyPolygon &p, flyBspNode *in)
  • centre
  • child
  • color
  • d0
  • distance(const flyVector &v) const [inline]
  • elem
  • flyBspNode()
  • flyBspNode(const flyBspNode &in)
  • flyPlane() [inline]
  • flyPlane(const flyVector &n, float dist) [inline]
  • flyPlane(const flyPlane &in) [inline]
  • leaf
  • neighbors
  • normal
  • operator=(const flyBspNode &in)
  • flyPlane::operator=(const flyPlane &in) [inline]
  • portals
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist)
  • ~flyBspNode() [virtual]


Member List

flyBspObject Member List

This is the complete list of members for flyBspObject, including all inherited members.
  • active
  • align_z(const flyVector &z)
  • bbox
  • box_collision(flyVector &destpos, flyVector &destvel, int maxcol=3)
  • bump
  • clipnodes
  • clone() [inline, virtual]
  • colflag
  • collide
  • compute_collision(flyVector &p, flyVector &v)
  • draw() [virtual]
  • draw_shadow() [inline, virtual]
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyBspObject()
  • flyBspObject(const flyBspObject &in)
  • flyLocalSystem() [inline]
  • flyLocalSystem(const flyLocalSystem &in) [inline]
  • flyParticle() [inline]
  • flyParticle(const flyParticle &in) [inline]
  • force
  • friction
  • get_custom_param_desc(int i, flyParamDesc *pd) [inline, virtual]
  • get_mesh() [inline, virtual]
  • get_param_desc(int i, flyParamDesc *pd)
  • id
  • init() [inline, virtual]
  • lastbsprecurse
  • lastdraw
  • latedraw
  • life
  • load_default_params(flyFile *file, const char *sec)
  • load_params(flyFile *file, const char *sec)
  • long_name
  • mass
  • mat
  • mat_t
  • message(const flyVector &p, float rad, int msg, int param, void *data) [inline, virtual]
  • name
  • next_obj
  • operator=(const flyBspObject &in)
  • flyBaseObject::operator=(const flyBaseObject &in)
  • flyParticle::operator=(const flyParticle &in) [inline]
  • flyLocalSystem::operator=(const flyLocalSystem &in) [inline]
  • pos
  • post_step() [inline, virtual]
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum) [virtual]
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist) [virtual]
  • remove_from_bsp()
  • rot
  • rotate(const flyVector &rot)
  • rotate(float ang, const flyVector &v)
  • rotate(const flyVector &v, const flyVector &u, float maxang=360)
  • source
  • step(int dt) [inline, virtual]
  • update_mat()
  • vel
  • X
  • Y
  • Z
  • ~flyBaseObject() [virtual]
  • ~flyBspObject() [virtual]
  • ~flyLocalSystem() [inline, virtual]
  • ~flyParticle() [inline, virtual]


Member List

flyClassDesc Member List

This is the complete list of members for flyClassDesc, including all inherited members.
  • create()=0 [pure virtual]
  • get_name()=0 [pure virtual]
  • get_type()=0 [pure virtual]
  • ~flyClassDesc() [inline, virtual]


Member List

flyConsole Member List

This is the complete list of members for flyConsole, including all inherited members.
  • add_string(const char *fmt,...)
  • buf
  • cmd_len
  • cmd_line
  • cmd_pos
  • command_exec(const char *str)
  • command_tokens(char *str, char **token) const
  • curr_line
  • curr_page
  • draw()
  • draw_text(float x, float y, const char *text) const
  • dx
  • dy
  • flyConsole()
  • hide()
  • key_char(int vk)
  • key_down(int vk)
  • lic
  • linecount
  • mode
  • nlines
  • show()
  • step(int dt)
  • time
  • winlines
  • ~flyConsole() [virtual]


Member List

flyDirectx Member List

This is the complete list of members for flyDirectx, including all inherited members.
  • add_player(const char *name, DWORD dpid, void *data, unsigned color=0xFF808080)
  • clone_sound(LPDIRECTSOUNDBUFFER buf)
  • create_game(LPGUID app_guid, const char *game_name)
  • enum_games(LPGUID app_guid)
  • flyDirectx(HWND hwnd, HINSTANCE hinst) [inline]
  • free_multiplayer()
  • get_input()
  • get_message(DWORD *size)
  • get_num_messages()
  • get_player_address(DWORD dpid)
  • guidInstance
  • hInst
  • hWnd
  • Init()
  • init_multiplayer(const char *netaddress=0)
  • join_game(LPGUID game_guid, const char *player_name, unsigned color=0xFF808080)
  • joy_axes
  • joy_caps
  • joy_dead_zone
  • joy_down
  • joy_max_range
  • joy_min_range
  • joy_pos
  • keys
  • load_wav_file(LONG cchBuffer, HPSTR pchBuffer, LPDIRECTSOUNDBUFFER *buf, LPDIRECTSOUND3DBUFFER *buf3d)
  • lpDI
  • lpDP
  • lpDPL
  • lpDS3dListener
  • lpDS3dPrimBuf
  • lpDSound
  • lpJoystick
  • lpJoystickPoll
  • lpKeyboard
  • lpMouse
  • lpSD
  • mouse_click
  • mouse_delta
  • mouse_down
  • mouse_pos
  • mouse_smooth
  • mpmode
  • nplayers
  • players
  • Release()
  • remove_player(int i)
  • s_invertjoyx [static]
  • s_invertjoyy [static]
  • s_invertmousex [static]
  • s_invertmousey [static]
  • s_joyspeed [static]
  • s_mousespeed [static]
  • send_message(const flyMPMsg *msg, int len, DWORD dpid=0)
  • set_listener(const float *pos, const float *vel, const float *Y, const float *Z)
  • set_master_volume(int volume)
  • zero_input()
  • ~flyDirectx() [inline, virtual]


Member List

flyDll Member List

This is the complete list of members for flyDll, including all inherited members.
  • dll_filename
  • fly_message
  • flyDll()
  • get_class_desc
  • get_global_param_desc
  • get_version
  • hdll
  • nclasses
  • num_classes
  • ~flyDll() [virtual]


Member List

flyDllGroup Member List

This is the complete list of members for flyDllGroup, including all inherited members.
  • add_class(const char *name)
  • add_dll(const char *filename)
  • cd
  • delete_class(flyBspObject *o)
  • delete_dll(const char *filename)
  • delete_references(flyBspObject *o)
  • dll
  • flyDllGroup()
  • load_all_classes(flyFile *file)
  • load_classes(int d, flyFile *file)
  • load_default_param(flyBspObject *o, const char *sec, flyFile *file)
  • load_params(int d, flyFile *file)
  • move_dll(const char *filename, int newrelpos)
  • ncd
  • ndll
  • reset()
  • send_message(int msg, int param, void *data) const
  • ~flyDllGroup() [virtual]


Member List

flyEngine Member List

This is the complete list of members for flyEngine, including all inherited members.
  • activate(flyBspObject *d)
  • active_objs
  • add_post_step(flyBspObject *o) [virtual]
  • add_to_bsp(flyBspObject *obj)
  • antialias
  • appid
  • bbox
  • bboxcenter
  • bboxdiag
  • bsp
  • bspfile
  • bsppicflipy
  • cam
  • cam_model_mat
  • cam_proj_mat
  • cam_viewport
  • check_input_map(int i, int clicked=0)
  • check_multiplayer()
  • close_fly_file()
  • close_multiplayer()
  • collision_bsp(const flyVector &p1, const flyVector &p2, int elemtype=0)
  • collision_test(const flyVector &p1, const flyVector &p2, int elemtype=0)
  • collisionmode
  • con
  • console_command
  • console_printf(const char *fmt,...)
  • crosshairpic
  • crosshairsize
  • cur_bsprecurse
  • cur_dt
  • cur_frame
  • cur_frame_base
  • cur_step
  • cur_step_base
  • cur_time
  • cur_time_float
  • curveerr
  • debug
  • demo_file_in
  • demo_file_out
  • dll
  • draw_bsp()
  • draw_faces(int nfd, flyFace **fd, flyVertex *v, int sort=1)
  • draw_frame()
  • dynlight
  • en
  • excludecollision
  • facechanged
  • facedraw
  • facedrawtransp
  • faces
  • filter
  • find_node(const flyVector &p) const
  • find_path(const flyVector &source, const flyVector &sourcedir, float sourceradius, const flyVector &dest, flyBezierCurve &curve)
  • flyEngine()
  • flyfile
  • flyfilename
  • flyfilepath
  • flysdkdatapath
  • flysdkpath
  • flysdkpluginpath
  • fm
  • fmbase
  • fmchanged
  • fmpic
  • fogmap
  • force_dt
  • fraglimit
  • frame_count
  • frame_rate
  • geomdetail
  • get_bezier_curve(const char *name)
  • get_global_param_desc0(int num, flyParamDesc *pd)
  • get_global_param_desc1(int i, flyParamDesc *pd)
  • get_global_param_desc2(int i, flyParamDesc *pd)
  • get_input_map(const char *name)
  • get_model_object(const char *name)
  • get_obj_param(const char *objname, const char *param, flyString &value) const
  • get_picture(const char *file, int droplevel=0)
  • get_sound_object(const char *name)
  • gravity
  • hinst
  • hitdist
  • hitface
  • hitip
  • hitmesh
  • hitnormal
  • hitobj
  • hitshader
  • hitsubface
  • hwnd
  • inputmaps
  • join_multiplayer(const char *addr, int num=0)
  • leaf
  • level_start_time
  • lm
  • lmbase
  • lmchanged
  • lmpic
  • load_default_tex(const char *path)
  • load_ini()
  • load_shaders(const char *file)
  • loading
  • lock_input(int free=0)
  • mastervolume
  • mouse
  • mpdelay
  • multitexture
  • mute
  • nen
  • nfaces
  • nleaf
  • nnodedraw
  • nodeonly
  • noinput
  • ntotelemdraw
  • ntotfacedraw
  • nvert
  • objdraw
  • octree
  • open_fly_file(const char *file)
  • picrender
  • play_demo(const char *file)
  • player
  • playercolor
  • playername
  • poststeps
  • process_multiplayer(int from, int size, const flyMPMsg *msg)
  • pvs
  • pvsoff
  • pvsrowsize
  • pvssize
  • record_demo(const char *file)
  • recurse_bsp(const flyVector &p, float rad, int elemtype, int pvsleaf=-1)
  • recurse_bsp(const flyVector &p1, const flyVector &p2, int elemtype, int pvsleaf=-1)
  • recurse_bsp(const flyVector *p, int np, int elemtype, int pvsleaf=-1)
  • recurse_bsp_box(const flyVector &min, const flyVector &max, int elemtype, int pvsleaf=-1)
  • resource_objs
  • restarttime
  • save_fly_file(const char *file)
  • save_ini()
  • selnodes
  • selobjs
  • send_bsp_message(const flyVector &p, float rad, int msg, int param, void *data, int elemtype=0, int pvsleaf=-1)
  • set_camera(flyBspObject *d)
  • set_global_param(const char *name, const char *value)
  • set_obj_param(const char *objname, const char *param, const char *value)
  • shadercolor
  • shadermask
  • shaders
  • shadowcolor
  • shadowdist
  • shadows
  • smooth_path(const flyArray< flyVector > &path, flyArray< flyVector > &newpath) [protected]
  • sse
  • start_time
  • status
  • status_msg
  • status_msg_time
  • step()
  • step(int dt)
  • step_end(int dt)
  • step_init(int dt)
  • step_objects(int dt)
  • stock_objs
  • T0
  • T1
  • timedemo
  • timedemoframes
  • timelimit
  • vert
  • vertprog
  • view
  • ~flyEngine() [virtual]


Member List

flyFace Member List

This is the complete list of members for flyFace, including all inherited members.
  • bbox
  • compute_normals(int flag)
  • d0
  • distance(const flyVector &v) const [inline]
  • en
  • facetype
  • flag
  • flyFace()
  • flyPlane() [inline]
  • flyPlane(const flyVector &n, float dist) [inline]
  • flyPlane(const flyPlane &in) [inline]
  • forward_map(float u, float v, flyVector &p) const
  • indx
  • inverse_map(const flyVector &p, float &u, float &v) const
  • lastbsprecurse
  • lastupdate
  • lm
  • normal
  • ntriface
  • ntrivert
  • nvert
  • octree
  • flyPlane::operator=(const flyPlane &in) [inline]
  • patch
  • patch_npu
  • patch_npv
  • pivot
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
  • flyPlane::ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist)
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist) const
  • ray_intersect_tri(int *facesindx, int facesnum, const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
  • ray_intersect_tri_test(int *facesindx, int facesnum, const flyVector &ro, const flyVector &rd, float dist) const
  • set_ntrivert(int n3v)
  • sh
  • sortkey
  • trivert
  • vert
  • vertindx
  • ~flyFace() [virtual]


Member List

flyFile Member List

This is the complete list of members for flyFile, including all inherited members.
  • buf
  • build_table()
  • build_ziplist(flyString path)
  • close()
  • flyFile()
  • get_float()
  • get_int()
  • get_profile_string(const char *section, const char *key, flyString &dest)
  • get_string(flyString &dest)
  • len
  • open(const char *filename)
  • pos
  • read(void *dest, int size)
  • seek(int offset)
  • table
  • unzip(const char *)
  • ziplist [static]
  • ~flyFile() [virtual]


Member List

flyFrustum Member List

This is the complete list of members for flyFrustum, including all inherited members.
  • bboxindx
  • build(const flyVector &pos, const flyVector &X, const flyVector &Y, const flyVector &Z, float camangle=flyRender::s_camangle, float aspect=flyRender::s_aspect, float farplane=flyRender::s_farplane)
  • clip_bbox(const flyBoundBox &bbox) const [inline]
  • draw() const
  • flyFrustum() [inline]
  • flyFrustum(const flyFrustum &in) [inline]
  • planes
  • verts
  • ~flyFrustum() [inline, virtual]


Member List

flyHashList Member List

This is the complete list of members for flyHashList, including all inherited members.
  • add(flyBaseObject *obj)
  • flyHashList()
  • get_next_object(const flyBaseObject *o, int type=0) const
  • get_object_longname(const char *long_name, int type=0) const
  • get_object_name(const char *name, int type=0) const
  • m_hash
  • m_last
  • m_list
  • remove(flyBaseObject *obj)
  • reset()
  • ~flyHashList() [virtual]


Member List

flyInputMap Member List

This is the complete list of members for flyInputMap, including all inherited members.
  • flyInputMap()
  • flyInputMap(const flyInputMap &in)
  • operator=(const flyInputMap &in)
  • ~flyInputMap() [virtual]


Member List

flyLightMap Member List

This is the complete list of members for flyLightMap, including all inherited members.
  • bmp
  • bytespixel
  • bytesx
  • bytesxy
  • d0
  • d1
  • d2
  • facenum
  • flyLightMap(int f, int p, int x, int y, int sx, int sy, int bp=3)
  • illum(const flyVector &pos, const flyVector &color, float radius, int shadows) [virtual]
  • lastupdate
  • load(const flyLightMapPic *lmp)
  • map_point(float u, float v, flyVector &point) const
  • map_point_local(float u, float v, flyVector &p, flyVector &n) const
  • offsetx
  • offsety
  • pic
  • save(flyLightMapPic *lmp) const
  • set_base(const flyFace *f, const flyLightMapPic *lmp, const flyVector &pos=flyVector(0, 0, 0))
  • sizex
  • sizey
  • ~flyLightMap() [virtual]


Member List

flyLightMapPic Member List

This is the complete list of members for flyLightMapPic, including all inherited members.
  • bmp
  • bytespixel
  • bytesx
  • bytesxy
  • flyLightMapPic(int sx, int sy, int bp=3)
  • sizex
  • sizey
  • ~flyLightMapPic() [virtual]


Member List

flyLightVertex Member List

This is the complete list of members for flyLightVertex, including all inherited members.
  • add_light(const flyVector &p, const flyVector &c, float r)
  • add_light(const flyVector &p, const flyVector &c, float r, const flyVector &objpos)
  • color
  • flyLightVertex()
  • flyLightVertex(const flyLightVertex &in)
  • frame
  • get_closest(const flyVector &p) const
  • init_draw(const flyBspObject *obj) const
  • nlights
  • operator=(const flyLightVertex &in)
  • pos
  • radius
  • ~flyLightVertex()


Member List

flyLocalSystem Member List

This is the complete list of members for flyLocalSystem, including all inherited members.
  • align_z(const flyVector &z)
  • flyLocalSystem() [inline]
  • flyLocalSystem(const flyLocalSystem &in) [inline]
  • mat
  • mat_t
  • operator=(const flyLocalSystem &in) [inline]
  • rotate(const flyVector &rot)
  • rotate(float ang, const flyVector &v)
  • rotate(const flyVector &v, const flyVector &u, float maxang=360)
  • update_mat()
  • X
  • Y
  • Z
  • ~flyLocalSystem() [inline, virtual]


Member List

flyMPGames Member List

This is the complete list of members for flyMPGames, including all inherited members.
  • flyMPGames() [inline]
  • guid
  • name
  • num
  • num_players


Member List

flyMPMsg Member List

This is the complete list of members for flyMPMsg, including all inherited members.
  • data
  • from
  • type


Member List

flyMPPlayerData Member List

This is the complete list of members for flyMPPlayerData, including all inherited members.
  • color
  • data
  • dpid
  • flyMPPlayerData() [inline]
  • name
  • type


Member List

flyMatrix Member List

This is the complete list of members for flyMatrix, including all inherited members.
  • flyMatrix() [inline]
  • flyMatrix(const flyMatrix &in) [inline]
  • lerp(const flyMatrix &m1, const flyMatrix &m2, float t)
  • load_identity(void) [inline]
  • m
  • null(void) [inline]
  • operator *(const flyMatrix &m1) const [inline]
  • operator=(const flyMatrix &in) [inline]
  • rotate(float ang, const flyVector &dir)
  • set_rotation(float ang, const flyVector &dir)


Member List

flyMesh Member List

This is the complete list of members for flyMesh, including all inherited members.
  • bbox
  • color
  • compute_normals(int flag=7)
  • draw() [virtual]
  • draw_plain()
  • draw_shadow_volume(const flyVector &lightdir)
  • faces
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyMesh() [inline]
  • flyMesh(const flyMesh &in)
  • illum_faces(const flyVector &ip, float d_max, const flyVector &c, int shadows) const
  • lastdraw
  • lastintesectedface
  • load(const char *file) [virtual]
  • localen
  • localfaces
  • localvert
  • long_name
  • name
  • nanims
  • nen
  • next_obj
  • nf
  • nv
  • operator=(const flyMesh &in)
  • flyBaseObject::operator=(const flyBaseObject &in)
  • pivotpos
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist)
  • reset() [virtual]
  • save(const char *file) const [virtual]
  • set_numen(int numen, int keep=0)
  • set_numfaces(int nfaces, int local, int keep=0)
  • set_numverts(int nverts, int keep=0)
  • ~flyBaseObject() [virtual]
  • ~flyMesh() [inline, virtual]


Member List

flyOcTree Member List

This is the complete list of members for flyOcTree, including all inherited members.
  • build_tree(flyFace *f)
  • draw()
  • face
  • flyOcTree()
  • flyOcTree(flyOcTree &in)
  • operator=(flyOcTree &in)
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist) const
  • reset()
  • root
  • ~flyOcTree() [virtual]


Member List

flyOcTreeNode Member List

This is the complete list of members for flyOcTreeNode, including all inherited members.
  • bbox
  • build_node(int *triverts, flyVertex *verts)
  • faces
  • flyOcTreeNode()
  • flyOcTreeNode(flyOcTreeNode &in)
  • nodes
  • ~flyOcTreeNode() [virtual]


Member List

flyParamDesc Member List

This is the complete list of members for flyParamDesc, including all inherited members.
  • data
  • get_string() const
  • name
  • set_string(const char *str)
  • type
  • ~flyParamDesc() [inline, virtual]


Member List

flyParticle Member List

This is the complete list of members for flyParticle, including all inherited members.
  • bump
  • colflag
  • compute_collision(flyVector &p, flyVector &v)
  • flyParticle() [inline]
  • flyParticle(const flyParticle &in) [inline]
  • force
  • friction
  • life
  • mass
  • operator=(const flyParticle &in) [inline]
  • pos
  • step(int dt)
  • vel
  • ~flyParticle() [inline, virtual]


Member List

flyPicture Member List

This is the complete list of members for flyPicture, including all inherited members.
  • buf
  • bytespixel
  • CheckSize(int maxlevel)
  • CreatePicture24(int xd, int yd)
  • CreatePicture32(int xd, int yd)
  • FlipY()
  • flyPicture() [inline]
  • flyPicture(flyPicture &in)
  • FreePicture(void)
  • LoadJPG(const unsigned char *data, int len, int flipy=0)
  • LoadTGA(const unsigned char *data, int len, int flipy=0)
  • name
  • operator=(const flyPicture &in)
  • SaveJPG(const char *file, int quality=85)
  • SaveJPG(FILE *fp, int quality=85)
  • SaveTGA(const char *file)
  • size
  • sx
  • sy
  • ~flyPicture() [inline, virtual]


Member List

flyPlane Member List

This is the complete list of members for flyPlane, including all inherited members.
  • d0
  • distance(const flyVector &v) const [inline]
  • flyPlane() [inline]
  • flyPlane(const flyVector &n, float dist) [inline]
  • flyPlane(const flyPlane &in) [inline]
  • normal
  • operator=(const flyPlane &in) [inline]
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist)


Member List

flyPolygon Member List

This is the complete list of members for flyPolygon, including all inherited members.
  • add(const flyVertex &v)
  • area()
  • build_edgeplanes()
  • build_normal()
  • build_quad(const flyVector &pos, const flyVector &x, const flyVector &y, const flyVector &z)
  • clear()
  • clip_edge(int i, const flyPlane &plane, flyVertex &v)
  • clip_plane(const flyPlane &plane)
  • d0
  • distance(const flyVector &v) const [inline]
  • draw()
  • edgeplanes
  • flyPlane() [inline]
  • flyPlane(const flyVector &n, float dist) [inline]
  • flyPlane(const flyPlane &in) [inline]
  • flyPolygon()
  • flyPolygon(const flyPolygon &in)
  • get_center() const
  • intersect(flyPolygon &in, flyPolygon &out)
  • normal
  • operator=(const flyPolygon &in)
  • flyPlane::operator=(const flyPlane &in) [inline]
  • order_verts()
  • random_point(flyVector &point, float threshold=0.1f)
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist)
  • verts
  • ~flyPolygon() [virtual]


Member List

flyQuaternion Member List

This is the complete list of members for flyQuaternion, including all inherited members.
  • cross(const flyVector &v1, const flyVector &v2) [inline]
  • distto(const flyVector &v) const [inline]
  • distto2(const flyVector &v) const [inline]
  • flyQuaternion(const flyQuaternion &in) [inline]
  • flyQuaternion() [inline]
  • flyQuaternion(const flyMatrix &mat)
  • flyQuaternion(float angle, const flyVector &axis) [inline]
  • flyVector() [inline]
  • flyVector(float f) [inline]
  • flyVector(const flyVector &v) [inline]
  • flyVector(float x0, float y0, float z0) [inline]
  • flyVector(float x0, float y0, float z0, float w0) [inline]
  • get_mat(flyMatrix &mat) const
  • get_rotate(float &angle, flyVector &axis) const
  • length(void) [inline]
  • length2(void) [inline]
  • lerp(const flyQuaternion &q1, const flyQuaternion &q2, float t)
  • negate(void) [inline]
  • normalize()
  • null(void) [inline]
  • operator *(const flyQuaternion &q)
  • operator+(const flyQuaternion &q)
  • operator-() const [inline]
  • operator=(const flyVector &in) [inline]
  • operator[](int i) [inline]
  • operator[](int i) const [inline]
  • vec(float f) [inline]
  • vec(float x0, float y0, float z0) [inline]
  • vec(float x0, float y0, float z0, float w0) [inline]
  • w
  • x
  • y
  • z


Member List

flyRender Member List

This is the complete list of members for flyRender, including all inherited members.
  • begin_draw()
  • begin_draw2d()
  • create()
  • destroy()
  • draw_progress(const char *text, int progress)
  • draw_text(int x, int y, const char *text, int size=16, int n=-1)
  • draw_text_center(int x, int y, const char *text, int size=16)
  • end_draw()
  • end_draw2d()
  • flyRender(HWND hWnd, HINSTANCE hInst) [inline]
  • get_text_size(const char *text, int size)
  • init()
  • m_accumbits
  • m_alphabits
  • m_colorbits
  • m_cursorx
  • m_cursory
  • m_curtime
  • m_depthbits
  • m_hdc
  • m_hinst
  • m_hrc
  • m_hwnd
  • m_numhwlights
  • m_numrendermodes
  • m_numtextureunits
  • m_numvideomodes
  • m_rendermodes
  • m_rendermodesindex
  • m_stencilbits
  • m_videomodes
  • m_winrect
  • resize(int sx, int sy)
  • s_ambient [static]
  • s_antialias [static]
  • s_aspect [static]
  • s_background [static]
  • s_brightness [static]
  • s_camangle [static]
  • s_clearbg [static]
  • s_consolepic [static]
  • s_farplane [static]
  • s_fog [static]
  • s_fontspic [static]
  • s_fontspiccharsize [static]
  • s_fontspicsize [static]
  • s_fontswidth [static]
  • s_fullscreen [static]
  • s_nearplane [static]
  • s_screensizex [static]
  • s_screensizey [static]
  • s_selrendermode [static]
  • s_selvideomode [static]
  • s_stencil [static]
  • s_texdroplevel [static]
  • s_videores [static]
  • s_wireframe [static]
  • set_full_screen()
  • ~flyRender() [inline, virtual]


Member List

flyShader Member List

This is the complete list of members for flyShader, including all inherited members.
  • color
  • flags
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyShader()
  • load(flyFile *fp, const char *section)
  • long_name
  • name
  • next_obj
  • npass
  • operator=(const flyBaseObject &in)
  • pass
  • restore_state()
  • save(const char *filename, int i) const
  • selfillum
  • set_state(int cp)
  • ~flyBaseObject() [virtual]
  • ~flyShader() [virtual]


Member List

flyShaderFunc Member List

This is the complete list of members for flyShaderFunc, including all inherited members.
  • args
  • eval() const
  • type


Member List

flyShaderPass Member List

This is the complete list of members for flyShaderPass, including all inherited members.
  • alphafunc
  • alphafuncref
  • anim_fps
  • anim_frames
  • anim_numframes
  • blenddst
  • blendsrc
  • depthfunc
  • flags
  • flyShaderPass()
  • load(flyFile *fp, const char *section, int i)
  • rgbgen
  • rgbgen_func
  • save(FILE *fp, int i) const
  • set_state_1(const flyVector &color)
  • set_state_2()
  • set_vp(const char *file)
  • tcmod
  • tcmod_rotate
  • tcmod_scale
  • tcmod_scroll
  • tcmod_stretch_func
  • tex
  • vp
  • vpfunc
  • vpid
  • ~flyShaderPass() [virtual]


Member List

flySkeletonMesh Member List

This is the complete list of members for flySkeletonMesh, including all inherited members.
  • animkeys
  • animkeyspos
  • animnames
  • bbox
  • bonenames
  • build_mesh()
  • color
  • compute_normals(int flag=7)
  • draw() [virtual]
  • draw_plain()
  • draw_shadow_volume(const flyVector &lightdir)
  • draw_skeleton() const
  • faces
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyMesh() [inline]
  • flyMesh(const flyMesh &in)
  • flySkeletonMesh() [inline]
  • flySkeletonMesh(const flySkeletonMesh &in)
  • get_bone(const char *name) const
  • get_key_factor(int anim, float &key_factor) [inline]
  • illum_faces(const flyVector &ip, float d_max, const flyVector &c, int shadows) const
  • lastdraw
  • lastintesectedface
  • load(const char *file) [virtual]
  • localen
  • localfaces
  • localvert
  • long_name
  • m
  • name
  • nanims
  • nbones
  • nen
  • next_obj
  • nf
  • nkeys
  • nv
  • nvweights
  • operator=(const flySkeletonMesh &in)
  • flyMesh::operator=(const flyMesh &in)
  • flyBaseObject::operator=(const flyBaseObject &in)
  • parent
  • pivotpos
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist) const
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist)
  • reset() [virtual]
  • root
  • save(const char *file) const [virtual]
  • set_numen(int numen, int keep=0)
  • set_numfaces(int nfaces, int local, int keep=0)
  • set_numverts(int nverts, int keep=0)
  • set_skeleton(int anim, int key)
  • set_skeleton(int anim, float key_factor)
  • set_skeleton(int anim1, float key_factor1, int anim2, float key_factor2, float blend)
  • tm
  • vindex
  • vweight
  • ~flyBaseObject() [virtual]
  • ~flyMesh() [inline, virtual]
  • ~flySkeletonMesh() [inline, virtual]


Member List

flySound Member List

This is the complete list of members for flySound, including all inherited members.
  • buf
  • buf3d
  • file_buf
  • file_buf2d
  • file_buf3d
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flySound()
  • free_sound_instance(int i)
  • get_sound_instace(int flag3d)
  • load_wav(const char *filename)
  • long_name
  • name
  • next_obj
  • operator=(const flyBaseObject &in)
  • reset()
  • total_time
  • ~flyBaseObject() [virtual]
  • ~flySound() [virtual]


Member List

flyStateMachine Member List

This is the complete list of members for flyStateMachine, including all inherited members.
  • flyStateMachine() [inline]
  • flyStateMachine(const flyStateMachine &in)
  • get_current_state() [inline]
  • load_behaviour(const char *filename)
  • nfactors [protected]
  • ninputs [protected]
  • nstates [protected]
  • rules [protected]
  • transition(int input, float *factors)


Member List

flyStateMachineRule Member List

This is the complete list of members for flyStateMachineRule, including all inherited members.
  • factorindex
  • negative_input
  • operator=(const flyStateMachineRule &in) [inline]
  • output
  • positive_input
  • state


Member List

flyStaticMesh Member List

This is the complete list of members for flyStaticMesh, including all inherited members.
  • active
  • align_z(const flyVector &z)
  • bbox
  • box_collision(flyVector &destpos, flyVector &destvel, int maxcol=3)
  • bump
  • clipnodes
  • clone() [inline, virtual]
  • colflag
  • collide
  • compute_collision(flyVector &p, flyVector &v)
  • draw() [virtual]
  • draw_shadow() [inline, virtual]
  • flyBaseObject()
  • flyBaseObject(const flyBaseObject &in)
  • flyBspObject()
  • flyBspObject(const flyBspObject &in)
  • flyLocalSystem() [inline]
  • flyLocalSystem(const flyLocalSystem &in) [inline]
  • flyParticle() [inline]
  • flyParticle(const flyParticle &in) [inline]
  • flyStaticMesh()
  • force
  • friction
  • get_custom_param_desc(int i, flyParamDesc *pd) [inline, virtual]
  • get_mesh() [inline, virtual]
  • get_param_desc(int i, flyParamDesc *pd)
  • id
  • init() [inline, virtual]
  • lastbsprecurse
  • lastdraw
  • latedraw
  • life
  • load_default_params(flyFile *file, const char *sec)
  • load_params(flyFile *file, const char *sec)
  • long_name
  • mass
  • mat
  • mat_t
  • message(const flyVector &p, float rad, int msg, int param, void *data) [virtual]
  • name
  • next_obj
  • objmesh
  • operator=(const flyBspObject &in)
  • flyBaseObject::operator=(const flyBaseObject &in)
  • flyParticle::operator=(const flyParticle &in) [inline]
  • flyLocalSystem::operator=(const flyLocalSystem &in) [inline]
  • pos
  • post_step() [inline, virtual]
  • ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum) const
  • flyBspObject::ray_intersect(const flyVector &ro, const flyVector &rd, flyVector &ip, float &dist, int &facenum) [virtual]
  • ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist) const
  • flyBspObject::ray_intersect_test(const flyVector &ro, const flyVector &rd, float dist) [virtual]
  • remove_from_bsp()
  • rot
  • rotate(const flyVector &rot)
  • rotate(float ang, const flyVector &v)
  • rotate(const flyVector &v, const flyVector &u, float maxang=360)
  • source
  • step(int dt) [inline, virtual]
  • update_mat()
  • vel
  • X
  • Y
  • Z
  • ~flyBaseObject() [virtual]
  • ~flyBspObject() [virtual]
  • ~flyLocalSystem() [inline, virtual]
  • ~flyParticle() [inline, virtual]
  • ~flyStaticMesh() [virtual]


Member List

flyString Member List

This is the complete list of members for flyString, including all inherited members.
  • compare(const char *str) const [inline]
  • compare(const char *str, int n) const [inline]
  • compare_nocase(const char *str) const [inline]
  • copy(const char *in, int p, int n)
  • crop_begin(int n) [inline]
  • find(const char *str) const [inline]
  • find(char c) const [inline]
  • find_reverse(char c) const [inline]
  • flyString()
  • flyString(const char *in)
  • flyString(const flyString &in)
  • flyString(const char *in, int p, int n)
  • format(const char *fmt,...)
  • left(int n) const
  • length() const [inline]
  • lower() [inline]
  • mid(int p, int n) const
  • operator const char *() const [inline]
  • operator+(const char *in)
  • operator+(const flyString &in)
  • operator+=(const char *in)
  • operator+=(const flyString &in)
  • operator=(const char *in)
  • operator=(const flyString &in)
  • operator==(const char *str) const [inline]
  • operator[](int i) const [inline]
  • right(int n) const
  • set_char(int i, char c) [inline]
  • upper() [inline]
  • ~flyString() [virtual]


Member List

flyTexCache Member List

This is the complete list of members for flyTexCache, including all inherited members.
  • add_tex(const char *name, int sx, int sy, int bytespixel, const unsigned char *buf, int flags)
  • add_tex(int np, flyPicture **pic, int flags)
  • add_tex(const char *name, flyVideo *video, int flags)
  • build_mipmaps(int pic, int sx, int sy, int bytespixel, const unsigned char *buf)
  • clear_tex_state()
  • curtex
  • curtexunit
  • find_tex(const char *file)
  • flyTexCache()
  • get_tex(int pic, unsigned char *buf)
  • ntex
  • reset()
  • s_texcompress [static]
  • s_texfilter [static]
  • s_texmipmap [static]
  • s_textruecolor [static]
  • sel_tex(int t) [inline]
  • sel_tex(int t, int u) [inline]
  • sel_unit(int u) [inline]
  • set_tex_flags()
  • tex
  • texinfo
  • update_subtex(int pic, int x, int y, int sx, int sy, int bytespixel, const unsigned char *buf)
  • update_tex(int pic, int sx, int sy, int bytespixel, const unsigned char *buf)
  • vid
  • ~flyTexCache()


Member List

flyVector Member List

This is the complete list of members for flyVector, including all inherited members.
  • cross(const flyVector &v1, const flyVector &v2) [inline]
  • distto(const flyVector &v) const [inline]
  • distto2(const flyVector &v) const [inline]
  • flyVector() [inline]
  • flyVector(float f) [inline]
  • flyVector(const flyVector &v) [inline]
  • flyVector(float x0, float y0, float z0) [inline]
  • flyVector(float x0, float y0, float z0, float w0) [inline]
  • length(void) [inline]
  • length2(void) [inline]
  • negate(void) [inline]
  • normalize(void) [inline]
  • null(void) [inline]
  • operator-() const [inline]
  • operator=(const flyVector &in) [inline]
  • operator[](int i) [inline]
  • operator[](int i) const [inline]
  • vec(float f) [inline]
  • vec(float x0, float y0, float z0) [inline]
  • vec(float x0, float y0, float z0, float w0) [inline]
  • w
  • x
  • y
  • z


Member List

flyVertex Member List

This is the complete list of members for flyVertex, including all inherited members.
  • color
  • color_static
  • cross(const flyVector &v1, const flyVector &v2) [inline]
  • distto(const flyVector &v) const [inline]
  • distto2(const flyVector &v) const [inline]
  • flyVector() [inline]
  • flyVector(float f) [inline]
  • flyVector(const flyVector &v) [inline]
  • flyVector(float x0, float y0, float z0) [inline]
  • flyVector(float x0, float y0, float z0, float w0) [inline]
  • flyVertex() [inline]
  • flyVertex(flyVector &p, flyVector &tx, flyVector &n, unsigned c) [inline]
  • flyVertex(const flyVertex &in) [inline]
  • length(void) [inline]
  • length2(void) [inline]
  • negate(void) [inline]
  • normal
  • normalize(void) [inline]
  • null(void) [inline]
  • operator-() const [inline]
  • operator=(const flyVertex &in) [inline]
  • flyVector::operator=(const flyVector &in) [inline]
  • operator[](int i) [inline]
  • operator[](int i) const [inline]
  • texcoord
  • vec(float f) [inline]
  • vec(float x0, float y0, float z0) [inline]
  • vec(float x0, float y0, float z0, float w0) [inline]
  • w
  • x
  • y
  • z


Member List

flyVideo Member List

This is the complete list of members for flyVideo, including all inherited members.
  • curframe
  • data
  • flyVideo()
  • frametime
  • height
  • load_avi(const char *file)
  • numframes
  • resolution
  • set_frame(int frame)
  • texture
  • update(int curtime)
  • width
  • ~flyVideo() [virtual]


Member List

flyTexInfo Member List

This is the complete list of members for flyTexInfo, including all inherited members.
  • bytespixel
  • flags
  • name
  • sx
  • sy