Réalisez votre propre écran de veille pour Windows

#ifndef _SCREEN_SAVER_H_
#define _SCREEN_SAVER_H_

#include <SFML/Window.hpp>
#include <Windows.h>

#ifdef _DEBUG
#pragma comment (lib, "sfml-window-s-d.lib")
#pragma comment (lib, "sfml-system-s-d.lib")
#else
#pragma comment (lib, "sfml-window-s.lib")
#pragma comment (lib, "sfml-system-s.lib")
#endif

// notre classe point d'entrée
class ScreenSaver
{
public:
	// CONSTRUCTEUR /!\ DESTRUCTEUR
	// toujours écrire les 2, sans aucune exception, même si les corps sont vides
	// cela permet de rappeller que faire une allocation dynamique implique la libération mémoire dans le destructeur
	ScreenSaver();
	~ScreenSaver();

	// La fonction run. Cette fonction est lancée par le main de l'application
	// retourne le code de retour que le main doit rendre
	// si debug est à true, alors on lance l'écran de veille en mode fenêtré, pour permettre le déboguage
	// si debug est à true, il empêche également la fenêtre de se détruire sur un évènement de mouvement de souris
	int run(HINSTANCE hInstance, LPSTR lpCmdLine, const sf::VideoMode & videoMode, const bool debug);

protected:
	// La fonction config est appelée depuis la fonction run, et permet de configurer l'écran de veille
	// son comportement par défaut est d'afficher une boîte de dialogue indiquant que rien n'est configurable
	// elle retourne 0 si tout s'est bien passé, sinon un code d'erreur (qui sera retourné par run)
	virtual int config();

	// La fonction init permet l'initialisation du rendu, et est appelée par le main avant le premier rendu (aperçu ou plein écran)
	// retourne true si l'appel à réussi, false sinon. Dans ce cas, la fonction run se termine et renvoie le code d'erreur EXIT_FAILURE
	// le handle passé est celui de la fenêtre de dessin
	virtual bool init();
	// La fonction shutDown est appelée par la fonction run à la fin de l'application et a l'effet inverse de init
	// retourne true si l'appel à réussi, false sinon. Dans ce cas, la fonction run se termine et renvoie le code d'erreur EXIT_FAILURE
	virtual bool shutDown();

	// Les fonctions suivantes sont appelées à chaque boucle et ont pour fonction d'effectuer le rendu à l'écran
	// celle-ci permet de faire un rendu en mode plein écran
	// elle retourne true si on doit continuer le rendu, false sinon
	virtual bool render() = 0;
	// celle-là permet de faire un rendu en mode aperçu
	// si cette fonction n'est pas surchargée, son comportement par défaut sera d'appeler la fonction render à sa place
	// elle retourne true si on doit continuer le rendu, false sinon
	virtual bool renderPreview();

	// pointeur vers une fenêtre SFML, que nous allons instancier si nécessaire et qui servira pour le rendu
	sf::Window * m_RenderWindow;
	// handle de fenêtre windows, désignant la fenêtre de dessin, la même que la fenêtre SFML ci-dessus
	HWND m_HandleFenetre;
	// mode vidéo utilise (résolution d'écran actuelle)
	sf::VideoMode m_VideoMode;
	// booléen indiquant si on est en mode plein écran ou non
	bool m_FullScreen;
private:
	// ce type définit les 3 types de comportements que l'on peut attendre de la part d'un écran de veille
	enum RequestType
	{
		CONFIG,
		PREVIEW,
		SCREEN_SAVER
	};
};

#endif // _SCREEN_SAVER_H_

#include "ScreenSaver.h"

#pragma warning (disable : 4996)

/************************************************************************/
/* Fonctions publiques                                                  */
/************************************************************************/
// construction et destructions
ScreenSaver::ScreenSaver() : m_RenderWindow(NULL)
{}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

