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

Version imprimable

25/08/2008, 15h35
Kurisu

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

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:

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

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

Code:

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

avec 6 combinations possibles, et

Code:

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).
25/08/2008, 17h17
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 :aie:
25/08/2008, 17h33
Kurisu

Citation:

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 :aie:

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.

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

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

reducation d'un array

Code:

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:

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:

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? :bug:

26/08/2008, 21h07
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).
26/08/2008, 23h57
Kurisu
Citation:

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:

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.

Un truc du style (non testé).

Code:

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>());
}

28/08/2008, 13h20
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).
28/08/2008, 13h58
HanLee

Citation:

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).
28/08/2008, 14h25
Kurisu

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

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... :roll:

Code:

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:

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:

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))	\
	)													\

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

Code:

BOOST_PP_TUPLE_ELEM_1_0

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

Code:

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).

03/09/2008, 22h39
Kurisu

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. :mouarf:
06/09/2008, 12h54
Kurisu

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).
10/09/2008, 11h54
Bakura

Un post qui devrait bien t'intéresser : http://www.devmaster.net/forums/showthread.php?t=12677
10/09/2008, 14h20
Kurisu

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).