AccueilAccueil  FAQFAQ  RechercherRechercher  S'enregistrerS'enregistrer  MembresMembres  Connexion  

Partagez | 
 

 [Tutoriel] Le système de particules de GM

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
onilink_
Modérateur
avatar

Messages : 8923
Localisation : Montpellier
Projet Actuel : Planet Centauri
OniDev

MessageSujet: [Tutoriel] Le système de particules de GM   Ven 7 Oct 2011 - 14:42

Les particules


Sommaire
1-Introduction
2-Premier système de particule
3-Système de particule avancé
4-Les attracteurs
5-Les destructeurs
6-Les déflecteurs

1-Introduction

Le système de particule de GM est un module très puissant permettant de créer facilement de nombreux effets.

Pour créer des particules il faut avant tout :
-La version enregistrée de GM Razz
-Un système de particule
-Un émetteur de particules
-Un type de particules a émettre.

Le système de particules contiendras le 'monde' des particules. C'est ici qu'elles évoluerons au cours du temps.
Vous avez un contrôle total sur un système de particule, et par défaut tous les systèmes que vous créerez seront affichés et mis a jour.
Vous pouvez avoir autant de système de particule que vous le souhaitez.

L’émetteur de particule lui vous permettra de créer des particules dans un système.
Vous ne pouvez pas créer de particules sans émetteur de particules.

Le type de particule quand a lui définiras le comportement des particules.
Il vous permet de choisir la forme, la couleurs, et le comportement 'physique' de vos particules.

Chaque particule crée a une durée de vie déterminée. Au cours du temps elle peut changer de couleur, de transparence,
et vous pouvez même décider si des particules doivent être crées depuis celle si pendant sa vie, ou même lors de sa mort.


2-Premier système de particule

Création d'un système de particule
La première étape, vous l'aurez compris, est de créer le système de particule.
La fonction part_system_create() est la pour ça. Elle retourne l'id du système crée.

Code:
ps = part_system_create()


Création de l'émetteur
La création de l'émetteur fonctionne de la même manière que pour le système,
mais il faut lui passer en paramètre le système de particule auquel il doit être assigné.
part_emitter_create(part system)

Code:
em = part_emitter_create(ps)


Création du type de particule
La création d'un type de particule ce fait avec pt = part_type_create()

Code:
pt = part_type_create()


Paramétrage de l'émetteur
Pour qu'un émetteur émette des particules, il faut le paramétrer avec :
part_emitter_region(ps,ind,xmin,xmax,ymin,ymax,shape,distribution) qui choisis la zone ou serons crées les particules.
part_emitter_stream(ps,ind,parttype,n) qui permet de créer n particules chaque step. Si n est négatif alors une particule est générée avec une chance de -1/n chaque step.
part_emitter_burst(ps,ind,parttype,n) permet d'émettre n particules une fois. A utiliser dans un évent.

exemple:
Code:
part_emitter_region(ps, em, 0, room_width, room_height/2, room_height/2, ps_shape_line, ps_distr_gaussian)
part_emitter_stream(ps, em, pt, 5)


Paramétrage du type de particule
Vous pouvez maintenant paramétrer votre type de particule avec les fonctions suivantes :
(le paramètre wiggle signifie remuer, incr incrémenter)

Forme, couleur et mélange :
part_type_shape(ind,shape)
part_type_sprite(ind,sprite,animat,stretch,random)
part_type_size(ind,size_min,size_max,size_incr,size_wiggle)
part_type_scale(ind,xscale,yscale)
part_type_orientation(ind,ang_min,ang_max,ang_incr,ang_wiggle,ang_relative)
part_type_color1(ind,color1)
part_type_color2(ind,color1,color2)
part_type_color3(ind,color1,color2,color3)
part_type_color_mix(ind,color1,color2)
part_type_color_rgb(ind,rmin,rmax,gmin,gmax,bmin,bmax)
part_type_color_hsv(ind,hmin,hmax,smin,smax,vmin,vmax)
part_type_alpha1(ind,alpha1)
part_type_alpha2(ind,alpha1,alpha2)
part_type_alpha3(ind,alpha1,alpha2,alpha3)
part_type_blend(ind,additive)

Vie et mort :
part_type_life(ind,life_min,life_max)
part_type_step(ind,step_number,step_type)
part_type_death(ind,death_number,death_type)

Mouvements :
part_type_speed(ind,speed_min,speed_max,speed_incr,speed_wiggle)
part_type_direction(ind,dir_min,dir_max,dir_incr,dir_wiggle)
part_type_gravity(ind,grav_amount,grav_dir)


Essayons de faire de petites particules simples qui se déplacent de façon linéaire vers le haut :
Code:
part_type_shape(pt, pt_shape_pixel)
part_type_speed(pt, 2, 2, 0, 0)
part_type_direction(pt, 90, 90, 0, 0)


Le résultat :

Code complet de l'exemple, a mettre dans le create event :
Code:
background_color = 0
room_speed = 60

ps = part_system_create()
em = part_emitter_create(ps)

pt = part_type_create()
part_type_shape(pt, pt_shape_pixel)
part_type_speed(pt, 2, 2, 0, 0)
part_type_direction(pt, 90, 90, 0, 0)

part_emitter_region(ps, em, 0, room_width, room_height/2, room_height/2, ps_shape_line, ps_distr_gaussian)
part_emitter_stream(ps, em, pt, 5)


3-Système de particule avancé

Maintenant que nous savons créer des particules basiques, nous pouvons créer des types de particules bien plus complexes.
Pour cela il suffiras de paramétrer le plus de paramètres possibles, en fonction de nos besoins.

Le feu

Imaginons, je veux faire un effet de feu. Je doit déjà faire des particules qui prendrons successivement la couleur jaune, puis rouge, avec un blending additif.
Elles se déplacent vers le haut, mais d'un angle un peu aléatoire, et on une vitesse qui peut être faible ou élevée.
De même la taille des particules et variable et tend a grossir un peu au cours du temps.
Nos particules aurons aussi une durée de vie plutôt courte.

Premier essais :
Code:
fire = part_type_create()
part_type_color2(fire, c_yellow, c_red)
part_type_blend(fire, true)
part_type_direction(fire, 90-30, 90+30, 0, 0)
part_type_speed(fire, 3, 6, 0.02, 0)
part_type_shape(fire, pt_shape_sphere)
part_type_size(fire, 0.25, 1, 0.01, 0)
part_type_life(fire, 30, 45)


Le résultat est donc sympathique mais c'est pas encore ça.
Nous allons donc faire un alpha progressif, pour une transition moins brute.
Revoir un peu quelques paramètres, et créer un nouveau type de particule qui apparaitra lors
de la mort d'une particule de feu : la particule de fumée.

Code:
part_type_alpha3(fire, 0.7, 0.6, 0)
part_type_death(fire, -5, smoke)


Notre particule de fumée apparaitra donc 1 fois sur 5 a la mort d'une particule de feu.
Elle se déplaceras vers le haut, seras grise, et auras un mouvement semblable a celui du feu.

Code:
smoke = part_type_create()
part_type_color3(smoke, c_dkgray, c_dkgray, c_gray)
part_type_direction(smoke, 80, 100, 0, 0)
part_type_speed(smoke, 0.25, 1, 0, 0.02)
part_type_shape(smoke, pt_shape_smoke)
part_type_size(smoke, 0.2, 0.5, 0.01, 0)
part_type_life(smoke, 60, 90)
part_type_alpha3(smoke, 0.2, 0.6, 0)


Le résultat est déjà bien plus concluant.
C'est bien sur encore améliorable, mais le but était de vous montrer pas a pas comment créer un
type de particule selon un modèle.

Nous nous servirons du système de particule complet qui suit pour le reste du cours :

Code:
smoke = part_type_create()
part_type_color3(smoke, c_dkgray, c_dkgray, c_gray)
part_type_direction(smoke, 80, 100, 0, 0)
part_type_speed(smoke, 0.25, 1, 0, 0.02)
part_type_shape(smoke, pt_shape_smoke)
part_type_size(smoke, 0.2, 0.5, 0.01, 0)
part_type_life(smoke, 60, 90)
part_type_alpha3(smoke, 0.2, 0.6, 0)

fire = part_type_create()
part_type_color2(fire, c_yellow, c_red)
part_type_blend(fire, true)
part_type_direction(fire, 90-20, 90+20, 0, 0)
part_type_speed(fire, 3, 6, 0.02, 0)
part_type_shape(fire, pt_shape_sphere)
part_type_size(fire, 0.25, 1, 0.02, 0)
part_type_life(fire, 30, 45)
part_type_alpha3(fire, 0.7, 0.6, 0)
part_type_death(fire, -5, smoke)

