Horde3D Wiki - User contributions [en]

Tutorial - Setup Horde with SFML

2011-08-20T05:39:59Z

Hannofcart: Fixed fullscreen toggling error

{| border="0"
| {{ContentBlock|width=800|color=white
|content='''Using Horde with SFML.'''

[http://www.sfml-dev.org/ SFML - Simple Fast Multimedia Library] is a free multimedia C++ API that provides you low and high level access to graphics, input, audio, etc.

The following example is a rewrite of main.cpp of the Horde sample - Chicago using SFML (instead of GLFW that the sample in trunk uses).
To test the sample, simply replace the code in main.cpp of the Chicago sample app with this code.
This code only requires SFML::Window library.

{{CppSourceCode|
description= main.cpp for Chicago Sample|
code=
<source lang="cpp" line="1">
// *************************************************************************************************
//
// 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;
}
</source>
}}
}}
| valign="top" | {{Extension_Summary|
name = Horde With SFML|
screenshot = H3DPlaceHolder.png|
description = This tutorial introduces the use of Horde3D with SFML|
version = 1.0|
horde3dversion = 1.0 beta|
released = 2011-08-20|
author = Balajee.R.C (Hannofcart) |
}}
|}
[[category: Tutorials]]

Tutorial - Setup Horde with SFML

2011-08-19T20:11:10Z

Hannofcart:

