Tutorial de scripts para Unity 3d

particles:

var particles : Particle[]


Devuelve una copia de todas las partículas y asigna un array de todas las partículas. Hemos de tener en cuenta que después de modificar el array de partículas debemos asignarlo de vuelta al particleEmitter para ver el cambio. Partículas con energía de cero o menos serán elmiminadas cuando se asignen las partículas. Así cuando se crea un completo nuevo array de partículas, necesitaremos colocar la energía de todas las partículas explicitamente.


particleCount:

var particleCount : int


El corriente número de partículas. Variable de sólo lectura.


enabled:

var enabled : boolean


Establece el ParticleEmitter en on o off. Un ParticleEmitter que no está habilitado no emitirá ninguna partícula, y las partículas emitidas no se animarán. Así, este valor nos permite pausar un sistema de partículas.

Reutilicemos el ejemplo anterior para pausar nuestro sistema de partículas transcurridos cinco segundos.

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 70;
particleEmitter.maxEmission = 110;
particleEmitter.emitterVelocityScale = 0.4;
particleEmitter.worldVelocity = Vector3(0,3,0);
particleEmitter.rndVelocity = Vector3(1,0.5,0.5);
particleEmitter.rndRotation = true;
particleEmitter.angularVelocity = 1;
particleEmitter.rndAngularVelocity = 66;

yield WaitForSeconds(5);
particleEmitter.enabled = false;

FUNCIONES:

ClearParticles:

function ClearParticles () : void


Borra todas las partículas del sistema de partículas.


Emit:

function Emit () : void


Emite un número de partículas. Hace que el emitter escupa un número aleatorio de partículas que se establecen entre las propiedades minEmission y maxEmission. Probemos:

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 20;
particleEmitter.maxEmission = 150;
particleEmitter.emitterVelocityScale = 0.4;
particleEmitter.angularVelocity = 1;
particleEmitter.rndAngularVelocity = 66;

particleEmitter.Emit();

function Emit (count : int) : void

Esta variante de la función emite el número count de partículas inmediatamente. Pasémosle el parámetro 300 a la función Emit del ejemplo anterior, por poner un caso muy exagerado.

function Emit (pos : Vector3, velocity : Vector3, size : float, energy : float, color : Color) : void

Este tercer prototipo de la función Emit emite una partícula individual con unos parámetros dados. Expliquemos brevemente qué representa cada parámetro:


pos: La posición de la partícula.
velocity: La velocidad de la partícula.
size: El tamaño de la partícula.
energy: El tiempo de vida restante de la partícula.
color: El color de la partícula.

particleEmitter.Emit(Vector3.zero, Vector3.up, 0.4, 4, Color.yellow);

Cuando le damos al play veremos una partícula en la posición central, con dirección hacia arriba, un tamaño de 0.4 unidades, que tardará 4 segundos en desvanecerse y tendrá color amarillo.

function Emit (pos : Vector3, velocity : Vector3, size : float, energy : float, color : Color, rotation : float, angularVelocity : float) : void

Y aún tenemos una tercera variante de la función, que incluye la rotación inicial de la partícula en grados y la velocidad angular por segundo.

particleEmitter.Emit(Vector3.zero, Vector3.up, 0.4, 4, Color.yellow, 75, 150);

Simulate:

function Simulate (deltaTime : float) : void

Avanzado sistema de simulación de partículas por un tiempo dado. Es útil para precalentar un sistema de partículas, como si se estuviera gestando:

particleEmitter.Simulate(5);

minEmission:

var minEmission : float


El mínimo número de partículas que serán generadas cada segundo.


maxEmission:

var maxEmission : float


El máximo número de partículas que serán generadas cada segundo.

Los valores por defecto en el inspector son 50. Editemos nuestro script para alterarlo.

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 70;
particleEmitter.maxEmission = 110;

Tenemos ahora un sistema de partículas más denso y compacto, como vemos.


emitterVelocityScale:

var emitterVelocityScale : float


La cantidad de la velocidad de emisión que las partículas heredan. Por defecto 0.05.


worldVelocity:

var worldVelocity : Vector3


La velocidad inicial de las partículas en el mundo global, a lo largo de x,y,z.


Incorporemos estas dos últimas variables a nuestro ejemplo, dándole a nuestro sistema de partículas una mayor velocidad de emisión y haciendo que nuestras partículas se desplacen hacia arriba (en coordenadas globales):

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 70;
particleEmitter.maxEmission = 110;
particleEmitter.emitterVelocityScale = 0.4;
particleEmitter.worldVelocity = Vector3(0,3,0);

localVelocity:

var localVelocity : Vector3

Es como la anterior, pero el desplazamiento se efectúa en las coordenadas locales del propio sistema de partículas.


rndVelocity:

