Sorry your browser is not supported!

JGC::Daddy->Update(); 

    float cx; float cy; float cz;
    if(!JGC::UserInput->MouseButton2 ){
      JGC::Cam0->Control(0.05f,0.50f,0.1f,0.05f,JGC::Clock->Time_ElapsedFloat);
    };

#include <DarkGDK.h>
#include "jfc_common.h"
#include "jgc_configuration.h"
#include "jgc_common.h"
void DarkGDK(void){
  JGC::Daddy = new JGC_DADDY();
  JGC::Daddy->Init();
  while(LoopGDK()){
    JGC::Daddy->Update();
  };
  delete JGC::Daddy;
};

  JGC::Daddy = new JGC_DADDY();

//----------------------------------------------------------------------------
void JGC_DADDY::Update(void){
//----------------------------------------------------------------------------
  JGC::DarkPhysics->Update();  
  JGC::Cull->Update_Cull_Objs(); 
  //dbUpdateTerrain();

  JGC::Clock->Update();
  JGC::Cam0->Update();  
  JGC::UserInput->Update(JGC::Clock->Time_New);    

  try{
    dbSync();    
    JGC::Cam0->Update();  
  }catch(...){
    int STOP=0;
  };
};
//----------------------------------------------------------------------------

#include "DarkGDK.h"
#include <jfc_common.h>
#include <jgc_configuration.h>
#include <jgc_common.h>

#define CAN_GUI

int CUR_TOOL = 2;
int drawcol;

#ifdef CAN_GUI

//--GUI CONTROLS--//
JGC_GUIMESSAGE *Msg=0; // Used in the Message Loop Below
JGC_GUIWINDOW *Win=0;// Our Window
JGC_GUIBUTTON *Btn=0; 
JGC_GUIBUTTON *Btn2=0;
int VideoPhreakBitmapFontIndex=0;
//----------------//

//--handles GUI input
void MessageHandler(JGC_GUIMESSAGE *p_Msg){
	switch(p_Msg->MsgType){
		case MSG_CONTROLCLICK:
		{
			if(p_Msg->Param2==(void*)Btn)
			{
				CUR_TOOL = 1;
			}
			else if(p_Msg->Param2==(void*)Btn2)
			{
				CUR_TOOL = 2;
			}
		default:
		  break;
		}
	}
}
#endif

bool MOUSE_INRANGE()
{
	if (dbMouseX() > 129 && dbMouseX() < 801)
	{
		if( dbMouseY() > -1  && dbMouseY() < 601)
			return true;
		else
			return false;
	}
	else
		return false;

}