ScreenSaver::~ScreenSaver()
{
	// destruction de m_RenderWindow si celui-ci a été construit
	if (m_RenderWindow) delete m_RenderWindow;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

/************************************************************************/
/* Fonction protégées                                                   */
/************************************************************************/
int ScreenSaver::config()
{
	MessageBox(m_HandleFenetre, L"Il n'y a rien à configurer", L"Information", MB_OK | MB_ICONASTERISK);
	return EXIT_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

bool ScreenSaver::init()
{
	return true;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

bool ScreenSaver::shutDown()
{
	return true;
}

//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////

bool ScreenSaver::renderPreview()
{
	return render();
}

int ScreenSaver::run(HINSTANCE hInstance, LPSTR lpCmdLine, const sf::VideoMode & videoMode, const bool debug)
{
	RequestType request; // la requête du système
	char * jeton; // ce qui sera retourné par strtok
	sf::Event toProcess; // évènement à traiter
	int mouseX = -1; int mouseY = -1;
	WNDCLASS childClass; // la classe utilisée pour créer une fenêtre
	HWND childWindow = NULL; // la fenêtre fille utilisée pour le mode aperçu

	// on fait un strtok sur lpCmdLine pour récupérer la requête
	jeton = strtok(lpCmdLine, " :");

	// si jeton est différent de null on teste
	if (NULL != jeton)
	{
		// on fait ensuite un if, pour savoir où l'on est
		if (strncmp(jeton, "/c", 2) == 0) // si on a /c
		{
			request = CONFIG;
		}
		else if (strncmp(jeton, "/p", 2) == 0) // si on a /p
		{
			request = PREVIEW;
		}
		else
		{
			request = SCREEN_SAVER; // si on /s ou rien ou n'importe quoi d'autre
		}
	}
	else
		request = SCREEN_SAVER;

	// fin de la fonction
	return EXIT_SUCCESS;
}

// en fonction du type de requête, on fait différentes initialisations
	switch(request)
	{
	case CONFIG:
		// dans le cas d'une config, on quitte direct la fonction run après l'appel de config
		// tout ce qui suit ne sera ainsi jamais appelé dans le cas d'une configuration
		m_HandleFenetre = (HWND)(atoi(strtok(NULL, "")));
		return config();

		break;
	case SCREEN_SAVER:
		// création de la fenêtre en plein écran, et remplissage des variables
		if (debug)
		{
			m_VideoMode = sf::VideoMode(800, 600, 32);
			m_FullScreen = false;
			m_RenderWindow = new sf::Window(m_VideoMode, "SiteDuZero");
		}
		else
		{
			m_VideoMode = videoMode;
			m_FullScreen = true;
			m_RenderWindow = new sf::Window(m_VideoMode, "SiteDuZero" , sf::Style::Fullscreen);
		}
		// on récupère le handle de la fenêtre SFML
		m_HandleFenetre = GetActiveWindow();
		// on cache le curseur de la souris
		m_RenderWindow->ShowMouseCursor(false);

		break;
	case PREVIEW:
		// création de la fenêtre depuis le handle récupéré
		m_HandleFenetre = (HWND)(atoi(strtok(NULL, "")));
		m_RenderWindow = new sf::Window(m_HandleFenetre);
		// enfin on définit les membres
		m_VideoMode = sf::VideoMode(m_RenderWindow->GetWidth(), m_RenderWindow->GetHeight());
		m_FullScreen = false;

		break;
	default:
		break;
	}

// boucle de rendu
	// d'abord on initialise
	if (!init()) return EXIT_FAILURE;

	// on rentre dans la boucle
	while (m_RenderWindow->IsOpened())
	{
		// traitement des évènements
		while (m_RenderWindow->GetEvent(toProcess))
		{
			// demande de fermeture de l'application
			if (sf::Event::Closed == toProcess.Type)
			{
				m_RenderWindow->Close();
				continue;
			}
			if (SCREEN_SAVER == request)
			{
				// évènements clavier et souris, sauf mouse moved
				if (sf::Event::KeyPressed == toProcess.Type ||
					sf::Event::KeyReleased == toProcess.Type ||
					sf::Event::MouseButtonPressed == toProcess.Type ||
					sf::Event::MouseButtonReleased == toProcess.Type)
				{
					m_RenderWindow->Close();
					continue;
				}
				if (sf::Event::MouseMoved == toProcess.Type && !debug)
				{
					if (mouseX < 0 || mouseY < 0)
					{
						mouseX = toProcess.MouseMove.X;
						mouseY = toProcess.MouseMove.Y;
					}
					else if (mouseX != toProcess.MouseMove.X || mouseY != toProcess.MouseMove.Y)
					{
						m_RenderWindow->Close();
						continue;
					}
				}
			}
		}
		// appel de render ou de renderPreview
		if (SCREEN_SAVER == request)
		{
			if (!(render()))  m_RenderWindow->Close();
		}
		else
		{
			if (!(renderPreview()))  m_RenderWindow->Close();
		}
	}
	// on finit par l'appel de shutDown, pour tout terminer correctement
	if (!shutDown()) return EXIT_FAILURE;

#include "ScreenSaver.h"

#ifdef _DEBUG
#pragma comment (lib, "sfml-system-s-d.lib")
#else
#pragma comment (lib, "sfml-system-s.lib")
#endif
#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "glu32.lib")

class SiteDuZero : public ScreenSaver
{
protected:
	virtual bool init()
	{
		// initialisation d'openGL
		// définition de la profondeur par défaut et de la couleur par défaut lors d'un clear
		glClearDepth(1.0f);
		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
		// activation du Z_BUFFER
		glEnable(GL_DEPTH_TEST);
		glDepthMask(GL_TRUE);
		// définition du projection en perspective
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(90.0f, (float)m_VideoMode.Width/(float)m_VideoMode.Height, 1.0f, 500.0f);

		// on retourne vrai
		return true;
	}

	virtual bool render()
	{
		// premièrement, on réinitialise les buffers
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		// on applique les transformations sur le modèle que l'on va dessiner
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glTranslatef(0.f, 0.0f, -200.0f); // la caméra est en identité
		glRotatef(m_Clock.GetElapsedTime() * 50.0f, 1.0f, 0.0f, 0.0f);
		glRotatef(m_Clock.GetElapsedTime() * 50.0f, 0.0f, 1.0f, 0.0f);
		glRotatef(m_Clock.GetElapsedTime() * 50.0f, 0.0f, 0.0f, 1.0f);

		// on dessine notre cube en mode immédiat
		glBegin(GL_QUADS);

		glColor3f(1.f, 0.f, 0.f);
		glVertex3f(-50.f, -50.f, -50.f);
		glVertex3f(-50.f,  50.f, -50.f);
		glVertex3f( 50.f,  50.f, -50.f);
		glVertex3f( 50.f, -50.f, -50.f);

		glColor3f(1.f, 0.f, 0.f);
		glVertex3f(-50.f, -50.f, 50.f);
		glVertex3f(-50.f,  50.f, 50.f);
		glVertex3f( 50.f,  50.f, 50.f);
		glVertex3f( 50.f, -50.f, 50.f);

		glColor3f(0.f, 1.f, 0.f);
		glVertex3f(-50.f, -50.f, -50.f);
		glVertex3f(-50.f,  50.f, -50.f);
		glVertex3f(-50.f,  50.f,  50.f);
		glVertex3f(-50.f, -50.f,  50.f);

		glColor3f(0.f, 1.f, 0.f);
		glVertex3f(50.f, -50.f, -50.f);
		glVertex3f(50.f,  50.f, -50.f);
		glVertex3f(50.f,  50.f,  50.f);
		glVertex3f(50.f, -50.f,  50.f);

		glColor3f(0.f, 0.f, 1.f);
		glVertex3f(-50.f, -50.f,  50.f);
		glVertex3f(-50.f, -50.f, -50.f);
		glVertex3f( 50.f, -50.f, -50.f);
		glVertex3f( 50.f, -50.f,  50.f);

		glColor3f(0.f, 0.f, 1.f);
		glVertex3f(-50.f, 50.f,  50.f);
		glVertex3f(-50.f, 50.f, -50.f);
		glVertex3f( 50.f, 50.f, -50.f);
		glVertex3f( 50.f, 50.f,  50.f);

		glEnd();

		// finalement, on fait le rendy
		m_RenderWindow->Display();

		// on retourne true
		return true;
	}
private:
	sf::Clock m_Clock;
};


int _stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	SiteDuZero app;
#ifdef _DEBUG
	return app.run(hInstance, lpCmdLine, sf::VideoMode(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 32), true);
#else
	return app.run(hInstance, lpCmdLine, sf::VideoMode(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 32), false);
#endif
}

// déclaration de notre propre callback, pour le mode aperçu
static long CALLBACK childWndProc(HWND, UINT, WPARAM, LPARAM);
static bool DestroyReceived = false;

// en fonction du type de requête, on fait différentes initialisations
	switch(request)
	{
	case CONFIG:
		// dans le cas d'une config, on quitte direct la fonction run après l'appel de config
		// tout ce qui suit ne sera ainsi jamais appelé dans le cas d'une configuration
		m_HandleFenetre = (HWND)(atoi(strtok(NULL, "")));
		return config();

		break;
	case SCREEN_SAVER:
		// création de la fenêtre en plein écran, et remplissage des variables
		if (debug)
		{
			m_VideoMode = sf::VideoMode(800, 600, 32);
			m_FullScreen = false;
			m_RenderWindow = new sf::Window(m_VideoMode, "SiteDuZero");
		}
		else
		{
			m_VideoMode = videoMode;
			m_FullScreen = true;
			m_RenderWindow = new sf::Window(m_VideoMode, "SiteDuZero" , sf::Style::Fullscreen);
		}
		// on récupère le handle de la fenêtre SFML
		m_HandleFenetre = GetActiveWindow();
		// on cache le curseur de la souris
		m_RenderWindow->ShowMouseCursor(false);

		break;
	case PREVIEW:
		// création de la fenêtre depuis le handle récupéré
		m_HandleFenetre = (HWND)(atoi(strtok(NULL, "")));
		m_RenderWindow = new sf::Window(m_HandleFenetre);
//## Y'A DU CODE EN PLUS ICI ! ##//
		// on remplit les champs de notre classe windows pour créer une autre fenêtre
		childClass.style = 0;
		childClass.lpfnWndProc = childWndProc;
		childClass.cbClsExtra = 0;
		childClass.cbWndExtra = 0;
		childClass.hInstance = hInstance;
		childClass.hIcon = NULL;
		childClass.hCursor = NULL;
		childClass.hbrBackground = NULL;
		childClass.lpszMenuName = NULL;
		childClass.lpszClassName = L"childWindowClass";
		// on l'enregistre dans le système
		RegisterClass(&childClass);
		// et enfin, on créée la fenêtre
		childWindow = CreateWindow(L"childWindowClass", L"SiteDuZero", WS_CHILD, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, m_HandleFenetre, NULL, hInstance, NULL);
		// si la fenêtre n'a pas été créée, on quitte immédiatement.
		if (!childWindow) return EXIT_FAILURE;
//## ET CA SE TERMINE LA ##//
		// enfin on définit les membres
		m_VideoMode = sf::VideoMode(m_RenderWindow->GetWidth(), m_RenderWindow->GetHeight());
		m_FullScreen = false;

		break;
	default:
		break;
	}

// boucle de rendu
	// d'abord on initialise
	if (!init()) return EXIT_FAILURE;

	// on rentre dans la boucle
	while (m_RenderWindow->IsOpened())
	{
//## LE CODE EN PLUS EST ICI ##//
		// si notre booléen est à true, on ferme la fenêtre
		if (DestroyReceived)
		{
			m_RenderWindow->Close();
			continue; // on applique immédiatement en terminant cette boucle
		}
//## ET VOILÀ ##//
		// traitement des évènements
		while (m_RenderWindow->GetEvent(toProcess))
		{
			// demande de fermeture de l'application
			if (sf::Event::Closed == toProcess.Type)
			{
				m_RenderWindow->Close();
				continue;
			}
			if (SCREEN_SAVER == request)
			{
				// évènements clavier et souris, sauf mouse moved
				if (sf::Event::KeyPressed == toProcess.Type ||
					sf::Event::KeyReleased == toProcess.Type ||
					sf::Event::MouseButtonPressed == toProcess.Type ||
					sf::Event::MouseButtonReleased == toProcess.Type)
				{
					m_RenderWindow->Close();
					continue;
				}
				if (sf::Event::MouseMoved == toProcess.Type && !debug)
				{
					if (mouseX < 0 || mouseY < 0)
					{
						mouseX = toProcess.MouseMove.X;
						mouseY = toProcess.MouseMove.Y;
					}
					else if (mouseX != toProcess.MouseMove.X || mouseY != toProcess.MouseMove.Y)
					{
						m_RenderWindow->Close();
						continue;
					}
				}
			}
		}
		// appel de render ou de renderPreview
		if (SCREEN_SAVER == request)
		{
			if (!(render()))  m_RenderWindow->Close();
		}
		else
		{
			if (!(renderPreview()))  m_RenderWindow->Close();
		}
	}
	// on finit par l'appel de shutDown, pour tout terminer correctement
	if (!shutDown()) return EXIT_FAILURE;

long CALLBACK childWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (uMsg == WM_DESTROY) DestroyReceived = true;
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

#include "include/ScreenSaver.h"

// pour faire un écran de veille
#include <ScreenSaver.h>

// ajout de la librairie
#ifdef _DEBUG
#pragma comment (lib, "SSLib-d.lib")
#else
#pragma comment (lib, "SSLib.lib")
#endif

// classe dérivant de ScreenSaver
class BoundingBox : public ScreenSaver
{
public:
protected:
	virtual bool render()
	{
		// faire du rendu ici !
	}

private:
};

int _stdcall WinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPSTR lpCmdLine, int /*nShowCmd*/)
{
	BoundingBox app; // on instancie notre classe fille !

#ifdef _DEBUG
	return app.run(hInstance, lpCmdLine, sf::VideoMode(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 32), true);
#else
	return app.run(hInstance, lpCmdLine, sf::VideoMode(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 32), false);
#endif

}