var rndVelocity : Vector3

Una velocidad aleatoria con relación a los ejes x,y,z que es añadida a la velocidad. En nuestro ejemplo:

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 70;
particleEmitter.maxEmission = 110;
particleEmitter.emitterVelocityScale = 0.4;
particleEmitter.worldVelocity = Vector3(0,3,0);
particleEmitter.rndVelocity = Vector3(1,0.5,0.5);

useWorldSpace:

var useWorldSpace : boolean


Si está habilitado, las partículas no se mueven cuando el emitter se mueve. Si está en false, cuando muevas el emitter, las partículas lo siguen.


rndRotation:

var rndRotation : boolean


Si está habilitado, las partículas serán generadas con rotaciones aleatorias. Por defecto está en false, así que observemos qué ocurre si lo habilitamos:

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 70;
particleEmitter.maxEmission = 110;
particleEmitter.emitterVelocityScale = 0.4;
particleEmitter.worldVelocity = Vector3(0,3,0);
particleEmitter.rndVelocity = Vector3(1,0.5,0.5);
particleEmitter.rndRotation = true;

angularVelocity:

var angularVelocity : float

La velocidad angular de las nuevas partículas en grados por segundo.


rndAngularVelocity:

var rndAngularVelocity : float


Un modificador aleatorio de velocidad angular para nuevas partículas. Un valor aleatorio en el rango de [-rndAngularVelocity,rndAngularVelocity] será aplicado a todas las nuevas partículas, en adición a ParticleEmitter. angularVelocity.

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;
particleEmitter.minEmission = 70;
particleEmitter.maxEmission = 110;
particleEmitter.emitterVelocityScale = 0.4;
particleEmitter.worldVelocity = Vector3(0,3,0);
particleEmitter.rndVelocity = Vector3(1,0.5,0.5);
particleEmitter.rndRotation = true;
particleEmitter.angularVelocity = 1;
particleEmitter.rndAngularVelocity = 66;

Antes que nada, pediros disculpas porque esa clase se me había pasado. Como podéis ver en el gráfico, ParticleEmitter deriva de Component (como Collider, Rigidbody, Transform...) y por lo tanto la debería haber explicado antes, pero bueno, subsanamos el error ahora.

Vamos a preparar antes que nada nuestra escena para acoger los nuevos ejemplos de esta clase:

1.- Borramos la cámara que creamos en la clase RenderTexture
2.- Devolvemos el cubo a sus valores previos: position (-2,0,0) scale(1,1,1)
3.- Eliminamos el script vinculado a la esfera.
4.- Eliminamos la render texture en la carpeta Proyecto.
5.- Nos vamos al menú Gameobject=>Create other=>Particle System.
6.- Ubicamos nuestro nuevo gameobject en 0,0,0 y lo renombramos como "Particulas".
7.- Salvamos la escena.

Deberíamos tener ahora una escena parecida a esta:


Vale, ya estamos listos.

VARIABLES:

emit:

var emit : boolean


Booleano que indica si deben las partículas ser automáticamente emitidas cada frame o no.

Podemos usar esta variable para "encender o apagar" la emisión de partículas.

Editemos nuestro script de la siguiente manera:

yield WaitForSeconds(5);
particleEmitter.emit = false;
yield WaitForSeconds(5);
particleEmitter.emit = true;

Observaremos que tras los cinco segundos iniciales, nuestro sistema de partículas comienza a extinguirse hasta desaparecer, y pasados otros cinco, vuelve a encenderse.


minSize:

var minSize : float


El tamaño mínimo que cada partícula puede tener cuando se genera.


maxSize:

var maxSize : float


El tamaño máximo que cada particular puede tener al tiempo de ser generada.

Si tenemos el gameobject Particulas seleccionado, podemos comprobar que por defecto el tamaño mínimo (y máximo) es 0.1. Veamos qué pasa si alteramos estos valores:

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;

minEnergy:

var minEnergy : float


El mínimo tiempo de vida de cada particular, medido en segundos.


maxEnergy:

var maxEnergy : float


El máximo tiempo de vida de cada partícula, medido en segundos.

En el inspector esta variable y la anterior está colocada en 3 por defecto. Añadamos al script anterior unos valores distintos.

particleEmitter.minSize = 0.2;
particleEmitter.maxSize = 0.5;
particleEmitter.minEnergy = 1;
particleEmitter.maxEnergy = 5;

Vemos que conseguimos así una mayor variedad en la persistencia de cada partícula, dándole mayor dinamismo a nuestro sistema de partículas.

Dejamos aquí esta lección. Si aún te queda algo de tiempo no cierres el editor de scripts, ya que seguiremos en la próxima lección añadiendo modificaciones a nuestro ejemplo.

Hasta ahora.