void DarkGDK ( void )
{	
	dbAlwaysActiveOn();
	dbSyncOn();
	dbSyncRate(60);
	
#ifdef CAN_GUI
	JGC::Daddy = new JGC_DADDY();
	JGC::Daddy->Init();
	JGC::ObjAnchor->Exclude_Set(true);   // hide the 3d World Home Marker at position 0,0,0
	
	JGC::BitmapFontArray->AppendItem_BitmapFont("C:/jegasllc/media/fonts/Video Phreak.dds",10,10);
	VideoPhreakBitmapFontIndex = JGC::BitmapFontArray->Size_Get()-1;

	Win=new JGC_GUIWINDOW(JGC::GUI->OwnerTopLevel,&MessageHandler);
	Win->BorderStyle = WindowBorderStyle_FixedToolWindow;
	Win->Size->X=130;
	Win->Size->Y=600;
	Win->Position->X=0;
	Win->Position->Y=0;
	Win->Text->String_Set("Tools");

	//Creating the controls
  
	//---------Button
	Btn=new JGC_GUIBUTTON(Win,Win); //Our Btn
	Btn->Position->X=10;
	Btn->Position->Y=10;
	Btn->Size->X=110;
	Btn->Size->Y=50;
	Btn->FontPosition->X=80;
	Btn->FontPosition->Y=30;  
	Btn->Text->String_Set("Pencil");
	Btn->TabIndex=0; 	

	//--Second Button
	Btn2 = new JGC_GUIBUTTON(Win, Win);
	Btn2->Position->X=10;
	Btn2->Position->Y=70;
	Btn2->Size->X=110;
	Btn2->Size->Y=50;
	Btn2->FontPosition->X=80;
	Btn2->FontPosition->Y=30;  
	Btn2->Text->String_Set("Bubble");
	Btn2->TabIndex=1;
	
	//Adding controls to the window
	Win->WidgetDL->AppendItemToList((void*)Btn);
	Win->WidgetDL->AppendItemToList((void*)Btn2);
#endif
	dbBackdropOff();
	//dbAutoCamOff();
	dbCreateBitmap(1, 800, 600);
	DWORD black = dbRGB(0,0,0);
	DWORD white = dbRGB(255,255,255);
	drawcol = black;
	dbInk( drawcol, black );
	dbCLS( white );
	while ( LoopGDK ( ) )
	{
#ifdef CAN_GUI
		while(0!=(Msg=JGC::GUI->MessageGet()))
		{
			JGC::GUI->MessagePost(Msg);
		}
#endif
		if (dbMouseClick() == 1 && MOUSE_INRANGE() )
		{
			switch(CUR_TOOL)
			{
				case 1:
					dbDot(dbMouseX(), dbMouseY());
					break;
				case 2:
					dbCircle(dbMouseX(), dbMouseY(), 6);
					break;
				case 3:
					dbBox(dbMouseX() - 3, dbMouseY() - 3, dbMouseX() + 3, dbMouseY() + 3);
					break;
				default:
					break;
			}
			dbCopyBitmap(1, 0);
		}
#ifdef CAN_GUI
		JGC::Daddy->Update();
#endif
		dbWait(1);
	}
	delete JGC::Daddy;
	return;
}

#include "DarkGDK.h"
#include "jfc_common.h"
#include "jgc_configuration.h"
#include "jgc_common.h"



JGC_GUIMESSAGE *Msg=0; // Used in the Message Loop Below
JGC_GUIWINDOW *Win=0;// Our Window

// Our Drawing Area - Basically, I set this up so it's a borderless window, and I made is transparent 
// but same size as your bitmap.
// Why? So we can use the existing mouse handler
// when the mouse is over it. This way we can process messages to the drawing area in this
// region. You did a fine job BTW - and there is no way you could know the lib 
// like I do - so you wouldn't have come up with this. But I know its inner workings, 
// and hopefully - between us - we can get this project underway and perhaps 
// others can learn from the techniques implemented here! :) - Jason
JGC_GUIWINDOW *Win2=0;

JGC_GUIBUTTON *btnPencil=0; 
JGC_GUIBUTTON *btnBubble=0;
JGC_GUIBUTTON *btnBox=0;
JGC_GUIBUTTON *btnClear=0;
JGC_GUIBUTTON *btnColor=0;


int CUR_TOOL = 1;
int drawcol;
JGC_BITMAP *BMap=0;
DWORD black = dbRGB(0,0,0);
DWORD white = dbRGB(255,255,255);



