Sorry your browser is not supported!

  #define cnDefault_Display_Width 1024
  #define cnDefault_Display_Height 1024
  #define cnDefault_Display_Depth 1024

#ifdef USE_DARKPHYSICS
  #include <DarkPhysics.h>
#endif

  #define USE_DARKPHYSICS

  //#define USE_DARKPHYSICS

IGUIDevice* GUI = NewGUIDevice( );

IGUIButton* Button = GUI->NewButton( ITexture* regImg, ITexture* overImg );

Sprite->SetPosition( 100.0f, 100.0f );

vector2d SpritePos;
SpritePos.x = 100.0f, SpritePos.y = 100.0f;
Sprite->SetPosition( SpritePos );

Bitmap Background;
.
.
Background.Line (0, 0, 128, 256);

struct point {
   int x;
   int y;

   point (){x = y = 0;}
   point (int a, int b){
      x = a;
      y = b;
   }

point operator/ (int d){
   return point (x/d, y/d);
}
};

Bitmap Background;
point origin (0, 0);  // upper left bitmap corner
point bottomright (width-1, height-1);
point center;
center = bottomright/2;

Background.Line (origin, center);

class Sprite
{
private:
	int index;//the core sprite index
	int image;//the index of the image
	int ix, iy, ivelx, iscaleX, iscaleY, ialpha, itheta;//internal values used to poll for changes from external program
	int htx, hty;
	int istart, iend, idelay;//parameters for the animation
	bool visible;
	bool animated,following_trajectory;
	Trajectory t;
public:
	bool enabled;
	int x,y,velx,vely,scaleX,scaleY,alpha,theta;
	Sprite()
	{
		x=ix=y=iy=theta=itheta=0;
		scaleX=iscaleX=scaleY=iscaleY=alpha=ialpha=100;
		velx=vely=0;
		visible=true;
		animated=false;
		enabled=false;
		following_trajectory=false;
		t.speed=5;
	}
	void create(int image_)//create a sprite. index_ is the index of the sprite and image_ is the image it's created from
	{
		int i;
		for(i=3;dbSpriteExist(i);i++);
		image=image_;
		index=i;
		dbSprite(index,x,y,image);
		enabled=true;
	}
	void create(char *filename)
	{
		int i;
		for(i=3;dbImageExist(i);i++);
		dbLoadImage(filename, i);
		image=i;
		for(i=3;dbSpriteExist(i);i++);
		index=i;
		dbSprite(index,x,y,image);
		enabled=true;
	}

	void createAnimated(char *filename,int cx_,int cy_)
	{
		int i;
		for(i=3;dbImageExist(i);i++);
		dbLoadImage(filename, i);
		image=i;
		for(i=3;dbSpriteExist(i);i++);
		index=i;
		dbCreateAnimatedSprite(index,filename,cx_,cy_,index);
		animated=true;enabled=true;
	}	
	void setAnimation(int istart_,int iend_, int idelay_)
	{
		istart=istart_;
		iend=iend_;
		idelay=idelay_;
	}
	void hide()
	{
		if(visible)
			dbHideSprite(index);
		visible=false;
	}
	void show()
	{
		if(!visible)
			dbShowSprite(index);
		visible=true;
	}
	bool getVisibility()
	{
		return visible;
	}
	void addWayPoint(int cx_,int cy_)
	{
		following_trajectory=true;
		t.addWayPoint(cx_,cy_);
		t.x=x;
		t.y=y;
	}
	void update()
	{
		if((x!=ix)||(y!=iy))
		{
			ix=x;
			iy=y;//change the internal values to the new ones.
			dbSprite(index, x,y,image);
		}
		if((scaleX!=iscaleX)||(scaleY!=iscaleY))
		{
			iscaleX=scaleX;
			iscaleY=scaleY;//change the internal values to the new ones.
			dbStretchSprite(index, scaleX,scaleY);
		}
		if(alpha!=ialpha)
		{
			ialpha=alpha;
			dbSpriteAlpha(alpha);
		}
	}
	void handle()
	{
		if(following_trajectory)
		{
			//t.x=x;
			//t.y=y;
			following_trajectory=t.calculateNext();
			x=this->t.x;
			y=this->t.y;//get the new values for x and y using the trajectories
			
		}
		update();//first poll for updates.
		if(animated)
		{
			dbPlaySprite(index, istart,iend,idelay);
		}		
	}
	void deleteSprite()
	{
		enabled=false;
		dbDeleteSprite(index);
	}
};

#define USE_SPARKY

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
April 6, 2008 - author: Jason P Sage
==============================================================================

Best viewed with word wrap OFF if you insist on using note pad. May I 
recommend and alternate viewer if you are not using the VS2008 C++ built in 
editor? TERAEDIT from http://www.terasoft.ru/ru/pages/texteditor.phtml for 
english and/or russian languages. I use it ALL the time!

How to use this document: Each SECTION of this documentation has a header with
the characters:   ~!~

By searching for this character combination, you can jump to each section
quickly. 

NOTE: DarkGDK Memblock Commands do NOT SEEM TO WORK ON VISTA! 
      DarkGDK Bug I think. This API Developed and tested in WinXP Pro.

==============================================================================
~!~ WELCOME
==============================================================================
Greetings and Thank You for downloading the Jegas DarkGDK OOP wrapper. This
library was created to be useful to the author in the development of software
and its being shared so that other programmers can get a jump start with their
own projects, albeit to simply learn from, cut code from, or use as a complete 
system the way I do. (Jason P Sage of Jegas, LLC)

This library is a product of necessity that came about during the development 
of Iron Infantry. Note, that this version of the library includes a new file
named jgc_configuration.h that can be used to control certain "hardcoded" 
settings as well as compiler directives that control the library's 
dependancies such as: DarkPhysics, Sparkys Dll, and DarkAI. Even though there
isn't alot of support for these add-ons - any reference to DarkPhysics, for 
example, when you do not have or wish to use DarkPhysics can make applications
not compile. This has been remedied to allow more people to be able to use this 
library regardless of the add-ons they may or may not have or wish to use.

Note that this library is not done, and I do not have the desire nor 
wherewithall to turn this into a huge opensource project, with a regular code
tree - to track versions, various build etc. If you wish to contribute and 
fixed something, or improved upon it, send it to me in an email and describe 
what ya did - I'll certainly look into it and implement it if I thinks its 
worthy - but if I DON'T - don't sweat it - you can use this code for yourself!

==============================================================================
~!~ SOFTWARE, ACKNOWLEDGEMENTS, and LINKS
==============================================================================
-The Game Creators - aka TGC - http://www.thegamecreators.com 

-DarkGDK - C++ Game Development SDK - http://gdk.thegamecreators.com/

-Dark Physics - aka DP - http://darkphysics.thegamecreators.com/ 

-Paul Johnson's (Sparky's) Collision DLL - aka Sparky's: 
 http://forum.thegamecreators.com/?m=forum_view&t=74762&b=5

-Ageia PhysX - aka - http://www.ageia.com

==============================================================================
~!~ CONFIGURATION
==============================================================================
This library and solution comes tailored to run as is BUT does make some 
assumtions about your configuration. If you wish to use DarkPhysics, DarkAI,
or Sparky's DLL - Note that the way I configure my system is to place the 
include files for these addon's in the DarkGDK's include directory and like-
wise, the lib files I place in the same directory as the DarkGDK lib files.

Dark Physics relies on the Agiea PhysX support DLL's and I put these into the 
folder that contains the source files so that they are readily available to 
applications compiled in the GameClasses Solution or whatever. This is not
the most efficient way to do this, but assures proper functionality. The 
proper way to do this would be to have one set of these files in a directory
that was in your system's path so they can be loaded when needed, and easily
upgraded if you download and install a Ageia PhysX upgrade.

If your configuration get's totally hosed, I recommended you use the default
solution that came with this software as your "working" starting point. If you
follow these guidelines you SHOULD have no problem installing, running, 
compiling and utilizing this software.

==============================================================================
~!~ Test Applications
==============================================================================
There are various test applications provided with this release, and all have 
modified to work regardless if you open the jgc_configuration.h file and
change the file to enable or disable for the three addons this library has 
references to. Note: To date - the integration of these libraries is virtually
non-existant except:

The DarkPhysics class - is designed to update DarkPhysics in the main loop in
a manner described in the documentation from TGC as being more efficient.

Sparky's is used to generate Ground Height values in the jgc_meshv class and 
the jgc_meshj class via ray casting. The values used for these raycasts is in 
jgc_configuration.

The way that I test the application personally is:

1: Open the Jegas, LLC solution
2: Using the Solution Explorer, open the JegasLLC->GameClasses->Main Program
   folder. 
3: remove (DO NOT select option to REMOVE PERMANTLY/DELETE!!) the source file
4: In the removed source file's place, add existing item. All applications in 
   the gameclasses directory meant to be run etc. start their filenames test_
   like this filter: test_*.cpp 
