Bonjour alors voilà, j'avais déjà fait un jeu 3D en Java, et maintenant je tente de un faire un autre en C++.

Donc j'ai suivit ce tutoriel, et jusque là pas de problèmes.

Mais comme il était assez court, je suis désormais le tutoriel de ThinMatrix et je l'ai mixer avec l'autre tutoriel, car bon celui de ThinMatrix c'est le plus complet que je connaisse, et il n'y a que quelques trucs qui changent, le code en lui-même ne changeant pas.

Voilà sa c'était pour la petite histoire, passons au problème en lui-même :

J'arrive a afficher une fenêtre (noire), mais quand je veut dessiner un carré, bah il veut plus. Alors après avoir fouiller pendant toute la matinée, j'ai trouvé que glGetError() == GL_INVALID_ENUM, et après une petite hiérarchie, j'en viens à la méthode glewInit() ; avant son appel il n'y a rien, après l'erreur survient. À noté que l'initialisation revoie GLEW_OK.

Après quelques recherchent que demandent d'enlever des lignes que je n'ai pas, d'ajouter des librairies qui ne marchent pas, donc je me tourne vers vous

La méthode en question (tout les includes sont bons, il compile) :

bool OpenGlScene::ini() {
	cout << "Initializing SDL... ";

	// Initialisation de la SDL
	if(SDL_Init(SDL_INIT_VIDEO) < 0) {
		cout << "FAILURE\n" << endl;

		cerr << SDL_GetError() << endl;
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		return false;
	}

	cout << "COMPLETE\nSettings attributes... ";

	// Version d'OpenGL

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);

	// Double Buffer

	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

	cout << "COMPLETE\nCreating window... ";

	// Création de la fenêtre

	m_window = SDL_CreateWindow("Sentinel", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);

	if(m_window == 0) {
		cout << "FAILURE\n" << endl;

		cerr << SDL_GetError() << endl;
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		return false;

	}

	cout << "COMPLETE\nCreating OpenGL context... ";

	// Création du contexte OpenGL

	m_glContext = SDL_GL_CreateContext(m_window);
	if(m_glContext == 0) {
		cout << "FAILURE\n" << endl;

		cerr << SDL_GetError() << endl;
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		return false;

	}

	cout << "COMPLETE\nInitializing Glew... ";

	glewExperimental = GL_FALSE; // Ne change rien si mit sur true ou false

	// Initialisation de Glew
	GLenum GLEWInit(glewInit());
	GLenum GLEWErr = glGetError();

	// Ici, GLEWInit == GLEW_OK et GLErr == GL_INVALID_ENUM
	if((GLEWInit != GLEW_OK) | (GLEWErr != GL_NO_ERROR)) {
		cout << "FAILURE\n" << endl;
		if(GLEWInit != GLEW_OK) cerr << "Can't init glew: " << glewGetErrorString(GLEWInit) << endl;
		else cerr << "Can't init glew: " << gluErrorString(GLEWErr) << endl;
		cerr << "Experimental: " << ((glewExperimental == GL_TRUE) ? "true" : "false") << endl;

		SDL_GL_DeleteContext(m_glContext);
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		return false;

	}

	cout << "COMPLETE\nInitializing input... ";
	Input::ini();

	cout << "COMPLETE\nLoading Render Engine... ";
	if(!m_render.load()) {
		cout << "FAILURE\n" << endl;
		cerr << "Can't load render engine!" << endl;

		SDL_GL_DeleteContext(m_glContext);
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		return false;
	}

	cout << "COMPLETE\nLoading Logic Engine... ";
	if(!m_logic.load()) {
		cout << "FAILURE\n" << endl;
		cerr << "Can't load logic engine!" << endl;

		SDL_GL_DeleteContext(m_glContext);
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		return false;
	}

	// Boucle principale

	cout << "COMPLETE\n\n*** Entering main game loop ***" << endl;
	loop();

	return true;
}

Et le résultat :

Initializing SDL... COMPLETE
Settings attributes... COMPLETE
Creating window... COMPLETE
Creating OpenGL context... COMPLETE
Initializing Glew... FAILURE

Can't init glew: Énumérant non valide
Experimental: false

Merci pour toutes vos futures réponses,

Cordialement, ShE3py.

Salut,

Déjà, est-il normal que tu essaye de faire appel à la fonction GLEWInit() (c'est quoi cette fonction, d'ailleurs?) en lui transmettant le résultat de l'appel à glewInit() (qui est la fonction qu'il faut appeler, et qui ne demande aucun paramètre)???