//----------------------------------------------------------------------------
void MessageHandlerWin1(JGC_GUIMESSAGE *p_Msg){
//----------------------------------------------------------------------------
  switch(p_Msg->MsgType){
  case MSG_CONTROLCLICK:
    if(p_Msg->Param2==(void*)btnPencil){
      CUR_TOOL = 1;
    }else{
      if(p_Msg->Param2==(void*)btnBubble){
        CUR_TOOL = 2;
      }else{
        if(p_Msg->Param2==(void*)btnBox){
          CUR_TOOL = 3;
        }else{
          if(p_Msg->Param2==(void*)btnClear){
            BMap->SetToCurrentBitmap(); 
            dbCLS( drawcol );
            JGC::Bitmap0->SetToCurrentBitmap();  
          }else{
            if(p_Msg->Param2==(void*)btnColor){
              drawcol=dbRGB(dbRnd(255),dbRnd(255),dbRnd(255));
              btnColor->BackColor->RGB_Set(drawcol);
              JGC::GUI->MessageSend(MSG_WINDOWPAINT,p_Msg->Param1);// Paint Me ;)
            };
          };
        };
      };
    };
    break;
  };//endswitch
}
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
void MessageHandlerWin2(JGC_GUIMESSAGE *p_Msg){
//----------------------------------------------------------------------------
	switch(p_Msg->MsgType){
	case MSG_WINDOWMOUSEMOVE:{
    int MX=p_Msg->Param3;// Mouse Position is RELATIVE to top left of window, 
    int MY=p_Msg->Param4;// Not ACTUALLY the Screen... but works here because
    // draw window is at position 0,0
    
    // Relevant Mouse buttons are sent with the MOUSEDOWN and MOUSEUP 
    // events and NOT with Mouse Move. (Maybe Next Version :) )
    // However the UserInput class has this info ready for us always.
    if(JGC::UserInput->MouseButton1){ 
      switch(CUR_TOOL){
		  case 1:
			  BMap->SetToCurrentBitmap(); 
			  dbInk(drawcol,0); 
			  dbDot(MX,MY);
			  JGC::Bitmap0->SetToCurrentBitmap();  
			  break;
		  case 2:
			  BMap->SetToCurrentBitmap(); 
			  dbInk(drawcol,0); 
			  dbCircle(MX,MY, 6);
			  JGC::Bitmap0->SetToCurrentBitmap();  
			  break;
		  case 3:
			  BMap->SetToCurrentBitmap(); 
			  dbInk(drawcol,0); 
			  dbBox(MX - 3, MY - 3, MX + 3, MY + 3);
			  JGC::Bitmap0->SetToCurrentBitmap();  
			  break;
		  default:
		 	  break;
	    };//End Switch
	  };
	};
	case MSG_WINDOWMOUSEUP:
	  if((p_Msg->Param5 & 1)==1){// lifted up mouse one?
	    // Let's make sure Tools window has focus
	    JGC::GUI->MessageSend(MSG_WINDOWSETFOCUS,(void*)Win);
	  };
          break;	
	default:
	  break;
	}//End Switch
}
//----------------------------------------------------------------------------



