Discussion :

[Vinkkk]

Salut tout le monde !
Je reviens vers vous car je suis bloqué dans la compilation de l'un de mes programmes. Tout d'abord je suis en ce moment le cours de Rémy Malgouyres sur OpenGL ici. Si vous connaissez ce cours j'aimerais
beaucoup avoir votre avis sur celui-ci ou si vous avez d'autre suggestion de cours OpenGL.
Bref, dans le premier chapitre on créer un "squelette" pour afficher, récupérer des événements, initialiser SDL etc... Mais arriver à la classe EventController g++ m'affiche ce message d'erreur " Error : expected unqualified-id before string constant extern "C" ". Sachant que cette ligne appartient au fichier SDL_platform.h et qu'elle permet (de ce que j'ai compris) d'utiliser des fonctions en C malgré qu'on soit en C++.

Voici EventCont.cpp :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
#include <stdlib.h>
#include <stdio.h>
#include "MouseData.h"
#include "Wrapper.h"
#include "Model.h"
 
SDL_TimerID Wrapper::EventCont::mTimerID;
 
void Wrapper::EventCont::Init(SDL_Window* window, Model* p_mod){
	mTimerID = SDL_AddTimer(20, CreateTimerRefresh, (void*)p_mod);
	EventCont::EventsLoop(window, p_mod);
}
 
void Wrapper::EventCont::EventsLoop(SDL_Window* window, Model* p_mod){
	bool fin = false;
	SDL_Event evet;
 
	while(!fin){
		while(SDL_PollEvent(&evet)){
			fin = Handle_SDL_Event(&evet, window, p_mod);
		}
	}
}
 
Uint32 Wrapper::EventCont::CreateTimerRefresh(Uint32 interval, void* p_mod){
	SDL_UserEvent userevent;
	userevent.type = SDL_USEREVENT;
	userevent.code = UserEventKind::ANIMATION_TIMER;
	userevent.data1 = (void*)p_mod;
	userevent.data2 = nullptr;
 
	SDL_Event evet;
	evet.type = SDL_USEREVENT;
	evet.user = userevent;
	SDL_PushEvent(&evet);
 
	return interval;
}
 
bool Wrapper::EventCont::Handle_SDL_Event(const SDL_Event* p_evet, SDL_Window* p_window, Model* p_mod){
	switch(p_evet->type){
		case SDL_MOUSEBUTTONDOWN:
			switch(p_evet->button.button){
				case SDL_BUTTON_LEFT:
					MouseData::leftButtonPressed = true;
					MouseData::mousex = p_evet->button.x;
					MouseData::mousey = p_evet->button.y;
					break;
				default:
					break;
			}
			break;
		case SDL_MOUSEBUTTONUP:
			switch(p_evet->button.button){
				case SDL_BUTTON_LEFT:
					MouseData::leftButtonPressed = false;
					break;
				default:
					break;
			}
			break;
		case SDL_MOUSEMOTION:
			if(MouseData::leftButtonPressed){
				p_mod->upMouseMo(p_evet->motion.x - MouseData::mousex, 
								p_evet->motion.y - MouseData::mousey);
				MouseData::mousex = p_evet->button.x;
				MouseData::mousey = p_evet->button.y;
			}
			break;
		case SDL_USEREVENT:
			if(p_evet->user.code == UserEventKind::ANIMATION_TIMER){
				p_mod->update();
				SDL_GL_SwapWindow(p_window);
			}
			break;
		case SDL_WINDOWEVENT:
			int w, h;
			SDL_GetWindowSize(p_window, &w, &h);
			p_mod->Redimentionner(w, h);
			break;
		case SDL_QUIT:
			return true;
			break;
		default:
			break;
	}
 
	return false;
}

ensuite la déclaration de la classe EventCont se fait dans Wrapper.h car c'est une classe imbriqué à la classe Wrapper :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#ifndef WRAPPER_H
#define WRAPPER_H
 
#include "SDL2/SDL.h"
#include "Model.h"
 
class Wrapper{
 
public:
	Wrapper(int largeurFeInit, int hauteurFeInit, const char* titre, int argc, char**argv);
	~Wrapper() = default;
	static int getTicks();
 
private:
 
	class WindowManager{
 
	public:
		WindowManager(int largeurFeInit, int hauteurFeInit, const char** titre);
		~WindowManager();
		SDL_Window* const getP_Window();
 
	private:
		SDL_Window* mP_Window;
		SDL_GLContext* mP_Context;
		static SDL_Window* init_SDL_Window(int windwoWidth, int windwoHeigth, const char** titre);
 
