Conseils de programmation intéressants pour Designer - Lancez votre image (première partie) : 16 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:11

Courir! Courir! Courir!

La programmation n'est pas si difficile. Le point clé est de trouver son rythme et de le faire un par un.

Avant de lire ce chapitre, j'espère que vous êtes déjà familiarisé avec la méthode de dessin de fonction de base, ou vous vous sentirez étourdi et confus par deux grandes fonctions de tête: configuration et dessin.

Puisque nous voulons faire des graphiques animés, nous devons savoir comment l'animation est produite.

L'image ci-dessus semble assez attrayante et révèle visuellement le principe de mise en œuvre de l'animation.

L'animation est magique. C'est une magie de la tricherie visuelle. Pourtant, dans cette information éclatée, à l'âge des inondations vidéo, on s'y est déjà habitué. Peu de gens seront surpris que c'est une chose incroyable de pouvoir voir l'animation.

Le même principe peut être appliqué dans l'animation de dessin avec le programme. Nous devons réfléchir à la manière de dessiner des graphiques différents dans chaque image, et le programme tournera automatiquement les pages pendant que nous complétons une animation terminée dans notre tête. Dans le chapitre suivant, nous parlerons de la façon de réaliser un mouvement graphique de base. Avant cela, nous devons avoir des connaissances de base sur les variables.

Étape 1: Variables

La variable est le conteneur des données. Il peut être utilisé à plusieurs reprises dans un programme.

Par exemple:

[cceN_cpp theme="dawn"] taille (500, 500); ellipse (100, 250, 50, 50); ellipse (200, 250, 50, 50); ellipse (300, 250, 50, 50); ellipse (400, 250, 50, 50);

[/cceN_cpp]

Cette section de code n'a utilisé aucune variable. Il dessine quatre cercles à l'écran. Nous pouvons trouver qu'ils ont la même largeur et la même hauteur. Maintenant qu'il en est de même, afin de minimiser les entrées de données répétées, nous pouvons définir un signe pour le représenter. Ce signe est variable.

Voici le code après avoir ajouté une variable:

[cceN_cpp theme="dawn"] taille (500, 500); int a = 50; ellipse (100, 250, a, a); ellipse (200, 250, a, a); ellipse (300, 250, a, a); ellipse (400, 250, a, a);

[/cceN_cpp]

On obtient totalement le même résultat !

Puisque nous avons défini la variable a, nous pouvons facilement modifier les paramètres. Si nous changeons a=50 en a=100, alors la largeur et la hauteur de tous les cercles deviendront 100 uniformément. Nous n'avons donc pas à modifier les paramètres un par un. La variable est vraiment une bonne invention.

Étape 2: La création de la variable

Avant d'utiliser la variable, nous devons faire une déclaration et désigner son type de données.

int je;

i 50;

La première phrase du code a fait une déclaration pour une variable i. int est un symbole principalement utilisé pour déclarer une variable. Lors de la déclaration, il économisera une place dans la mémoire de l'ordinateur, ce qui équivaut à générer une "boîte", spécialement utilisée pour restaurer des données entières. La deuxième phrase signifie que l'affectation 50 doit être mise en œuvre par la variable i. Après la mise en œuvre de cette phrase, les données seront stockées dans la variable i de manière stable. Ou vous pouvez être plus paresseux pour combiner les deux phrases ci-dessus en une seule et complète tâche tout en faisant une déclaration.

int i 50;

Il est relativement libre de nommer une variable. Mais parfois, nous devons faire attention à quelque chose.

Étape 3: Nommer la régulation de la variable

• Il doit s'agir de la combinaison de l'alphabet et du soulignement. Il peut s'agir d'un symbole ou d'un mot.

• Sensible aux majuscules et minuscules. Le nom et le nom peuvent représenter différentes variables.

• Essayez de le nommer aussi facilement que possible pour vous permettre de comprendre d'un seul coup. Le caractère initial doit être un alphabet au lieu d'un nombre ou d'un caractère spécial.

• Aucun mot clé comme int, float

Les éléments suivants sont des déclarations erronées.

int $a;

int 89b;

Voici les affirmations correctes:

int r;

int super_24;

int openTheDoor;

Étape 4: Type de variable

À l'exception de la déclaration de données entières, nous pouvons déclarer des données décimales (également appelées données à virgule flottante) avec le mot clé float.