void DarkGDK ( void )
{	
	//dbAlwaysActiveOn();
	//dbSyncOn();
	//dbSyncRate(60);
	
	JGC::Daddy = new JGC_DADDY();
	JGC::Daddy->Init();
	//JGC::Cam0->Backdrop_Set(false); 
	JGC::ObjAnchor->Exclude_Set(true);   // hide the 3d World Home Marker at position 0,0,0
  
	// I make Win2 First So Win1 made last - and therefore focused.
	// there is a MSG_SETFOCUS message, but you need to send in a message handler 
	// or strategically (underneath the main gui loop below and made to only 
	// happen once - first time through that GUI While loop.
	Win2=new JGC_GUIWINDOW(JGC::GUI->OwnerTopLevel,&MessageHandlerWin2);
	Win2->BorderStyle = WindowBorderStyle_None;
	Win2->Size->X=JGC::Display->Width_Get();
	Win2->Size->Y=JGC::Display->Height_Get();
	Win2->Position->X=0;
	Win2->Position->Y=0;
	Win2->Opacity=0; // make it invisible partially 
  

	Win=new JGC_GUIWINDOW(JGC::GUI->OwnerTopLevel,&MessageHandlerWin1);
	Win->BorderStyle = WindowBorderStyle_FixedToolWindow;
	Win->Size->X=130;
	Win->Size->Y=600;
	Win->Position->X=0;
	Win->Position->Y=0;
	Win->Text->String_Set("Tools");
	Win->ButtonClose->Visible=false; 

	//Creating the controls
  
	btnPencil=new JGC_GUIBUTTON(Win,Win); //Our Btn
	btnPencil->Position->X=10;
	btnPencil->Position->Y=10;
	btnPencil->Size->X=110;
	btnPencil->Size->Y=50;
	btnPencil->Text->String_Set("Pencil");
	btnPencil->TabIndex=0; 	

	btnBubble = new JGC_GUIBUTTON(Win, Win);
	btnBubble->Position->X=10;
	btnBubble->Position->Y=70;
	btnBubble->Size->X=110;
	btnBubble->Size->Y=50;
	btnBubble->Text->String_Set("Bubble");
	btnBubble->TabIndex=1;
	
	btnBox = new JGC_GUIBUTTON(Win, Win);
	btnBox->Position->X=10;
	btnBox->Position->Y=130;
	btnBox->Size->X=110;
	btnBox->Size->Y=50;
	btnBox->Text->String_Set("Box");
	btnBox->TabIndex=2;

	btnClear = new JGC_GUIBUTTON(Win, Win);
	btnClear->Position->X=10;
	btnClear->Position->Y=200;
	btnClear->Size->X=110;
	btnClear->Size->Y=50;
	btnClear->Text->String_Set("Clear");
	btnClear->TabIndex=3;

	btnColor = new JGC_GUIBUTTON(Win, Win);
	btnColor->Position->X=10;
	btnColor->Position->Y=270;
	btnColor->Size->X=110;
	btnColor->Size->Y=50;
	btnColor->Text->String_Set("Color");
	btnColor->TabIndex=4;


	//Adding controls to the window
	Win->WidgetDL->AppendItemToList((void*)btnPencil);
	Win->WidgetDL->AppendItemToList((void*)btnBubble);
	Win->WidgetDL->AppendItemToList((void*)btnBox);
	Win->WidgetDL->AppendItemToList((void*)btnClear);
	Win->WidgetDL->AppendItemToList((void*)btnColor);

	// Remember in my post in the TGC forums I said I didn't have a ton of 
	// bitmap code written? Well, we can mix and match DarkGDK native stuff
	// with a little care.
	BMap=new JGC_BITMAP();  // Force ID 1 ;)
  dbCreateBitmap(BMap->ID, JGC::Display->Width_Get(), JGC::Display->Height_Get());
	drawcol = black;
	dbInk( drawcol, black );
	dbCLS( white );
  JGC::Bitmap0->SetToCurrentBitmap();  
	
	while ( LoopGDK ( ) )
	{
		while(0!=(Msg=JGC::GUI->MessageGet())){
			JGC::GUI->MessagePost(Msg);
		};
		JGC::Bitmap0->CopyFrom(BMap->ID);  // Grab the drawn On Bitmap 1 into view via a copy
		JGC::Daddy->Update();
		//dbWait(1);
		//Sleep(10);
	}
	delete JGC::Daddy;
	return;
}

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
May 26, 2008 - Version 1.1 - author: Jason P Sage
==============================================================================
Project Home Web Site: http://code.google.com/p/darkgdkoop/


Thanx for downloading and installing the JGC Library v1.1! I Hope you LOVE IT!

Please forgive the fact that the the documentation in this 1.1 release aside 
from this "release notes doc" has not been modified, but I think its important 
to get the latest and greatest out there in your hands as soon as possible!