Pour le reste, un petit tour sur cette page devrait te fournir des réponses et t'indiquer comment t'y prendre

Déjà ;

GLenum GLEWInit(glewInit());
// est strictement égal à
GLenum GLEWInit = glewInit();

(Oui le nom respecte pas la convention mais c'était dans le tuto alors bon)

Et sinon pour ta page, tu pense bien que j'ai fait le wiki et le tour des forums avant de passer 10 minutes à créer un topic

Et la traduction de l'api, sa donne

Vous pouvez toujours obtenir GL_INVALID_ENUM (en fonction de la version de Glew vous utilisez), mais au moins Glew ignore glGetString(GL_EXTENSIONS) et obtient tous les pointeurs de fonction.

Mais je comprend pas si sa veut dire que sa marche quand même, car il ne rend rien à l'écran, et j'ai vérifier mon code plusieurs fois.

-
Edité par Anonyme 25 mai 2017 à 18:12:53

On peut voir le reste de ton code, du coup ?

Main.cpp :

#include <iostream>

#include "render/OpenGlScene.h"
#include "Sentinel.h"

using namespace std;

int main(int argc, char* argv[]) {
	cout << "***** SENTINEL DEBUGGING *****\n\n";

	OpenGlScene scene;
	if(!scene.ini()) return -1;

	return Sentinel::returnCode;
}

render/OpenGlScene.h :

#ifndef OPENGLSCENE_H_
#define OPENGLSCENE_H_

#include <ctime>
#include <cstdio>
#include <string>
#include <sstream>
#include <iostream>

#include "glm/glm.hpp"
#include "glm/gtc/type_ptr.hpp"
#include "glm/gtx/transform.hpp"
#include "GL/glew.h"
#include "GL/glu.h"
#include "SDL2/SDL.h"
#include "RenderSettings.h"
#include "RenderEngine.h"
#include "../logic/LogicEngine.h"

#include "../Sentinel.h"
#include "../core/SentinelPopup.h"
#include "../utils/StringUtils.h"
#include "../system/Input.h"

class OpenGlScene {
	public:
		OpenGlScene();

		bool ini();

	private:
		SDL_Window* m_window;
		SDL_GLContext m_glContext;

		RenderEngine m_render;
		LogicEngine m_logic;

		void loop();
		void onFrame();
		void onTick();

		void cleanUp();
};

#endif

render/OpenGlScene.cpp :

#include "OpenGlScene.h"

#define CANT_INIT_SDL SentinelPopup::p0x00001
#define CANT_CREATE_WINDOW SentinelPopup::p0x00002
#define CANT_CREATE_OPENGL_CONTEXT SentinelPopup::p0x00003
#define CANT_INIT_GLEW SentinelPopup::p0x00004
#define CANT_LOAD_RENDER_ENGINE SentinelPopup::p0x00005
#define CANT_LOAD_LOGIC_ENGINE SentinelPopup::p0x00006
#define OPENGL_ERROR SentinelPopup::p0x00007

using namespace std;
using namespace glm;

// Constructeur
OpenGlScene::OpenGlScene() : m_window(0), m_glContext(0) {}

bool OpenGlScene::ini() {
	cout << "Initializing SDL... ";

	// Initialisation de la SDL
	if(SDL_Init(SDL_INIT_VIDEO) < 0) {
		cout << "FAILURE\n" << endl;

		cerr << SDL_GetError() << endl;
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		Sentinel::pop(CANT_INIT_SDL);

		return false;
	}

	cout << "COMPLETE\nSettings attributes... ";

	// Version d'OpenGL

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);

	// Double Buffer

	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

	cout << "COMPLETE\nCreating window... ";

	// Création de la fenêtre

	m_window = SDL_CreateWindow("Sentinel", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, render::WINDOW_WIDTH, render::WINDOW_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);

	if(m_window == 0) {
		cout << "FAILURE\n" << endl;

		cerr << SDL_GetError() << endl;
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		Sentinel::pop(CANT_CREATE_WINDOW);

		return false;

	}

	cout << "COMPLETE\nCreating OpenGL context... ";

	// Création du contexte OpenGL

	m_glContext = SDL_GL_CreateContext(m_window);
	if(m_glContext == 0) {
		cout << "FAILURE\n" << endl;

		cerr << SDL_GetError() << endl;
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		Sentinel::pop(CANT_CREATE_OPENGL_CONTEXT);

		return false;

	}

	cout << "COMPLETE\nInitializing Glew... ";
	cout << glewIsSupported("GL_VERSION_3_10") << endl;

	glewExperimental = GL_TRUE;

	// Initialisation de Glew
	GLenum GLEWInit(glewInit());
	GLenum GLEWErr = glGetError();

	if((GLEWInit != GLEW_OK) | (GLEWErr != GL_NO_ERROR)) {
		cout << "FAILURE\n" << endl;
		if(GLEWInit != GLEW_OK) cerr << "Can't init glew: " << glewGetErrorString(GLEWInit) << endl;
		else cerr << "Can't init glew: " << gluErrorString(GLEWErr) << endl;
		cerr << "Experimental: " << ((glewExperimental == GL_TRUE) ? "true" : "false") << endl;

		SDL_GL_DeleteContext(m_glContext);
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		Sentinel::pop(CANT_INIT_GLEW);

		return false;

	}

	cout << "COMPLETE\nInitializing input... ";
	Input::ini();

	cout << "COMPLETE\nLoading Render Engine... ";
	if(!m_render.load()) {
		cout << "FAILURE\n" << endl;
		cerr << "Can't load render engine!" << endl;

		SDL_GL_DeleteContext(m_glContext);
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		Sentinel::pop(CANT_LOAD_RENDER_ENGINE);

		return false;
	}

	cout << "COMPLETE\nLoading Logic Engine... ";
	if(!m_logic.load()) {
		cout << "FAILURE\n" << endl;
		cerr << "Can't load logic engine!" << endl;

		SDL_GL_DeleteContext(m_glContext);
		SDL_DestroyWindow(m_window);
		SDL_Quit();

		Sentinel::pop(CANT_LOAD_LOGIC_ENGINE);

		return false;
	}

	// Boucle principale

	cout << "COMPLETE\n\n*** Entering main game loop ***" << endl;
	loop();

	return true;
}