flotteur b = 0,5

Nous devons garder à l'esprit le type de données que nous avons utilisé pour notre déclaration. Si nous avons utilisé le mot clé int, cette dernière affectation ne peut pas écrire i＝0.5 ou quelque chose comme ça, ou le programme deviendra une erreur. Mais si nous écrivons à l'envers, tout va bien. Par exemple, float i=5 est la bonne grammaire mais le programme le reconnaîtra comme un nombre décimal.

Certaines variables ont déjà été définies par le système. Nous n'avons pas à les déclarer nous-mêmes. Tout comme le "largeur, hauteur" évoqué précédemment, il acquerra automatiquement la largeur et la hauteur de l'écran de l'ordinateur. Une fréquence d'utilisation si élevée que le concepteur la définit directement comme une variable par défaut afin de la rendre plus pratique à utiliser.

Étape 5: Opérateur

Sont opérateurs de traitement:

+ plus

- moins

* multiplier

diviser

％ Module de reste

Vous devez être familier avec tous ces opérateurs sauf %. Cela semble assez étrange car son résultat est le reste. 9%3 est 0. Alors que 9%5 est 4.

Les opérateurs peuvent être utilisés parmi les affectations et les variables.

[cceN_cpp theme="dawn"] int a = 1; //déclare la variable entière a, l'affectation est 1. int b = 2; //Déclare la variable entière b, l'affectation est 2. int c; //Déclarer la variable entière c. c = a + b; //Plus deux affectations et assigner son résultat à c. imprimer(c); //Variable de sortie c.

[/cceN_cpp]

Étape 6: Résultat de l'opération:

Le résultat de sortie ne sera pas affiché sur la fenêtre mais dans la console en bas.

La méthode d'écriture de la quatrième ligne semble assez étrange. Mais il s'agit d'un format courant fréquemment utilisé lors de l'affectation à l'ordinateur. Le côté gauche du symbole égal doit être la variable assignée finale, tandis que le côté droit doit être le processus d'opération.

La fonction d'impression de la cinquième ligne peut imprimer des variables dans la console, qui est souvent utilisée pour tester l'état de sortie des données.

Étape 7: Régulation de fonctionnement

Un point gênant dans Processing est que nous devons clarifier le type de variable. Nous devons porter une attention particulière au processus de nombre à virgule flottante et de type entier.

imprimer（6 / 5）; //résultat 1

L'opération entre entiers aura un nouvel entier. 6 divisé par 5 fait 1,2. Mais le résultat de sortie du programme est 1. Ceci est contraire à notre intuition. Le programme ne traitera pas l'arrondi mais supprimera le nombre derrière la virgule décimale.

imprimer (6.0 / 5.0); //résultat 1.2

L'opération entre les virgules flottantes entraînera un nouveau nombre à virgule flottante. Si le résultat réel est 1,2, le résultat de sortie du programme sera le même.

impression (6 / 5.0); //résultat 1.2

imprimer (6.0 / 5); //résultat 1.2

Enfin c'est le mélange d'entier et de nombre à virgule flottante. Le résultat de sortie final sera 1.2.

• En fait, vous devez garder à l'esprit que le but de cette conception de réglementation est de ne pas perdre l'exactitude des données. Ainsi, si un élément est un nombre à virgule flottante, le résultat sera également un nombre à virgule flottante.

Étape 8: Fonction de configuration et fonction de dessin

Auparavant, nous avons parlé d'une pile de connaissances fondamentales. Maintenant, nous arrivons enfin à jouer quelque chose d'intéressant. La configuration des fonctions et le dessin sont équivalents aux principales fonctions de traitement. Ces deux fonctions sont très particulières. Il peut contrôler la procédure du programme. Un programme relativement compliqué comprendra ces deux fonctions car elles constituent le cadre de base du programme. Format:

void setup(){

}

tirage nul (){

}

L'utilisation spéciale rend leur format d'appel différent des autres fonctions. Nous devons ajouter "void" avant le nom de la fonction, qui signifie aucune "valeur renvoyée". Derrière le nom de la fonction, nous devons ajouter des parenthèses et des accolades.

[cceN_cpp theme="dawn"] void setup(){ print(1); } void draw(){ print(2); } [/cceN_cpp]

Regardons un exemple:

