Unity Shuriken: Rendre le système de particules complètement à l'échelle

Question

J'ai un peu de problème. Dans mon jeu, j'ai besoin de ma carte entière pour pouvoir monter ou descendre, ce qui signifie que les systèmes de particules le font aussi. Certains sont locaux et certains sont des espaces mondiaux. Y at-il un moyen de faire en sorte que le même système mis à l'échelle 10 fois plus gros serait exactement le même que l'original mais 10 fois la taille? Cela signifie que les vélocités, la gravité, l'amortissement, etc. seront également mis à l'échelle

Answer 1

Créez un script et placez-le sur vos objets de jeu ParticleSystem.

class ParticleSystemScaler : Monobehaviour 
{ 
    ParticleSystem _ps; 
    public float sizeModifier = 1.0f; 

    void Awake() 
    { 
     _ps = GetComponent<ParticleSystem>(); 
     //For each property you want to scale, just multiply it by the size modifier. 
     _ps.startSize *= sizeModifier; 
    } 
} 

Vous pouvez améliorer cela en quelques façons ..

1. magasin le sizeModifier dans une classe de type GameManager, et le récupérer quand il est nécessaire
2. Cache les valeurs d'origine sur éveillé dans certains float, et faire originalStartSize *= sizeModifier
3. Faire une fonction ResizeParticles(float modifier) qui peut être appelée au lieu de faire le redimensionner sur éveillé.

Ces améliorations vous permettront d'appeler ResizeParticles() à tout moment et avoir le « modificateur » appliqué à leur taille d'origine (qui aurait été copié des composants eux-mêmes sur éveillé)

Answer 2

À la suite de la réponse de Bejasc , J'ai fait une version un peu plus complète et automatisée, mais il y a certainement des paramètres que je n'ai pas encore ajouté

using System.Collections; 
using System.Collections.Generic; 
using UnityEngine; 

public class ParticleSystemScaler : MonoBehaviour 
{ 
    private ParticleSystem ThisSystem; 
    private ParticleSystem.MainModule ThisMain; 
    private ParticleSystem.NoiseModule ThisNoise; 
    private ParticleSystem.LimitVelocityOverLifetimeModule ThisLimitVelocity; 

    private float CurrentScale; 

    private float InitialGravity; 
    private float InitialNoiseStrength; 
    private float InitialNoiseFrequency; 
    private float InitialMaxVelocity; 

    private void Start() 
    { 
     Initialise(); 
     ResizeSystem(transform.lossyScale.x); 
    } 

    private void Initialise() 
    { 
     ThisSystem = GetComponent<ParticleSystem>(); 

     if (ThisSystem) 
     { 
      ThisMain = ThisSystem.main; 
      ThisNoise = ThisSystem.noise; 
      ThisLimitVelocity = ThisSystem.limitVelocityOverLifetime; 

      InitialGravity = ThisMain.gravityModifierMultiplier; 
      InitialNoiseStrength = ThisNoise.strengthMultiplier; 
      InitialNoiseFrequency = ThisNoise.frequency; 
      InitialMaxVelocity = ThisLimitVelocity.limitMultiplier; 
     } 
    } 

    private void ResizeSystem(float NewScale) 
    { 
     CurrentScale = NewScale; 

     if (ThisSystem) 
     { 
      ThisMain.gravityModifierMultiplier = InitialGravity * NewScale; 
      if (ThisMain.simulationSpace == ParticleSystemSimulationSpace.World) 
      { 
       ThisNoise.strengthMultiplier = InitialNoiseStrength * NewScale; 
       ThisNoise.frequency = InitialNoiseFrequency/NewScale; 
       ThisLimitVelocity.limitMultiplier = InitialMaxVelocity * NewScale; 
      } 
     } 
    } 

    private void Update() 
    { 
     if (transform.lossyScale.x != CurrentScale) { ResizeSystem(transform.lossyScale.x); } 
    } 
}