background_color = 0
room_speed = 60
ps = part_system_create()
em = part_emitter_create(ps)
part_emitter_region(ps, em, 64, room_width-64, room_height, room_height, ps_shape_line, ps_distr_gaussian)
part_emitter_stream(ps, em, fire, 5)


4-Les attracteurs

Pour faire un système de particule plus vivant et complexe, vous pouvez ajouter des attracteurs (qui peuvent aussi jouer le rôle inverse).
Un attracteur se crée avec la fonction part_attractor_create(part system).
Vous devez lui définir une position avec part_attractor_position(ps, attract id, x, y)
Et vous pouvez lui définir ses attributs avec part_attractor_force(ps, attract id, force, rayon, type, additif)

Attention : un attracteur agis sur toutes les particules d'un système de particules.
S'il ne doit pas agir sur certaines particules, alors vous devez créer un autre système de particules.

Essayons de créer un attracteur dans le système de particule définis précédemment :
Code:
at = part_attractor_create(ps)
part_attractor_position(ps, at, 320, 400)
part_attractor_force(ps, at, -10, 100, ps_force_constant, 0)


On vois que les particules sont bien attirées par le point indiqué.
Voici le résultat si on augmente la force jusqu’à 10 :


Et a -10:


5-Les destructeurs

Les destructeurs servent, comme leur nom l'indique, a détruire les particules qui entrent dans leur zone d'effet.
Leur fonctionnement est assez semblable a celui des attracteurs.
On crée un destroyer avec part_destroyer_create(ps)
Et on le paramètre avec part_destroyer_region(ps, destroyer, xmin, xmax, ymin, ymax, shape)
Comme les attracteurs, ils agissent sur toutes les particules d'un système de particule.
Attention : une particule détruite par un destroyer ne crée pas de particule de fin de vie.

Exemple :
Code:
dt = part_destroyer_create(ps)
part_destroyer_region(ps, dt, 0, room_width, 400, 450, ps_shape_rectangle)


6-Les déflecteurs

Les déflecteurs servent a dévier des particules. Ainsi si des particules arrivent verticalement sur un déflecteur vertical, elles rebondirons dessus.
Ils fonctionnent comme les attracteurs, et agissent sur toutes les particules d'un système de particule.
On crée un deflector avec part_deflector_create(ps)
On choisis sa zone d'effet avec part_deflector_region(ps, deflector, xmin, xmax, ymin, ymax)
Et on le paramètre avec part_deflector_kind(ps, deflector, kind) ou kind est soit ps_deflect_vertical, soit ps_deflect_horizontal

Exemple :
Code:
df = part_deflector_create(ps)
part_deflector_region(ps, df, 0, 640, 260, 360)
part_deflector_kind(ps, df, ps_deflect_vertical)



J'aurais pu aussi vous parler des 'changers', mais ils fonctionnent comment les attracteurs, destructeurs, et déflecteurs.
Je vous laisse donc aller voir la documentation, qui contient de précieuses informations, et vous y trouverez un bon complément a ce tutoriel
qui n'est la que pour présenter une partie des nombreuses fonctionnalités du module de particules de GM.


_________________
                 


Dernière édition par onilink_ le Dim 13 Jan 2013 - 20:32, édité 3 fois
Revenir en haut Aller en bas
onilink_
Modérateur
avatar

Messages : 8923
Localisation : Montpellier
Projet Actuel : Planet Centauri
OniDev

MessageSujet: Re: [Tutoriel] Le système de particules de GM   Sam 8 Oct 2011 - 10:34

It's done :p

_________________
                 
Revenir en haut Aller en bas
Caly
Utilisateur confirmé: Rang ****
avatar

Messages : 1279
Localisation : Haute Normandie
Projet Actuel : Capturer, apprivoiser et dresser des Pokémons sauvages pour faire des spectacles de rue et en faire mon métier.

MessageSujet: Re: [Tutoriel] Le système de particules de GM   Sam 8 Oct 2011 - 12:01

It's great! Thanks onilink_ !
Revenir en haut Aller en bas
Contenu sponsorisé




MessageSujet: Re: [Tutoriel] Le système de particules de GM   

Revenir en haut Aller en bas
 
[Tutoriel] Le système de particules de GM
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
Forum Le CBNA :: Développement :: Game Maker-
Sauter vers: