Difference between revisions of "Tutorial - Setup Horde with SFML"

// *************************************************************************************************
//
// Horde3D
//   Next-Generation Graphics Engine
//
// Sample Application
// --------------------------------------
// Copyright (C) 2006-2011 Nicolas Schulz
//
//
// This sample source file is not covered by the EPL as the rest of the SDK
// and may be used without any restrictions. However, the EPL's disclaimer of
// warranty and liability shall be in effect for this file.
//
// *************************************************************************************************

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>

#include <SFML/Window.hpp>

#include "app.h"

// Configuration
const int appWidth = 1024;
const int appHeight = 576;
static bool fullScreen = false;
static int benchmarkLength = 600;

bool setupWindow( int&, int&, bool, const char* title );
static bool running;
static int mx0, my0;
static Application *app;

sf::Window* pSfmlWindow;
sf::Clock RenderClock;
double timeAtLastFrame;
double timeSinceLastFrame;
double timeAtCurrentFrame;

std::string extractAppPath( char *fullPath )
{
#ifdef __APPLE__
	std::string s( fullPath );
	for( int i = 0; i < 4; ++i )
		s = s.substr( 0, s.rfind( "/" ) );
	return s + "/../";
#else
	const std::string s( fullPath );
	if( s.find( "/" ) != std::string::npos )
		return s.substr( 0, s.rfind( "/" ) ) + "/";
	else if( s.find( "\\" ) != std::string::npos )
		return s.substr( 0, s.rfind( "\\" ) ) + "\\";
	else
		return "";
#endif
}

int windowCloseListener()
{
	running = false;
	return 0;
}

void keyPressListener( int key )
{
	if( !running ) return;
	
	int width = appWidth, height = appHeight;
	
	switch (key)
	{
		case sf::Key::Escape:
			running = false;
			break;
		case sf::Key::F1:
			app->release();		
			// Toggle fullscreen mode
			fullScreen = !fullScreen;
			setupWindow(width, height, fullScreen, app->getTitle());		
			app->init();
			app->resize( width, height );
			break;
			
			//KLUDGE ALERT: 
			//The samples in trunk use GLFW keycodes to set keystates
			//within Application. In order not to modify the sample code
			//we play nice and set the GLFW keycoded array it is interested in
		case sf::Key::Space:
			app->setKeyState(32,true);
			break;
		case sf::Key::F3:
			app->setKeyState(260,true);
			break;
		case sf::Key::F6:
			app->setKeyState(263,true);
			break;
		case sf::Key::F7:
			app->setKeyState(264,true);
			break;
		case sf::Key::F8:
			app->setKeyState(265,true);
			break;
		case sf::Key::LShift:
			app->setKeyState(287,true);
			break;
		case sf::Key::W:
			app->setKeyState(int('W'),true);
			break;
		case sf::Key::A:
			app->setKeyState(int('A'),true);
			break;
		case sf::Key::S:
			app->setKeyState(int('S'),true);
			break;
		case sf::Key::D:
			app->setKeyState(int('D'),true);
			break;			
	}
}

void mouseMoveListener( int x, int y )
{
	if( !running )
	{
		mx0 = x; my0 = y;
		return;
	}

	app->mouseMoveEvent( (float)(x - mx0), (float)(my0 - y) );
	mx0 = x; my0 = y;
}


bool setupWindow( int& width, int& height, bool fullscreen, const char* windowTitle = NULL)
{	
	//Initialise OpenGL context using SFML
	sf::WindowSettings Settings;	 // Create a settings object to initialise OpenGL context with 	
	Settings.DepthBits         = 24; // Request a 24 bits depth buffer
	Settings.StencilBits       = 8;  // Request a 8 bits stencil buffer
	Settings.AntialiasingLevel = 2;  // Request 2 levels of antialiasing
	
	if(!windowTitle)
		windowTitle = "SFML Chicago sample";
	
	if (pSfmlWindow==NULL)	//First time creation
	{	
		pSfmlWindow = new sf::Window(sf::VideoMode(width, height, 32),	//Create a width * height framebuffer with 32 bits per pixel
									 windowTitle,						//Title for the window to be created
									 sf::Style::Close,					//Create a window with a titlebar and close button
									 Settings);							//Settings object to initialise the OpenGL context with		
	}
	else	//Reinitialisation of window
	{	
		//Close the old window
		//pSfmlWindow->Close();

		//Initialise a new window
		if(fullscreen)
		{	
			// Creating a fullscreen window with the best video mode supported
			pSfmlWindow->Create(sf::VideoMode::GetMode(0),
								windowTitle,
								sf::Style::Fullscreen,
								Settings);
			width = pSfmlWindow->GetWidth();
			height = pSfmlWindow->GetHeight();
		}
		else
		{	
			pSfmlWindow->Create(sf::VideoMode(width, height, 32),
								windowTitle,
								sf::Style::Close,					
								Settings);									
		}		
	}
		
	return true;
}

