[Operateurs ## et #] Boucle d'appel de fonction paramétrée

Bonjour,

Comme d'habitude, je viens ici pour poser une question un peu tordue.
En gros, en OpenGL, on définit un certain nombre de lumières activables en passant l'appel

Code:

---

glEnable(GL_LIGHTX);

---

Où X est le numéro de la lumière. De base, il y en a jusqu'à 8, mais ça peut aller au-delà. Cette limitation est fixée par la constante GL_MAX_LIGHTS en fonction du système sur lequel OpenGL tourne (software & hardware je suppose).
Maintenant, ce que je voudrais faire, c'est quelque chose comme ça :

Code:

---

1 2 3 4

#define ENABLE_LIGHT(i) glEnable(i); #define ENABLE_LIGHTS for(int i = 0; i < GL_MAX_LIGHTS; ++i) \   ENABLE_LIGHT(GL_LIGHT ## #i);

---

Ce qui dans ma tête aurait pour sortie si on a GL_MAX_LIGHTS = 8 :

Code:

---

1 2 3 4 5

glEnable(GL_LIGHT0); glEnable(GL_LIGHT1); ... glEnable(GL_LIGHT7);

---

Seulement, j'ai une sortie d'erreur du compilateur :

Code:

---

1 2 3

error: pasting "GL_LIGHT" and "#" does not give a valid preprocessing token error: stray '#' in program

---

J'ai essayé de multiples combinaisons, mais pour le coup, ça fonctionne vraiment pas, et ça m'embête bien.
Je me doutais que sous cette forme c'était pas possible, mais je suis certain (pour avoir vu un code dans le thème) que dans l'esprit c'est faisable.

J'ai cherché en vain sur le net, je ne tombe que sur des trucs bien moches avec des appels hideux du genre :

Code:

---

LOOP8(x) glxps(8); LOOP7(x)

---

Bon, après, ce que je me dis, c'est que vu que GL_MAX_LIGHTS sera déterminé par la machine où je compilerai le programme, ça signifie qu'il faudra que je compile obligatoirement ces macros à chaque fois que je veux installer mon application quelque part. Mais c'est pas trop grave ça.

Bref, est-ce que l'un de vous aurait une idée derrière la tête pour faire ce genre de cochonceté ?

Bonsoir,

#i ne sera pas bon, ça transforme i en chaîne de caractère => "i" :aie:
## sert à concaténer, et ne marchera pas non plus : GL_LIGHT ## i => GL_LIGHTi :aie:

Il faudrait que la boucle for soit déroulée à la compilation, un moyen en métaprogrammation existe peut-être, mais m'est inconnu.

Sinon, puisque les GL_LIGHTx sont des define qui se suivent, tu peux essayer ceci

Code:

---

1 2	#define ENABLE_LIGHTS for(int i = 0; i < GL_MAX_LIGHTS; ++i) \   ENABLE_LIGHT(GL_LIGHT0 + i);

---

Si ce n'est pas une erreur et que c'est bien du C++ et non du C...
Ce que tu fais est une horreur et il n'y a pas de raison de faire ça. Faire une macro avec 1 paramètre pour appeler une fonction à 1 paramètre, ça n'a pas de sens. Tu peux bannir (ou presque) les #define en C++.

Code:

---

1 2 3

const GLenum LIGHT_VALUES[8] = { GL_LIGHT0, GL_LIGHT1, GL_LIGHT2, GL_LIGHT3, GL_LIGHT4, GL_LIGHT5, GL_LIGHT6, GL_LIGHT7 }; inline void enableLight(glInt i) { glEnable(LIGHT_VALUES[i]); } inline void enableLights() { for(int i = 0; i < GL_MAX_LIGHTS; ++i) enableLight(i); }

---

Et je conseillerais de passer à de l'OpenGL moderne (> 3.x ou ES 2.0 dans lequel GL_LIGHT est déprécié)

Même si je pense que gbdivers a raison, je donne juste un indice pour réaliser ce que tu demandes initialement :
Il existe une biblitohèque boost pour réaliser de la meta-programmation à l'aide du préprocesseur. Par exemple :
http://www.boost.org/doc/libs/1_48_0...doc/index.html
Et en particulier :
http://www.boost.org/doc/libs/1_48_0...um_params.html

Citation:

---

Envoyé par Bousk

Bonsoir,
Sinon, puisque les GL_LIGHTx sont des define qui se suivent, tu peux essayer ceci

---

Oui, j'y avais pensé. Mais je n'aime pas cette solution dans le sens où elle n'utilise plus les constantes prévues à cet effet, et que je désolidarise le paramétrage de mon contexte OpenGL des conventions. Si jamais les valeurs des lumières changent, je me retrouverai avec un bug.

Citation:

---

Envoyé par gbdivers

Et je conseillerais de passer à de l'OpenGL moderne (> 3.x ou ES 2.0 dans lequel GL_LIGHT est déprécié)

---

Malheureusement, l'OpenGL moderne n'est pas, selon certains, ou peu supporté. Et même si ma machine personnelle est compatible à 100% jusqu'à l'OpenGL 3.3, moi je dois me contenter des versions 1.2 et moins.
Pour ce que tu m'as dit, je comprends, mais l'idée qui me dérange dans le code que tu m'as montré, c'est qu'il prend un nombre de lumières fixes. Alors que selon le système, cela peut varier, il peut y en avoir bien plus que 8.
Je préférerai une solution plus souple, d'où le fait que je regardais du côté des macros pour avoir des GL_LIGHTXX avec un nombre potentiellement grand.
Accessoirement, pourquoi faudrait-il bannir les macros ? Surtout dans ce genre de cas ? La méta-programmation n'est-elle pas une bonne chose, quelle que soit le paradigme de programmation utilisé ?

Citation:

---

Envoyé par JolyLoic

Même si je pense que gbdivers a raison, je donne juste un indice pour réaliser ce que tu demandes initialement :
Il existe une biblitohèque boost pour réaliser de la meta-programmation à l'aide du préprocesseur. Par exemple :
http://www.boost.org/doc/libs/1_48_0...doc/index.html
Et en particulier :
http://www.boost.org/doc/libs/1_48_0...um_params.html

---

Merci beaucoup. C'est exactement ça. Par contre, j'aimerai bien savoir comment ça marche à l'intérieur. Je suppose que je peux regarder le code source de boost, j'ai juste peur qu'il soit illisible comme la plupart du temps.
En tout cas, si ils ont réussi à faire cette fonctionnalité, je suppose que ça veut dire que je pourrai la reproduire sans boost, non ?

Citation:

---

Envoyé par Ylvin

Malheureusement, l'OpenGL moderne n'est pas, selon certains, ou peu supporté. Et même si ma machine personnelle est compatible à 100% jusqu'à l'OpenGL 3.3, moi je dois me contenter des versions 1.2 et moins.
Pour ce que tu m'as dit, je comprends, mais l'idée qui me dérange dans le code que tu m'as montré, c'est qu'il prend un nombre de lumières fixes. Alors que selon le système, cela peut varier, il peut y en avoir bien plus que 8.
Je préférerai une solution plus souple, d'où le fait que je regardais du côté des macros pour avoir des GL_LIGHTXX avec un nombre potentiellement grand.

---

Le pipeline programmable date quand même de OpenGL 2, c'est à dire 2004. Tu peux au moins utiliser cette version. Le pipeline programmable est très bien supporté.
Pour les lumières, les spécifications limitent bien le nombre de lumière à 8 maximum. Peut être que certaine implémentation en propose plus, mais c'est pas portable d'en utiliser plus.
Et il suffit de modifier le code avec un petit hack suivant :

Code:

---

1 2	inline void enableLight(glInt i) { glEnable(GL_LIGHT0 + i); } inline void enableLights() { for(int i = 0; i < GL_MAX_LIGHTS; ++i) enableLight(i); }

---

Citation:

---

Envoyé par Ylvin

Accessoirement, pourquoi faudrait-il bannir les macros ? Surtout dans ce genre de cas ? La méta-programmation n'est-elle pas une bonne chose, quelle que soit le paradigme de programmation utilisé ?

---

Parce que les macros permettent de faire des choses très moches, donc peu maintenables, difficilement évolutives et pas type safe. De plus, je suis pas sur qu'on puisse parler de méta programmation avec les macros. Et les macro ne sont pas un paradigme.

Citation:

---

Envoyé par Ylvin

Je suppose que je peux regarder le code source de boost, j'ai juste peur qu'il soit illisible comme la plupart du temps.

---

Je ne pense pas. Je pense qu'il est en fait bien plus illisible que la plupart du temps... :S

Citation:

---

Envoyé par Ylvin

En tout cas, si ils ont réussi à faire cette fonctionnalité, je suppose que ça veut dire que je pourrai la reproduire sans boost, non ?

---

Oui, assurément. Mais à quel coût ?

Citation:

---

Envoyé par JolyLoic

Je ne pense pas. Je pense qu'il est en fait bien plus illisible que la plupart du temps... :S

---

De mémoire, c'est surtout bien bourin.

Citation:

---

Envoyé par Jean-Marc.Bourguet

De mémoire, c'est surtout bien bourin.

---

Oui, après lecture, c'est en fait un fichier constitué d'appels récursifs écrits en dur. C'est d'une mocheté ahurissante et à part si y a une subtilité qui m'a échappé, c'est une solution limitée à 255 itérations maximum.

Bref, incompatible avec mes aspirations. C'est dommage, parce que je voulais utiliser une méthode de ce style pour faire une version améliorée de boost::reference_wrapper.

En fait, mon objectif final est de passer à quelque chose comme :

Code:

---

1 2 3

for (auto it = list.begin(), end = list.end(); it != end; ++it) (*it)->doThings();

---

À :

Code:

---

1 2 3

for (auto it = list.begin(), end = list.end(); it != end; ++it) it->do("doThings");

---

Ou, encore mieux :

Code:

---

1 2 3

for (auto it = list.begin(), end = list.end(); it != end; ++it) it->doThings();

---

Autrement, il me faudrait une solution pour réussir à utiliser des références dans les container de la STL. Ce serait top ça aussi.

Citation:

---

De plus, je suis pas sur qu'on puisse parler de méta programmation avec les macros. Et les macro ne sont pas un paradigme.

---

Je parlais du paradigme objet. Parce qu'entre le C (dans lequel tu sembles accepter l'utilisation des macros) et le C++, je vois pas 36 différences à part le paradigme objet. Et ce que je disais, c'est que quelque soit les paradigmes de programmation avec lequel on travaille (fonctionnel, prototype, objet, concurrentiel, impérative.) la méta-programmation est toujours bonne à prendre.
Bon, dans mon cas, j'avoue que je veux utiliser les macros dans un sens détourné mais qui justement ajouterait de la lisibilité. Donc je vois encore moins le problème.
Et oui, à ma connaissance, la méta-programmation en c++ ce sont les templates mais aussi les macros.

En même temps, comme le disait gbdivers ainsi que la spécification OpenGL, tu es limité à 8 sources de lumière acttives simultanément en pipeline fixe. Donc je ne vois pas l'intérêt d'essayer d'en faire plus.
De plus ton argument "Si jamais les valeurs des lumières changent, je me retrouverai avec un bug" ne tient pas car la spécification dit clairement :

Citation:

---

It is always the case that GL_LIGHT i = GL_LIGHT0 + i.

---

Code:

---

1 2 3 4 5

#include <boost/prepocessor/repetition/repeat.hpp> #include <boost/preprocessor/cat.hpp>   #define ENABLE_LIGHTS(z,n,t) glEnable(BOOST_PP_CAT(GL_LIGHT, n)); BOOST_PP_REPEAT(GL_MAX_LIGHTS, ENABLE_LIGHTS, ~)

---