void OpenGlScene::loop() {
	// Variables

	unsigned int frameRate(1000 / render::MAX_FPS);
	Uint32 start(0), stop(0), duration(0);

	int lastFrame = time(0);
	int fps = 0;

	int lastTick = time(0);
	int tps = 0;

	int lastFps = 0;
	int lastTps = 0;

	// Boucle

	while(!Input::exitRequest() & (Sentinel::returnCode == 0)) {
		start = SDL_GetTicks();

		// Mise à jours du nom de la fenêtre
		ostringstream sstream;
		sstream << "Sentinel — " << lastFps << " fps — " << lastTps << " tps";

		SDL_SetWindowTitle(m_window, sstream.str().c_str());

		// Gestion des TPS
		if(time(0) > lastTick) {
			lastTps = tps;

			lastTick = time(0);
			tps = 0;
		}
		if((render::MAX_TPS == -1 )| (tps < render::MAX_TPS)) {
			tps++;

			onTick();
		}

		// Gestion des FPS
		if(time(0) > lastFrame) {
			lastFps = fps;

			lastFrame = time(0);
			fps = 0;
		}
		if((render::MAX_FPS == -1) | (fps < render::MAX_FPS)) {
			fps++;

			onFrame();
		}

		// Vérification s'il n'y a pas d'erreur d'OpenGL

		GLenum error = glGetError();
		if(error != GL_NO_ERROR) {
			cerr << "OpenGL error: ";
			cerr << gluErrorString(error) << endl;

			string errCode = StringUtils::concatenate("", error);
			string array[1][2] = {{"error", errCode}};

			SentinelPopup popup = /*SentinelPopup::derive(*/OPENGL_ERROR/*, array)*/;
			Sentinel::pop(popup);

			break;
		}

		// Attente

		stop = SDL_GetTicks();
		duration = stop - start;

		if(duration < frameRate) SDL_Delay(frameRate - duration);
	}

	cleanUp();
}

void OpenGlScene::onFrame() {
	/*
	 * Attribues :
	 *
	 * 0 -> vertices
	 * 1 -> colors
	 * 2 -> texture coords
	 */

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	m_render.calc();

	SDL_GL_SwapWindow(m_window);
}

void OpenGlScene::onTick() {
	m_logic.calc();
}

