Sorry your browser is not supported!

set window on
do:sync:loop

/**********************************************************
**     DirectX example program                            **
**********************************************************/

//Include windows stuff
#include <windows.h>

//Include DX9 stuff
#include <d3d9.h>

//Windows stuff
HINSTANCE				hInst;		//handle to an instance
HWND					wndHandle;	//handle to a window

//DX9 stuff
LPDIRECT3D9				pD3D;		//the Direct3D object
LPDIRECT3DDEVICE9		pd3dDevice;	//the Direct3D device


//Declare windows functions
bool initWindow( HINSTANCE hInstance );
LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );

//Declare DX9 functions
bool initDirect3D( void );
void render( void );
void cleanUp( void );


//WinMain function
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
				   LPSTR lpCmdLine, int nShowCMD )
{
	if ( !initWindow( hInstance ) )
	{
		MessageBox( NULL, "Window could not be initiated.", "ERROR", MB_OK );
		return false;
	}
	if ( !initDirect3D( ) )
	{
		MessageBox( NULL, "DirectX could not be initiated.", "ERROR", MB_OK );
		return false;
	}

	MSG msg;
	ZeroMemory( &msg, sizeof( msg ) );
	while( msg.message!=WM_QUIT )
	{
		if ( PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE) )
		{
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
		else
		{
			render( );
		};
	};

	cleanUp( );

	return (int) msg.wParam;
}



//InitWindow function

bool initWindow( HINSTANCE hInstance )
{
	WNDCLASSEX wcex;

	//Fill the windows class structure
	wcex.cbSize				= sizeof(WNDCLASSEX);	//Size of the WNDCLASSEX structure
	wcex.style				= CS_HREDRAW | CS_VREDRAW;	//style of it
	wcex.lpfnWndProc		= (WNDPROC)WndProc;	//the window procedure callback
	wcex.cbClsExtra			= 0;	//do not allocate any extra bytes for this class
	wcex.cbWndExtra			= 0;	//do not allocate any extra bytes for this instance
	wcex.hInstance			= hInstance;	//handle to the application instance
	wcex.hIcon				= 0;	//icon to associate with the application
	wcex.hCursor			= LoadCursor(NULL, IDC_ARROW);	//default cursor
	wcex.hbrBackground		= (HBRUSH)(COLOR_WINDOW+1);	//instance's background color
	wcex.lpszMenuName		= NULL;	//the resource name for the menu
	wcex.lpszClassName		= "DirectXExample";	//the class name being created
	wcex.hIconSm			= 0;	//handle to a small icon
	RegisterClassEx(&wcex);

	//create the window
	wndHandle = CreateWindow(
		"DirectXExample",						//window class to use
		"DirectXExample",						//window's caption
		WS_EX_TOPMOST | WS_POPUP | WS_VISIBLE,	//window style
		CW_USEDEFAULT,							//starting x coord
		CW_USEDEFAULT,							//starting y coord
		640,480,								//resolution
		NULL,									//parent window; NULL for desktop
		NULL,									//menu for the application; NULL for none
		hInstance,								//handle to the application instance
		NULL);									//no values passed to the window

	//is the window handle valid
	if ( !wndHandle )
		return false;


	//show the window on the screen
	ShowWindow(wndHandle, SW_SHOW);
	UpdateWindow(wndHandle);
	return true;
}




//WndProc function

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	//Check any available messages from the queue
	switch (message)
	{
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	}
	//Always return the message to the default window
	//procedure for further processing
	return DefWindowProc(hWnd, message, wParam, lParam);
}




//initDirect3D function

