Boost.Preprocessor pour générer des "swizzle-parameters"

**Kurisu** · 25/08/2008, 16h35

Comme promis, la prochaine question sur la génération de code avec Boost.Preprocessor, cette fois concernant la génération de paramètres dit de swizzle.

Je veux créer un enum qui indique toutes les combinations possibles d'un vecteur (2d à 4d). Par exemple, pour un vec2 avec les éléments x et y, ce sera

Code :

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

enum vec2swizzle2{ xx, xy, yx, yy };

et avec un vec3 et les éléments r, g, b, ce sera

Code :

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

enum vec3swizzle2{ rr, rg, rb, ... , gg, ..., bb};

avec 6 combinations possibles, et

Code :

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

enum vec3swizzle3{ rrr, rrg, rrb, ... , ggg, ..., bbb};

avec 9 combinations possibles.

je pars d'un array #defini comme (4, (x, y, z, w)) que je donne en pature à une macro avec un paramètre pour la taille des combinations et je veux que ca me sorte un array (n, (...)) dans un premier temps (ou une séquence (n)(xx)...(yy)).

N'hésitez pas à donner vos idées ou remarques sur la facon de procédér.

(Nota: je pense m'y prendre avec une macro qui me donner une sorte de merge sur deux arrays donnés en paramètre).

**Alp** · 25/08/2008, 18h17

Pour ce genre de tâches ça n'irait pas plus vite d'écrire un parseur-modifieur de code C++ ?

J'aime bien ce genre ed défi et vais y réfléchir, mais bon faut garder la tête sur les épaules

**Kurisu** · 25/08/2008, 18h33

Envoyé par Alp

Pour ce genre de tâches ça n'irait pas plus vite d'écrire un parseur-modifieur de code C++ ?

J'aime bien ce genre ed défi et vais y réfléchir, mais bon faut garder la tête sur les épaules

J'avoue que le truc que je pense faire est un peu "brainfuck", mais j'ai une idée en tête de comment m'y prendre. Ca risque d'être assez lourds en macros cependant.

Puis, si j'écrit un modifieur/générateur de code (en Perl, Python, Ruby, PHP,...), tout ce que j'ai écrit pour l'instant avec Boost.Pp n'a aucun intérêt, vu que ca va 3 fois plus de scripter ca dans un "vrai" language de programmation et non dans le Preprocesseur de C...
Mais l'idée de n'avoir qu'un header me plaît bien, donc je mettrais mon idée en pratique.

**Kurisu** · 26/08/2008, 18h56

cr***e, le preprocesseur ne supporrte pas la recursivité.

Voici 2 solutions qui auraient très bien fonctionnés de facon recursive:

reducation d'un array

Code :

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

1
2
3
4
5
6
7
8
9
 
#define GEN_DIM_ARRAY(size, array)						\
		BOOST_PP_IIF(									\
			BOOST_PP_EQUAL(size,						\
				BOOST_PP_ARRAY_SIZE(array)),			\
			array,										\
			BOOST_PP_EXPAND(GEN_DIM_ARRAY(size,			\
				BOOST_PP_ARRAY_POP_BACK(array)))		\
		)												\

et combinaisons des éléments d'un array

Code :

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

1
2
3
4
5
6
7
8
9
 
#define EXTEND_COMBINE_ARRAY(size, array)		\
		BOOST_PP_IF(size,						\
			EXTEND_COMBINE_ARRAY(				\
				BOOST_PP_DEC(size),				\
				SELF_CROSS_COMBINE_ARRAY(array)	\
			),									\
			array								\
		)										\

avec ce bout de code avant:

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
 
#define SUB_REP_COMBINE_B(n, a, arrayB)			\
		(BOOST_PP_CAT(a,						\
			BOOST_PP_ARRAY_ELEM(n, arrayB)))	\
 
 
#define REP_COMBINE_B(z, n, param)				\
		SUB_REP_COMBINE_B(n,					\
			BOOST_PP_TUPLE_ELEM(2, 0, param),	\
			BOOST_PP_TUPLE_ELEM(2, 1, param)	\
		)										\
 
 
#define SUB_REP_COMBINE_A(n, arrayA, arrayB)			\
		BOOST_PP_REPEAT(								\
			BOOST_PP_ARRAY_SIZE(arrayB),				\
			REP_COMBINE_B,								\
			(BOOST_PP_ARRAY_ELEM(n, arrayA), arrayB)	\
		)												\
 
 
#define REP_COMBINE_A(z, n, param)				\
		SUB_REP_COMBINE_A(n,					\
			BOOST_PP_TUPLE_ELEM(2, 0, param),	\
			BOOST_PP_TUPLE_ELEM(2, 1, param)	\
		)										\
 
#define CROSS_COMBINE_ARRAYS(arrayA, arrayB)	\
		BOOST_PP_SEQ_TO_ARRAY(					\
			BOOST_PP_REPEAT(					\
				BOOST_PP_ARRAY_SIZE(arrayA),	\
				REP_COMBINE_A,					\
				(arrayA, arrayB)				\
			)									\
		)										\
 
#define SELF_CROSS_COMBINE_ARRAY(array)			\
		CROSS_COMBINE_ARRAYS(array, array)		\

des idées comment arriver à avoir de la recursion avec des repeats ou des while?

**HanLee** · 26/08/2008, 22h07

Pourquoi tu fais pas un truc du style :

get<x,x,z,w>(v), avec x,y,z,w qui sont des constantes entières voire des types ? (avec des noms différents bien sûr, si tu veux).

**Kurisu** · 27/08/2008, 00h57

Envoyé par HanLee

Pourquoi tu fais pas un truc du style :

get<x,x,z,w>(v), avec x,y,z,w qui sont des constantes entières voire des types ? (avec des noms différents bien sûr, si tu veux).

Tu peux expliquer un peu plus? Ca m'intéresse, ton approche.

Ce que je voulais faire au début, c'est une fonction membre swizzle, du genre

Code :

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

1
2
3
vec2 swizzle(ESwizzle2);
vec3 swizzle(ESwizzle3);
vec4 swizzle(ESwizzle4);

et ainsi définir toutes les possibilités du paramètre dans un enum (ou plutôt 3 enum). Bien sûr, écrire les 16... 256 paramètres avec xyzw et rgba, c'est lourd, d'où l'idée du preprocesseur...

mais je suis preneur de toute autre approche, d'autant plus si elle rend la chose plus facile.

**HanLee** · 27/08/2008, 12h47

Un truc du style (non testé).

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
enum vector_member { x, y, z, w };
 
 
template <vector_member>
float get();
 
template <>
float get<x>() { return this->x; }
 
// etc... jusqu'à get<w>()
 
template <vector_member v1, vector_member v2, vector_member v3>
vec3 swizzle()
{
    return vec3(this->get<v1>(), this->get<v2>(), this->get<v3>());
}

**Kurisu** · 28/08/2008, 14h20

je vois, ce n'est pas mal non plus, puis c'est le compilateur qui prend ca en charge (à la compilation, donc)... si je veux la même chose, mais de facon runtime, ca revient quasiment à la même chose (mais sans template).

Je pensais en fait surcharger l'opérateur . et l'opérateur () avec l'enum. Aucune idée si ca marche, mais l'idée y est de rendre l'utilisation au plus simple (et au plus proche à GLSL).

**HanLee** · 28/08/2008, 14h58

Envoyé par Kurisu

je vois, ce n'est pas mal non plus, puis c'est le compilateur qui prend ca en charge (à la compilation, donc)... si je veux la même chose, mais de facon runtime, ca revient quasiment à la même chose (mais sans template).

Je pensais en fait surcharger l'opérateur . et l'opérateur () avec l'enum. Aucune idée si ca marche, mais l'idée y est de rendre l'utilisation au plus simple (et au plus proche à GLSL).

On ne peux pas surcharger l'opérateur point.

Mais je savais très bien que tu voulais faire comme avec les shaders, et j'avais prévu de faire le même truc pour ma classe de vecteurs.
Perso, j'trouve ça plutôt pratique d'écrire : v.swizzle<x,x,y,y>(). C'est pas super lourd à écrire.

C'est simple à implémenter, j'ai pas besoin de jouer avec le préprocesseur.
Après, tu pourrais générer les enums, il faudrait aussi pouvoir traiter un enum.
Tu devras ensuite faire des méta fonctions pour transformer le tout en base 4 (x,y,z,w <=> 0,1,2,3, et donc xxyz <=> 0012).

**Kurisu** · 28/08/2008, 15h25

base 4 ou simplement prendre les 4 premiers bits pour un élément, ce qui me donnerait 16 bits pour l'enum vec4, ou encore prendre les valeurs 32 bits de 4 charactères, genre 'xyzw'. J'ai déjà fait ce genre de truc au boulot, et je pensais mieux m'y prendre cette fois-ci (genre avec 4 bits/élément).

Bon, rien ne m'empêche de ne pas utiliser ton idée en plus.

Ah oui, j'ai mis la chose en ligne (actuellement dans le svn de mon autre projet, kagefx):
https://kagefx.svn.sourceforge.net/s...efx/kazu/trunk

**Kurisu** · 02/09/2008, 00h42

Bon, j'ai plus ou moins réussi ce que je voulais faire. Seulement, ...ca dépasse les capacités de longueur de Boost.PP, ce qui est un peu... embêtant.

voici le code:

reducation d'un array... de facon, mouais, recursive...

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
#define REDUCE_ARRAY_1(array)	BOOST_PP_ARRAY_POP_BACK(array)
#define REDUCE_ARRAY_2(array)	REDUCE_ARRAY_1(BOOST_PP_ARRAY_POP_BACK(array))
#define REDUCE_ARRAY_3(array)	REDUCE_ARRAY_2(BOOST_PP_ARRAY_POP_BACK(array))
 
 
#define SUB_REDUCE_ARRAY(tosize, array)				\
	BOOST_PP_IIF(BOOST_PP_GREATER(tosize, 0),		\
		BOOST_PP_CAT(REDUCE_ARRAY_, tosize)(array),	\
		BOOST_PP_EMPTY()							\
	)												\
 
 
#define REDUCE_ARRAY(size, array)		\
	SUB_REDUCE_ARRAY(					\
		BOOST_PP_SUB(					\
			BOOST_PP_ARRAY_SIZE(array),	\
			size						\
		),								\
		array							\
	)									\

Puis combination de deux arrays:

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
#define SUB_REP_COMBINE_B(n, a, arrayB)		\
	(BOOST_PP_CAT(a,						\
		BOOST_PP_ARRAY_ELEM(n, arrayB)))	\
 
 
#define REP_COMBINE_B(z, n, param)			\
	SUB_REP_COMBINE_B(n,					\
		BOOST_PP_TUPLE_ELEM(2, 0, param),	\
		BOOST_PP_TUPLE_ELEM(2, 1, param)	\
	)										\
 
 
#define SUB_REP_COMBINE_A(n, arrayA, arrayB)		\
	BOOST_PP_REPEAT(								\
		BOOST_PP_ARRAY_SIZE(arrayB),				\
		REP_COMBINE_B,								\
		(BOOST_PP_ARRAY_ELEM(n, arrayA), arrayB)	\
	)												\
 
 
#define REP_COMBINE_A(z, n, param)			\
	SUB_REP_COMBINE_A(n,					\
		BOOST_PP_TUPLE_ELEM(2, 0, param),	\
		BOOST_PP_TUPLE_ELEM(2, 1, param)	\
	)										\
 
 
#define CROSS_COMBINE_ARRAYS(arrayA, arrayB)	\
	BOOST_PP_SEQ_TO_ARRAY(						\
		BOOST_PP_REPEAT(						\
			BOOST_PP_ARRAY_SIZE(arrayA),		\
			REP_COMBINE_A,						\
			(arrayA, arrayB)					\
		)										\
	)											\
 
 
#define SELF_CROSS_COMBINE_ARRAY(array)		\
	CROSS_COMBINE_ARRAYS(array, array)		\
 
 
#define EXTEND_COMBINE_ARRAY(size, array)	\
	BOOST_PP_IF(size,						\
		EXTEND_COMBINE_ARRAY(				\
			BOOST_PP_DEC(size),				\
			SELF_CROSS_COMBINE_ARRAY(array)	\
		),									\
		array								\
	)										\
 
 
#define	SELF_CROSS_COMBINE_2(array)		\
	CROSS_COMBINE_ARRAYS(array, array)	\
 
 
#define SELF_CROSS_COMBINE_3(array)		\
	CROSS_COMBINE_ARRAYS(				\
		SELF_CROSS_COMBINE_2(array),	\
		array							\
	)									\
 
 
#define SELF_CROSS_COMBINE_4(array)		\
	CROSS_COMBINE_ARRAYS(				\
		SELF_CROSS_COMBINE_3(array),	\
		array							\
	)									\
 
 
#define SELF_CROSS_COMBINE(times, array)			\
	BOOST_PP_CAT(SELF_CROSS_COMBINE_, times)(array)	\

Manque de pot, 81, 128 et 256 sont trop grand pour les récursions de Boost.PP...
faut que je trouve une autre solution....

EDIT: oh que c'était con. Suffisait de changer SELF_CROSS_COMBINE_4 de facon à prendre 2 fois SELF_CROSS_COMBINE_2 en tant que paramètre, et là ca fonctionne.

Code :

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

1
2
3
4
5
#define SELF_CROSS_COMBINE_4(array)						\
	CROSS_COMBINE_ARRAYS(								\
		BOOST_PP_EXPAND(SELF_CROSS_COMBINE_2(array)),	\
		BOOST_PP_EXPAND(SELF_CROSS_COMBINE_2(array))	\
	)													\

**Kurisu** · 03/09/2008, 23h34

J'ai un peu continué le développement, et je me retrouve confronté à une erreur que je n'arrive pas à localiser:

Code :

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

BOOST_PP_TUPLE_ELEM_1_0

partout dans mon code généré.
Il y aurait une explication pour cela?

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
//---------------------------------------------------------------------------
 
#define REP_LIST_ARRAY_ELEMS(z, n, array)	\
	BOOST_PP_ARRAY_ELEM(n, array)			\
	BOOST_PP_COMMA_IF(						\
		BOOST_PP_GREATER(					\
			BOOST_PP_DEC(					\
				BOOST_PP_ARRAY_SIZE(array)	\
			),								\
			n								\
		)									\
	)										\
 
 
#define LIST_ARRAY_ELEMS(array)				\
	BOOST_PP_REPEAT(						\
		BOOST_PP_ARRAY_SIZE(array),			\
		REP_LIST_ARRAY_ELEMS,				\
		array								\
	)										\
 
 
 
#define ADD_ARRAY_SIZES(arrayA, arrayB)		\
	BOOST_PP_ADD(							\
		BOOST_PP_ARRAY_SIZE(arrayA),		\
		BOOST_PP_ARRAY_SIZE(arrayB)			\
	)										\
 
 
#define MERGE_ARRAYS_APPEND(arrayA, arrayB)				\
	(ADD_ARRAY_SIZES(arrayA, arrayB),					\
		(LIST_ARRAY_ELEMS(arrayA)						\
		BOOST_PP_COMMA_IF(BOOST_PP_ARRAY_SIZE(arrayB))	\
		LIST_ARRAY_ELEMS(arrayB))						\
	)													\
 
 
//---------------------------------------------------------------------------
//Testing macros
 
#define REP_ARRAY_OF_SUBARRAYS(z, n, array)	\
	BOOST_PP_COMMA_IF(n)					\
	(1, BOOST_PP_ARRAY_ELEM(n, array))		\
 
 
#define GEN_ARRAY_OF_SUBARRAYS(array)		\
	(BOOST_PP_ARRAY_SIZE(array),			\
	(BOOST_PP_REPEAT(						\
		BOOST_PP_ARRAY_SIZE(array),			\
		REP_ARRAY_OF_SUBARRAYS,				\
		array								\
	) ) )									\
 
//-----------------------------
 
#define SUB_REP_COMBINE_2_ARRAYS(arrayA, arrayB)	\
	MERGE_ARRAYS_APPEND(arrayA,	arrayB)				\
 
 
#define SUB_REP_COMBINE_ARRAY_OF_SUB_B(n, arrayA, arrayofsubB)	\
	( SUB_REP_COMBINE_2_ARRAYS(arrayA,							\
			BOOST_PP_ARRAY_ELEM(n, arrayofsubB)					\
	) )															\
 
 
#define REP_COMBINE_ARRAY_OF_SUB_B(z, n, param)	\
	SUB_REP_COMBINE_ARRAY_OF_SUB_B(n,			\
		BOOST_PP_TUPLE_ELEM(2, 0, param),		\
		BOOST_PP_TUPLE_ELEM(2, 1, param)		\
	)											\
 
 
#define SUB_REP_COMBINE_ARRAYS_OF_SUB_A(n, arrayofsubA, arrayofsubB)	\
	BOOST_PP_REPEAT(													\
		BOOST_PP_ARRAY_SIZE(arrayofsubB),								\
		REP_COMBINE_ARRAY_OF_SUB_B,										\
		(BOOST_PP_ARRAY_ELEM(n, arrayofsubA), arrayofsubB)				\
	)																	\
 
 
#define REP_COMBINE_ARRAYS_OF_SUB_A(z, n, param)	\
	SUB_REP_COMBINE_ARRAYS_OF_SUB_A(n,				\
		BOOST_PP_TUPLE_ELEM(2, 0, param),			\
		BOOST_PP_TUPLE_ELEM(2, 1, param)			\
	)												\
 
 
#define CROSS_COMBINE_ARRAYS_OF_SUB(arrayofsubA, arrayofsubB)	\
	BOOST_PP_EXPAND(BOOST_PP_SEQ_TO_ARRAY(						\
		BOOST_PP_REPEAT(										\
			BOOST_PP_ARRAY_SIZE(arrayofsubA),					\
			REP_COMBINE_ARRAYS_OF_SUB_A,						\
			(arrayofsubA, arrayofsubB)							\
		)														\
	))															\
 
//-----------------------------
 
#define	SELF_CROSS_COMBINE_ARRAYS_OF_SUB_2(array)	\
	CROSS_COMBINE_ARRAYS_OF_SUB(array, array)		\
 
 
#define SELF_CROSS_COMBINE_ARRAYS_OF_SUB_3(array)				\
	CROSS_COMBINE_ARRAYS_OF_SUB(								\
	BOOST_PP_EXPAND(SELF_CROSS_COMBINE_ARRAYS_OF_SUB_2(array)),	\
	array														\
	)															\
 
 
#define SELF_CROSS_COMBINE_ARRAYS_OF_SUB_4(array)				\
	CROSS_COMBINE_ARRAYS_OF_SUB(								\
	BOOST_PP_EXPAND(SELF_CROSS_COMBINE_ARRAYS_OF_SUB_2(array)),	\
	BOOST_PP_EXPAND(SELF_CROSS_COMBINE_ARRAYS_OF_SUB_2(array))	\
	)															\
 
 
#define SELF_CROSS_COMBINE_ARRAYS_OF_SUB(times, array)				\
	BOOST_PP_CAT(SELF_CROSS_COMBINE_ARRAYS_OF_SUB_, times)(array)	\

En bref, MERGE_ARRAYS_APPEND(arrayA, arrayB) permet d'ajouter tous les éléments d'arrayB à la suite de l'arrayA,
GEN_ARRAY_OF_SUBARRAYS(array) va générer un array d'arrays unitaire pour tous les éléments. (4, (x, y, z, w)) devient ainsi (4, ( (1, x) , (1, y) , (1, z) , (1, w) ) ).

Et enfin, CROSS_COMBINE_ARRAYS_OF_SUB(arrayofsubA, arrayofsubB) va faire la même chose que mon code de concatenation des éléments du post précédent, seulement en combinant les arrays contenus dans arrayofsubA avec ceux contenus dans arrayofsubB via la méthode MERGE_ARRAYS_APPEND. (En détail, ca génére des séquences qui seront retransformés en array avec une fonction de Boost.pp).

**Kurisu** · 03/09/2008, 23h39

Faut que je poste plus rapidement mes erreurs ici car 2 secondes après avoir envoyé le post précédent, j'avais trouvé mon erreur: il faut que GEN_ARRAY_OF_SUBARRAYS donne (4, ( (1, (x)) , (1, (y)) , (1, (z)) , (1, (w)) ) ) au final, et tout fonctionne. Encore une fois, c'était une bête parenthèse qui manquait.

**Kurisu** · 06/09/2008, 13h54

La facon de s'y prendre avec des arrays était limité, sutout si on arrive à 256 éléments (un tuple est limité à 25 éléments), donc j'ai recommencé la même chose mais avec des séquences pour me rendre compte qu'au final, 256 éléments étaient limites aussi. Mais vu qu'on peut diviser une séquences en sous-séquences, ca arrange la chose.

Bah, voilà, j'ai quasiment fini la génération de paramètres du swizzle. Si vous voulez avoir un apercu du code, rendez-vous sur Sourceforge:
http://kagefx.svn.sourceforge.net/vi...fx/kazu/trunk/ et
svn co https://kagefx.svn.sourceforge.net/s...fx/kazu/trunk/ kazu

Encore une fois merci à Alp pour l'idée d'utiliser Boost.PP et à HanLee pour l'idée de la fonction swizzle via template<> (je m'en sers pas finalement, mais l'idée était bonne et s'est retrouvée dans les fonctions "fast swizzle" à venir).

**Bakura** · 10/09/2008, 12h54

Un post qui devrait bien t'intéresser : http://www.devmaster.net/forums/showthread.php?t=12677

**Kurisu** · 10/09/2008, 15h20

Bakura>merci beaucoup pour le lien. Leur problème est exactement le même que le mien, mais leur facon de s'y prendre diffère.

Dans Kazu, il y a la fonction swizzle(), surchargée de facon à prendre les bons paramètres de swizzling, et il y a aussi les fonctions inline directs comme xxxx() ou rgga() qui renvoient la comination des éléments. Le tout, généré avec le PP.

A propos, le projet Kazu avance assez bien, il ne reste plus que les constructeurs à ajouter. (Générés avec le PP, eux aussi bien sûr).

Boost.Preprocessor pour générer des "swizzle-parameters"

Boost C++

Discussions similaires

Partager

Partager