void OpenGlScene::cleanUp() {
	cout << "\n*** Stopping ***\n\nDeleting OpenGL context... ";
	SDL_GL_DeleteContext(m_glContext);

	cout << "COMPLETE\nDestroying window... ";
	SDL_DestroyWindow(m_window);

	cout << "COMPLETE\nQuitting SDL... ";
	SDL_Quit();

	cout << "COMPLETE\n\nSuccessfull stopping." << endl;
}

core/Engine.h (il n'y a pas de .cpp) :

#ifndef CORE_ENGINE_H_
#define CORE_ENGINE_H_

class Engine {
	public:
		Engine();
		virtual ~Engine();

		virtual bool load() = 0;
		virtual void calc() = 0;
};

#endif

render/RenderEngine.h :

#ifndef RENDER_RENDERENGINE_H_
#define RENDER_RENDERENGINE_H_

#include <vector>

#include "GL/glew.h"

#include "../core/Engine.h"
#include "../gpu/GPULoader.h"
#include "../models/RawModel.h"

class RenderEngine : public Engine {
	public:
		RenderEngine();
		virtual ~RenderEngine();

		bool load();
		void calc();

	private:
		RawModel m_model;
};

#endif

render/RenderEngine.cpp :

#include "RenderEngine.h"

#include <iostream>

#include "GL/glu.h"

using namespace std;

RenderEngine::RenderEngine() : m_model(0, 0) {

}

RenderEngine::~RenderEngine() {

}

bool RenderEngine::load() {
	GPULoader loader;

	m_model = loader.loadToVAO(vector<float> {
		-0.5f, 0.5f, 0.0f,
		-0.5f, -0.5f, 0.0f,
		0.5f, -0.5f, 0.0f,
		0.5f, -0.5f, 0.0f,
		0.5f, 0.5f, 0.0f,
		-0.5f, 0.5f, 0.0f
	});

	return true;
}

void RenderEngine::calc() {
	glBindVertexArray(m_model.getVaoId());
	glEnableVertexAttribArray(0);

	glDrawArrays(GL_TRIANGLES, 0, m_model.getVertexCount());

	glDisableVertexAttribArray(0);
	glBindVertexArray(0);
}

gpu/GPULoader.h :

#ifndef GPU_GPULOADER_H_
#define GPU_GPULOADER_H_

#include <vector>

#include "VAO.h"
#include "VBO.h"
#include "../models/RawModel.h"

class GPULoader {
	public:
		GPULoader();
		virtual ~GPULoader();

		RawModel loadToVAO(std::vector<float> const& floats);
};

#endif

gpu/GPULoader.cpp :

#include "GPULoader.h"

#include <iostream>

using namespace std;

GPULoader::GPULoader() {}

GPULoader::~GPULoader() {}

RawModel GPULoader::loadToVAO(vector<float> const& floats) {
	VAO vao;
	vao.bind();
	vao.setVBO(VBO(0, floats));
	vao.unbind();

	return RawModel(vao.getId(), floats.size() / 3);
}

gpu/VAO.h :

#ifndef GPU_VAO_H_
#define GPU_VAO_H_

#include <vector>

#include "GL/glew.h"

#include "VBO.h"

class VAO {
	public:
		VAO(std::vector<VBO> const& vbos);
		VAO();
		virtual ~VAO();

		std::vector<VBO>& getVBOs();
		VBO& getVBO(int index);
		void setVBO(VBO const& vbo);

		void bind() const;
		void unbind() const;

		int size() const;
		GLuint getId() const;

	private:
		std::vector<VBO> m_vbos;
		GLuint m_id;
};

#endif

gpu/VAO.cpp :

#include "VAO.h"

using namespace std;

VAO::VAO(vector<VBO> const& vbos) : m_vbos(vbos) {
	glGenVertexArrays(1, &m_id);
}

VAO::VAO() : m_vbos() {
	glGenVertexArrays(1, &m_id);
}

VAO::~VAO() {
	glDeleteVertexArrays(1, &m_id);
}

vector<VBO>& VAO::getVBOs() {
	return m_vbos;
}

VBO& VAO::getVBO(int index) {
	return m_vbos[index];
}

void VAO::setVBO(VBO const& vbo) {
	int index = vbo.getAttributeNumber();

	if(m_vbos.size() <= (unsigned int) index) m_vbos.push_back(vbo);
	else m_vbos[index] = vbo;
}

void VAO::bind() const {
	glBindVertexArray(m_id);
}

void VAO::unbind() const {
	glBindVertexArray(0);
}

int VAO::size() const {
	return m_vbos.size();
}

GLuint VAO::getId() const {
	return m_id;
}

gpu/VBO.h :

#ifndef GPU_VBO_H_
#define GPU_VBO_H_

#include <vector>

#include "GL/glew.h"

class VBO {
	public:
		VBO(int attribute, std::vector<float> const& data);
		virtual ~VBO();

		std::vector<float>& getData();

		GLuint getId() const;
		int getAttributeNumber() const;
		int size() const;

	private:
		std::vector<float> m_data;
		GLuint m_id;
		int m_attribute;
};

#endif

gpu/VBO.cpp :

#include "VBO.h"

using namespace std;

VBO::VBO(int attribute, vector<float> const& data) : m_data(data), m_attribute(attribute) {
	glGenBuffers(1, &m_id);

	glBindBuffer(GL_ARRAY_BUFFER, m_id);
	glBufferData(GL_ARRAY_BUFFER, data.size(), data.data(), GL_STATIC_DRAW);
	glVertexAttribPointer(attribute, 3, GL_FLOAT, false, 0, 0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
}

VBO::~VBO() {
	glDeleteBuffers(1, &m_id);
}

vector<float>& VBO::getData() {
	return m_data;
}

GLuint VBO::getId() const {
	return m_id;
}

int VBO::getAttributeNumber() const {
	return m_attribute;
}

int VBO::size() const {
	return m_data.size();
}

models/RawModel.h :

#ifndef MODELS_RAWMODEL_H_
#define MODELS_RAWMODEL_H_

#include "GL/glew.h"

class RawModel {
	public:
		RawModel(GLuint vaoId, int vertexCount);
		virtual ~RawModel();

		GLuint getVaoId() const;
		int getVertexCount() const;

	private:
		GLuint m_vaoId;
		int m_vertexCount;
};

#endif

models/RawModel.cpp :

#include "RawModel.h"

RawModel::RawModel(GLuint vaoId, int vertexCount) : m_vaoId(vaoId), m_vertexCount(vertexCount) {}

RawModel::~RawModel() {}

GLuint RawModel::getVaoId() const {
	return m_vaoId;
}

int RawModel::getVertexCount() const {
	return m_vertexCount;
}

Je crois que j'ai tout mis, désolé du temps de réponse.

1- Ta fonction ini est beaucoup trop grande : près de 130 lignes, c'est au moins 4 fois trop!!!  D'autant plus qu'elle prend en réalité de nombreuses responsabilité:

• lignes 17 à 31 : SDL_ini et la gestion du résultat
• lignes 33 à 43 : définition de quelques attributs de la SDL
• lignes 49 à 64 : SDL_CreateWindow et gestion du résultat
• ligne 68 à 83: SDL_GL_CreateContext et gestion du résultat
• lignes 85 à 105 : glewInit et gestion du résultat
• lignes 107 et 108: Input::ini()
• lignes 110 à 122 : m_render.load et gestion du résultat
• 124 à 136 :m_logic.load et gestion du résultat

Cela représente donc 8 responsabilités, qui devraient donc être réparties au travers ... de huit fonctions différentes.

2- Chacune de ces responsabilités (hormis la deuxième) fait intervenir un processus qui n'est pas sensé échouer, mais qui peut malgré tout survenir, et auquel le développeur (c'est à dire toi) ne peut absolument rien à ce niveau ci.

Je pourrais expliquer les choses différemment et te dire que, si l'un de ces processus échoue, il te met dans l'impossibilité d'assurer les post conditions de ton travail, vu que "quelque chose" ne sera pas correctement initialisé.

C'est, typiquement, une situation exceptionnelle, qui, bien qu'elle ne doive pas survenir, peut arriver dans certaines circonstances.  Si on n'utilise pas les exceptions dans ce genre de cas, nous ne les utiliserons jamais ==> au lieu de renvoyer false, lance une exception, c'est le moyen "officiel" en C++ de dire que "quelque chose (à laquelle le développeur ne peut rien) s'est mal passé"

Il y aurait aussi quelques trucs à dire sur ta fonction loop, mais je vais déjà te laisser digérer ceci

Pour la longue fonction, moi sa me dérange un peu de créer 8 fonctions avec 2-3 lignes dedans :/

Et sinon, cela veut dire que sa ne marche pas et que je peut rien n'y faire?
J'ai essayé de mettre à jours les librairies (qui dataient de 2013), mais maintenant j'ai des undefined references un peu partout (extrait) :

/src/gpu/VBO.cpp:16: undefined reference to `_imp____glewBufferData'
/src/gpu/VBO.cpp:17: undefined reference to `_imp____glewVertexAttribPointer'
/src/gpu/VBO.cpp:18: undefined reference to `_imp____glewBindBuffer'
src\gpu\VBO.o: In function `ZN3VBOD2Ev':
/src/gpu/VBO.cpp:22: undefined reference to `_imp____glewDeleteBuffers'
src\render\OpenGlScene.o: In function `ZN11OpenGlScene3iniEv':
/src/render/OpenGlScene.cpp:28: undefined reference to `SDL_Init'
/src/render/OpenGlScene.cpp:31: undefined reference to `SDL_GetError'

[...]

c:/mingw/bin/../lib/gcc/mingw32/5.3.0/../../../libmingw32.a(main.o):(.text.startup+0xa0): undefined reference to `WinMain@16'
collect2.exe: error: ld returned 1 exit status

Et je ne comprend pas d'où sa viens, j'ai ajouter les librairies, j'ai configurer les includes et mit les dlls dans le même dossier (je pense justement qu'il ne lit pas les dlls, d'où les undefined references).

Cordialement,

ShE3py.

ShE3pyGame a écrit:

Pour la longue fonction, moi sa me dérange un peu de créer 8 fonctions avec 2-3 lignes dedans :/

Et pourquoi donc? Tu n'es pas obligé de les rendre accessibles à tout le monde (l'accessibilité privée, elle sert aussi à te permettre de créer des fonction "à usage interne only" :D), mais ca rend facilite la compréhension générale, et, partant, la maintenance en cas de problème.

En plus, il s'agit de respecter un principe fondamental de la programmation connu sous le nom de SRP (pour Single Responsability Principle ou, si tu préfères en français : le principe de la responsabilité unique)

Si tu hésites à créer huit fonction avec quatre ou cinq lignes dedans (d'autant plus que je suis sur que tu n'hésites pas forcément autant que tu ne le crois... combien d'accesseurs -- qui ne sont composés que d'une instruction return XXX_;, voire d'une assertion juste avant -- as tu dans tes différentes classes???), où vas tu mettre la limite? à 10 ignes?

mais, si tu hésites pour dix lignes, pourquoi ne pas hésiter pour quinze? Et si tu hésites pour quinze lignes, pourquoi ne pas hésiter pour vingt ou pour trente?

Tu imagines un peu le résultat que cela te donnera si tu hésites à créer quelques fonctions (mettons, dix) "de seulement trente lignes", et que, du coup, tu te retrouve à créer une seule fonction qui regroupe les dix responsabilités?

Et sinon, cela veut dire que sa ne marche pas et que je peut rien n'y faire?
J'ai essayé de mettre à jours les librairies (qui dataient de 2013), mais maintenant j'ai des undefined references un peu partout (extrait) :

/src/gpu/VBO.cpp:16: undefined reference to `_imp____glewBufferData'
/src/gpu/VBO.cpp:17: undefined reference to `_imp____glewVertexAttribPointer'
/src/gpu/VBO.cpp:18: undefined reference to `_imp____glewBindBuffer'
src\gpu\VBO.o: In function `ZN3VBOD2Ev':
/src/gpu/VBO.cpp:22: undefined reference to `_imp____glewDeleteBuffers'
src\render\OpenGlScene.o: In function `ZN11OpenGlScene3iniEv':
/src/render/OpenGlScene.cpp:28: undefined reference to `SDL_Init'
/src/render/OpenGlScene.cpp:31: undefined reference to `SDL_GetError'

[...]

c:/mingw/bin/../lib/gcc/mingw32/5.3.0/../../../libmingw32.a(main.o):(.text.startup+0xa0): undefined reference to `WinMain@16'
collect2.exe: error: ld returned 1 exit status

Et je ne comprend pas d'où sa viens, j'ai ajouter les librairies, j'ai configurer les includes et mit les dlls dans le même dossier (je pense justement qu'il ne lit pas les dlls, d'où les undefined references).

Cordialement,

ShE3py.

Les erreur de type "undefined reference to XXX" sont des erreurs lancées par l'éditeur de liens, c'est à dire, par le dernier outil dont le rôle est de regrouper tous les fichiers objets créés lors de la compilation et toutes les fonctions issues des bibliothèques tierces en un exécutable unique.

Par cette erreur, il t'indique qu'il n'a pas trouvé le symbole qui correspond à l'appel d'une fonction, et, comme tous les noms commencent par glew, il semblerait que tu as, tout simplement, oublié de lui dire d'aller voir à l'intérieur de la bibliothèque glew s'il n'y trouverait pas ce qui lui manque

Bah tu pense bien que j'ai vérifier les librairies quand même :')
La commande MinGW :