Lorsque vous appuyez sur le bouton de fonctionnement, la console affichera d'abord "1", puis constamment "2" jusqu'à ce que vous ayez appuyé sur le bouton d'arrêt ou fermé la fenêtre.

Le code entre parenthèses dans la fonction de configuration ne sera implémenté qu'une seule fois. Tandis que le code dans la fonction draw s'exécutera constamment en circulation (implémentation par défaut 60 fois/seconde).

En raison de ce caractère, la configuration est généralement utilisée pour initialiser les propriétés de l'environnement, telles que la largeur et la hauteur de l'écran, la couleur d'arrière-plan et toutes sortes d'affectations de variables. Alors que nous plaçons souvent des fonctions de dessin dans la fonction draw afin de générer des graphiques continuellement modifiés.

Étape 9: Cercle en mouvement horizontal

Avec la fonction draw, nous pouvons commencer à créer nos animations. La méthode d'écriture de l'effet d'animation par Processing est assez "maladroite". Il n'a aucune commande existante. Par exemple, désignez une certaine forme pour faire curviligne.

Nous devons définir ces détails par nous-mêmes. Vous devez indiquer au programme le type de graphiques dont chaque image a besoin.

Écrivez-y le code suivant (Commençons maintenant à le faire à la main):

[cceN_cpp theme="dawn"] int x; int y; void setup(){ size(300, 300); x = 0; y = hauteur/2; } void draw(){ background(234, 113, 107); noStroke(); ellipse(x, y, 50, 50); x = x+1; }

[/cceN_cpp]

Cette section de code affiche un cercle en mouvement. Les anciennes variables déclarées x, y sont utilisées pour stocker la position des coordonnées. Ses affectations s'exécutent dans la configuration de la fonction. Le code clé est le suivant dans la fonction draw:

x = x + 1

Ne le considérez pas comme une équation mathématique, ou ce sera très étrange. Ici, "＝" est un symbole d'affectation. Cela représente de placer les bons nombres dans la variable de gauche. Supposons que x soit 50, une fois le code exécuté, le côté droit de "＝" est égal à 50+1, c'est-à-dire 51. Le résultat final sera affecté à la variable x. Donc la valeur de x devient 51.

Suivez la procédure du programme, à chaque fois que la fonction draw fonctionnera pour une fois, la valeur de x augmentera de 1. Ainsi, à chaque fois que nous dessinerons, le cercle se déplacera d'un pixel horizontalement vers la droite, par rapport à l'image précédente. Par conséquent, le graphique devient mouvementé.

• Afin que le code obtienne une meilleure lisibilité, nous devons ménager une certaine place avant chaque ligne de code entre accolades. Et il doit être aussi aligné que possible. Appuyez sur TAB ou sur plusieurs espaces vides, cela peut se rétracter.

• Le symbole d'espace et de saut de ligne dans le programme n'influencera pas le programme. Donc c'est ok si nous en tapons un de plus ou de moins.

Voici une autre façon plus simple de l'exprimer. Pour que le cercle variable augmente de 1 automatiquement, nous devons l'écrire au format suivant.

cercle ＝ cercle ＋1

Assez gênant ! Si le nom de la variable est plus long, alors nous devons taper plus de mots. Ainsi, nos prédécesseurs paresseux réfléchissent à une idée comme celle-ci.

cercle＋＋

N'est-ce pas très simple ? Cela signifie augmenter 1 automatiquement. Semblable à cela, il y a - -, ce qui signifie diminuer 1 automatiquement.

Mais si nous espérons que la quantité d'augmentation automatique est un autre nombre comme 2, nous devons essayer une autre expression.

cercle += 2

Cela équivaut à

cercle = cercle + 2

De même, il existe －＝, /=, *=.

Étape 10: Direction du mouvement

La direction dans laquelle le graphique se déplace dépend de la façon dont vous modifiez vos coordonnées. S'il est changé en y＝y＋1, le cercle se déplacera vers le bas. Si à la fois x et y augmentent 1, le cercle se déplacera vers le bas en bas à droite. Si nous l'écrivons comme un symbole moins, il se déplacera dans la direction opposée.

[cceN_cpp theme="dawn"] int x, y; //Peut déclarer plusieurs variables en même temps, utilisez une virgule pour les séparer. void setup(){ size(300, 300); x = 0; y = 0; } void draw(){ background(234, 113, 107); noStroke(); ellipse(x, y, 50, 50); x++; y++; }

