Bugfix: Revised/repaired SFML2 sample

Changed the code such that the SFML 2 sample is compatible with the
revised libraries of SFML2

Samples/basic/sfml2/SFML.vcproj

@@ -61,7 +61,7 @@
 			/>
 			<Tool
 				Name="VCLinkerTool"
-				AdditionalDependencies="RocketCore_d.lib RocketDebugger_d.lib sfml-system-s-d.lib sfml-window-s-d.lib sfml-graphics-s-d.lib"
+				AdditionalDependencies="opengl32.lib RocketCore_d.lib RocketDebugger_d.lib sfml-system-d.lib sfml-window-d.lib sfml-graphics-d.lib"
 				LinkIncremental="2"
 				AdditionalLibraryDirectories="..\..\..\..\sfml\lib;..\..\..\bin"
 				GenerateDebugInformation="true"

Samples/basic/sfml2/src/RenderInterfaceSFML.cpp

@@ -28,17 +28,11 @@
 #include <Rocket/Core/Core.h>
 #include "RenderInterfaceSFML.h"
 
-#ifdef ENABLE_GLEW
-#include <gl/glew.h>
-#endif
-
 #ifndef GL_CLAMP_TO_EDGE
 #define GL_CLAMP_TO_EDGE 0x812F
 #endif
-// If built with the GL Easy Extension library we can compile geometry to VBO's
-// http://www.opengl.org/sdk/libs/GLee/
-#ifdef ENABLE_GLEW
 
+#ifdef ENABLE_GLEW
 class RocketSFMLRendererGeometryHandler
 {
 public:
@@ -61,7 +55,6 @@ public:
 		VertexID = IndexID = 0;
 	};
 };
-
 #endif
 
 struct RocketSFMLRendererVertex
