void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { Vector3 pos = particleCollisionEvent.intersection; Quaternion rot = Quaternion.LookRotation(particleCollisionEvent.normal); Instantiate(hitObject, pos, rot); }
public void shot(ParticleCollisionEvent hit, Gradient colors) { Debug.Log(" shot is called "); SetDecaleData(hit, colors); display(); }
// TODO: this will affect particles from ANY system. Need to setup a link to the target particle system. // WARNING: For every particle collision in this frame, we check EVERY particle. Could be slow with 1000's of the things and lots of objects. // So that's 'number of particles that had a collision with this object in this frame' X 'number of particles' = number of loops. // In our case, we're train-lining particles so only one collision occurs at a time. // TODO: We use a hard-coded 0.2f in the below. What about units/scaling etc? // This value was chosen because 0.1f resulted in some particles not being detected as close enough to change their colour. void OnParticleCollision(GameObject fromThisParticleSystem) { if (fromThisParticleSystem) { ParticleSystem ps = fromThisParticleSystem.GetComponent <ParticleSystem>(); //Get all collision events from the particle system that occurred with this sphere in this frame. int numCollisionEvents = ParticlePhysicsExtensions.GetCollisionEvents(ps, gameObject, collisionEvents); //ps.GetCollisionEvents(sc, collisionEvents); for (int collisionEventCounter = 0; collisionEventCounter < numCollisionEvents; collisionEventCounter++) { ParticleCollisionEvent pce = collisionEvents [collisionEventCounter]; // Now we have to find out which particles actually hit. // Get all the particles from this particle system that are 'in flight'. ParticleSystem.Particle[] inflightParticles = new ParticleSystem.Particle[ps.particleCount]; int inflightParticleCount = ps.GetParticles(inflightParticles); // Find out which ones are close enough to the sphere to be considered a hit. for (int i = 0; i < inflightParticleCount; i++) { //MUST use the 'transform' of the PS to get the particles position world space. Vector3 particlePosWS = ps.transform.TransformPoint(inflightParticles [i].position); double distance = Vector3.Distance(pce.intersection, particlePosWS); if (distance < 0.2f) { inflightParticles[i].color = photonColor; } } ps.SetParticles(inflightParticles, inflightParticleCount); // Think, if multiple particles hit the same point vs hitting different points in this frame? } } }
void OnParticleCollision(GameObject other) { if (collisionEvents == null) { return; } if (other.tag == "Barrel") { for (int i = 0; i < collisionEvents.Length; i++) { collisionEvents[i] = new ParticleCollisionEvent[sprinklers[i].GetSafeCollisionEventSize()]; } for (int i = 0; i < collisionEvents.Length; i++) { sprinklers[i].GetCollisionEvents(gameObject, collisionEvents[i]); } for (int i = 0; i < collisionEvents.Length; i++) { for (int j = 0; j < collisionEvents[i].Length; j++) { lid.AddForceAtPosition(Vector3.down * dropletForce, collisionEvents[i][j].intersection); } } } }
void SetParticleData(ParticleCollisionEvent particleCollisionEvent, Gradient colorGradient) { if (particleDecalDataIndex >= maxDecals) { particleDecalDataIndex = 0; } particleData[particleDecalDataIndex].position = particleCollisionEvent.intersection; Vector3 particleRotationEuler = Quaternion.LookRotation(particleCollisionEvent.normal).eulerAngles; particleRotationEuler.z = Random.Range(0, 360); particleData[particleDecalDataIndex].rotation = particleRotationEuler; if (particleCollisionEvent.colliderComponent != null) { if (particleCollisionEvent.colliderComponent.CompareTag("Prop")) { particleData[particleDecalDataIndex].size = Random.Range(propDecalSizeMin, propDecalSizeMax); } else { particleData[particleDecalDataIndex].size = Random.Range(decalSizeMin, decalSizeMax); } } particleData[particleDecalDataIndex].color = colorGradient.Evaluate(Random.Range(0f, 1f)); particleDecalDataIndex++; }
void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { ParticleSystem.MainModule psMain = SnowPieces.main; // Instantiate(Snow, particleCollisionEvent.intersection,Quaternion.identity); objectPooler.SpawnFromPool("Snow", particleCollisionEvent.intersection, Quaternion.identity); }
void SplatterParticles(ParticleCollisionEvent collisionEvent) { splatterParticles.transform.position = collisionEvent.intersection; splatterParticles.transform.rotation = Quaternion.LookRotation(collisionEvent.normal); splatterParticles.Clear(); splatterParticles.Play(); }
void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { splatter.transform.position = particleCollisionEvent.intersection; splatter.transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); if (_flyScore % 150 == 0) {// 솜사탕 SoundManager._uniqueinstance.PlayEffSound(SoundManager.eEffType.COMBO); _scoreEff[3].GetComponent <ParticleSystem>().Play(); _scoreEff[3].transform.position = particleCollisionEvent.intersection; _scoreEff[3].transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); } else if (_flyScore % 350 == 0) {// BAAM SoundManager._uniqueinstance.PlayEffSound(SoundManager.eEffType.COMBO_YEAHH); _scoreEff[2].GetComponent <ParticleSystem>().Play(); _scoreEff[2].transform.position = particleCollisionEvent.intersection; _scoreEff[2].transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); } else if (_flyScore % 800 == 0) {// 별 SoundManager._uniqueinstance.PlayEffSound(SoundManager.eEffType.COMBO_SHINE); _scoreEff[1].GetComponent <ParticleSystem>().Play(); _scoreEff[1].transform.position = particleCollisionEvent.intersection; _scoreEff[1].transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); } ParticleSystem.MainModule psMain = splatter.main; psMain.startColor = particleGradient.Evaluate(Random.Range(0f, 1f)); splatter.Emit(10); }
private void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { splatterParticle.transform.position = particleCollisionEvent.intersection; splatterParticle.transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); print(particleCollisionEvent.intersection); splatterParticle.Emit(5); }
private void SpawnDecalBloodDroplets(ParticleCollisionEvent particleCollisionEvent) { float randomAngle = Random.Range(0f, 360f); float randomScale = Random.Range(-0.2f, 0.2f); Ray precise = new Ray(); RaycastHit hit; //raising the collision height slightly makes the blood droplet positioning look better Vector3 rayOrigin = particleCollisionEvent.intersection; rayOrigin.y += 0.1f; precise.origin = rayOrigin; precise.direction = (particleCollisionEvent.intersection - transform.position).normalized; //Debug.DrawRay(precise.origin, precise.direction, Color.white, 5f); if (Physics.Raycast(precise, out hit, sprayDistance)) { GameObject decal = Instantiate(decalPrefab, bucketFX.transform); decal.transform.position = hit.point; decal.transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal * -1f); decal.transform.Rotate(0f, 0f, randomAngle); decal.transform.localScale += new Vector3(randomScale, randomScale, randomScale); } }
void EnemyDamage(ParticleCollisionEvent EnemeyHit) { if (gameObject.CompareTag("Enemy")) { EnemeyHealth--; } }
void OnParticleCollision(GameObject obj) { if (ps == null) { Debug.LogError("ParticleSystemHelper: OnParticleCollision: null ps"); return; } collisionObject = obj; collisionCollider = obj.GetComponent <Collider>(); if (collisionCollider == null) { return; } collisionEvents.Clear(); collisionCount = ps.GetCollisionEvents(obj, collisionEvents); //Debug.Log("ParticleSystemHelper: OnParticleCollision: obj: " + obj + " ps: " + ps + " collisionCount: " + collisionCount + " collisionObject: " + collisionObject + " collisionCollider: " + collisionCollider); for (int i = 0; i < collisionCount; i++) { ParticleCollisionEvent collision = collisionEvents[i]; //Debug.Log("ParticleSystemHelper: OnParticleCollision: i: " + i + " collision: " + collision + " colliderComponent: " + collision.colliderComponent + " intersection: " + collision.intersection.x + " " + collision.intersection.y + " " + collision.intersection.z + " " + " normal: " + collision.normal.x + " " + collision.normal.y + " " + collision.normal.x + " velocity: " + collision.velocity.x + " " + collision.velocity.y + " " + collision.velocity.z); float r = 0.1f; Debug.DrawLine(collision.intersection - (Vector3.up * r), collision.intersection + (Vector3.up * r), Color.red, 1.0f, false); Debug.DrawLine(collision.intersection - (Vector3.forward * r), collision.intersection + (Vector3.forward * r), Color.red, 1.0f, false); Debug.DrawLine(collision.intersection - (Vector3.right * r), collision.intersection + (Vector3.right * r), Color.red, 1.0f, false); } SendEventName("ParticleCollision"); }
// OnParticleCollision在Collider所属游戏对象脚本上执行,other为ParticleSystem所属游戏对象 void OnParticleCollision(GameObject other) { ParticleSystem ps = other.GetComponent <ParticleSystem>(); int safeLength = ps.GetSafeCollisionEventSize(); print("safe length = " + safeLength.ToString()); if (collisionEvents.Length < safeLength) { collisionEvents = new ParticleCollisionEvent[safeLength]; } int num = ps.GetCollisionEvents(gameObject, collisionEvents); print("received collision event number = " + num.ToString()); for (int i = 0; i < num; ++i) { ParticleCollisionEvent ev = collisionEvents [i]; Vector3 pos = ev.intersection; if (ev.colliderComponent.tag == "Cube") { print("hit cube at position : " + pos.Str()); } else if (ev.colliderComponent.tag == "Capsule") { print("hit capsule at position : " + pos.Str()); } else if (ev.colliderComponent.tag == "Cylinder") { print("hit cylinder at position : " + pos.Str()); } } }
void Start() { p11 = this.gameObject.GetComponent <ParticleSystem>(); p11Transform = this.gameObject.transform; if (ParticlePOOL != null) { Propagator = ParticlePOOL.GetComponent(typeof(ParticlePropagationSKYMASTER)) as ParticlePropagationSKYMASTER; } collisionEvents = new ParticleCollisionEvent[1][]; if (Gameobj_instances != null) { Gameobj_instances.Clear(); } systems_To_override = new List <ParticlePropagationSKYMASTER>(); if (Systems_To_override != null) { if (Systems_To_override.Count > 0) { for (int i = 0; i < Systems_To_override.Count; i++) { systems_To_override.Add(Systems_To_override[i].GetComponent(typeof(ParticlePropagationSKYMASTER)) as ParticlePropagationSKYMASTER); } } } }
private void OnParticleCollisionManual(GameObject other, int aliveParticles = -1) { this.collisionEvents.Clear(); int num = this.initiatorPS.GetCollisionEvents(other, this.collisionEvents); int num2 = 0; while (true) { while (true) { if (num2 >= num) { return; } ParticleCollisionEvent event2 = this.collisionEvents[num2]; float num3 = Vector3.Angle(event2.normal, Vector3.up); if (num3 <= this.MaxGroundAngleDeviation) { if (this.InstantiateWhenZeroSpeed) { if (this.collisionEvents[num2].velocity.sqrMagnitude > 0.1f) { break; } bool flag = false; int index = 0; while (true) { if (index < aliveParticles) { ParticleCollisionEvent event4 = this.collisionEvents[num2]; float num5 = Vector3.Distance(event4.intersection, this.particles[index].position); if (num5 < this.MinDistanceBetweenDecals) { flag = true; } index++; continue; } if (!flag) { break; } break; } } ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams { position = this.collisionEvents[num2].intersection + (this.collisionEvents[num2].normal * this.MinDistanceBetweenSurface) }; Vector3 eulerAngles = Quaternion.LookRotation(-this.collisionEvents[num2].normal).eulerAngles; eulerAngles.z = Random.Range(0, 360); emitParams.rotation3D = eulerAngles; this.DecalParticles.Emit(emitParams, 1); } break; } num2++; } }
void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { splatterParticles.transform.position = particleCollisionEvent.intersection; splatterParticles.transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); ParticleSystem.MainModule psMain = splatterParticles.main; psMain.startColor = particleColorGradient.Evaluate(Random.Range(0f, 1f)); splatterParticles.Emit(1); }
void SetParticleData(ParticleCollisionEvent particleCollisionEvent, Gradient colorGradient) { if (DecalDataIndex >= maxDecals) { DecalDataIndex = 0; } DecalDataIndex++; }
void OnParticleCollision(GameObject other) { if (counter > limit && (other.tag == "Floor")) { ParticleSystem ps = GetComponent <ParticleSystem>(); ParticleSystem.Particle[] particleList = new ParticleSystem.Particle[ps.particleCount]; ps.GetParticles(particleList); ParticleCollisionEvent[] collisions = new ParticleCollisionEvent[ps.GetSafeCollisionEventSize()]; int noOfCollisions = ps.GetCollisionEvents(other, collisions); Instantiate(instantiateObject, new Vector3(collisions[0].intersection.x, collisions[0].intersection.y + 0.01f, collisions[0].intersection.z), Quaternion.Euler(90, Random.Range(0, 360), 0)); for (int i = 0; i < collisions.Length; i++) { Instantiate(instantiateObject, new Vector3(collisions[i].intersection.x, collisions[i].intersection.y + 0.01f, collisions[i].intersection.z), Quaternion.Euler(90, Random.Range(0, 360), 0)); } counter = 0; } if (counter > limit && (other.tag == "Platform")) { if (privateColor == 0) { foreach (Renderer childRenderer in other.transform.GetChild(1).GetComponentsInChildren <Renderer>()) { childRenderer.material.color = Color.blue; } } if (privateColor == 1) { foreach (Renderer childRenderer in other.transform.GetChild(1).GetComponentsInChildren <Renderer>()) { childRenderer.material.color = Color.green; } } } if (counter > limit && (other.tag == "Enemy")) { other.GetComponent <EnemyAi2> ().AdDamage(damage, 0); } if (counter > limit && (other.tag == "EnemySkull")) { other.GetComponent <EnemyAI3> ().AdDamage(damage, 0); } if (counter > limit && (other.tag == "Boss")) { Debug.Log("dsadsa"); other.GetComponent <EnemyAiBoos> ().AdDamage(damage); } if ((other.tag == "Boss2")) { Debug.Log("dsadsa"); other.GetComponent <EnemyAiBos2> ().AdDamage(damage); } }
public void HittedByParticle(ParticleCollisionEvent collisionEvent) { var decalInstance = SpawnController.SpawnDecal(); var decalTransform = decalInstance.transform; ApplyDecalTransform(decalTransform, collisionEvent); OnHitted(decalInstance, collisionEvent); }
//particleSystem is the particle system whose particles cause the collision void OnParticleCollision(GameObject other) { ParticleSystem part = other.GetComponent <ParticleSystem>(); ParticleCollisionEvent[] collisionEvents = new ParticleCollisionEvent[100]; int numParticles = ParticlePhysicsExtensions.GetCollisionEvents(part, gameObject, collisionEvents); this.hp -= numParticles; }
void EmitAtPos(ParticleCollisionEvent hit) { splatter.transform.position = hit.intersection; splatter.transform.rotation = Quaternion.LookRotation(hit.normal); ParticleSystem.MainModule splatterMain; splatterMain = splatter.main; splatterMain.startColor = colorsGradient.Evaluate(Random.Range(0f, 1.1f)); splatter.Emit(1); }
private void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { foreach (var fx in _collisionFX) { fx.transform.position = particleCollisionEvent.intersection; fx.transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); fx.Play(); } }
private void EmitAtLocation(ParticleCollisionEvent particleCollisionEvent) { splashDroplets.transform.position = particleCollisionEvent.intersection; splashDroplets.transform.rotation = Quaternion.LookRotation(particleCollisionEvent.normal); splashDroplets.Emit(1); var coll = oilDroplets.collision; coll.enabled = false; }
/// <summary> /// /// </summary> /// <param name="particleCollisionEvent"></param> public void ParticleHit(ParticleCollisionEvent particleCollisionEvent) { _particleHitCallCount++; if (_particleHitCallCount > _countOfDecals) { return; } SetParticleData(particleCollisionEvent); SpawnPrefabs(); }
protected override bool ShouldSpawn(ParticleCollisionEvent particleCollisionEvent) { var normal = particleCollisionEvent.normal; float angle = Vector3.Angle(normal, planeNormal); bool shouldSpawn = angle >= minAngle && angle <= maxAngle; return(shouldSpawn); }
void EmitAtLocation(ParticleCollisionEvent pCE) { /* * To set the particle to spawn at the POI (point of intersection) use the following statement * collisionParticle.transform.position = pCE.intersection; * To calculate rotation * collisionParticle.transform.rotation = Quaternion.LookRotation (particleCollisionEvent.normal) */ collisionParticle.Emit(1); }
void ApplyDecalTransform(Transform decalTransform, ParticleCollisionEvent collisionEvent) { decalTransform.position = collisionEvent.intersection + collisionEvent.normal * Offset; ApplyDecalRotationByNormal(decalTransform, collisionEvent.normal); if (ParentOnHit) { decalTransform.SetParent(collisionEvent.colliderComponent.transform); } }
public void OnParticleSplat(ParticleCollisionEvent particleCollisionEvent, float size, Gradient colorGradient) { if (decalContainer != null) { Vector3 position = particleCollisionEvent.intersection; Vector3 particleRotationEuler = Quaternion.LookRotation(particleCollisionEvent.normal).eulerAngles; particleRotationEuler.z = Random.Range(0, 360); Color color = colorGradient.Evaluate(Random.Range(0f, 1f)); decalContainer.AddDecal(position, size, particleRotationEuler, color); } }
private void SpawnBlood(ParticleCollisionEvent particleCollision) { // Clear the list so it's ready for the next collision _collisionEvents.Clear(); // Get the position of where the collision happened Vector3 intersectionPosition = new Vector3(particleCollision.intersection.x, 0.0001f, particleCollision.intersection.z); // We spawn a blood quad from the object pool _objectPooler.SpawnFromPool("Blood", intersectionPosition, Quaternion.Euler(90, 0, 0)); }
void EmitAtLocation(ParticleCollisionEvent e) { var emitParams = new ParticleSystem.EmitParams(); emitParams.position = e.intersection; for (var i = 0; i < 3; i++) { emitParams.velocity = new Vector3(Random.value, Random.value, 0); splasher.Emit(emitParams, 1); } }
/// <summary> /// <para>Get the particle collision events for a GameObject. Returns the number of events written to the array.</para> /// </summary> /// <param name="go">The GameObject for which to retrieve collision events.</param> /// <param name="collisionEvents">Array to write collision events to.</param> /// <param name="ps"></param> public static int GetCollisionEvents(this ParticleSystem ps, GameObject go, ParticleCollisionEvent[] collisionEvents) { return ParticleSystemExtensionsImpl.GetCollisionEvents(ps, go, collisionEvents); }