Discussion :

[Kurisu]

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]

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]

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]

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]

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]

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.