g++ "-LC:\\Users\\Qqn\\Desktop\\Eclipse C++\\projects\\Sentinel\\Client\\libs\\lib" -o Client.exe "src\\Main.o" "src\\Sentinel.o" "src\\core\\Engine.o" "src\\core\\Lang.o" "src\\core\\SentinelPopup.o" "src\\gpu\\GPULoader.o" "src\\gpu\\VAO.o" "src\\gpu\\VBO.o" "src\\logic\\LogicEngine.o" "src\\models\\RawModel.o" "src\\render\\OpenGlScene.o" "src\\render\\RenderEngine.o" "src\\system\\Input.o" "src\\utils\\StringUtils.o" -lopengl32 -lglew32 -lglu32 -lSDL2 -lSDL2main 

Mais il n'arrive pas à trouver les références, j'ai pourtant bien linker les libs.

Si c'était une erreur que pour glew j'aurais chercher un peu plus loin, mais il fait sa aussi pour la SDL.

Et pour tes méthodes privées, sache que je code en Java, donc private public protected package je connais

Et pour tes 8 méthodes, je pense aussi que cela peut rendre la visibilité meilleure, mais sur mon IDE j'ai des sortes de spoilers que je peut mettre pour justement réduire la taille du code (donc pour chaque méthode que tu veut faire le code tiens en une ligne une fois fermé), et bon ça sa dépend plus du développeur en fonction de ses attentes, et moi je suis justement très maniaque dans ma façon de coder