What's New? Many bugs fixed and many systemic changes to tighten up the 
library's architecture! If you already have version 1.0, fear not, the changes 
aren't that earth shattering for conversion and I'd be glad to offer any 
suggestions and or help I can that time allows! (Visit me in the TGC forums, 
I'm usually scoping out the threads in the DarkGDK forum on the regular!)

I can say this with confidence: This release is the best yet!

MAJOR CHANGE:
Configuration paradigm overhauled! There is more than 152 settings you can 
change before you pull the trigger and init the library, and more if you 
count some of the compiler directives found in JGC_CONFIGURATION.H

I explain my two step start up design in another document - (The Getting 
Started Guide yet to be updated available on the project web site) and this 
design hasn't changed - its just been expanded. If you have some old code that says a 
setting doesn't exist anymore (some identifier not found error while compiling,
then it might still be there but now in UPPER CASE. Also some names changed 
slightly like D_CameraRange_Far might now be D_CAMERA_RANGE_FAR for example.
Here's an example you'll see in various demos more or less:
----Code
void DarkGDK ( void ){ 
  JGC::Daddy = new JGC_DADDY(); 
  JGC::Daddy->D_USERINPUT_MOUSE_VISIBLE=false;
  JGC::Daddy->Init(); 
----Code

Now this allows changing settings BEFORE the library is started. Notice the
"D_" before "USERINPUT" .. this means DEFAULT. In the JGC_CONFIGURATION.H 
file, these same values (the hardcoded defaults, have SAME NAMES but have 
the word DEFAULT spelled out. DEFAULT_USERINPUT_MOUSE_VISIBLE. 

The groundwork has been laid to in the future add code that allows loading 
of this configuration data... but that's still vaporware :)

JGC inventories its usage of GDK and some JGC core classes! This paves the way 
for lost DirectX "Surfaces" (Switching full screen to windowed mode via ALT-TAB
can cause all objects to be discarded. Having a list of ALL objects for example 
and their filenames (if you loaded them) handy is a step in the right 
direction! Also, these entities (classes or whatever) will self clean them-
selves at the end of the application in case you overlook any of them. This is 
not a replacement for good proper coding practices... however its nice to have 
a list of EVERYTHING you have going on in the system. If you use this JGC lib 
to invoke all your GDK entities.. sounds etc, you have a very useful 
(diagnostics or whatever) source of resources information available to you
via the arrays that house this info in the JGC namespace.

--The following entities are now self managed in the API. 
    JGC_PIXELGRID
    JGC_OBJECT
    JGC_CAMERA
    JGC_VECTOR
    JGC_BITMAP
    JGC_IMAGE
    JGC_VECTOR
    JGC_LIGHT
    JGC_SPRITE
    JGC_EFFECT
    JGC_TIMER
    JGC_MESH
    JGC_MEMBLOCK
    JGC_MATRIX
    JGC_TERRAIN
    JGC_BITMAPFONT
    JGC_BITMAPTEXT
    JGC_MUSIC
    JGC_SOUND

-They arrays (of type JFC_AR in the foundations classes) that house them:
  JGC::PixelGridArray;
  JGC::ObjectArray;
  JGC::CameraArray;
  JGC::VectorArray;
  JGC::BitmapArray;
  JGC::ImageArray;
  JGC::VectorArray;
  JGC::LightArray;
  JGC::SpriteArray;
  JGC::EffectArray;
  JGC::TimerArray;
  JGC::MeshArray;
  JGC::MemblockArray;
  JGC::MatrixArray;
  JGC::TerrainArray;
  JGC::BitmapFontArray;
  JGC::BitmapTextArray;
  JGC::MusicArray;
  JGC::SoundArray;

To understand these arrays, see the JFC_AR class, but in short, its a a dynamic
array with easy commands. The ONE thing you need to know about it is that I DID
NOT use the STDLIB and I did not use a template design. This means that array
only keeps track of one data type! It's a dynamic array of 32 bit integers!

This means I can store any 32 bit value in there however via type casting. So,
to examine the contents of say the JGC::ObjectArray, you first make sure there 
is something there: 

  if(JGC::ObjectArray->Size_Get()>0){ do whatever here };
  
Then you say.. for this example want to examine (or set) the new Description 
string in the first object in the array. Well, you could type cast this ugly
way - which is very efficient from a speed perspective:

  dbPrint( ((JGC_OBJECT*)JGC::ObjectArray->ar[0])->Description->s );
  
Or cheat which I do when readability is more important:

  JGC_OBJECT *ObjReference =   (JGC_OBJECT*)JGC::ObjectArray->ar[0];
  dbPrint(ObjReference->Description->s);
  
Any ways, thats how it works in a nut shell. 

Also, all classes with load and or save functionality now have a string 
(JFC_STRING class in the foundation classes) containing the last successful
LOAD or SAVE of that entity. Also, there is a Description string also for 
these, to make your custom editor or game creation that much easier! Have a
bunch of music loaded? Maybe a description would do more justice than a 
filename alone! Example:

  JGC_OBJECT *MyObject=new JGC_OBJECT();
  if(MyObject->Load("MyModel.x")){
    dbPrint(MyObject->Filename->s);
    MyObject->Description->Set("My Awesome Model!");
  }else{
    dbPrint("See Log file, file not found!");
  };
  
Note - I said the new "Filename" strings get set when a successful LOAD or SAVE.
If you loaded "MyModel.x", and then saved it as "MyModelCopy.x", the the filename
string for this object would become: "MyModelCopy.x". 


Ok... So you are aware, some stuff is created for you when the library is 
initialized via : JGC::Init(); (See demos and source for examples) Here is a 
break down of what they are - new things have been added. Welcome to the 
JFC and JGC Namespaces!


=== JFC Namespace ============Foundation Classes Project==========
  char CHAR1K[1024];  
    Char buffer I use for all string ops. Volatile but handy 
    when you need a char buffer now!
    
  float Interpolate(float x0, float x1, float x , float y0, float y1);
    The famous LERP function! Look in 
    
  (I presume these are obvious)
  float Convert_Meters_To_Millimeters(float p_Meters); 
  float Convert_Meters_To_Centimeters(float p_Meters);
  float Convert_Meters_To_Feet(float p_Meters);
  float Convert_Meters_To_Yards(float p_Meters);
  float Convert_Meters_To_Miles(float p_Meters);
  float Convert_Meters_To_Inches(float p_Meters);
  float Convert_Meters_To_Kilometers(float p_Meters);
  float Convert_Millimeters_To_Meters(float p_Millimeters);
  float Convert_Centimeters_To_Meters(float p_Centimeters);
  float Convert_Feet_To_Meters(float p_Feet);
  float Convert_Yards_To_Meters(float p_Yards);
  float Convert_Miles_To_Meters(float p_Miles);
  float Convert_Inches_To_Meters(float p_Inches);
  float Convert_Kilometers_To_Meters(float p_Kilometers);
  float Convert_Seconds_To_MilliSeconds(float p_Seconds);
  float Convert_Seconds_To_Minutes(float p_Seconds);
  float Convert_Seconds_To_Hours(float p_Seconds);
  float Convert_Seconds_To_Days(float p_Seconds);
  float Convert_Milliseconds_To_Seconds(float p_Milliseconds);
  float Convert_Milliseconds_To_Minutes(float p_Milliseconds);
  float Convert_Milliseconds_To_Hours(float p_Milliseconds);
  float Convert_Minutes_To_Seconds(float p_Minutes);
  float Convert_Hours_To_Seconds(float p_Hours);
  float Convert_Days_To_Hours(float p_Days);
  
  int ABS(int i);
    Drop in replacement for the DarkGDK ABS function. 
    This one is for integers. (Faster to use these)
    
  float ABS(float f);
    Drop in replacement for the DarkGDK ABS function. 
    This one is for floats. (Faster to use these)
    If you inline these - you could make em faster still.
    Compiler might be doing it automagically. I don't know for sure.


=== JGC Namespace =========GameClasses Project===========
  JFC_AR            *PixelGridArray; This array has an element for each instantiated JGC_PIXELGRID class. 
  JFC_AR            *ObjectArray;    This array has an element for each instantiated JGC_OBJECT class. 
  JFC_AR            *CameraArray;    This array has an element for each instantiated JGC_CAMERA class. 
  JFC_AR            *VectorArray;    This array has an element for each instantiated JGC_VECTOR class. 
  JFC_AR            *BitmapArray;    This array has an element for each instantiated JGC_BITMAP class. 
  JFC_AR            *ImageArray;     This array has an element for each instantiated JGC_IMAGE class. 
  JFC_AR            *LightArray;     This array has an element for each instantiated JGC_LIGHT class. 
  JFC_AR            *SpriteArray;    This array has an element for each instantiated JGC_SPRITE class. 
  JFC_AR            *EffectArray;    This array has an element for each instantiated JGC_EFFECT class.  
  JFC_AR            *TimerArray;     This array has an element for each instantiated JGC_TIMER class. 
  JFC_AR            *MeshArray;      This array has an element for each instantiated JGC_MESH class. 
  JFC_AR            *MemblockArray;  This array has an element for each instantiated JGC_MEMBLOCK class. 
  JFC_AR            *MatrixArray;    This array has an element for each instantiated JGC_MATRIX class. 
  JFC_AR            *TerrainArray;   This array has an element for each instantiated JGC_TERRAIN class. 
  JFC_AR            *BitmapFontArray;This array has an element for each instantiated JGC_BITMAPFONT class. 
  JFC_AR            *BitmapTextArray;This array has an element for each instantiated JGC_BITMAPTEXT class. 
  JFC_AR            *MusicArray;     This array has an element for each instantiated JGC_MUSIC class. 
  JFC_AR            *SoundArray;     This array has an element for each instantiated JGC_SOUND class. 
  
  JGC_CAMERA        *Cam0;           This is the default camera in a globally available JGC_CAMERA class
  
  JGC_DADDY         *Daddy;          This is the Heart of the JGC library. See demos to see how its fired up!
  
  JGC_DARKPHYSICS   *DarkPhysics;    This class is instantiated for you and manages DarkPhysics. Light implementation
                                     so far, but it's magic is the seamless updating in JGC::Daddy->Update(); and the
                                     ability to change a compiler directive and DFarkPhysics stuff gets compiled in or
                                     not depending on setting. The class is Inert if you don't link to DarkPhysics via
                                     the default JGC_CONFIGURATION compiler directive setting.
  
  JGC_DISPLAY       *Display;        This class is instantiated for you and allows you to control and query the display.
  
  JGC_CLOCK         *Clock;          This is created for you and is the heart of all timer based anything.
  
  JGC_FILE          *File;           This utility class is created for you and is the heart of the logging system as well
                                     as a few other file related tools. Including built in checklist diagnostic routines you 
                                     can call to spit out any DarkGDK CheckList and spit it to a file!
  JGC_USERINPUT     *UserInput;      Well.. I imagine you know what this class is used for, however note that the 
                                     mouse visible set and get functions herein are for the hardware mouse and are 
                                     akin to DarkGDK's dbHideMouse() or whatever. The GUI has its own mouse setting that 
                                     pertains to a "sprite mouse pointer". Yes you can have both on at same time :)
  
  JGC_VECTOR        *mthDistanceVector; Used internally for some of the Distance functions found in JGC_COMMON.H that are 
                                        avilable for you.. distance to object, plus others.
  
  JGC_LIGHT         *Light0;         Default Light0 (JGC_LIGHT class)
  
  JGC_LIGHT         *Light1;         Default Light1 (JGC_LIGHT class)  because Light0 doesn't behave right all the time 
                                     in DarkGDK, so having Light1 created already is just another leg up to get stuff running!
  
  JGC_OBJECT        *ObjAngleFinder; This is a JGC_OBJECT and is defaulted to excluded (not seen or rendered) but you can 
                                     change that as it works like any other object. I use this to get information... like
                                     place it somewhere, turn it, then read back the coordinates and the angles. 
  
  JGC_OBJECT        *ObjAnchor;      This is by default visible, its the same "object design" (Cloned? I forget) as the 
                                     object angle finder - a big colorful 3d cursor like cross - resembles a jack from the 
                                     game "jacks" (...rubber ball.. little metal things that stink if you step on them barefoot.)
                                     Visible by default.
  
  JGC_OBJECT        *ObjToy;         Just like ObjAnchor and ObjAngleFinder - this is another 3d Cursor. I use this myself as a visible
                                     3d cursor and utility thing... but - its hidden by default.
  JGC_IMAGE         *ImgTest;        This image is hardcoded and is created at startup. It's just a default JGC_IMAGE with data ready to go.
  
  JGC_IMAGE         *ImgRed;         JGC_IMAGE - a red pixel.
  
  JGC_IMAGE         *ImgGreen;       JGC_IMAGE - a green pixel.
  
  JGC_IMAGE         *ImgYellow;      JGC_IMAGE - a yellow pixel.
  
  JGC_IMAGE         *ImgBlue;        JGC_IMAGE - a blue pixel.
  
  JGC_PIXELGRID     *PG;             JGC_PIXELGRID - for scratch use. Until you play with the pixelgrid, you won't appreciate having this 
                                     little tool available on the ready. 
  JGC_CULL          *Cull;           JGC_CULL - the frustrum culling system - instantiated and ready to go. Just feed it objects!
                                     Read the code, and view the demos. A powerful (expandable) frustrum (limb) culling system is there
                                     for the taking.
  JGC_BITMAP        *Bitmap0;        This is the default Bitmasp Zero - with a JGC class already configured for it: JGC_BITMAP.
  
  JGC_BITMAPFONT    *BitmapFont_Default; - This is the default bitmap font, preloaded, ready to go. Also, the JGC_BITMAPTEXT class
                                           REQUIRES a "real JGC_BITMAPFONT" instance is associated with it or its metrics functions error out.
                                           This is the font all JGC_BITMAPTEXT's instances use if nothing else is specified.
  JGC_BITMAPFONT    *BitmapFont_DefaultBold; This is the default BOLD font, preloaded, ready to go. Also, the JGC_BITMAPTEXT class.
                                           The GUI system relies on both of these two preloaded fonts. 
  JGC_GUI           *GUI;           Wow.. alot of work went into this. I don't don't knwo where to start except to say you have a GUI at 
                                    your disposal, read code in the demos, and give it a whirl. All source included :)

  


==============================================================================
May 15, 2008 - Version 1.0 - author: Jason P Sage
==============================================================================
I Disable the Escape key in many projects and the code so far has never been 
made into a true release as yet. Thats up to you.. but YOU MUST during testing 
stop the application via the Visual Studio 2008 Debug Menu, "Stop Debugging"
option. NOT because of memleaks.. but vs2008 TAKES FOREVER to shut down GDK 
apps and it will frustrate you.

So TRY to make a habit of ALT-TAB back to Visual Studio and Selecting that
Stop Debuggin option or pressing SHIFT+F5.

Of Course you CAN shut these apps down the proper way.. just go get a cup of
Joe while it does its thing! :)

Enjoy - I put a lot of work in to this and I hope people can utilize it, 
learn from it, and have fun!

--Jason P Sage

/*============================================================================
|    _________ _______  _______  ______  _______    Jegas, LLC               |
|   /___  ___// _____/ / _____/ / __  / / _____/    JasonPSage@jegas.com     |
|      / /   / /__    / / ___  / /_/ / / /____                               |
|     / /   / ____/  / / /  / / __  / /____  /                               |
|____/ /   / /___   / /__/ / / / / / _____/ /                                |
/_____/   /______/ /______/ /_/ /_/ /______/                                 |
|                 Under the Hood                                             |
==============================================================================
           Copyright(c)2008 Jegas, LLC                      
============================================================================*/
May 27, 2008


Installation Instructions. Copy the three source files that came in this patch
into your GameClasses folder. That's it! Just recompile and go!

What does the patch do? 

--Fixes problem where the JGC_GUIBUTTON class would not honor the FontPosition
  offsets "X" and "Y". This meant that no matter what your text was pinned 
  into the upper left of the button. 
  File jgc_gui.cpp

  Note: There is also a "Z" FontPosition offset. This is not implemented but 
        may be in future versions (Maybe you write it and contribute!) to 
        allow "automagically" positioning Bitmap Fonts in 3d Space by rendering 
        to a GDK plane! (You can accomplish this now, so I haven't made it a
        priority. Just render to an image, followed by texturing your 3d Plane
        with it!

--Fixes Issue with the JGC_BITMAPTEXT class (it renders you have in mem loaded 
  into instances of JGC_BITMAPFONT) where it wasn't properly rendering Right 
  aligned and centered strings. How do you align? jfc_common.h has an enum 
  declared: ALIGNLEFT, ALIGNCENTER, ALIGNRIGHT. Use these like this:

    JGC_BITMAPTEXT *bmt=new JGC_BITMAPTEXT();
    bmt->Alignment_Set(ALIGNRIGHT);
    bmt->String_Write(X,Y,"Hello!");

  File: jgc_bitmapfonts.cpp


That's all - sorry about the mishaps! I updated the Bitmap demo to illustrate
how this is accomplished. 

Enjoy,
Jason P Sage