J'ai un système qui génère des particules à partir de sources et met à jour leurs positions. Actuellement, j'ai écrit un programme en OpenGL qui appelle mes GenerateParticles(...) et UpdateParticles(...) et affiche ma sortie. Une fonctionnalité que j'aimerais que mon système ait est de pouvoir générer n particules par seconde. Dans mes fonctions GenerateParticles(...) et UpdateParticles(...), j'accepte 2 paramètres importants: current_time et delta_time. Dans UpdateParticles(...), je mets à jour la position de ma particule selon la formule suivante: new_pos = curr_pos + delta_time*particle_vector. Comment puis-je utiliser ces paramètres et variables globales (ou d'autres mécanismes) pour produire n particules par seconde?système de particules: génération de particules
Répondre
Vous devez faire attention, la façon naïve de créer des particules vous fera créer des particules fractionnaires pour les faibles valeurs de n (probablement pas ce que vous voulez). Créez à la place une variable d'accumulateur qui est additionnée avec vos valeurs delta_time chaque image. Chaque cadre vérifier pour voir combien de particules dont vous avez besoin pour créer ce cadre et soustraire les montants appropriés:
void GenerateParticles(double delta_time) {
accumulator += delta_time;
while (accumulator > 1.0/particles_per_second) {
CreateParticle(...);
accumulator -= 1.0/particles_per_second;
}
}
Assurez-vous de mettre certaines limites en sorte que si le delta de temps est grande que vous ne créez pas un million particules en même temps.
Vous avez juste besoin de créer n * delta_time particules dans GenerateParticles.
Le nombre de particules émises à un cadre peut être calculé par:
double n = delta_time * frequency
int i = (int)n;
f = n - i;
Fondamentalement, vous pouvez émettre i particules.
La partie fractionnelle f peut être cumulée pour les trames suivantes. Quand il accumule plus d'un, vous pouvez émettre le nombre entier de particules:
f_sum += f;
if (f_sum > 1.0) {
int j = (int)f_sum;
f_sum -= j;
i += j;
}
Cependant, ce qui suit est une autre solution intéressante pour nombre fractionnaire de particules.
En utilisant un générateur de nombres pseudo-aléatoires (PRNG), nous pouvons l'utiliser pour déterminer si une particule doit être émise:
if (f >= r()) // Assumes r() is a PRNG generating a random value in [0, 1)
i++;
Cette approche est utile lorsque les changements de fréquence dans le temps. Et il élimine le besoin de stocker une variable supplémentaire.
Une autre beauté de cette approche est que le système de particules semblera moins uniforme. Par exemple, si la fréquence est 1,5 et le temps delta est 1, en utilisant la première approche, les trames émettront une séquence de 1, 2, 1, 2, ... particules. La deuxième approche peut casser ce modèle.
En outre, vous pouvez utiliser modf() pour extraire la partie intégrale et fractionnaire d'un nombre à virgule flottante.
delta_time est généralement un double inférieur à zéro. Supposons que je ne peux pas créer une fraction d'une particule. – Myx
@Myx: Je pense que vous voulez dire qu'il y en a moins d'un? Pas vraiment un problème comme le souligne @Ron bien qu'il soit plus simple et plus rapide d'accumuler 'n * delta_time' et de le comparer à' 1.' ... – Troubadour