5: Run the code and the compiler should compile and launch the application.

==============================================================================
~!~ TEST APPLICATIONS - Commentary
==============================================================================
NOTE: All testing for this release was without SPARKY'S and without physics 
      due to successful tests in the previous version with these options 
      (hardcoded) as enabled.


test_bitmapfonts.cpp - Literally the basic "HOW TO" use the jgc_bitmapfonts.* 
  files demo. 

test_frustrumculling_basic.cpp - This application shows the most basic form
  of frustrum culling as its name implies. You'll see some helis, and as you
  move around - watch the poly count raise and lower accordingly.

test_frustrumculling_lod_Sample1.cpp - just like the name says. This sample
  shows LOD in its simplest form.

test_frustrum_regions.cpp - This sample tests having different frustrum 
  culling regions, has LOD for trees and tanks - and shows off this library's
  integrated LOD and billboarding. 
  
test_frustrum_smartsetup.cpp - This demo isn't fully implemented with an
  example of what I consider SMART frustrum culling (This would be when you
  have multiple "Regions" And placing a static object alone would either find
  an appropriate region for frustrum culling the item based on its static 
  position or create a new region or something... I haven't implemented this
  type of object placement yet. However this is still a good example of using
  LOD, Billoarding, and region based frustrum culling to aid in processing 
  larger numbers of objects in a confinded area - (trees in this case). I 
  apologize for the trees being just a few inches above the ground LOL.
  
test_jgc_funstuff01_TreadMenu.cpp - this is a nice demo of my first TREAD 
  MENU for iron infantry. If the gfx look a bit squashed its because the 
  media has changed considerably during this project's life span.

test_jgc_funstuff02_TreadMenu.cpp - this shows of the very menu system 
  that WILL be in Iron Infantry! This also has a somewhat decent water
  shader and a decent jgc_vmesh (jgc_meshv.*) implementation.
  
test_jgc_gui.cpp - Not NEARLY ready for a release. This is a Work In Progress,
  and is slated as my test app while I develop my GUI. Currently its nothing
  more than a test app for some manipulation of sprites and using the
  JGC_FSFONTMAKER class to create a font bitmap for later loading. Just a test
  app.
  
test_jgc_meshj.cpp - Good Example of using the JGC_JMESH class.

test_jgc_meshj_gg.cpp - This version Allows you to toggle Green Gandalf's
 terrain shader. Note, only Normalization routine 1 (clear) and 4 
 (works but inverted normals ... kinda dark). Still shows how to use the 
 JGC_JMESH class though (jgc_meshj.*)
 
test_jgc_meshv.cpp  - Demonstration of JGC_VMESH (jgc_meshv.*)
test_jgc_meshv2.cpp - Nothing to fancy. Make sure to move the camera Up a 
  bit via the KEYPAD '*' key.
  
test_jgc_meshv3.cpp - Fledging Menu Test is what this one REALLY is, 
  of course it does use JGC_VMESH and have water.. just more about the menu.

test_jgc_meshv_bigterrain1.cpp - THIS ONE TAKES AWHILE TO LOAD!!!!
  But IMHO its worth it! This is fun to fly in. Remember, WASD and Mouse
  (and keypad) move ya, and holding SHIFT+WASD makes you go faster. Keypad 
  - try All keys (including the center KeyPad5 to zero out the camera 
  angles) I love this demo.
  
test_jgc_meshv_gg.cpp - This is a decent show of Green Gandalf's terrain
  shader as applied to JGC_VMESH.
  
test_jgc_sky.cpp - Decent example of the JGC_SKYDOME class in jgc_sky.*

test_jgc_sky2.cpp - More of the previous Sky testing.

test_jgc_terrain.cpp - Shows the DarkGDK advanced terrain in use as 
  implemented in the Jegas, LLC DarkGDK OPP Library.
  
test_jgc_vmesh_uv.cpp - this demo demonstrates the control you have over the 
  UV settings in a JGC_VMESH. Experiment, see how you can control texturing
  the JGC_VMESH. 
  
test_sparky.cpp - this application was made to demonstrate Sparky's DLL to
  someone on the forums and really doesn't belong in this library other to 
  serve as a working example of using Sparky's Collision. There is no sense
  trying to compile or run this application if you do not have Sparky's dll
  configured like I mentioned above in the configuration section.

==============================================================================
~!~ DOCUMENTATION PREFACE
==============================================================================
To start, this library is a moving target, and although I see the value in
"comments" driven help documentation and the like, I have not implemented 
such haneous lloking comments in my code for the sake of a documentation
utility being able to read my code. 

I personally use the source code as my reference, but you obviously will 
flounder about if you don't know where to look for certain things. To help you,
I am going to document the nature and purpose of each of the source files as 
they sit in this release so you know where to look for certain things.

==============================================================================
~!~ DOCUMENTATION Library Design Considerations
==============================================================================
Still being new to C++ at the time of writing this and having success 
regardless, there are somethings that I wrote from scratch that are available
already that I did not utilize: template classes, use of the string datatype,
use of the STDLIB for linked lists, dynamic arrays via the stdlib vector 
classes.

Additionally, DarkGDK is comprised of various types of "things" that each
follow their own rules for how thier ID's need to be created, or limited to
certain values etc. I could have rolled these into a base class but instead 
chose to code their ID generators similiarly, but individually for each.

In short - I have the right to code however I wish, but because I deviated 
from what many rightly would argue isn't mainstream - I mention it for 
thoroughness. I found my own string and dynamic double linked lists and 


The flipside to all this is that the classes herein are for the most part 
self contained and integrated with each other. There are only two visible
"projects" in the Jegas, LLC solution - FOUNDATION CLASSES and GAMECLASSES.

The foundation classes project consists of the following files:

==============================================================================
~!~ FOUNDATION CLASSES - jfc_ar.h and jfc_ar.cpp 
==============================================================================
These files make up a dynamic array class that is used heavily in this 
library. It currently only supports one datatype and I have plans to turn this 
into a template class so more datatypes are supported. I leverage this class 
as it stands now easily because the float datatype is 32bits wide like a 
pointer, and an int data type. Therefore, I can and do use this simple class 
for having arrays of:  pointers, classes, functions, floats, strings, etc. 
Type casting is my friend! :) Additionally by having an instance 
of this class contain instances to this class... you can effectively emulate
multidimentional arrays that you can delete and insert entire "rows" easily.