bool initDirect3D ( void )
{
	pD3D = NULL;
	pd3dDevice = NULL;


	//Create the DirectX object
	if ( NULL == ( pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
	{
		return false;
	}


	//Fill the presentation parameters structure
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory( &d3dpp, sizeof( d3dpp ) );
	d3dpp.Windowed			= FALSE;	//This app will (not) be windowed
	d3dpp.SwapEffect		= D3DSWAPEFFECT_DISCARD;	//Page flipping effect
	d3dpp.BackBufferFormat	= D3DFMT_X8R8G8B8;	//Set the backbuffer format
	d3dpp.BackBufferCount	= 1;	//There is only 1 backbuffer
	d3dpp.BackBufferHeight	= 480;	//Set the vertical resolution
	d3dpp.BackBufferWidth	= 640;	//Set the horizontal resolution
	d3dpp.hDeviceWindow		= wndHandle;	//The window handle to render on

	//Create a default DirectX device
	if( FAILED( pD3D->CreateDevice( D3DADAPTER_DEFAULT,	//Use the default adapter
									D3DDEVTYPE_REF,	//Set the device type
									wndHandle,	//The window handle to render on
									D3DCREATE_SOFTWARE_VERTEXPROCESSING,	//Set the thingy
									&d3dpp,	//Give it that thingy
									&pd3dDevice ) ) )	//And that thingy
	{
		return false;
	}
	return true;
}




//Render

void render( void )
{
	//Is the DX9 device valid
	if ( NULL == pd3dDevice )
		return;
	
	//Clear the back buffer to blue
	pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET,
						D3DCOLOR_XRGB( 0,0,255 ), 1.0f, 0 );


	//Render
	pd3dDevice->Present( NULL, NULL, NULL, NULL );
}




//Cleany!!

void cleanUp ( void )
{
	//Release the device
	if( pd3dDevice != NULL )
		pd3dDevice->Release( );

	//Release the Direct3D object
	if( pD3D != NULL )
		pD3D->Release( );
}

#include <stdlib.h>
#include <stdio.h>

// Typedefs and mesh/vertex/etc. classes
#include "FMTypes.h"

// Plugin OS-abstraction layer
#include "plugin.h"

// Engine-related base classes
#include "Engine.h"

cPlugMan PM; // Must declare this to keep track of loaded plugins. Used by NewEngine().

int main(){
    cMeshp M;
    cImagep I;

    // Load the engine plugin. In this case, use OpenGL
    cEngine *Engine = NewEngine("plugins/oglRenderer");

    // If there was an error loading, bail out
    if( !Engine ) return 1;

    Engine->Init(); // Initialize

    if( !Engine->OpenWindow( 800, 600, 0 ) ) return 1335;  // Try to create an 800x600 windowed mode screen

    Engine->SetTitle( "Hello World" ); //   ^_^
    Engine->ToggleClear();             // Clear colour buffer on each frame
    Engine->AddLoader( "plugins/TestNode" ); // TestNode makes a pyramid thingy for... *drumroll*... testing!
    Engine->AddLoader( "plugins/3ds" );      // 3DS mesh loading plugin
    Engine->AddLoader( "plugins/images" );   // Can load: .bmp, .cut, .dds, .doom, .gif, .ico, .jpg, .lbm, .mdl, .mng, .pal, .pbm, .pcd, .pcx, .pgm, .pic, .png, .ppm, .psd, .psp, .raw, .sgi, .tga, .tif, .hdr

    M = (cMeshp) Engine->Load("meshes/audi.3DS"); // Loads a textured mesh
    Engine->Adopt( M ); // Tells the engine that it should render said mesh on each frame

    // M = (cMeshp) Engine->Load("TESTNODE"); // Got tired of seeing this thing

    char Text[50];
    cLight& La = Engine->NewLight(); // Allocate one of seven lights
    La.SetPosition( cVertex( 10.0f, 0.5f, 0.0f ) ); // set some properties...
    La.SetAmbient(  cVertex(  0.5f, 0.5f, 0.5f ) );
    La.SetDiffuse(  cVertex(  0.8f, 0.8f, 0.8f ) );
    La.SetSpecular( cVertex(  1.0f, 1.0f, 1.0f ) );

    f32 LFR=0, NFR;
	  M->Scale = 1.0f; // Model was a bit too big. Shrink it down some.
    while( Engine->Running() ){ // Window still open?

      if( (NFR=Engine->GetFPS()) != LFR ){  // Update the title bar so as to show framerate
        LFR = NFR;
        sprintf( Text, "<< FishMotor2 - FPS: %f >>", LFR ); 
        Engine->SetTitle( Text );
      }

      if( M ) M->Rot[1]+=0.5f; // If the mesh was properly loaded, rotate it a bit

      Engine->Draw(); // Draws everything and swaps buffers

    }

    if( M ) M->Drop(); // Meshes are shared resources so they must be Dropped when no longer needed

    Engine->Drop(); // Shuts down the engine and frees resources

    return 0;
}