[/cceN_cpp]

Taux de mouvement

Vous vous souvenez des 60 images par seconde par défaut dans la fonction Draw ? Selon ce taux, le cercle ci-dessus se déplacera de 60 pixels par seconde vers la droite.

Si nous voulons changer la vitesse de déplacement graphique, il existe deux méthodes: l'une consiste à augmenter la valeur x à chaque fois puisqu'elle va être modifiée.

x＝x＋10

Il a amélioré la vitesse 10 fois par rapport à l'original !

L'autre méthode consiste à modifier la fréquence d'actualisation du canevas. frameRate()

Cette fonction peut changer la fréquence de diffusion de la toile. Écrivez frameRate (10) dans la configuration de la fonction, cela changera les 60 images par seconde d'origine en 10 images par seconde. La vitesse est ralentie 6 fois plus qu'avant.

Étape 11: arrière-plan négligé

Tous les exemples précédents écrivent l'arrière-plan dans la fonction draw. Avez-vous déjà pensé à l'écrire dans la configuration des fonctions ? Y aura-t-il des différences ? Maintenant, mettons à jour l'exemple de mouvement horizontal.

[cceN_cpp theme="dawn"] int x, y; void setup(){ size(300, 300); arrière-plan (234, 113, 107); x = 0; y = hauteur/2; } void draw(){ noStroke(); ellipse(x, y, 50, 50); x += 1; } [/cceN_cpp]

Ce qui s'est passé? Peut-être qu'il ne peut pas comprendre correctement la raison de la production du problème. Supprimez la fonction noStroke, ajoutez à nouveau un trait et voyez la trajectoire de mouvement du cercle.

Oh, c'est parce que le cercle précédemment créé n'a pas été supprimé ! Parce que la configuration de la fonction ne fonctionne qu'une seule fois, si nous écrivons l'arrière-plan au-dessus, cela ne remplira l'arrière-plan qu'une seule fois et plus tard, il n'aura plus d'effet. L'arrière-plan de la fonction est comme un outil de pot de peinture. Une fois utilisé, il couvrira tout le contenu du canevas au lieu de définir uniquement une couleur d'arrière-plan. Nous l'écrivons avant le dessin de la fonction afin que l'ancien cadre soit couvert chaque fois que nous créons un nouveau motif. Par conséquent, le cercle peut fonctionner comme prévu. A part se souvenir des usages de chaque fonction, il faut penser à la position du code. Beaucoup de temps, monter ou descendre une ligne pour le codea et l'écrire à l'intérieur ou à l'extérieur d'une accolade, cela créera des effets tout à fait différents. La direction du code est bidimensionnelle. Si un bug apparaît, il faut calibrer dans cette deux dimension.

• Cette méthode de dessin non répétée peut créer un effet très spécial si elle est correctement utilisée. Vous pouvez copier le code suivant et essayer.

[cceN_cpp theme="dawn"] void setup(){ size(400, 400); } void draw(){ ellipse(width/2-mouseX, height/2-mouseX, mouseY, mouseY); ellipse(largeur/2-sourisX, hauteur/2+sourisX, sourisY, sourisY); ellipse(largeur/2+sourisX, hauteur/2-sourisX, sourisY, sourisY); ellipse(largeur/2+sourisX, hauteur/2+sourisX, sourisY, sourisY); } [/cceN_cpp]

Ici, nous avons utilisé les variables magiques mouseX et mouseY. Plus tard, nous en parlerons en détail.

Étape 12: Cercle secouant

Que faire si je veux que la direction du mouvement du cercle devienne irrégulière ? Avec la fonction aléatoire astucieusement, vous pouvez également réaliser cet effet. Aléatoire est une fonction fréquemment utilisée. Il peut être utilisé pour générer une fonction aléatoire. C'est comme un esprit sans piste. Une fois lié aux variables, vous ne pouvez pas imaginer ce qui va devenir ensuite.

Format d'appel:

aléatoire (élevé)