==============================================================================
~!~ FOUNDATION CLASSES - jfc_common.h and jfc_common.cpp
==============================================================================
NOTE: NOT to be confused with the jgc_common.* files!!!

The files contain a few notable functions and definitions for conversions
a metric meter is defined as ONE (1) while the derfinitions (except perhaps 
some related to time) are based on this 1 Meter value for comparision.

IMPORTANT: These files create a NAMESPACE named: JFC which needs to be either
fully qualified or utilized via the "using namespace" C++ keywords. 
Example: int MyInt = JFC::ABS(i);


IMPORTANT 2: there is a 1024byte char buffer in the JFC namespace that was 
placed there so you could readily have a char buffer anywhere in your 
application without neededin to declare you own. Considered a wise form of
recycling, try to get into the habit of using it where applicable.
Example: 
            sprintf(JFC::CHAR1K, "Screen FPS: %i",dbScreenFPS());
            dbPrint(JFC::CHAR1K);

Functions to note: 

ABS(int or float) - These functions are identical to the DarkGDK dbABS() 
                    function with the exception that they are type based, and 
                    designed to perform faster than the stock function by 
                    having tYPE based versions of the function: Int or Float.
                    
Interpolate(float x0, float x1, float x , float y0, float y1) - 
  This is a LERP function. 
  This Function Interpolates Linear Data to numerically
  "Guess" what the missing data is.
  The Formula Semantics are to Find "Y", but by swapping the parameters
  you can find Your own "X" just as easily.
  
 y1|-------------O   In The Diagram we know everything except y
   |             |   e.g. y1, y0, x0, x1, x WE KNOW THEM ALL
 y |      x,y    |        y = ????? 
   |        ^    |
 y0|---O    |    |
   |___|____|____|
      x0    x   x1 



The following conversion functions SHOULD be fairly intutive.
Remember to use the JFC namespace to get to these functions after
including the jfc_common.h file into your project source code file.
 
Convert_Meters_To_Millimeters(float p_Meters);
Convert_Meters_To_Centimeters(float p_Meters);
Convert_Meters_To_Feet(float p_Meters);
Convert_Meters_To_Yards(float p_Meters);
Convert_Meters_To_Miles(float p_Meters);
Convert_Meters_To_Inches(float p_Meters);
Convert_Meters_To_Kilometers(float p_Meters);
Convert_Millimeters_To_Meters(float p_Millimeters);
Convert_Centimeters_To_Meters(float p_Centimeters);
Convert_Feet_To_Meters(float p_Feet);
Convert_Yards_To_Meters(float p_Yards);
Convert_Miles_To_Meters(float p_Miles);
Convert_Inches_To_Meters(float p_Inches);
Convert_Kilometers_To_Meters(float p_Kilometers);
Convert_Seconds_To_MilliSeconds(float p_Seconds);
Convert_Seconds_To_Minutes(float p_Seconds);
Convert_Seconds_To_Hours(float p_Seconds);
Convert_Seconds_To_Days(float p_Seconds);
Convert_Milliseconds_To_Seconds(float p_Milliseconds);
Convert_Milliseconds_To_Minutes(float p_Milliseconds);
Convert_Milliseconds_To_Hours(float p_Milliseconds);
Convert_Minutes_To_Seconds(float p_Minutes);
Convert_Hours_To_Seconds(float p_Hours);
Convert_Days_To_Hours(float p_Days);
                    


==============================================================================
~!~ FOUNDATION CLASSES - jfc_dl.h and jfc_dl.cpp
==============================================================================
Dynamic double Linked List Class. This class is both complex and simple to 
use. It's not template driven and probably should be. Set up is not intuitive 
if you wish to make your own "children" of this class pair.

The class pair is simple enough: 

JFC_DLITEM is the class to represent ONE item in the JFC_DL class which 
maintains a unlimited double linked list of JFC_DLITEM's. 

STRENGTHES: search functions, Database like commands such as: AppendItem,
MoveFirst, MoveLast, MovePrevious, MoveNext as well the fact that this
class pair simply has a lot of integrated functionality so even in its stock 
form it can be used for MANY things.

WEAKNESSES: because this class pair is not template based, and the BASE DLITEM 
comes with a few variables out the box - it's not the most memory efficient 
tool if you only wanted a double linked list of integers for example.



==============================================================================
~!~ FOUNDATION CLASSES - jfc_string.h and jfc_string.cpp
==============================================================================
This class (JFC_STRING) was written out of the typical C++ newbie frustration
with manipulating strings. I was also still learning the language so I wrote
a lowlevel string class that worked at the lowest level I could without 
spending to much time on it. Its not mainstream - as there is a string 
datatype I believe that is part of the STDLIB for C++.

STRENGTHES - EASY to USE, Small, lean, fairly fast, battle tested! (If you can 
             optimize it without breaking it the apps that rely on its current 
             calling conventions, let me know, I'll probably implement your 
             changes!)
           
WEAKNESSES - Not Mainstream STDLIB usage, no overloaded operators.

 

==============================================================================
~!~ GAMECLASSES - Overview
==============================================================================
The GAMECLASSES consist mostly of wrappers for the DarkGDK "things" as well as
higher functionality classes that utilize these base "thing" classes. An 
example to illustrate this point is that there is a class for DarkGDK images,
DarkGDK mesh, and DarkGDK Memblocks while the JGC_JMESH (jgc_meshj.*) and 
JGC_VMESH (jgc_meshv.*) classes utilize these base classes to offer a simpler 
way to create terrain and other custom mesh objects that maybe you don't want
to use a DarkGDK MATRIX to create.

To make these classes work as a unified "SYSTEM" or ENGINE, many of the base
classes (and descendants of the JFC_AR Foundation Class for Dynamic Arrays) 
are included in a namespace called the JGC namespace (see JGC_COMMON.*).

There is a class named affectionately the "Daddy" class (jgc_daddy.*) that
handles bringing the system "alive", Updating the system in your main loop,
and cleanly shutting the system down.

In order to be able to document this code enough where I feel it can be
released this weekend, I am going to be brief as regards per class 
documentation, however I try to habitually document the source code.

Before I do - I need to explain the premise of how the base classes that wrap 
the various DarkGDK "things" work. GENERALLY - when you instantiate these base
classes - you can either pass ZERO parameters, and a DarkGDK ID for that type 
of "thing" is created for you, or you can pass your OWN DarkGDK ID and the 
class will use the ID you supplied versus trying to create one for you. 
Additionally, when you create an instance of these base classes - regardless 
if you pass your own DarkGDK ID or let the class create one for you, nothing
is created in DarkGDK. you literally are instantiating a "shell" that in most
cases you can create, load, Delete (a method, not the destructor) etc at will. 

Destructors (destroying these classes) usually, if the DarkGDK thing "exists" 
with the ID in the class, that object is deleted. It makes sense that a 
mechanism could be added to prevent this - but to date for myself, I've not 
needed such a mechanism in practice. However the flexible nature of the class
instantiation and the ability to use the same class for various DarkGDK
"things" - creating and deleting them with one class instantiation and recycling 
a given DarkGDK ID has been invaluable!

Note, many of the BASE gameclasses have a associated ARRAY class that is used 
to manage multiple instantces of whatever "thing" they are modelled after. 
These are important class to consider because - the JGC_LIGHTARRAY class for 
example has functions that are germain to ALL lights at once for instance.

==============================================================================
~!~ GAMECLASSES - Base GAMECLASSES
==============================================================================
JGC_BITMAP - for DarkGDK bitmaps.
JGC_BITMAPARRAY - For multiple instances of JGC_BITMAP.
JGC_CAMERA - for DarkGDK Cameras. (JGC::Cam0 is the default camera if you use
             the JGC_DADDY class to manage your program.)
JGC_CAMERARRAY - for multiple instances of JGC_CAMERA and some functions that 
                 apply to all CAMERAS (Example - Backdrop and AutoCam)             
JGC_EFFECT - Wrapper for maintaining Effects (aka Shaders)      
JGC_EFFECTARRAY - For multiple instances of JGC_EFFECT
JGC_IMAGE - Wrapper for DarkGDK images.
JGC_LIGHT - Wrapper for DarkGDK lights. 
JGC_LIGHTARRAY - For multiple instances of JGC_LIGHT, note some functions in this
                 class apply to ALL LIGHTS (JGC_LIGHT instances or lights 
                 in general.).
JGC_MATRIX - Wrapper for DarkGDK Matrices. 
JGC_MATRIXARRAY - For multiple instances of JGC_MATRIX.
JGC_MEMBLOCK - Wrapper for DarkGDK Memblocks
JGC_MEMBLOCKARRAY - For multiple instances of JGC_MEMBLOCK.
JGC_MESH - Wrapper for DarkGDK Meshes
JGC_MESHARRAY - For multiple instances of JGC_MESH.
JGC_MUSIC - Wrapper for DarkGDK music
JGC_MUSICARRAY - For Multiple instances of JGC_MUSIC
JGC_OBJECT - Wrapper for DarkGDK objects. Definately the most elaborate of the 
             wrappers.
JGC_OBJECTARRAY - For multiple instances of JGC_OBJECT.
JGC_SOUND - wrapper for DarkGDK sounds.
JGC_SOUNDARRAY - for multiple instances of JGC_OBJECT
JGC_SPRITE - Wrapper for DarkGDK Sprites.
JGC_SPRITEARRAY - for multiple JGC_SPRITE
JGC_TERRAIN - Wrapper for DarkGDK (advanced) terrain.
JGC_TERRAINARRAY - For multiple JGC_TERRAIN instances.
JGC_VECTOR - Wrapper for DarkGDK Vectors (aka 3DMaths)
JGC_VECTORARRAY - for multiple instances of JGC_VECTOR


==============================================================================
~!~ GAMECLASSES - Complimentary GAMECLASSES and source files.
==============================================================================
JGC_CLOCK - This is not Directly related to DarkGDK "things" but utilizes the
            DarkGDK dbTimer() function and is one of the classes that is 
            instantiated and updated by the JGC_DADDY class(jgc_daddy.*).
            It provides both a integer of time elapsed and a float vaersion
            to prevent implementations from losing clock cycles by constantly
            converting the typical int to a float for math where floats are 
            used in math.

(jgc_common.*)
JGC Namespace - Instantiated by the JGC_DADDY class when init is called, this
                namespace is the glue for the "System" this library attempts 
                to become... your system with a ton of tools available to 
                you ready to go! (see jgc_daddy.*)

(jgc_common.*)
Miscellaeous - this file pair contains various constant declarations such as:
               Keyscan codes for use with the DarkGDK "dbKeyState(KeyScanCode)"
               function, Collision types for Sparky's, missing DarkGDK
               GetMatrix4Element function (by LIT), also a SetMatrixElement
               function and 3 variety of Distance function for use with 
               3d "How far is this from that" sort of programming logic. 
                

(jgc_configuration.h) - this file has various configuration (hardcoded values) 
    and compiler directives to tell the library how to compile and default 
    values to use etc.
    


JGC_CULLNODE - (jgc_frustrumculling.*) Part of the frustrum culling system.
                an individual node - can be a "parent" to other nodes, and/or
                a GROUP of Objects to be managed like ONE OBJECT, there are 
                different kinds of Cull nodes, and routines to make creating 
                them fairly simple. These work in conjunction with JGC_CULL.