Pourquoi de l'escaping à la C de chemins à coup de "\\" dans une ligne de commande qui n'est pas dans du code C ou C++ ???

Suivez les conseils éclairés de @koala01.

ShE3pyGame a écrit:

Et pour tes 8 méthodes, je pense aussi que cela peut rendre la visibilité meilleure, mais sur mon IDE j'ai des sortes de spoilers que je peut mettre pour justement réduire la taille du code (donc pour chaque méthode que tu veut faire le code tiens en une ligne une fois fermé), et bon ça sa dépend plus du développeur en fonction de ses attentes, et moi je suis justement très maniaque dans ma façon de coder

Et ceux qui utilisent un outil différent pour lire ton code (je sais pas, moi, nano, par exemple : un petit éditeur de texte qui fonctionne en ligne de commande), ils font quoi?

En plus, ce n'est pas (ou du moins pas tout à fait) le nombre de lignes affiché qui pose problème, c'est la "compréhensibilité" du code. Car le premier destinataire de ton code n'est pas le compilateur (qui s'en foutrait royalement d'avoir une fonction de 150 000 lignes) comme tu sembles le penser, mais c'est un humain : le type qui devra relire (ou pire, tester ou modifier) ton code.  Et cet humain, ce pourrait être toi, dans un mois, dans six mois ou dans un an.  Soit, bien longtemps après avoir eu tout le temps nécessaire pour oublier ce que tu voulais faire dans cette fonction de 150 lignes!