{| border="0"
| {{ContentBlock|width=800|color=white
|content='''Using Horde with SFML.'''

[http://www.sfml-dev.org/ SFML - Simple Fast Multimedia Library] is a free multimedia C++ API that provides you low and high level access to graphics, input, audio, etc.

The following example is a rewrite of main.cpp of the Horde sample - Chicago using SFML (instead of GLFW that the sample in trunk uses).
To test the sample, simply replace the code in main.cpp of the Chicago sample app with this code.
This code only requires SFML::Window library.

{{CppSourceCode|
description= main.cpp for Chicago Sample|
code=
<source lang="cpp" line="1">
// *************************************************************************************************
//
// 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(appWidth, appHeight, 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);
}
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( extractAppPath(argv[0]) );

// Initialize a GLFW window
pSfmlWindow = NULL;
if( !setupWindow( appWidth, appHeight, 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;
}
</source>
}}
}}
| valign="top" | {{Extension_Summary|
name = Horde With SFML|
screenshot = H3DPlaceHolder.png|
description = This tutorial introduces the use of Horde3D with SFML|
version = 1.0|
horde3dversion = 1.0 beta|
released = 2011-08-20|
author = Balajee.R.C (Hannofcart) |
}}
|}
[[category: Tutorials]]

Tutorial - Setup Horde with SFML

2011-08-19T20:10:21Z

Hannofcart:

{| border="0"
| {{ContentBlock|width=800|color=white
|content='''Using Horde with SFML.'''

[http://www.sfml-dev.org/ SFML - Simple Fast Multimedia Library] is a free multimedia C++ API that provides you low and high level access to graphics, input, audio, etc.

The following example is a rewrite of main.cpp of the Horde sample - Chicago using SFML (instead of GLFW that the sample in trunk uses).
To test the sample, simply replace the code in main.cpp of the Chicago sample app with this code.
This code only requires SFML::Window library.

{{CppSourceCode|
description= main.cpp for Chicago Sample|
code=
<source lang="cpp" line="1">
// *************************************************************************************************
//
// 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(appWidth, appHeight, 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);
}
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( extractAppPath(argv[0]) );

// Initialize a GLFW window
pSfmlWindow = NULL;
if( !setupWindow( appWidth, appHeight, 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;
}
</source>
}}
}}
| valign="top" | {{Extension_Summary|
name = Horde With SFML|
screenshot = H3DPlaceHolder.png|
description = This tutorial introduces the use of Horde3D with SFML|
version = 1.0|
horde3dversion = 1.0 beta|
released = 2008-07-31|
author = Balajee.R.C (Hannofcart) |
}}
|}
[[category: Tutorials]]

Tutorial - Setup Horde with SFML

2011-08-19T20:09:29Z

Hannofcart: New page: {| border="0" | {{ContentBlock|width=800|color=white |content='''Using Horde with SFML.''' [http://www.sfml-dev.org/ SFML - Simple Fast Multimedia Library] is a free multimedia C++ API...

{| border="0"
| {{ContentBlock|width=800|color=white
|content='''Using Horde with SFML.'''

[http://www.sfml-dev.org/ SFML - Simple Fast Multimedia Library] is a free multimedia C++ API that provides you low and high level access to graphics, input, audio, etc.

The following example is a rewrite of main.cpp of the Horde sample - Chicago using SFML (instead of GLFW that the sample in trunk uses).
To test the sample, simply replace the code in main.cpp of the Chicago sample app with this code.
This code only requires SFML::Window library.

{{CppSourceCode|
description= main.cpp for Chicago Sample|
code=
<source lang="cpp" line="1">
// *************************************************************************************************
//
// 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(appWidth, appHeight, 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);
}
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( extractAppPath(argv[0]) );

// Initialize a GLFW window
pSfmlWindow = NULL;
if( !setupWindow( appWidth, appHeight, 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;
}
</source>
}}
}}
| valign="top" | {{Extension_Summary|
name = Horde With SFML|
screenshot = H3DPlaceHolder.png|
description = This tutorial introduces the use of Horde3D with SFML|
version = 1.0|
horde3dversion = 1.0 beta|
released = 2008-07-31|
author = Raynaldo Rivera|
}}
|}
[[category: Tutorials]]

Horde3D Wiki:Community portal

2011-08-19T19:57:40Z

Hannofcart:

__NOEDITSECTION__ __NOTOC__{{ContentBlock|color=orange
|content= '''The community portal section of the Horde3D wiki contains community contributed articles that are not part of the official documentation. Feel free to add articles to our wiki or links to external tutorials.'''}}
{{SpacerBlock}}
{{ContentBlock|
|header=Information, instructions and tips on using Horde3D
|content={{!!}}
==Programming Guide==
=== Build Instructions ===
#[[Building Horde3D]] - Instructions for obtaining the code and building Horde on all supported platforms

[[Category: Tutorials]]

===Beginner Tutorials===
#[[Tutorial - Hello World]] - In this section we will create a simple application that loads a character and animates it using a walk cycle.
#[[Tutorial - Picking]] - In this section we will demonstrate picking the node under the mouse cursor
#[[Tutorial - Simple HUD]] - How to use showOverlay to create a simple HUD.
#[[Tutorial - Setup Horde with SDL]] - How to Setup Horde with SDL.
#[[Tutorial - Setup Horde with Qt4]] - How to Setup Horde with Qt4.
#[[Tutorial - Setup Horde with Gtkmm]] - How to Setup Horde with Gtkmm
#[[Tutorial - Setup Horde with SFML]] - How to Setup Horde with SFML
#[[Tutorial - Stereo rendering]] - Basic outline for quad-buffered stereo rendering

===Advanced Tutorials===
#[[Basic Pipeline Tutorial]] - Create your first custom pipeline.
#[[Procedurally generated geometry tutorial]] - How to create Horde3D compatible procedural geometry (Horde3D 1.0.0 '''Beta 3''' only!).

==Shader Development==
[[Category: Techniques]]

===Debugging and Profiling===
#[[Using GPU PerfStudio]] - Quick steps to get started with GPU PerfStudio

===Render System Basics===
#[[The Flexible Rendering Pipeline]] - Introduction to Horde's data-driven rendering pipelines

===Rendering Quality===
#[[Gamma Correction]] - Overview of gamma correction and how to apply it with Horde

===Shading===
#[[Shading Technique - Dot Product Detail Texturing]] - Using the dot product of vectors and signed textures for high frequency detail
#[[Shading Technique - Palette Coloring]] - Quick and dirty palette recoloration of objects
#[[Shading Technique - Gloss Mapping]] - Mask which areas of an object have specular highlights
#[[Shading Technique - Glow Mapping]] - Allow areas on an object to emit a strong glowing highlight
#[[Shading Technique - Fresnel]] - Using reflection and refraction
#[[Shading Technique - Linear Depth Buffer]] - Create a custom linear depth buffer using vertex
#[[Shading Technique - Terrain Shading]] - Height and slope based shading with triplanar texturing

===Preprocessing===
#[[Preprocessing Technique - Distance Field Vector Textures]] - Using Adobe Photoshop to generate textures suitable for efficient vector art rendering

==Asset Creation==

[[Category: Content Import]]
#[[DCC Tool Support]] - List of supported Digital Content Creation Tools
#[[AssetTroubleshooting|Troubleshooting]] - ''"Help, my model is not showing up!"''
#[[Tips and Techniques]] - Asset creation suggestions & ideas for Horde3d, exporting and program quirks..
#[[Extending ColladaConv]] - Add support for exporting cameras
}}