JGC_CULL - (jgc_frustrumculling.*) this is the main class for controlling and
           manipulating the FRUSTRUM CULLING system based on the DarkBasic 
           Limb Frustrum culling port by LOST IN THOUGHT (aka LIT). Converted, 
           implemented and enhanced for DarkGDK by yours Truly, Jason P Sage 
           of Jegas,LLC.

(jgc_daddy.*)
JGC_DADDY - This class doesn't look like to much at first glance but this
            class is the glue that holds this entire system together. It really
            can be summarized as the class you reference to START and STOP
            this Jegas DarkGDK OOP wrapper, as well as update in your main loop
            so things like the default (all you need really) JGC_CLOCK gets
            updated as well as the DarkPhysics physics engine if you are using 
            it. Note instantiating the JGC_DADDY class alone doesn't start 
            things. The reason is so you can override various default values 
            before calling the Init function which then uses the default
            values in the initialization process.

(jgc_darkphysics.*)
JGC_DARKPHYSICS - Its ok to use this class with or without DarkPhysics. Its 
                  designed to set up a heartbeat timer for calling DarkPhysics 
                  and is called internally by the JGC_DADDY class during 
                  JGC_DADDY Update method in your main loop. I have plans to 
                  expand on this and add functionality (wrapper stuff) to 
                  DarkPhysics in this class where appropriate (if appropriate).

JGC_DISPLAY - Simple wrapper for controlling the display and is instantiated 
            by the JGC_DADDY Class.

JGC_FILE - Wrapper for basic file functions. Note: This class has a debug 
           implementation of EVERY DarkGDK "checkList" and the code dumps
           the results to a text file. Look at the class, its easy to 
           use and great for a number of reasons. I still want to implement 
           a generic logging system that can be selectively compiled into 
           release builds or not, but haven't had time as yet.

(JGC_FUNSTUFF Files) - (jgc_funstuff.*) This is a work in progress, more 
               appropriately, it is a place I put functions and things that 
               just don't really deserve their own set of files (YET anyways)
               ... for example, I made a special menu system for my own uses 
               that you are welcome to play with - however I reserve the right
               to use in Iron Infantry and anything else - however - if you 
               have fun getting it working and using it, go for it! I think 
               the name of this says file pair says it all.

JGC_FS2DLINES - (jgc_funstuff.*) This is a class designed for development - it
                draws four lines on the screen and allows you to move them 
                with the function keys and it reports the coordinates on the 
                screen so that you can locate mouse click regions are anything 
                else. Inspect the class to see how the keyboard works with it.

JGC_FSFONTMAKER - (jgc_funstuff.*) This is actually a utility that takes a 
                  System font, positions it on the screen and captures a 
                  image that can be used for bitmap fonts. the class then
                  saves the image for future use in games or what have you.
                  Such a bitmap font system is included in this library.
                  (No Anti-Aliased Fonts at this time.)

JGC_FSMENU01ITEM - (jgc_funstuff.*) (Child class of JGC_DLITEM) An individual 
                   menu item in my JGC_FSMENU01 Class.

JGC_FSMENU01DL - (jgc_funstuff.*) (Child class of JFC_DL) - Double Linked List 
                 class designed to create, use, manipulate the JGC_FSMENU01 
                 menu "system".

JGC_FSMENU02ITEM - (jgc_funstuff.*) (Child class of JGC_DLITEM) An individual 
                   menu item in my JGC_FSMENU02 Class.

JGC_FSMENU02DL - (jgc_funstuff.*) (Child class of JFC_DL) - Double Linked List 
                 class designed to create, use, manipulate the JGC_FSMENU02 
                 menu "system".
                                
JGC_FVFINFO - (jgc_fvfinfo.*) This class is merely a helper class for making 
              and manipulating meshes in memblocks and what have you. The
              JGC_JMESH and JGC_VMESH classes utilize this I believe. This is 
              mainly a structure to hold data, and making a class of it is my 
              MO these days (Method of Operation).

(JGC_GDK.h) - This file contains declarations I've run into so far that 
              are literally missing from the DarkGDK header files. Note there
              is also a routine named "GetMatrix4Element" located in 
              the jgc_common.* files made MIT as a workaround for the missing 
              DarkGDK "dbGetMatrix4Element" function.

(jgc_gui.*)
JGC_GUI - Work in Progress - not functional yet
JGC_GUIWIDGET - Work in progress - Not functional yet.
JGC_GUIWINDOW - Work in progress - Not functional yet.
JGC_GUICONTROL - Work in progress - Not functional yet.
JGC_GUIWIDGETARRAY - Work in progress not functional yet.