		WindowManager(const &WindowManager) = delete;
		WindowManager & operator = (const WindowManager&) = delete;
	};
 
	class EventCont{
 
	public:
		static void Init(SDL_Window* window, Model* p_mod);
 
	private:
		enum UserEventKind{
			ANIMATION_TIMER = 0
		};
 
		static bool Handle_SDL_Event(const SDL_Event* p_evet, SDL_Window* p_window, Model* p_mod);
		static void EventsLoop(SDL_Window* window, Model* p_mod);
		static Uint32 CreateTimerRefresh(Uint32 interval, void* p_mod);
 
		static SDL_TimerID mTimerID;
	};
 
	WindowManager mWindowManager;
	Model mModel;
};
 
#endif //WRAPPER_H

Merci d'avance pour votre aide !

[LittleWhite]

Bonjour,

Pour d'autres "cours" vous avez cette page des tutoriels disponibles sur Developpez.com : https://opengl.developpez.com/tutoriels/
Ma crainte est que les cours de Remy Malgouyres (c'était un de mes profs d'ailleurs) utilisent OpenGL 1 (ou 2.1) mais pas OpenGL 3 (ou autrement nommé, OpenGL moderne).

Pour l'erreur que vous indiquez, le problème c'est que vous ne donnez pas la ligne provoquant l'erreur. Donc dur pour nous de savoir ce dont il en retourne.

[Vinkkk]

Bonjour,
Merci pour votre réponse. J'ai résolu mon problème en changeant l'ordre des fichiers à compiler ce qui ma permis de régler les problèmes des autres fichiers avant.

Pour ce qui est du cours :
Au début du cours il dit utiliser OpenGL 3.0, mais je ne sais pas où j'ai entendu ça mais je crois que l'utilisation de glBegin() et glEnd() signifie que l'on ne fais pas d'OpenGL moderne (je me trompe peut-être).
En plus j'ai vu qu'il travail à l'Université d'Auvergne (si c'est toujours d'actualité) donc si j'ai besoin de lui poser une question sur son cours j'irais le voir directement ^^

[Garvelienn]

Pour ce qui est du cours :
Au début du cours il dit utiliser OpenGL 3.0, mais je ne sais pas où j'ai entendu ça mais je crois que l'utilisation de glBegin() et glEnd() signifie que l'on ne fais pas d'OpenGL moderne (je me trompe peut-être).
En plus j'ai vu qu'il travail à l'Université d'Auvergne (si c'est toujours d'actualité) donc si j'ai besoin de lui poser une question sur son cours j'irais le voir directement ^^

En effet, ce sont des fonctions des anciennes versions d'OpenGL.

Si vous cherchez des tutoriels plus à la page, je vous invite à lire les versions françaises des excellents tutoriels anglophones du site Learn OpenGL : https://opengl.developpez.com/tutori...rendre-opengl/

Ces tutoriels sont idéales pour débuter avec OpenGL Modern.

[Vinkkk]

Merci pour les liens !
Je voulais savoir si c'était intéressant de commencer par du openGL dit "classique" pour ensuite enchaîner sur openGL moderne ? Y a-t-il beaucoup de différence entre les deux versions d'openGL ?

[Kannagi]

Oui , il y a beaucoup de différence et OpenGL 1 n'a que peut d’intérêt vraiment avec le temps , je la trouve assez médiocre en faite

[Garvelienn]

@Vinkkk

Tout dépend ce que vous recherchez. Il est vrai qu'OpenGL 1 et 2 sont un peu obsolètes (quoi que). Mais ces versions sont plus simples à appréhender. OpenGL 3 est plus permissif et surtout plus bas-niveau donc plus compliqué. Cela permet d'avoir des programmes plus optimisés et légers si le développeur fait bien son travail. Cela étant également les possibilités.

OpenGL 3 n'est pas disponible sur les vieux périphériques.

Donc à voir avec votre besoin. Si vous souhaitez apprendre pour le plaisir ou vous former pour un usage futur professionnel, je vous conseille comme Kannagi, OpenGL Modern.

Personnellement, donc avec un avis subjectif, je préfère OpenGL Modern (3 et 4). C'est nettement plus rigolo car vous pouvez bidouiller et trifouiller beaucoup plus (et donc casser encore plus de choses).

[Vinkkk]

Merci pour vos réponses.
Je vais commencer à apprendre OpenGL classique pour avoir des résultats plus rapidement pour ne pas me décourager mais je passerais je pense très vite à OpenGL moderne.