Or, il n'y a rien à faire: si tu as huit responsabilités, il est à la fois plus facile de comprendre et de tester fait chacune d'elles si elles sont clairment séparée que... si elles sont toutes emmêlées les unes dans les autres (ou qu'elles utilisent le résultat de l'une comme point de départ)

En séparant tes huit responsabilités en autant de fonctions différentes, tu obtiendra quelque chose ressemblant à

void fonctionQuiFaitPif(){
   /* dix à douze lignes ici */
}
void fonctionQuiFaitPaf(){
   /* dix à douze lignes ici, peut être moins,
    * idéaement pas plus de deux fois autant
    */
}
void fonctionQuiFaitPouf(){
   /* dix à douze lignes ici, peut être moins,
    * idéaement pas plus de deux fois autant
    */
}
void fonctionQuiFaitBrol(){
   /* dix à douze lignes ici, peut être moins,
    * idéaement pas plus de deux fois autant
    */
}
void fonctionQuiFaitBidule(){
   /* elle est beaucoup plus petite : deux lignes à peine */
}
void fonctionQuiFaitMachin(){
   /* celle-ci se contente d'une ligne */
}

si bien que tu pourras voir l'intégralité de ta fonction sans avoir besoin de jouer avec les fonctions de pliage ou d'ascenseur de ton EDI/éditeur de texte.  Et tu auras facile à les comprendre, à les tester et à les corriger au besoin!

