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.
- 1. Système de particules SFML.NET
- 2. comment créer un système de particules sur iphone et conserver les particules créées?
- 3. iPhone. La performance du système de particules
- 4. Générateur de particules jquery
- 5. Création d'un attracteur de particules dans DirectX
- 6. XML Schema unique de particules Attribution Constraint
- 7. open source hydrodynamique des particules lisses
- 8. Dessiner rapidement de nombreuses particules texturées dans OpenGL ES 1.1
- 9. Moteur de physique actionscript qui supporte les particules qui s'attirent
- 10. Comment rendre des particules non triviales dans OpenGL
- 11. Modifications en temps réel de XML pour modifier l'effet des particules
- 12. Cette idée de projet java est-elle pratique? (Ordonnanceur et particules Swarm Optimisation)
- 13. Comment créer une structure de Particules à partir de texte dans AS3?
- 14. Comment créer une image fixe à partir de particules en LSL?
- 15. opengl modélisation fusée flammes et des traînées de vapeur avec des particules
- 16. Le flux de particules doit être de la même longueur quelle que soit la vitesse de l'émetteur
- 17. OpenGL ES: Est-il plus efficace d'allumer et d'éteindre les lumières ou d'attribuer simplement l'émissivité à mes particules?
- 18. Comment assembler un système de génération multi-projet
- 19. Génération de numéros d'identification
- 20. Génération de métadonnées avec XSLT
- 21. Génération de formulaires papier dynamique
- 22. Système de template et système de plugins
- 23. Génération de correctifs JBPM Workflow
- 24. Génération d'API Agnostic de langage
- 25. Django, génération de champs uniques
- 26. génération de frappe
- 27. Génération de code Xcode
- 28. Génération de code MD5
- 29. Scripts de génération automatique
- 30. Génération de séquence simple?
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