@@ -88,37 +81,29 @@ sf::RenderWindow *RocketSFMLRenderer::GetWindow()
 
 void RocketSFMLRenderer::Resize()
 {
-	MyWindow->SetActive(true);
-	//MyWindow->SaveGLStates();
-
 	static sf::View View;
-	//View.SetFromRect(sf::FloatRect(0, (float)MyWindow->GetWidth(), (float)MyWindow->GetHeight(), 0));
-	View.SetViewport(sf::FloatRect(0, (float)MyWindow->GetWidth(), (float)MyWindow->GetHeight(), 0));
-	MyWindow->SetView(View);
+	View.setViewport(sf::FloatRect(0, (float)MyWindow->getSize().x, (float)MyWindow->getSize().y, 0));
+	MyWindow->setView(View);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
-	glOrtho(0, MyWindow->GetWidth(), MyWindow->GetHeight(), 0, -1, 1);
+	glOrtho(0, MyWindow->getSize().x, MyWindow->getSize().y, 0, -1, 1);
 	glMatrixMode(GL_MODELVIEW);
 
-	glViewport(0, 0, MyWindow->GetWidth(), MyWindow->GetHeight());
-
-	//MyWindow->RestoreGLStates();
+	glViewport(0, 0, MyWindow->getSize().x, MyWindow->getSize().y);
 };
 
 // Called by Rocket when it wants to render geometry that it does not wish to optimise.
 void RocketSFMLRenderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
 {
-	MyWindow->SetActive();
-
-	glPushMatrix();
+	MyWindow->pushGLStates();
 	glTranslatef(translation.x, translation.y, 0);
 
 	std::vector<Rocket::Core::Vector2f> Positions(num_vertices);
 	std::vector<Rocket::Core::Colourb> Colors(num_vertices);
 	std::vector<Rocket::Core::Vector2f> TexCoords(num_vertices);
 
-	for(int  i = 0; i < num_vertices; i++)
+	for(int i = 0; i < num_vertices; i++)
 	{
 		Positions[i] = vertices[i].position;
 		Colors[i] = vertices[i].colour;
@@ -136,11 +121,11 @@ void RocketSFMLRenderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	sf::Image *image = (sf::Image *)texture;
+	sf::Texture *sfTexture = (sf::Texture *)texture;
 
-	if(image)
+	if(sfTexture)
 	{
-		image->Bind();
+		sf::Texture::bind(sfTexture);
 	}
 	else
 	{
@@ -156,21 +141,13 @@ void RocketSFMLRenderer::RenderGeometry(Rocket::Core::Vertex* vertices, int num_
 
 	glColor4f(1, 1, 1, 1);
 
-	glPopMatrix();
+	MyWindow->popGLStates();
 }
 
 // Called by Rocket when it wants to compile geometry it believes will be static for the forseeable future.		
-Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket::Core::Vertex* vertices,
-																		   int num_vertices, int* indices,
-																		   int num_indices,
-																		   const Rocket::Core::TextureHandle texture)
+Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture)
 {
 #ifdef ENABLE_GLEW
-	MyWindow->SetActive();
-
-	//if(!GLEE_VERSION_2_0)
-		//return (Rocket::Core::CompiledGeometryHandle) NULL;
-
 	std::vector<RocketSFMLRendererVertex> Data(num_vertices);
 
 	for(unsigned long i = 0; i < Data.size(); i++)
@@ -199,7 +176,7 @@ Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket:
 
 	return (Rocket::Core::CompiledGeometryHandle)Geometry;
 #else
-	return NULL;
+	return (Rocket::Core::CompiledGeometryHandle)NULL;
 #endif
 }
 
@@ -207,20 +184,18 @@ Rocket::Core::CompiledGeometryHandle RocketSFMLRenderer::CompileGeometry(Rocket:
 void RocketSFMLRenderer::RenderCompiledGeometry(Rocket::Core::CompiledGeometryHandle geometry, const Rocket::Core::Vector2f& translation)
 {
 #ifdef ENABLE_GLEW
-	MyWindow->SetActive();
-
 	RocketSFMLRendererGeometryHandler *RealGeometry = (RocketSFMLRendererGeometryHandler *)geometry;
 
-	glPushMatrix();
+	MyWindow->pushGLStates();
 	glTranslatef(translation.x, translation.y, 0);
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	sf::Image *image = (sf::Image *)RealGeometry->Texture;
+	sf::Texture *texture = (sf::Texture *)RealGeometry->Texture;
 
-	if(image)
+	if(texture)
 	{
-		image->Bind();
+		sf::Texture::bind(texture);
 	}
 	else
 	{
@@ -249,9 +224,9 @@ void RocketSFMLRenderer::RenderCompiledGeometry(Rocket::Core::CompiledGeometryHa
 
 	glColor4f(1, 1, 1, 1);
 
-	glPopMatrix();
+	MyWindow->popGLStates();
 #else
-	ROCKET_ASSERT(false /*& "Not Implemented"*/);
+	ROCKET_ASSERT(false);
 #endif
 }
 
@@ -259,19 +234,15 @@ void RocketSFMLRenderer::RenderCompiledGeometry(Rocket::Core::CompiledGeometryHa
 void RocketSFMLRenderer::ReleaseCompiledGeometry(Rocket::Core::CompiledGeometryHandle geometry)
 {
 #ifdef ENABLE_GLEW
-	MyWindow->SetActive();
-
 	delete (RocketSFMLRendererGeometryHandler *)geometry;
 #else
-	ROCKET_ASSERT(false /*& "Not Implemented"*/);
+	ROCKET_ASSERT(false);
 #endif
 }
 
 // Called by Rocket when it wants to enable or disable scissoring to clip content.		
 void RocketSFMLRenderer::EnableScissorRegion(bool enable)
 {
-	MyWindow->SetActive();
-
 	if (enable)
 		glEnable(GL_SCISSOR_TEST);
 	else
@@ -281,16 +252,12 @@ void RocketSFMLRenderer::EnableScissorRegion(bool enable)
 // Called by Rocket when it wants to change the scissor region.		
 void RocketSFMLRenderer::SetScissorRegion(int x, int y, int width, int height)
 {
-	MyWindow->SetActive();
-
-	glScissor(x, MyWindow->GetHeight() - (y + height), width, height);
+	glScissor(x, MyWindow->getSize().y - (y + height), width, height);
 }
 
 // Called by Rocket when a texture is required by the library.		
 bool RocketSFMLRenderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle, Rocket::Core::Vector2i& texture_dimensions, const Rocket::Core::String& source)
 {
-	MyWindow->SetActive();
-
 	Rocket::Core::FileInterface* file_interface = Rocket::Core::GetFileInterface();
 	Rocket::Core::FileHandle file_handle = file_interface->Open(source);
 	if (file_handle == NULL)
@@ -304,19 +271,19 @@ bool RocketSFMLRenderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle
 	file_interface->Read(buffer, buffer_size, file_handle);
 	file_interface->Close(file_handle);
 
-	sf::Image *image = new sf::Image();
+	sf::Texture *texture = new sf::Texture();
 
-	if(!image->LoadFromMemory(buffer, buffer_size))
+	if(!texture->loadFromMemory(buffer, buffer_size))
 	{
 		delete buffer;
-		delete image;
+		delete texture;
 
 		return false;
 	};
 	delete buffer;
 
-	texture_handle = (Rocket::Core::TextureHandle) image;
-	texture_dimensions = Rocket::Core::Vector2i(image->GetWidth(), image->GetHeight());
+	texture_handle = (Rocket::Core::TextureHandle) texture;
+	texture_dimensions = Rocket::Core::Vector2i(texture->getSize().x, texture->getSize().y);
 
 	return true;
 }
@@ -324,18 +291,15 @@ bool RocketSFMLRenderer::LoadTexture(Rocket::Core::TextureHandle& texture_handle
 // Called by Rocket when a texture is required to be built from an internally-generated sequence of pixels.
 bool RocketSFMLRenderer::GenerateTexture(Rocket::Core::TextureHandle& texture_handle, const Rocket::Core::byte* source, const Rocket::Core::Vector2i& source_dimensions)
 {
-	MyWindow->SetActive();
-
-	sf::Image *image = new sf::Image();
-
-	if(!image->LoadFromPixels(source_dimensions.x, source_dimensions.y, source))
-	{
-		delete image;
+	sf::Texture *texture = new sf::Texture();
 
+	if (!texture->create(source_dimensions.x, source_dimensions.y)) {
+		delete texture;
 		return false;
-	};
+	}
 
-	texture_handle = (Rocket::Core::TextureHandle)image;
+	texture->update(source, source_dimensions.x, source_dimensions.y, 0, 0);
+	texture_handle = (Rocket::Core::TextureHandle)texture;
 
 	return true;
 }
@@ -343,7 +307,5 @@ bool RocketSFMLRenderer::GenerateTexture(Rocket::Core::TextureHandle& texture_ha
 // Called by Rocket when a loaded texture is no longer required.		
 void RocketSFMLRenderer::ReleaseTexture(Rocket::Core::TextureHandle texture_handle)
 {
-	MyWindow->SetActive();
-
-	delete (sf::Image *)texture_handle;
+	delete (sf::Texture *)texture_handle;
 }

Samples/basic/sfml2/src/RenderInterfaceSFML.h

@@ -27,11 +27,25 @@
 #ifndef RENDERINTERFACESFML_H
 #define RENDERINTERFACESFML_H
 
+// NOTE: uncomment this only when you want to use the
+// OpenGL Extension Wrangler Library (GLEW)
+//#define ENABLE_GLEW
+
+// if the OpenGL Extension Wrangler Library (GLEW) should be used include it
+#ifdef ENABLE_GLEW
+#include <GL/glew.h>
+#endif
 
 #include <Rocket/Core/RenderInterface.h>
 #include <SFML/Graphics.hpp>
 
-#define ENABLE_GLEW
+// if the OpenGL Extension Wrangler Library (GLEW) should not be used
+// include the standard OpenGL library
+#ifndef ENABLE_GLEW
+// NOTE: add this if you receive a lot of errors in gl.h
+//#include <windows.h>
+#include <GL/gl.h>
+#endif
 
 class RocketSFMLRenderer : public Rocket::Core::RenderInterface
 {

Samples/basic/sfml2/src/SystemInterfaceSFML.cpp

@@ -31,272 +31,272 @@ int RocketSFMLSystemInterface::GetKeyModifiers(sf::Window *Window)
 {
 	int Modifiers = 0;
 
-	if(Window->GetInput().IsKeyDown(sf::Key::LShift) ||
-		Window->GetInput().IsKeyDown(sf::Key::RShift))
+	if(sf::Keyboard::isKeyPressed(sf::Keyboard::LShift) ||
+		sf::Keyboard::isKeyPressed(sf::Keyboard::RShift))
 		Modifiers |= Rocket::Core::Input::KM_SHIFT;
 
-	if(Window->GetInput().IsKeyDown(sf::Key::LControl) ||
-		Window->GetInput().IsKeyDown(sf::Key::RControl))
+	if(sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) ||
+		sf::Keyboard::isKeyPressed(sf::Keyboard::RControl))
 		Modifiers |= Rocket::Core::Input::KM_CTRL;
 
-	if(Window->GetInput().IsKeyDown(sf::Key::LAlt) ||
-		Window->GetInput().IsKeyDown(sf::Key::RAlt))
+	if(sf::Keyboard::isKeyPressed(sf::Keyboard::LAlt) ||
+		sf::Keyboard::isKeyPressed(sf::Keyboard::RAlt))
 		Modifiers |= Rocket::Core::Input::KM_ALT;
 
 	return Modifiers;
 };
 
-Rocket::Core::Input::KeyIdentifier RocketSFMLSystemInterface::TranslateKey(sf::Key::Code Key)
+Rocket::Core::Input::KeyIdentifier RocketSFMLSystemInterface::TranslateKey(sf::Keyboard::Key Key)
 {
 	switch(Key)
 	{
-	case sf::Key::A:
+	case sf::Keyboard::A:
 		return Rocket::Core::Input::KI_A;
 		break;
-	case sf::Key::B:
+	case sf::Keyboard::B:
 		return Rocket::Core::Input::KI_B;
 		break;
-	case sf::Key::C:
+	case sf::Keyboard::C:
 		return Rocket::Core::Input::KI_C;
 		break;
-	case sf::Key::D:
+	case sf::Keyboard::D:
 		return Rocket::Core::Input::KI_D;
 		break;
-	case sf::Key::E:
+	case sf::Keyboard::E:
 		return Rocket::Core::Input::KI_E;
 		break;
-	case sf::Key::F:
+	case sf::Keyboard::F:
 		return Rocket::Core::Input::KI_F;
 		break;
-	case sf::Key::G:
+	case sf::Keyboard::G:
 		return Rocket::Core::Input::KI_G;
 		break;
-	case sf::Key::H:
+	case sf::Keyboard::H:
 		return Rocket::Core::Input::KI_H;
 		break;
-	case sf::Key::I:
+	case sf::Keyboard::I:
 		return Rocket::Core::Input::KI_I;
 		break;
-	case sf::Key::J:
+	case sf::Keyboard::J:
 		return Rocket::Core::Input::KI_J;
 		break;
-	case sf::Key::K:
+	case sf::Keyboard::K:
 		return Rocket::Core::Input::KI_K;
 		break;
-	case sf::Key::L:
+	case sf::Keyboard::L:
 		return Rocket::Core::Input::KI_L;
 		break;
-	case sf::Key::M:
+	case sf::Keyboard::M:
 		return Rocket::Core::Input::KI_M;
 		break;
-	case sf::Key::N:
+	case sf::Keyboard::N:
 		return Rocket::Core::Input::KI_N;
 		break;
-	case sf::Key::O:
+	case sf::Keyboard::O:
 		return Rocket::Core::Input::KI_O;
 		break;
-	case sf::Key::P:
+	case sf::Keyboard::P:
 		return Rocket::Core::Input::KI_P;
 		break;
-	case sf::Key::Q:
+	case sf::Keyboard::Q:
 		return Rocket::Core::Input::KI_Q;
 		break;
-	case sf::Key::R:
+	case sf::Keyboard::R:
 		return Rocket::Core::Input::KI_R;
 		break;
-	case sf::Key::S:
+	case sf::Keyboard::S:
 		return Rocket::Core::Input::KI_S;
 		break;
-	case sf::Key::T:
+	case sf::Keyboard::T:
 		return Rocket::Core::Input::KI_T;
 		break;
-	case sf::Key::U:
+	case sf::Keyboard::U:
 		return Rocket::Core::Input::KI_U;
 		break;
-	case sf::Key::V:
+	case sf::Keyboard::V:
 		return Rocket::Core::Input::KI_V;
 		break;
-	case sf::Key::W:
+	case sf::Keyboard::W:
 		return Rocket::Core::Input::KI_W;
 		break;
-	case sf::Key::X:
+	case sf::Keyboard::X:
 		return Rocket::Core::Input::KI_X;
 		break;
-	case sf::Key::Y:
+	case sf::Keyboard::Y:
 		return Rocket::Core::Input::KI_Y;
 		break;
-	case sf::Key::Z:
+	case sf::Keyboard::Z:
 		return Rocket::Core::Input::KI_Z;
 		break;
-	case sf::Key::Num0:
+	case sf::Keyboard::Num0:
 		return Rocket::Core::Input::KI_0;
 		break;
-	case sf::Key::Num1:
+	case sf::Keyboard::Num1:
 		return Rocket::Core::Input::KI_1;
 		break;
-	case sf::Key::Num2:
+	case sf::Keyboard::Num2:
 		return Rocket::Core::Input::KI_2;
 		break;
-	case sf::Key::Num3:
+	case sf::Keyboard::Num3:
 		return Rocket::Core::Input::KI_3;
 		break;
-	case sf::Key::Num4:
+	case sf::Keyboard::Num4:
 		return Rocket::Core::Input::KI_4;
 		break;
-	case sf::Key::Num5:
+	case sf::Keyboard::Num5:
 		return Rocket::Core::Input::KI_5;
 		break;
-	case sf::Key::Num6:
+	case sf::Keyboard::Num6:
 		return Rocket::Core::Input::KI_6;
 		break;
-	case sf::Key::Num7:
+	case sf::Keyboard::Num7:
 		return Rocket::Core::Input::KI_7;
 		break;
-	case sf::Key::Num8:
+	case sf::Keyboard::Num8:
 		return Rocket::Core::Input::KI_8;
 		break;
-	case sf::Key::Num9:
+	case sf::Keyboard::Num9:
 		return Rocket::Core::Input::KI_9;
 		break;
-	case sf::Key::Numpad0:
+	case sf::Keyboard::Numpad0:
 		return Rocket::Core::Input::KI_NUMPAD0;
 		break;
-	case sf::Key::Numpad1:
+	case sf::Keyboard::Numpad1:
 		return Rocket::Core::Input::KI_NUMPAD1;
 		break;
-	case sf::Key::Numpad2:
+	case sf::Keyboard::Numpad2:
 		return Rocket::Core::Input::KI_NUMPAD2;
 		break;
-	case sf::Key::Numpad3:
+	case sf::Keyboard::Numpad3:
 		return Rocket::Core::Input::KI_NUMPAD3;
 		break;
-	case sf::Key::Numpad4:
+	case sf::Keyboard::Numpad4:
 		return Rocket::Core::Input::KI_NUMPAD4;
 		break;
-	case sf::Key::Numpad5:
+	case sf::Keyboard::Numpad5:
 		return Rocket::Core::Input::KI_NUMPAD5;
 		break;
-	case sf::Key::Numpad6:
+	case sf::Keyboard::Numpad6:
 		return Rocket::Core::Input::KI_NUMPAD6;
 		break;
-	case sf::Key::Numpad7:
+	case sf::Keyboard::Numpad7:
 		return Rocket::Core::Input::KI_NUMPAD7;
 		break;
-	case sf::Key::Numpad8:
+	case sf::Keyboard::Numpad8:
 		return Rocket::Core::Input::KI_NUMPAD8;
 		break;
-	case sf::Key::Numpad9:
+	case sf::Keyboard::Numpad9:
 		return Rocket::Core::Input::KI_NUMPAD9;
 		break;
-	case sf::Key::Left:
+	case sf::Keyboard::Left:
 		return Rocket::Core::Input::KI_LEFT;
 		break;
-	case sf::Key::Right:
+	case sf::Keyboard::Right:
 		return Rocket::Core::Input::KI_RIGHT;
 		break;
-	case sf::Key::Up:
+	case sf::Keyboard::Up:
 		return Rocket::Core::Input::KI_UP;
 		break;
-	case sf::Key::Down:
+	case sf::Keyboard::Down:
 		return Rocket::Core::Input::KI_DOWN;
 		break;
-	case sf::Key::Add:
+	case sf::Keyboard::Add:
 		return Rocket::Core::Input::KI_ADD;
 		break;
-	case sf::Key::Back:
+	case sf::Keyboard::BackSpace:
 		return Rocket::Core::Input::KI_BACK;
 		break;
-	case sf::Key::Delete:
+	case sf::Keyboard::Delete:
 		return Rocket::Core::Input::KI_DELETE;
 		break;
-	case sf::Key::Divide:
+	case sf::Keyboard::Divide:
 		return Rocket::Core::Input::KI_DIVIDE;
 		break;
-	case sf::Key::End:
+	case sf::Keyboard::End:
 		return Rocket::Core::Input::KI_END;
 		break;
-	case sf::Key::Escape:
+	case sf::Keyboard::Escape:
 		return Rocket::Core::Input::KI_ESCAPE;
 		break;
-	case sf::Key::F1:
+	case sf::Keyboard::F1:
 		return Rocket::Core::Input::KI_F1;
 		break;
-	case sf::Key::F2:
+	case sf::Keyboard::F2:
 		return Rocket::Core::Input::KI_F2;
 		break;
-	case sf::Key::F3:
+	case sf::Keyboard::F3:
 		return Rocket::Core::Input::KI_F3;
 		break;
-	case sf::Key::F4:
+	case sf::Keyboard::F4:
 		return Rocket::Core::Input::KI_F4;
 		break;
-	case sf::Key::F5:
+	case sf::Keyboard::F5:
 		return Rocket::Core::Input::KI_F5;
 		break;
-	case sf::Key::F6:
+	case sf::Keyboard::F6:
 		return Rocket::Core::Input::KI_F6;
 		break;
-	case sf::Key::F7:
+	case sf::Keyboard::F7:
 		return Rocket::Core::Input::KI_F7;
 		break;
-	case sf::Key::F8:
+	case sf::Keyboard::F8:
 		return Rocket::Core::Input::KI_F8;
 		break;
-	case sf::Key::F9:
+	case sf::Keyboard::F9:
 		return Rocket::Core::Input::KI_F9;
 		break;
-	case sf::Key::F10:
+	case sf::Keyboard::F10:
 		return Rocket::Core::Input::KI_F10;
 		break;
-	case sf::Key::F11:
+	case sf::Keyboard::F11:
 		return Rocket::Core::Input::KI_F11;
 		break;
-	case sf::Key::F12:
+	case sf::Keyboard::F12:
 		return Rocket::Core::Input::KI_F12;
 		break;
-	case sf::Key::F13:
+	case sf::Keyboard::F13:
 		return Rocket::Core::Input::KI_F13;
 		break;
-	case sf::Key::F14:
+	case sf::Keyboard::F14:
 		return Rocket::Core::Input::KI_F14;
 		break;
-	case sf::Key::F15:
+	case sf::Keyboard::F15:
 		return Rocket::Core::Input::KI_F15;
 		break;
-	case sf::Key::Home:
+	case sf::Keyboard::Home:
 		return Rocket::Core::Input::KI_HOME;
 		break;
-	case sf::Key::Insert:
+	case sf::Keyboard::Insert:
 		return Rocket::Core::Input::KI_INSERT;
 		break;
-	case sf::Key::LControl:
+	case sf::Keyboard::LControl:
 		return Rocket::Core::Input::KI_LCONTROL;
 		break;
-	case sf::Key::LShift:
+	case sf::Keyboard::LShift:
 		return Rocket::Core::Input::KI_LSHIFT;
 		break;
-	case sf::Key::Multiply:
+	case sf::Keyboard::Multiply:
 		return Rocket::Core::Input::KI_MULTIPLY;
 		break;
-	case sf::Key::Pause:
+	case sf::Keyboard::Pause:
 		return Rocket::Core::Input::KI_PAUSE;
 		break;
-	case sf::Key::RControl:
+	case sf::Keyboard::RControl:
 		return Rocket::Core::Input::KI_RCONTROL;
 		break;
-	case sf::Key::Return:
+	case sf::Keyboard::Return:
 		return Rocket::Core::Input::KI_RETURN;
 		break;
-	case sf::Key::RShift:
+	case sf::Keyboard::RShift:
 		return Rocket::Core::Input::KI_RSHIFT;
 		break;
-	case sf::Key::Space:
+	case sf::Keyboard::Space:
 		return Rocket::Core::Input::KI_SPACE;
 		break;
-	case sf::Key::Subtract:
+	case sf::Keyboard::Subtract:
 		return Rocket::Core::Input::KI_SUBTRACT;
 		break;
-	case sf::Key::Tab:
+	case sf::Keyboard::Tab:
 		return Rocket::Core::Input::KI_TAB;
 		break;
 	};
@@ -306,7 +306,7 @@ Rocket::Core::Input::KeyIdentifier RocketSFMLSystemInterface::TranslateKey(sf::K
 
 float RocketSFMLSystemInterface::GetElapsedTime()
 {
-	return timer.GetElapsedTime();
+	return timer.getElapsedTime().asSeconds();
 };
 
 bool RocketSFMLSystemInterface::LogMessage(Rocket::Core::Log::Type type, const Rocket::Core::String& message)

Samples/basic/sfml2/src/SystemInterfaceSFML.h

@@ -35,7 +35,7 @@ class RocketSFMLSystemInterface : public Rocket::Core::SystemInterface
 {
 public:
 
-	Rocket::Core::Input::KeyIdentifier TranslateKey(sf::Key::Code Key);
+	Rocket::Core::Input::KeyIdentifier TranslateKey(sf::Keyboard::Key Key);
 	int GetKeyModifiers(sf::Window *Window);
 	float GetElapsedTime();
 	bool LogMessage(Rocket::Core::Log::Type type, const Rocket::Core::String& message);

Samples/basic/sfml2/src/main.cpp

@@ -25,7 +25,17 @@
  *
  */
 
-#include <gl/glew.h>
+/*
+ * Modifed 2013 by Megavolt2013 in order to get the SFML2 sample working
+ * with the revised libraries of SFML2
+ * Please check the comments starting with NOTE in the files "main.cpp" and
+ * "RenderInterfaceSFML.h" if you have trouble building this sample
+ */
+
+// NOTE: uncomment this only when you want to use the
+// OpenGL Extension Wrangler Library (GLEW)
+//#include <GL/glew.h>
+
 #include <Rocket/Core.h>
 #include "SystemInterfaceSFML.h"
 #include "RenderInterfaceSFML.h"
@@ -35,8 +45,10 @@
 
 int main(int argc, char **argv)
 {
-	sf::RenderWindow MyWindow(sf::VideoMode(800, 600), "libRocket with SFML");
+	sf::RenderWindow MyWindow(sf::VideoMode(800, 600), "libRocket with SFML2", sf::Style::Close);
+	MyWindow.setVerticalSyncEnabled(true);
 
+#ifdef ENABLE_GLEW
 	GLenum err = glewInit();
 	if (GLEW_OK != err)
 	{
@@ -45,12 +57,16 @@ int main(int argc, char **argv)
 	  //...
 	}
 	fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
+#endif
 
 	RocketSFMLRenderer Renderer;
 	RocketSFMLSystemInterface SystemInterface;
-	ShellFileInterface FileInterface("../Samples/assets/");
 
-	if(!MyWindow.IsOpened())
+	// NOTE: if fonts and rml are not found you'll probably have to adjust
+	// the path information in the string
+	ShellFileInterface FileInterface("../../assets/");
+
+	if(!MyWindow.isOpen())
 		return 1;
 
 	Renderer.SetWindow(&MyWindow);
@@ -59,6 +75,7 @@ int main(int argc, char **argv)
 	Rocket::Core::SetRenderInterface(&Renderer);
 	Rocket::Core::SetSystemInterface(&SystemInterface);
 
+
 	if(!Rocket::Core::Initialise())
 		return 1;
 
@@ -68,7 +85,7 @@ int main(int argc, char **argv)
 	Rocket::Core::FontDatabase::LoadFontFace("Delicious-Roman.otf");
 
 	Rocket::Core::Context *Context = Rocket::Core::CreateContext("default",
-		Rocket::Core::Vector2i(MyWindow.GetWidth(), MyWindow.GetHeight()));
+		Rocket::Core::Vector2i(MyWindow.getSize().x, MyWindow.getSize().y));
 
 	Rocket::Debugger::Initialise(Context);
 
@@ -85,52 +102,56 @@ int main(int argc, char **argv)
 		fprintf(stdout, "\nDocument is NULL");
 	}
 
-	while(MyWindow.IsOpened())
+	while(MyWindow.isOpen())
 	{
 		static sf::Event event;
 
-		MyWindow.Clear();
+		MyWindow.clear();
 		Context->Render();
-		MyWindow.Display();
+		MyWindow.display();
 
-		while(MyWindow.GetEvent(event))
+		while(MyWindow.pollEvent(event))
 		{
-			switch(event.Type)
+			switch(event.type)
 			{
 			case sf::Event::Resized:
 				Renderer.Resize();
 				break;
 			case sf::Event::MouseMoved:
-				Context->ProcessMouseMove(event.MouseMove.X, event.MouseMove.Y,
+				Context->ProcessMouseMove(event.mouseMove.x, event.mouseMove.y,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::MouseButtonPressed:
-				Context->ProcessMouseButtonDown(event.MouseButton.Button,
+				Context->ProcessMouseButtonDown(event.mouseButton.button,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::MouseButtonReleased:
-				Context->ProcessMouseButtonUp(event.MouseButton.Button,
+				Context->ProcessMouseButtonUp(event.mouseButton.button,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::MouseWheelMoved:
-				Context->ProcessMouseWheel(event.MouseWheel.Delta,
+				Context->ProcessMouseWheel(-event.mouseWheel.delta,
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::TextEntered:
-				if (event.Text.Unicode > 32)
-					Context->ProcessTextInput(event.Text.Unicode);
+				if (event.text.unicode > 32)
+					Context->ProcessTextInput(event.text.unicode);
 				break;
 			case sf::Event::KeyPressed:
-				Context->ProcessKeyDown(SystemInterface.TranslateKey(event.Key.Code),
+				Context->ProcessKeyDown(SystemInterface.TranslateKey(event.key.code),
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::KeyReleased:
-				if(event.Key.Code == sf::Key::F8)
+				if(event.key.code == sf::Keyboard::F8)
 				{
 					Rocket::Debugger::SetVisible(!Rocket::Debugger::IsVisible());
 				};
 
-				Context->ProcessKeyUp(SystemInterface.TranslateKey(event.Key.Code),
+				if(event.key.code == sf::Keyboard::Escape) {
+					MyWindow.close();
+				}
+
+				Context->ProcessKeyUp(SystemInterface.TranslateKey(event.key.code),
 					SystemInterface.GetKeyModifiers(&MyWindow));
 				break;
 			case sf::Event::Closed: