public PlaygroundParticlesC particles; // Set the Particle Playground System through Inspector
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
particles.Emit(!particles.emit);
}
}
IEnumerator Emit()
{
float emissionRate = 0;
int emitted = 0;
while (emitted < particles.particleCount)
{
emissionRate += (particles.particleCount / seconds) * (Time.deltaTime);
int r = Mathf.RoundToInt(emissionRate);
if (r > 0)
{
if (emitted + r >= particles.particleCount)
{
r = (particles.particleCount - emitted);
}
particles.Emit(
r,
position,
minVelocity,
maxVelocity,
color
);
emitted += r;
emissionRate = 0;
}
yield return(null);
}
}
public IEnumerator StartDelayedEmission()
{
particles.particleSystemGameObject.SetActive(false);
yield return(new WaitForSeconds(startTime));
particles.Emit(true);
}
protected override void DoStart()
{
core.onDamaged += (float value) => {
var minVelocity = damageParticle.initialLocalVelocityMin;
var maxVelocity = damageParticle.initialLocalVelocityMax;
damageParticle.Emit(emitParticlesPerDamaged, transform.position, minVelocity, maxVelocity, Color.white);
};
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown("space"))
{
Debug.Log("space");
m_particles.Emit(true);
}
}
void Update()
{
// As an example, emit when pressing left mouse-button.
// This version of Emit () processes random velocities within range set by you. Initial Velocity Shape will apply when available.
if (Input.GetMouseButtonDown(0))
{
particles.Emit(amount, position, minimumVelocity, maximumVelocity, color);
}
}
void Update()
{
// Ensure particle system is ready before we use it
if (!particles.IsReady())
{
return;
}
// Emit
_emitTimer += Time.deltaTime / emitTime;
if (_emitTimer >= 1f)
{
// Emit onto the initial position of the spline
Vector3 emitPos = spline.GetPoint(0);
particles.Emit(emitPos, Vector3.zero, color);
_emitTimer = 0;
}
// Ensure correct length of scatter positions (upon changing particle count)
if (applyPositionScatter && particles.particleCount != _scatterPosition.Length)
{
GenerateScatter();
}
// Position
for (int i = 0; i < particles.particleCount; i++)
{
// If Playground Cache is resized while in here we need to exit the loop
if (applyPositionScatter && particles.playgroundCache.simulate.Length != _scatterPosition.Length)
{
break;
}
// Check if the particle is simulating
if (particles.playgroundCache.simulate[i])
{
// Normalize the time for the particle
float t = Mathf.Min(particles.playgroundCache.life[i] / (particles.lifetime - particles.playgroundCache.lifetimeSubtraction[i]), .99f);
// Create a position on the spline along with the generated scattering
Vector3 pos = spline.GetPoint(t);
if (applyPositionScatter)
{
pos += applyScatterLifetimeMultiplier? _scatterPosition[i] * positionScatterLifetimeMultiplier.Evaluate(t) : _scatterPosition[i];
}
// Set the position of the particle
particles.ParticlePosition(i, pos);
}
}
}
void ShootParabola()
{
for (int i = 0; i < particles.particleCount; i++)
{
float movePercentage = (i * 1f) / (particles.particleCount * 1f);
Vector3 currentPos = Vector3.Lerp(startPosition, endPosition, movePercentage);
currentPos.x += bending.x * Mathf.Sin(Mathf.Clamp01(movePercentage) * Mathf.PI);
currentPos.y += bending.y * Mathf.Sin(Mathf.Clamp01(movePercentage) * Mathf.PI);
currentPos.z += bending.z * Mathf.Sin(Mathf.Clamp01(movePercentage) * Mathf.PI);
particles.Emit(currentPos, Vector3.zero, Color.white);
}
}
// Update is called once per frame
void Update()
{
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
if (WebCamManager.checkActivePixel(x, y))
{
Vector3 pos = new Vector3((x - Width / 2), (y - Height / 2), 0) + transform.position;
Particle.Emit(pos);
}
}
}
}
IEnumerator Pop()
{
/* A manipulator using events will contain a list of all its particles in form of List<ManipulatorParticle>
* where each item has a particle system id and a particle id.
* When using manipulator.GetParticles() the list will be converted into List<PlaygroundEventParticle> and
* contain detailed information about each particle currently inside its shape.
*/
// Get the list of particles inside the manipulator
List <PlaygroundEventParticle> manipulatorParticles = manipulator.GetParticles();
// Work through the list and emit popParticles and popTurbulenceParticles
foreach (PlaygroundEventParticle particle in manipulatorParticles)
{
popParticles.Emit(particle.position, particle.velocity, particle.color);
for (int i = 0; i < 5; i++)
{
popTurbulenceParticles.Emit(particle.position, particle.velocity + RandomV3(), particle.color);
}
}
// Kill all tracked particles within the Manipulator
manipulator.KillAllParticles();
// This part is just for the gui text
if (manipulatorParticles.Count > 0)
{
if (manipulatorParticles.Count > highestPop)
{
popTextColor.a = 1f;
popText.color = popTextColor;
highestPop = manipulatorParticles.Count;
popText.text = highestPop.ToString();
Vector2 pixelOffset = mainCamera.WorldToScreenPoint(manipulatorTransform.position);
pixelOffset.y += 50;
popText.pixelOffset = pixelOffset;
int highestNow = highestPop;
while (popTextColor.a > 0 && highestNow == highestPop)
{
popTextColor.a -= .5f * Time.deltaTime;
popText.color = popTextColor;
yield return(null);
}
}
}
}
void Update()
{
// Emit on left-click
if (Input.GetMouseButtonDown(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 1000f))
{
particles.Emit(
hit.point,
velocity,
color
);
}
}
}
IEnumerator Start()
{
PlaygroundParticlesC particles = GetComponent <PlaygroundParticlesC>();
while (!particles.IsReady())
{
yield return(null);
}
Vector3 position = particles.particleSystemTransform.position;
for (int i = 0; i < particles.particleCount; i++)
{
float iCircle = 360f * ((i * 1f) / (particles.particleCount * 1f));
Vector3 direction = new Vector3(Mathf.Cos(Mathf.Deg2Rad * iCircle) * width, Mathf.Sin(Mathf.Deg2Rad * iCircle) * height, 0);
particles.Emit(position, direction * velocity, color);
}
}
IEnumerator EmitOverAllVertices()
{
while (true)
{
yield return(new WaitForSeconds(emitRepeatTime));
swo.BoneUpdate();
swo.UpdateOnNewThread();
while (!swo.isDoneThread)
{
yield return(null);
}
for (int i = 0; i < swo.vertexPositions.Length; i += vertexStep)
{
particles.Emit(swo.vertexPositions[i], particleVelocity, particleColor);
}
}
}
void Update()
{
if (Time.time > lastTimeUpdated + emissionRate)
{
// Iterate through each transform
foreach (Transform t in transforms)
{
particles.Emit(
emissionAmount,
t.position + randomPositionMin,
t.position + randomPositionMax,
randomVelocityMin,
randomVelocityMax,
color
);
}
lastTimeUpdated = Time.time;
}
}
public void Game_Event(string event_name)
{
switch (event_name)
{
case "hover start":
StartCoroutine(Text_Wait());
break;
case "hover play":
m_text_hover.Play();
m_text_hover.GetComponent <AudioSource>().Play();
m_text_onetimer.Play();
break;
case "hover stop":
m_text_hover.Stop();
m_text_hover.GetComponent <AudioSource>().Stop();
break;
case "onetimer":
m_text_onetimer.Play();
break;
case "onetimer small":
m_text_onetimer_small.Play();
break;
case "goal":
m_goal.Emit(true);
break;
case "summary record":
//include particles
break;
case "summary record stop":
//stop particles
break;
}
}
/// <summary>
/// Emit when particle system is moving.
/// </summary>
void EmissionMoveCheck()
{
if (movingTransform.position != previousPosition)
{
float emissionStepper = 0;
float deltaDistance = Vector3.Distance(previousPosition, movingTransform.position);
if (deltaDistance < minSpace)
{
return;
}
Vector3 delta = previousPosition;
Vector3 velocity = Vector3.zero;
Color color = Color.white;
while (emissionStepper < deltaDistance)
{
delta = Vector3.Lerp(previousPosition, movingTransform.position, emissionStepper / deltaDistance);
particles.Emit(delta, velocity, color);
emissionStepper += minSpace;
}
}
previousPosition = movingTransform.position;
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButton(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 1000f))
{
particles.Emit(
Mathf.RoundToInt(4000 * Time.deltaTime),
hit.point - new Vector3(.2f, .2f, .2f),
hit.point + new Vector3(.2f, .2f, .2f),
new Vector3(-1f, -1f, -1f),
new Vector3(1f, 1f, 1f),
Color.white
);
if (controlTransform != null)
{
controlTransform.position = hit.point;
}
}
}
}
void Update()
{
if (!_ready || !particles.IsReady() || particles.particleCount < 2)
{
return;
}
// Generate new interpolation positions if needed
if (_spiralInterpolations.Length != particles.particleCount ||
_startPos != start.position ||
_endPos != end.position ||
!Mathf.Approximately(_i, swirlIterations) ||
!Mathf.Approximately(_r, radius))
{
GenerateSpiralInterpolations();
}
for (int i = 0; i < particles.particleCount; i++)
{
// If particles cache is resized in the middle of execution we need to exit the loop
if (_spiralInterpolations.Length != particles.playgroundCache.simulate.Length)
{
break;
}
// Emit or position particles to the calculated spiral position
if (!particles.playgroundCache.simulate[i])
{
particles.Emit(_spiralInterpolations[i]);
}
else
{
particles.ParticlePosition(i, _spiralInterpolations[i]);
}
}
}
// Set emission on/off
public static void Emit (PlaygroundParticlesC playgroundParticles, bool setEmission) {
playgroundParticles.Emit(setEmission);
}
// Emit next particle while setting scriptedEmission data - using the particle system as a pool. Returns emitted particle number.
public static int Emit (PlaygroundParticlesC playgroundParticles, Vector3 position, Vector3 normal, Color color, Transform parent) {
return playgroundParticles.Emit(position,normal,color,parent);
}
/// <summary>
/// Load next effect while transitioning.
/// </summary>
IEnumerator NextEffect(int increment)
{
if (!canLoadNext)
{
yield break;
}
isSimulating = true;
inTransition = true;
canLoadNext = false;
pressSpaceText.SetActive(false);
// Internally used variables
bool canContinue = looping || !looping && currentIndex < particleFx.Count - 1;
float startTime;
// Store current particle system's values before we change them
int previousIndex = currentIndex;
bool previousOnlySourcePositioning = previousIndex >= 0?particleFx[previousIndex].particles.onlySourcePositioning:false;
bool previousOnlyLifetimePositioning = previousIndex >= 0?particleFx[previousIndex].particles.onlyLifetimePositioning:false;
bool previousTransitionBackToSource = previousIndex >= 0?particleFx[previousIndex].particles.transitionBackToSource:false;
// Make Lifetime Positioning unable to set new positions (this makes particles behave like a target manipulator has affected them)
if (previousOnlyLifetimePositioning)
{
for (int p = 0; p < particleFx[previousIndex].particles.particleCount; p++)
{
particleFx[previousIndex].particles.playgroundCache.changedByPropertyTarget[p] = true;
}
}
// Prepare current (previous) particle system for transition
if (previousIndex >= 0)
{
particleFx[previousIndex].particles.emit = false;
particleFx[previousIndex].particles.onlySourcePositioning = false;
particleFx[previousIndex].particles.onlyLifetimePositioning = false;
particleFx[previousIndex].particles.transitionBackToSource = false;
particleFx[previousIndex].particles.particleMaskTime = transitionTime * .75f;
particleFx[previousIndex].particles.particleMask = particleFx[previousIndex].particles.particleCount;
particleFx[previousIndex].particles.applyParticleMask = true;
}
if (canContinue)
{
if (!isSelfRunning)
{
particleBlastSound.clip = particleBlastClips[UnityEngine.Random.Range(0, particleBlastClips.Length)];
particleBlastSound.pitch = UnityEngine.Random.Range(.9f, 1.1f);
particleBlastSound.Play();
}
currentIndex = (currentIndex + increment) % particleFx.Count;
if (currentIndex < 0)
{
currentIndex = particleFx.Count - 1;
}
// Scene transition fx
StartCoroutine(NextSkyboxColor());
nextParticleFx.Emit(true);
nextParticleSmokeFx.Emit(true);
repellentManipulator.enabled = true;
// Camera push back
yield return(new WaitForSeconds(.05f));
startTime = Time.time;
while (Time.time < startTime + (transitionTime / 2f))
{
cameraPushBack = Mathf.Lerp(cameraPushBack, cameraPushBackForce, (Time.time - startTime) / (transitionTime / 2f));
yield return(null);
}
// Prepare new (next) particle system for transition
particleFx[currentIndex].particles.particleMaskTime = 0;
particleFx[currentIndex].particles.particleMask = particleFx[currentIndex].particles.particleCount;
particleFx[currentIndex].particles.applyParticleMask = true;
yield return(null);
repellentManipulator.enabled = false;
if (particleFx[currentIndex].moveInOut)
{
particleFx[currentIndex].particles.particleSystemTransform.position = new Vector3(0, -20f, 0);
}
particleFx[currentIndex].particles.Emit(true);
while (!particleFx[currentIndex].particles.IsReady())
{
yield return(null);
}
for (int p = 0; p < particleFx[currentIndex].particles.particleCount; p++)
{
particleFx[currentIndex].particles.playgroundCache.maskAlpha[p] = 0f;
particleFx[currentIndex].particles.playgroundCache.isMasked[p] = true;
}
yield return(null);
particleFx[currentIndex].particles.particleMaskTime = transitionTime / 2f;
particleFx[currentIndex].particles.particleMask = 0;
nextParticleFx.Emit(false);
nextParticleSmokeFx.Emit(false);
inTransition = false;
// Move particle system in if needed
if (particleFx[currentIndex].moveInOut)
{
startTime = Time.time;
while (Time.time < startTime + (transitionTime / 2f))
{
particleFx[currentIndex].particles.particleSystemTransform.position =
new Vector3(
0,
Mathf.Lerp(-20f, 0, Easing(2, (Time.time - startTime) / (transitionTime / 2f))),
0
);
yield return(null);
}
particleFx[currentIndex].particles.particleSystemTransform.position = Vector3.zero;
}
}
// Wait around till all fx is ready, move previous particle system if needed
startTime = Time.time;
while (Time.time < startTime + transitionTime + .5f)
{
if (previousIndex >= 0 && particleFx[previousIndex].moveInOut)
{
particleFx[previousIndex].particles.particleSystemTransform.position =
new Vector3(
0,
Mathf.Lerp(0, 20f, Easing(1, (Time.time - startTime) / (transitionTime / 2f))),
0
);
}
yield return(null);
}
// Restore previous particle system (for when it returns in the fx cycle)
if (previousIndex >= 0 && canContinue)
{
yield return(null);
particleFx[previousIndex].particles.onlySourcePositioning = previousOnlySourcePositioning;
particleFx[previousIndex].particles.onlyLifetimePositioning = previousOnlyLifetimePositioning;
particleFx[previousIndex].particles.transitionBackToSource = previousTransitionBackToSource;
particleFx[previousIndex].particles.particleSystemGameObject.SetActive(false);
}
if (canContinue)
{
canLoadNext = true;
}
else
{
StartCoroutine(FadeOut());
}
}
void OnTrailPoint(PlaygroundEventTrailPoint trailPoint)
{
Vector3 position = trailPoint.position;
particles.Emit(position, velocity, color);
}
IEnumerator Shoot()
{
// Set variables
float rotationSpeed = 360f / numberOfParticles;
float timeDone;
// Set particle count to match the amount needed
particles.particleCount = numberOfParticles * cycles;
// Wait before emission starts (if applicable)
if (yieldBeforeEmission > 0)
{
timeDone = PlaygroundC.globalTime + yieldBeforeEmission;
while (PlaygroundC.globalTime < timeDone)
{
yield return(null);
}
}
// Loop through every cycle (c) and particle (p)
for (int c = 0; c < cycles; c++)
{
for (int p = 0; p < numberOfParticles; p++)
{
// Emit a particle in rotated direction
particles.Emit(thisTransform.position, thisTransform.right * force, color);
// Rotate towards direction
thisTransform.Rotate(rotationNormal * rotationSpeed);
// Wait for next emission (if applicable)
if (yieldBetweenShots > 0)
{
timeDone = PlaygroundC.globalTime + yieldBetweenShots;
while (PlaygroundC.globalTime < timeDone)
{
yield return(null);
}
}
}
// Wait for next cycle (if applicable)
if (yieldBetweenCycles > 0)
{
timeDone = PlaygroundC.globalTime + yieldBetweenCycles;
while (PlaygroundC.globalTime < timeDone)
{
yield return(null);
}
}
}
// Return if not in Play Mode in Editor
#if UNITY_EDITOR
if (!UnityEditor.EditorApplication.isPlaying)
{
yield break;
}
#endif
// Wait for action when last particle's lifetime is over
switch (whenDone)
{
case WhenDoneCircleShot.Inactivate:
yield return(new WaitForSeconds(particles.lifetime));
gameObject.SetActive(false);
break;
case WhenDoneCircleShot.Destroy:
yield return(new WaitForSeconds(particles.lifetime));
Destroy(gameObject);
break;
}
}
// Emit next particle - using the particle system as a pool (note that you need to set scriptedEmission-variables on beforehand). Returns emitted particle number.
public static int Emit (PlaygroundParticlesC playgroundParticles) {
return playgroundParticles.Emit(playgroundParticles.scriptedEmissionPosition,playgroundParticles.scriptedEmissionVelocity,playgroundParticles.scriptedEmissionColor,playgroundParticles.scriptedEmissionParent);
}