int main( int argc, char** argv )
{
	printf("Starting SFML Chicago!\n");
	
	// Initialize application and engine
	app = new Application( std::string(argv[0]) );

	// Initialize a GLFW window
	pSfmlWindow = NULL;
	int width = appWidth, height = appHeight;
	if( !setupWindow( width, height, fullScreen, app->getTitle() ) ) return -1;
		
	// Check if benchmark mode is requested
	bool benchmark = false;
	if( argc > 1 && strcmp( argv[1], "-bm" ) == 0 )
	{	
		benchmark = true;
		//TODO: Equivalent in SFML
		//glfwDisable( GLFW_AUTO_POLL_EVENTS );
	}
		
	if ( !app->init() )
	{
		std::cout << "Unable to initalize engine" << std::endl;
		std::cout << "Make sure you have an OpenGL 2.0 compatible graphics card";
		return -1;
	}
	
	app->resize( appWidth, appHeight );

	pSfmlWindow->ShowMouseCursor(false);

	int frames = 0;
	float fps = 30.0f;
	timeSinceLastFrame = RenderClock.GetElapsedTime();
	RenderClock.Reset();	
	timeAtCurrentFrame += timeSinceLastFrame;
	running = true;
	
	// Game loop
	while( running )
	{
		timeSinceLastFrame = RenderClock.GetElapsedTime();
		RenderClock.Reset();	
		timeAtCurrentFrame += timeSinceLastFrame;
		
		// Calc FPS
		++frames;
		if( !benchmark && frames >= 3 )
		{
			fps = frames / (float)timeSinceLastFrame;
			if( fps < 5 ) fps = 30;  // Handle breakpoints
			frames = 0;
		}
		
		//Initialise all app keys' states to false
		for( int i = 0; i < 320; ++i )
			app->setKeyState(i,false);

		// Inject inputs from SFML
		sf::Event Event;
		while (pSfmlWindow->GetEvent(Event))
		{
			// Window closed
			if (Event.Type == sf::Event::Closed)
				running = false;
			// Key Press Event
			else if (Event.Type == sf::Event::KeyPressed)
			{	
				keyPressListener(Event.Key.Code);
			}
			else if(Event.Type == sf::Event::MouseMoved)
			{
				mouseMoveListener(Event.MouseMove.X,Event.MouseMove.Y);
			}
		}
		
		app->keyStateHandler();
		
		// Render
		app->mainLoop( benchmark ? 60 : fps );		
		pSfmlWindow->Display();
		
		if( benchmark && frames == benchmarkLength ) break;
	}

	pSfmlWindow->ShowMouseCursor(true);
	
	// Show benchmark results
	if( benchmark )
	{	
		timeSinceLastFrame = RenderClock.GetElapsedTime();
		RenderClock.Reset();	
		timeAtCurrentFrame += timeSinceLastFrame;
		double avgFPS = benchmarkLength / timeSinceLastFrame;
		char title[256];
		sprintf( title, "Average FPS: %.2f", avgFPS );
		
		//Simply write the logistics to console
		printf("%s",title);
		
		//TODO: Equivalent in SFML
//		double startTime = glfwGetTime();
//		while( glfwGetTime() - startTime < 5.0 ) {}  // Sleep
	}	
	
	// Quit
	app->release();
	delete app;
	
	if(pSfmlWindow->IsOpened())
		pSfmlWindow->Close();
	
	delete pSfmlWindow;
	
	return 0;
}