Sans compter le fait que, même si ce n'est pas le cas dans le code que tu présentes (les choses doivent être entreprises dans un ordre bien précis), tu pourras choisir de les effectuer selon n'importe quel ordre imposé par tes besoin, et non selon un ordre imposé par le fait que toutes les responsabilités sont regroupées au sein d'une seule et même fonction.

Par contre, si tu regroupe toutes les responsabilités au sein d'une seule et même fonction, le système de pliage ne t'aidera sans doute pas à comprendre ce qui se passe à l'intérieur de cette fonction, si bien que tu devra suivre son cheminement depuis le début afin d'espérer trouver "où s'arrête l'une et où commence l'autre" (en espérant déjà qu'elles ne soient pas plus emmêlées que le noeud gordien).

Mais, en plus, tu ne pourra plus tester le résultat de chacune d'elle séparément: tu ne pourras tester que... le résultat global de l'ensemble.

Bref, tu peux me croire sur parole lorsque je te dis que tu as tout à gagner à séparer les différentes responsabilités, même celles qui ne nécessitent qu'un nombre (très) restreint d'instructions.  Je dirais même surtout celles qui ne nécessitent qu'un nombre (très) restreint d'instructions, car ce sont très certainement celles dont tu auras, de par leur nature même, sans doute besoin le plus souvent

okbacelar a écrit:

Pourquoi de l'escaping à la C de chemins à coup de "\\" dans une ligne de commande qui n'est pas dans du code C ou C++ ???

Suivez les conseils éclairés de @koala01.

C'est généré tout seul pas mon IDE.

koala01 a écrit:

ShE3pyGame a écrit:

Et pour tes 8 méthodes, je pense aussi que cela peut rendre la visibilité meilleure, mais sur mon IDE j'ai des sortes de spoilers que je peut mettre pour justement réduire la taille du code (donc pour chaque méthode que tu veut faire le code tiens en une ligne une fois fermé), et bon ça sa dépend plus du développeur en fonction de ses attentes, et moi je suis justement très maniaque dans ma façon de coder

Et ceux qui utilisent un outil différent pour lire ton code (je sais pas, moi, nano, par exemple : un petit éditeur de texte qui fonctionne en ligne de commande), ils font quoi?

En plus, ce n'est pas (ou du moins pas tout à fait) le nombre de lignes affiché qui pose problème, c'est la "compréhensibilité" du code. Car le premier destinataire de ton code n'est pas le compilateur (qui s'en foutrait royalement d'avoir une fonction de 150 000 lignes) comme tu sembles le penser, mais c'est un humain : le type qui devra relire (ou pire, tester ou modifier) ton code.  Et cet humain, ce pourrait être toi, dans un mois, dans six mois ou dans un an.  Soit, bien longtemps après avoir eu tout le temps nécessaire pour oublier ce que tu voulais faire dans cette fonction de 150 lignes!

Or, il n'y a rien à faire: si tu as huit responsabilités, il est à la fois plus facile de comprendre et de tester fait chacune d'elles si elles sont clairment séparée que... si elles sont toutes emmêlées les unes dans les autres (ou qu'elles utilisent le résultat de l'une comme point de départ)

[...]

Cordialement,

ShE3py.

-
Edité par Anonyme 30 mai 2017 à 18:58:21

>tu peut m'aider à résoudre mon problème ?

Lisez les réponses, Bordel !!!

Vous n'avez pas à escaper les backslash '\' dans une commande dans le shell !!!

Au pire, utilisez des slashs.

bacelar a écrit:

>tu peut m'aider à résoudre mon problème ?

Lisez les réponses, Bordel !!!

Vous n'avez pas à escaper les backslash '\' dans une commande dans le shell !!!

Au pire, utilisez des slashs.

Bah vu qu'il arrive à compiler avec les double backslash mais que c'est justement quand j'ajoute les libs qu'il arrive à pas compiler, je pense que ce n'est pas les backslash.

EDIT: Non sa ne marche pas.

-
Edité par Anonyme 30 mai 2017 à 19:05:46

dragonjoker a écrit:

Tu as bien pris les libs adaptées à la plateforme cible ? (x86, x64)