High représente la limite supérieure aléatoire et la limite inférieure par défaut est 0. Par exemple, random(10). Il produira un nombre de 0 à 10 au hasard (0 est inclus mais 10 n'est pas inclus).

aléatoire (faible, élevé)

Si nous définissons deux paramètres, il reviendra à la valeur aléatoire entre eux. Par exemple, random (5, 10). Il produira un nombre de 5 à 10 au hasard (5 est inclus mais 10 n'est pas inclus).

Exemple:

[cceN_cpp theme="dawn"] float x;

x = aléatoire (50, 100);

imprimer(x); [/cceN_cpp]

Chaque fois que nous exécutons le programme, la console affichera des valeurs différentes.

• Remarque: Les valeurs créées par la fonction random appartiennent au type à virgule flottante (type nombre décimal). Si nous voulons affecter une valeur à une variable entière, nous devons la transformer via la fonction int(). La transformation ne respecte pas l'arrondi mais supprime directement la partie décimale. Ainsi la sortie de int (aléatoire (5)), n'a que 5 possibilités: 0, 1, 2, 3, 4.

Une fois que nous nous sommes familiarisés avec l'utilisation de la fonction random, nous pouvons entrer directement dans le cas ci-dessous.

[cceN_cpp theme="dawn"] int x, y; void setup(){ size(300, 300); x = largeur/2; y = hauteur/2; } void draw(){ background(234, 113, 107); noStroke(); x += int(aléatoire(-5, 5)); y += int(aléatoire(-5, 5)); ellipse(x, y, 50, 50); }

[/cceN_cpp]

Les anciennes valeurs de coordonnées ajoutées sont fixes. Ce n'est que si nous augmentons une valeur aléatoire que le cercle se déplacera dans une direction indéfinie. Avec la plus grande plage aléatoire, il secoue plus fréquemment. Étant donné que le changement de valeur entre les images est rebondi, le mouvement ne sera plus fluide. Alors que le premier cadre est à (150, 150), le dernier cadre se déplacera vers la position (170, 170) en un clin d'œil.

Étape 13: Migrer le cercle

Cercle de migration

Cela créera-t-il un mouvement fluide ? Le bruit de fonctionnement peut nous aider. Il a un meilleur rythme que le random standard. Et les nombres aléatoires générés aléatoirement sont en continu.

Format d'appel:

bruit（t）

Le bruit de fonction ne peut pas définir sa plage de sortie. Le programme qui le définit ne peut générer que des nombres à virgule flottante de 0 à 1 et une entrée fixe ne peut avoir qu'une sortie fixe.

[cceN_cpp theme="dawn"] float x = noise(5); flottant y = bruit(5); imprimer(x, y); [/cceN_cpp]

Parce que les paramètres d'entrée ci-dessus sont 5, donc les résultats de sortie sont les mêmes. Alors comment changer le résultat ? La réponse est de modifier les paramètres d'entrée de manière dynamique. En fait, nous pouvons considérer le bruit comme une piste vocale illimitée, les paramètres d'entrée sont comme "le temps présent". Si l'entrée du paramètre est continue, la sortie sera également continue.

[cceN_cpp theme="dawn"] float x, y; void setup(){ size(700, 100); x = 0; arrière-plan(0); } void draw(){ x += 1; y = bruit(frameCount/100.0)*100; noStroke(); ellipse(x, y, 2, 2); }

[/cceN_cpp]

Dans ce cas, nous dessinons le chemin de changement de Y afin que nous puissions mieux comprendre le bruit de la fonction.

• Parmi celles-ci, la variable frameCount obtiendra la trame actuelle. Différent de la largeur, de la hauteur dans le précédent, il est stable sans aucun changement. De plus, il commence à augmenter à partir de 0. Si nous le comprenons par notre graphique animé d'affichage initial, il montre la page vers laquelle nous nous sommes tournés (plutôt que la conception du temps dans le programme).

• frameCount est une variable entière. Divisé par une autre variable entière, le programme traitera par défaut le résultat comme un entier. Afin d'améliorer la précision du résultat, nous devons changer 100 à 100,0. Divisé par un nombre à virgule flottante, nous obtiendrons également un nombre à virgule flottante.

• Afin de changer l'axe Y de 0 à 100, nous devons multiplier le résultat du bruit par 100. Ainsi, nous pouvons contrôler la plage de valeurs aléatoires.

Certains d'entre vous capables de réfléchir pourraient se demander « pourquoi devons-nous diviser frameCount par 100 ? N'est-il pas possible d'écrire frameCount directement ? » Bien sûr vous pouvez! Mais ici, afin de mieux afficher les caractéristiques du bruit de fonction, on ralentit le "taux de diffusion". L'exemple ci-dessous montre les changements de valeur de sortie sous différents taux de changement.

[cceN_cpp theme="dawn"] float x, y1, y2, y3, y4, y5; void setup(){ size(700, 500); x = 0; arrière-plan(0); } void draw(){ x += 1; y1 = bruit(frameCount)*100; y2 = bruit(frameCount/10.0)*100; y3 = bruit(frameCount/100.0)*100; y4 = bruit(frameCount/1000.0)*100; y5 = bruit (nombre d'images/100000.0)*100; noStroke(); ellipse(x, y1, 2, 2); ellipse(x, y2+100, 2, 2); ellipse(x, y3+200, 2, 2); ellipse(x, y4+300, 2, 2); ellipse(x, y5+400, 2, 2); course (80); ligne (0, 100, largeur, 100); ligne (0, 200, largeur, 200); ligne (0, 300, largeur, 300); ligne (0, 400, largeur, 400); }

[/cceN_cpp]

Vous pouvez considérer les paramètres changeants dans le bruit de fonction comme une barre de progression. Changer le paramètre, c'est comme déplacer la barre de progression. Ainsi, lorsque la portée changeante de cette "piste vocale" est plus grande, les caractéristiques continues avant et arrière de la valeur de sortie seront plus faibles. (Nous pouvons imaginer ce qui se passera si nous diffusons un morceau de musique ou une vidéo avec une vitesse 2 fois supérieure, 5 fois la vitesse, 20 fois la vitesse). Lorsque la portée est supérieure à une certaine valeur, il n'y a pas de grande différence à fonctionner de manière aléatoire lors de la génération de valeur.

Si vous pouvez comprendre tous les exemples ci-dessus, alors vous aurez l'impression que rien ne peut être plus facile pour tracer un cercle de migration. Vous pouvez également comprendre les principes internes.

[cceN_cpp theme="dawn"] float x, y; void setup(){ size(300, 300); x = 0; } void draw(){ background(234, 113, 107); x = bruit (nombre d'images/100,0 + 100)*300; y = bruit(frameCount/100.0)*300; noStroke(); ellipse(x, y, 50, 50); }

[/cceN_cpp]

Maintenant, le mouvement est plus intéressant tout comme un gyroscope rotatif.

• La raison pour laquelle la variable x dans le bruit de la fonction doit être plus 100 est que pour les séparer sur une distance. Si les paramètres de xy dans le bruit de la fonction sont identiques ou assez proches, le changement des coordonnées x, y sera proche du même. C'est pour que le mouvement devienne beaucoup plus aléatoire.

Étape 14: Cercle déplacé par la souris

Ensuite, nous arrivons enfin à deux variables que j'aime le plus: mouseX et mouseY. A la première vue des deux conceptions, mes yeux brillent de lumière. Parce que c'est le moyen le plus direct d'interagir avec le graphique. Nous pouvons créer beaucoup de programmes intéressants avec.

Le cas est assez simple:

[cceN_cpp theme="dawn"] int x, y; void setup(){ size(300, 300); x = 0; y = 0; } void draw(){ background(234, 113, 107); noStroke(); x = sourisX; y = sourisY; ellipse(x, y, 50, 50); }

[/cceN_cpp]

mouseX peut acquérir la coordonnée x de la souris, tandis que mouseY peut obtenir la coordonnée y.

• Essayons de changer le symbole positif et négatif, ou échangeons mouseX et mouseY.

Étape 15: Fin

À partir de ces commandes familières, vous pourrez peut-être effectuer le mouvement des graphiques. Avec le contenu du dernier chapitre, utilisez votre imagination correctement, vous pouvez créer de nombreux effets animés intéressants.

Dans notre prochain chapitre, nous pouvons voir des exemples plus abondants. Dans le même temps, nous utiliserons des fonctions mathématiques et les combinerons avec le mouvement graphique.

Cet article vient du designer Wenzy.

Étape 16: Lectures relatives:

Guide de programmation intéressant pour le concepteur - Traitement de la touche initiale

Conseils de programmation intéressants pour Designer - Créez votre premier programme de traitement

Cet article provient de:

Si vous avez besoin d'aide, vous pouvez contacter: [email protected].