(jgc_meshj.*)
JGC_JMESH - 
              
JGC_PIXELGRID - (jgc_pixelgrid.*) Powerful class to create, manipulate, save, 
                convert images. This class needs to be more optimized, as it 
                currently sits you can manipulate images at the pixel level, 
                however things like FILL currently use this same per pixel 
                plotting and should be optimized for using pointer math to 
                speed them up. As yet, this hasn't been an issue for me and 
                hence not a priority. But just be aware this class can be 
                expanded and optimized and probably should be. As it stands - 
                its VERY useful.

JGC_PIXELGRIDARRAY - For managing multiple JGC_PIXELGRID instances.

JGC_RGBA (jgc_rgba.*) - this class is for manipulating individual RGB and RGBA 
                        values and is used throughout the system and is useful
                        for setting all or individual color(and alpha) channels.
                        Note the jgc_rgba.h file also has a definition for a RGBA 
                        union structure that might be of interest to you and is 
                        used by the JGC_RGBA class.

(jgc_sky.*)
JGC_SKY_SHADER1 - This is a class that utilizes CuCumBer's moving sky shader.

JGC_SKYDOME - is a class I (Jason P Sage) Wrote and created media for that 
              basically accomplishes the same thing as the JGC_SKY_SHADER1 
              class but without shaders - and therefore can be effected by 
              default DarkGDK FOG.

(jgc_timer.*)
JGC_TIMER - A class designed to act like a timer - in that you specify how
            much time must elapse before it goes off. It handles this and 
            it resets itself automatically applying any extra time to the next 
            go around for accuracy's sake.
            
JGC_TIMERARRAY - For handling multiple instances of JGC_TIMER class.

(jgc_userinput.*)
JGC_USERINPUT - this calss most notably has a MOUSE interface designed to 
                be called once per loop or once per USER INPUT POLL in your
                application. This prevents having to worry about making 
                redundant calls to DarkGDK to get mouse information. Note 
                this class has its own "Mouse Moved" functions. It alo 
                stores the old and new button status' to help with writing 
                GUI systems or whatever you do with the mouse.
                
(jgc_usgs.*) namespace USGS - TWO functions:
USGS::USGSMapConvert - Used to convert RAW USGS satellite images in GRIDFLOAT
    format to smaller scaled down versions of the original. No LERPING
    (interpolating) is performed. The function works by skipping "N" number of
    height points. In short - it makes smaller or scaled down version of 
    the original file.
    
USGS::USGSMapToBitMap - Converts a GRIDFLOAT formatted "Height Map" from USGS
  satellite GRIDFLOAT format to a simple BITMAP file.
  
(jgc_vertinfo.*)
JGC_VERTINFO -  a Class that is integrated into the JGC_JMESH class and the 
    JGC_VMESH class (jgc_meshj.* and jgc_meshv.* respectively) for manipulating 
    individual verts during mesh/memblock vertice manipulations.
    
(jgc_xyz.*)
JGC_XYZ - this is simply a class that serves much the same purpose as a DarkGDK 
    Vector3 Vector. Its simply a structure that stores three floats: X, Y and Z. 
    It is used extensively thourhgout the library and you will likely find a 
    use for it as well.

1>libcpmtd.lib(xdebug.obj) : warning LNK4098: defaultlib 'libcmt.lib' conflicts with use of other libs; use /NODEFAULTLIB:library
1>libcpmtd.lib(xdebug.obj) : error LNK2019: unresolved external symbol __malloc_dbg referenced in function "void * __cdecl operator new(unsigned int,struct std::_DebugHeapTag_t const &,char *,int)" (??2@YAPAXIABU_DebugHeapTag_t@std@@PADH@Z)
1>libcpmtd.lib(xdebug.obj) : error LNK2019: unresolved external symbol __free_dbg referenced in function "void __cdecl operator delete(void *,struct std::_DebugHeapTag_t const &,char *,int)" (??3@YAXPAXABU_DebugHeapTag_t@std@@PADH@Z)

private:
   bool pvt_visible;


public:

   bool visible (){
      get (){
         return pvt_visible;
      }
      set (bool value){
         pvt_visible = value;
         if (value) dbShowMouse();
         else dbHideMouse();
      }
   }

private bool m_Visible;
public bool Visible 
{
   get {return m_Visible;}
   set {m_Visible = value;}
 }