Je vous l'ai dis OpenGl permet de faire de l'affichage, mais il permet de ne faire que cela. Sauf que sans fenêtre, pas d'affichage.

Mais dans la chapitre précédent je vous ai appris à faire une fenêtre avec SDL et quelle coïncidence ces deux libs peuvent fonctionner ensemble.

Je vous conseillerai de recopier le programme minimal avec SDL dans un autre dossier pour continuer ce chapitre.

Il y a cependant quelques petites modifications à faire dans le programme. Il faut en effet dire à SDL de démarrer avec OpenGl, en changeant le flag passé à SDL_SetVideoMode :

1

SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);

Une des révolution d'OpenGl est que l'on a plus besoin de se trimballer avec une SDL_Surface* ecran juste pour faire de l'affichage. Il suffit d'appeler les fonctions d'affichages, OpenGl se charge du reste.

Bon, aller, comme je suis super sympa je vous donne le code minimal que nous allons utiliser pour vous faire manipuler les différentes fonctions d'affichage :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>

void draw(){}

int main(int argc, char **argv){
	SDL_Init(SDL_INIT_VIDEO);
	SDL_WM_SetCaption("programme de base avec OpenGL !",NULL);
	SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
	SDL_Event event;
	while (event.type != SDL_QUIT){
		SDL_WaitEvent(&event);
		//on efface l'écran, que l'on a pas à trimballer
		glClear(GL_COLOR_BUFFER_BIT);
		draw(); //notre fonction d'affichage
		glFlush();
		SDL_GL_SwapBuffers(); //ça vous rappel quelque chose
	}
	SDL_Quit(); //c'est aussi SDL qui arrête OpenGl
	return 0;
}

La fonction SDL_GL_SwapBuffers() est l'équivalent de SDL_Flip(ecran) quand SDL gère son affichage personnel.

Quant à glFlush() elle est là pour forcer l'exécution des commandes GL dans un temps fini.

Pourquoi il y a une fonction draw() vide ?

C'est dans cette fonction que nous allons mettre les éléments à afficher.

Comment compiler cette chose avec g++ (maintenant vous êtes capable de le faire tout seul) :

Mais je vous donne quand même la correction :

g++ -Wall main.cpp -o exBaseOpenGl -lSDL -lGL -lGLU

Compiler avec Make à l'aide d'un makefile :

1
2
3
4
5
6
7
8
9

CXX = g++
NAME = exBaseOpenGl
CXX_FLAGS = -Wall -g3
LIBS = -lSDL -lGL -lGLU
RM = rm -f
INC = *.h
SRC = *.cpp
all :
	$(CXX) $(CXX_FLAGS) $(SRC) -o $(NAME) $(LIBS)s

Ça ne change pas grand chose.

Compilons plutôt avec CMake à l'aide d'un CMakeLists.txt :

1
2
3
4
5
6
7
8
9
10
11
12

project(exBaseOpengl)
cmake_minimum_required(VERSION 2.6)
#on demande a CMake de trouver les paquets SDL et OpenGl
find_package(SDL REQUIRED)
find_package(OpenGl)
#il faut inclure de dossier ou il y a les .h de SDL
include_directories(${SDL_INCLUDE_DIR})

#on créé l’exécutable
add_executable(exBaseOpengl main.cpp)
#on lie SDL au programme
target_link_libraries(exBaseOpengl SDL GL GLU)

Et on ne met pas de include_directories(${OPENGL_INCLUDE_DIR) ?

on, ce n'est pas la peine de mettre include_directories(${OPENGL_INCLUDE_DIR).

Compilez, exécutez et vous verrez une magnifique fenêtre... noire. Ben c'est un début.

Pour ceux qui compileraient avec CMake, voici le détail de la compilation :

On créé un dossier build :

mkdir build

On va dedans :

cd build

On appel CMake :

cmake ..
-- The C compiler identification is GNU
-- The CXX compiler identification is GNU
-- Check for working C compiler: /usr/bin/gcc
-- Check for working C compiler: /usr/bin/gcc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Looking for include files CMAKE_HAVE_PTHREAD_H
-- Looking for include files CMAKE_HAVE_PTHREAD_H - found
-- Looking for pthread_create in pthreads
-- Looking for pthread_create in pthreads - not found
-- Looking for pthread_create in pthread
-- Looking for pthread_create in pthread - found
-- Found Threads: TRUE 
CMake Warning at CMakeLists.txt:5 (find_package):
  Could not find module FindOpenGl.cmake or a configuration file for package
  OpenGl.

  Adjust CMAKE_MODULE_PATH to find FindOpenGl.cmake or set OpenGl_DIR to the
  directory containing a CMake configuration file for OpenGl.  The file will
  have one of the following names:

    OpenGlConfig.cmake
    opengl-config.cmake



-- Configuring done
-- Generating done

Heu, ça à changer non ?

Oui, mas ne vous inquiétez pas. CMake à mis un warning en disant qu'il n'a pas trouvez le module de CMake qui cherche OpenGl sous le nom habituel :

  Could not find module FindOpenGl.cmake or a configuration file for package
  OpenGl.

Mais après il nous rassure en nous disant qu'il en a trouvé un sous un autre nom :

Adjust CMAKE_MODULE_PATH to find FindOpenGl.cmake or set OpenGl_DIR to the
  directory containing a CMake configuration file for OpenGl.  The file will
  have one of the following names:

    OpenGlConfig.cmake
    opengl-config.cmake

Donc en fait tout va bien.

Poursuivons la compilation (elle ne part pas en courrant mais on ne sait jamais) :

make
Scanning dependencies of target exBaseOpengl
[100%] Building CXX object CMakeFiles/exBaseOpengl.dir/main.cpp.o
Linking CXX executable exBaseOpengl
[100%] Built target exBaseOpengl

Exécutez le programme :

./exBaseOpengl

Vous devriez obtenir quelque chose comme ça :

Voilà une belle fenêtre toute noire, en même temps on à juste initialisé OpenGl mais on ne s'en est pas servis, enfin on a pas rajouté de forme à afficher.