void AddParticles() { if (myRootObject == null) { return; } float farthestObjectSqDistance = 0.0f; int childCount = myRootObject.transform.childCount; for (int i = 0; i < childCount; i++) { Transform tr = myRootObject.transform.GetChild(i); farthestObjectSqDistance = Mathf.Max(farthestObjectSqDistance, (myRootObject.transform.position - tr.position).sqrMagnitude); } SetMaterialAndProperties(myStarMaterial, myStarSize, 0, farthestObjectSqDistance); Random.seed = 0; ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams(); emitParams.velocity = Vector3.zero; emitParams.startLifetime = Mathf.Infinity; myStarfieldPS.Clear(); for (int i = 0; i < childCount; i++) { Transform tr = myRootObject.transform.GetChild(i); Color color = Color.white; if (myColors.Length > 0) { color = myColors[Random.Range(0, myColors.Length)]; } emitParams.startColor = color; emitParams.position = tr.position; emitParams.startSize = myStarSize; myStarfieldPS.Emit(emitParams, 1); } }
public void SpawnInitalParticles() { #if UNITY_5_2 Debug.Log("Functionality nor supported in this unity version"); #else for (int x = 0; x < _vecSpawnDevisionsPerAxis.x; x++) { for (int y = 0; y < _vecSpawnDevisionsPerAxis.y; y++) { for (int z = 0; z < _vecSpawnDevisionsPerAxis.z; z++) { Vector3 vecCordPercent = new Vector3(x / (_vecSpawnDevisionsPerAxis.x - 1), y / (_vecSpawnDevisionsPerAxis.y - 1), z / (_vecSpawnDevisionsPerAxis.z - 1)); vecCordPercent -= new Vector3(0.5f, 0.5f, 0.5f); vecCordPercent = Vector3.Scale(vecCordPercent, _vecSpawnVolume); Vector3 vecWorldCord = _trnSpawnBox.TransformPoint(vecCordPercent); //transfer world to particle effect // Vector3 vecParticelCord = _psyBoxParticelSystem.transform.worldToLocalMatrix * vecWorldCord; //Debug.Log("ParticleLocal " + vecParticelCord.ToString() + " world " + vecWorldCord.ToString()); float fSize = _fParticleSize * Mathf.Min(new float[] { _trnSpawnBox.lossyScale.x, _trnSpawnBox.lossyScale.y, _trnSpawnBox.lossyScale.z }); ParticleSystem.EmitParams empEmitParamiters = new ParticleSystem.EmitParams(); empEmitParamiters.startColor = _colColour; empEmitParamiters.velocity = Vector3.up; empEmitParamiters.position = vecWorldCord; empEmitParamiters.startSize = fSize; empEmitParamiters.startLifetime = Random.Range(_vecLifetime.x, _vecLifetime.y); empEmitParamiters.rotation = Random.Range(_vecStartRotation.x, _vecStartRotation.y); //spawn particle _psyBoxParticelSystem.Emit(empEmitParamiters, 1); } } } #endif }
private void EmitExplosion(ref Vector3 pos) { int count = UnityEngine.Random.Range(2, 5); while (count != 0) { float xVelocity = UnityEngine.Random.Range(-2.0f, 2.0f) * cameraMultiplier; float yVelocity = UnityEngine.Random.Range(1.0f, 3.0f) * cameraMultiplier; float lifetime = UnityEngine.Random.Range(0.1f, 0.2f); float size = UnityEngine.Random.Range(0.05f, 0.1f) * cameraMultiplier; ParticleSystem.EmitParams param = new ParticleSystem.EmitParams(); param.position = pos; param.velocity = new Vector3(xVelocity, yVelocity, 0.0f); param.startLifetime = lifetime; param.startSize = size; param.startColor = explosionColor; RainExplosionParticleSystem.Emit(param, 1); count--; } }
void PlayThrowImpulseParticles(Vector2 direction) { float angle = Mathf.Atan2(-direction.normalized.y, direction.normalized.x) * Mathf.Rad2Deg; var throwEmitParams = new ParticleSystem.EmitParams(); //add 180 to compensate for the initial offset if (direction != Vector2.zero) { angle -= 60; } else { angle = 0; } throwEmitParams.rotation3D = new Vector3(0, 0, angle); VFXManager.instance.EmitAtPosition("Throw_Impulse", 1, target.position, false, target); }
void EmitParticle(float x, float y, float z) { var emitParams = new ParticleSystem.EmitParams(); emitParams.startColor = Color.red; emitParams.startSize = 0.2f; emitParams.velocity = Vector3.zero; emitParams.position = new Vector3(x, y, z); emitParams.startLifetime = this.pointLifetime; this.ps.Emit(emitParams, 1); // alternatively, to create a first-class GameObject instead GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); cube.transform.position = new Vector3(x, y, z); cube.transform.localScale = Vector3.one * this.cubeScale; cube.transform.parent = this.pointRoot.transform; Debug.Log("PointCloudMaker :: Point created at " + x + ", " + y + ", " + z); }
void UpdateParticles() { if (rotatedVerts == null) { InitializeTesseract(); InitializeParticles(); } for (int i = 0; i < rotatedVerts.Count; i++) { //particles[i].position = rotatedVerts[i]; //particles[i].color = Color.white; //particles[i].size = 1f; ParticleSystem.EmitParams p = new ParticleSystem.EmitParams(); p.position = rotatedVerts[i]; p.startSize = 1f; p.startLifetime = 0.5f; particleSystem.Emit(p, 1); } //GetComponent<ParticleSystem>().SetParticles(particles, particles.Length); }
public void Emit_SquareShot(ParticleSystem par, Transform tr, float speed, float size, float lifetime, int rows) { ParticleSystem.EmitParams em = emitParamsDefault; em.startLifetime = lifetime; em.startSize = size; int r = rows / 2; for (int i = -r; i <= r; i++) { for (int j = -r; j <= r; j++) { if (i == -r || i == r || j == -r || j == r) { em.position = tr.position; em.velocity = tr.TransformDirection(i, 0, j) * speed / r; par.Emit(em, 1); } } } }
private void EmitLayerCloudType(LayerCloudType layerCloudType, float deltaTime) { if ((layerCloudType.MaterialIds.Length != 0) && layerCloudType.IsEmit(deltaTime)) { int[] materialIds = layerCloudType.MaterialIds; Vector3 vector = new Vector3(); float num = 0f; if (!layerCloudType.IsOdd()) { num = -layerCloudType.InterleavedOffset * layerCloudType.GetRandomSize(); } Color color = new Color(0f, 0f, 1f, 1f); Vector3 vector2 = (Vector3)(Vector3.forward * this._particleSystem.startSpeed); Vector3 vector3 = (Vector3)(this.EmitterSize / 2f); while (num < 1f) { int index = UnityEngine.Random.Range(0, materialIds.Length); color.r = ((float)materialIds[index]) / ((float)this._materialCount); color.r += 0.5f / ((float)this._materialCount); float randomSize = layerCloudType.GetRandomSize(); color.g = randomSize / 2f; num += randomSize / 2f; vector.x = num; num += layerCloudType.GetRandomGap() * randomSize; vector.y = layerCloudType.GetRandomPositionY(); vector = ((Vector3)(vector * 2f)) - Vector3.one; vector.x *= vector3.x; vector.x = -vector.x; vector.y *= vector3.y; vector.z = UnityEngine.Random.value * 10f; ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams { position = vector, velocity = vector2, startSize = this.GetParticleId(), startLifetime = this._particleSystem.startLifetime * UnityEngine.Random.Range((float)0.99f, (float)1.01f), startColor = color }; this._particleSystem.Emit(emitParams, 1); } } }
private void UseBlink() { // This would cast rays only against colliders in layer 9 and 11 int aux9 = 1 << 9; int aux11 = 1 << 11; int layerMask = aux9 | aux11; // But instead we want to collide against everything except layer 9 and 11 layerMask = ~layerMask; RaycastHit hit; Vector3 direction = new Vector3(moveInput.x, 0, moveInput.z); player.audioSource.PlayOneShot(player.sounds[2]); //Player.sounds[2] is the blink sound if (Physics.Raycast(transform.position, direction, out hit, player.blinkDistance, layerMask)) { Debug.Log("Blink interference, layer: " + hit.collider.gameObject.layer); Vector3 nextPosition = CalculateBlinkDirection(hit.distance); transform.position = Vector3.Lerp(transform.position, nextPosition, player.movementSpeed); } else { Debug.Log("No blink interference"); Vector3 nextPosition = CalculateBlinkDirection(); transform.position = Vector3.Lerp(transform.position, nextPosition, player.movementSpeed); } currentSkillRate = player.blinkRate; StartCoroutine(SetInvulnerability()); ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams(); emitParams.position = transform.position; emitParams.applyShapeToPosition = true; particles.Emit(emitParams, 50); uiManager.StartCd(player.blinkRate); soundActive = false; }
private void OnParticleCollisionManual(GameObject other, int aliveParticles = -1) { collisionEvents.Clear(); var aliveEvents = initiatorPS.GetCollisionEvents(other, collisionEvents); for (int i = 0; i < aliveEvents; i++) { var angle = Vector3.Angle(collisionEvents[i].normal, Vector3.up); if (angle > MaxGroundAngleDeviation) { continue; } if (InstantiateWhenZeroSpeed) { if (collisionEvents[i].velocity.sqrMagnitude > 0.1f) { continue; } var isNearDistance = false; for (int j = 0; j < aliveParticles; j++) { var distance = Vector3.Distance(collisionEvents[i].intersection, particles[j].position); if (distance < MinDistanceBetweenDecals) { isNearDistance = true; } } if (isNearDistance) { continue; } } var emiter = new ParticleSystem.EmitParams(); emiter.position = collisionEvents[i].intersection; var rotation = Quaternion.LookRotation(-collisionEvents[i].normal).eulerAngles; rotation.z = Random.Range(0, 360); emiter.rotation3D = rotation; DecalParticles.Emit(emiter, 1); } }
private void FixedUpdate() { if (target == null) { Destroy(gameObject); return; } Rigidbody rBody = target.GetComponent <Rigidbody>(); AudioSource aSource = DriftAudio; float speed = rBody.velocity.magnitude; float rot = rBody.angularVelocity.magnitude / 2; float angle = Vector3.Angle(rBody.velocity, Quaternion.Euler(0, -90, 0) * rBody.angularVelocity); if (((angle > 50 && (rot > 10 || speed > 10)) || (rot > 30 && speed < 30)) && grounded) { var emitParams = new ParticleSystem.EmitParams { position = target.transform.position - new Vector3(0, +0.5f, 0) + Random.insideUnitSphere * 0.25f, velocity = Vector3.zero, startSize = Random.Range(3f, 5f), startLifetime = 5, startColor = Color.white }; pSystem.Emit(emitParams, 1); if (aSource && aSource.volume < 1) { aSource.volume = Mathf.Min(aSource.volume + 0.5f, 1); } //aSource.pitch = 0.8f+Mathf.Min(rot/400f,1.2f); } else { if (aSource && aSource.volume > 0) { aSource.volume = Mathf.Max(aSource.volume - 0.2f, 0); } } }
private void Update() { if (Input.GetMouseButtonDown(0)) { Vector3 wp = Camera.main.ScreenToWorldPoint(Input.mousePosition); wp.z = 0; ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams(); emitParams.position = wp; emitParams.applyShapeToPosition = true; m_Particles.Emit(emitParams, 100); Collider2D[] allOverlaps = Physics2D.OverlapCircleAll(wp, 1.1f); Debug.Log(string.Format("Hit {0} objects", allOverlaps.Length)); for (int i = 0; i < allOverlaps.Length; i++) { GameObject target = allOverlaps[i].gameObject; //Do your thing here. } } }
public void Hurt(GameObject source, int amount) { Value -= amount; unhurtTime = 0; if (blood != null) { ParticleSystem.EmitParams p = new ParticleSystem.EmitParams(); Vector3 sourcePosition = source != null ? source.transform.position : this.transform.position - new Vector3(0, 6f, 0); p.position = this.transform.position; for (int i = 0; i < 10 * amount; ++i) { p.velocity = (this.transform.position - sourcePosition).normalized * Random.Range(1f, 2f) * (source == null?2:1) + new Vector3(Random.RandomRange(-0.5f, 0.5f), Random.RandomRange(-0.5f, 0.5f), 0); blood.Emit(p, (source == null ? 5: 1)); } } else { Debug.LogWarning(this.gameObject.name + " does not have a blood emitter"); } }
public void Emit_TriangleSpread(ParticleSystem par, Transform tr, float speed, float speedRate, float size, float figureSize, float lifetime, int rows, int cols) { ParticleSystem.EmitParams em = emitParamsDefault; em.startLifetime = lifetime; em.startSize = size; for (int i = -rows; i <= rows; i++) { Vector3 pos = tr.TransformDirection(i, 0, -Mathf.Abs(i) * 2); float sp = speed; float fsp = figureSize; for (int a = 0; a < cols; a++) { sp += speed * speedRate; fsp += figureSize * speedRate; em.position = tr.position; em.velocity = ((tr.forward * sp) + (tr.forward * rows + (pos / rows) * cols) * fsp); par.Emit(em, 1); } } }
private void AddFootprint(Vector3 position, Vector3 direction, State state) { Setting setting = state.setting; ParticleSystem particleSystem = state.particleSystem; float y = Mathf.Atan2(direction.x, direction.z) * 57.29578f; ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams(); Vector3 vector = position + setting.offset; vector.y = 0f; emitParams.position = vector; emitParams.axisOfRotation = Vector3.up; emitParams.rotation = y; emitParams.startSize = setting.size; emitParams.startLifetime = this.duration; Vector3 vector2 = (Vector3)(Quaternion.Euler(0f, y, 0f) * -this._lightDir); vector2 = (Vector3)((vector2 + Vector3.one) * 0.5f); emitParams.startColor = new Color(vector2.x, vector2.y, vector2.z, 1f); particleSystem.Emit(emitParams, 1); }
public void Emit_SquareShot(ParticleSystem par, Vector3 position, Vector3 forward, Vector3 upVec, float speed, float size, float lifetime, int rows) { ParticleSystem.EmitParams em = emitParamsDefault; em.startLifetime = lifetime; em.startSize = size; shotTransform.rotation = Quaternion.LookRotation(forward, upVec); int r = rows / 2; for (int i = -r; i <= r; i++) { for (int j = -r; j <= r; j++) { if (i == -r || i == r || j == -r || j == r) { em.position = position; em.velocity = shotTransform.TransformDirection(i, 0, j) * speed / r; par.Emit(em, 1); } } } }
public void Emit_CycleShot(ParticleSystem par, Transform tr, float speed, float speedRate, float size, float sizeRate, float lifetime, int rows, int cols) { ParticleSystem.EmitParams em = emitParamsDefault; em.startLifetime = lifetime; for (int i = 0; i < rows; i++) { float angle = i * Mathf.PI * 2 / rows; Vector3 pos = tr.TransformDirection(Mathf.Cos(angle), 0, Mathf.Sin(angle)); float sp = speed; em.startSize = size; for (int a = 0; a < cols; a++) { sp += speed * speedRate; em.position = tr.position; em.velocity = pos * sp; em.startSize += size * sizeRate; par.Emit(em, 1); } } }
public void Update() { if (beamRemainingTime > 0) { Debug.DrawLine(lineRenderer.GetPosition(0), lineRenderer.GetPosition(1)); lineRenderer.widthMultiplier = stats.beamWidth * beamRemainingTime / stats.beamDuration; beamRemainingTime -= Time.deltaTime; var emitParams = new ParticleSystem.EmitParams(); emitParams.position = lineRenderer.GetPosition(1); //emitParams.startColor = Color.red; //emitParams.startSize = 0.8f; hitParticles.Emit(emitParams, 15); } else { lineRenderer.enabled = false; isInCooldown = false; } }
private void Emit(ParticleSystem p, ref Vector3 pos) { int count = UnityEngine.Random.Range(2, 5); while (count != 0) { float yVelocity = UnityEngine.Random.Range(1.0f, 3.0f); float zVelocity = UnityEngine.Random.Range(-2.0f, 2.0f); float xVelocity = UnityEngine.Random.Range(-2.0f, 2.0f); const float lifetime = 0.75f;// UnityEngine.Random.Range(0.25f, 0.75f); float size = UnityEngine.Random.Range(0.05f, 0.1f); ParticleSystem.EmitParams param = new ParticleSystem.EmitParams(); param.position = pos; param.velocity = new Vector3(xVelocity, yVelocity, zVelocity); param.startLifetime = lifetime; param.startSize = size; param.startColor = color; p.Emit(param, 1); count--; } }
public void PlayJumpParticles() { var jumpEmitParams = new ParticleSystem.EmitParams(); jumpEmitParams.rotation3D = new Vector3(0, 0, Mathf.Abs(velocity.x * 2f) * faceDir); if (jumpsCompleted > 0) { var circleEmitParams = new ParticleSystem.EmitParams(); circleEmitParams.rotation3D = new Vector3(0, 0, Mathf.Abs(velocity.x * 2f) * faceDir); //circleEmitParams.velocity = new Vector3(0, -1, 0); VFXManager.instance.EmitAtPosition("Double_Jump_Circle", circleEmitParams, 1, transform.position + Vector3.down * 0.5f, false); //jumpEmitParams.velocity = new Vector3(0, 2, 0); VFXManager.instance.EmitAtPosition("Double_Jump_Dust", jumpEmitParams, 1, new Vector3(transform.position.x, transform.position.y - 0.5f, 0), false); } else //transform.position + Vector3.up * 0.5f { VFXManager.instance.EmitAtPosition("Jump_Dust", jumpEmitParams, 5, new Vector3(transform.position.x, controller.raycastOrigins.bottomLeft.y - 0.1f, 0) + (Vector3.up), false); } }
void Generate() { myStarfieldPS.Clear(); SetMaterialAndProperties(myStarMaterial, myStarSize, myMinDistance, myMaxDistance); ParticleSystem.MainModule mainModule = myStarfieldPS.main; mainModule.maxParticles = myStarCount; Random.State previousState = Random.state; Random.InitState(myRandomSeed); ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams(); emitParams.velocity = Vector3.zero; emitParams.startLifetime = Mathf.Infinity; Vector3 starfieldCenter = myCenterAroundZero ? Vector3.zero : transform.position; for (int i = 0; i < myStarCount; ++i) { Color color = Color.white; if (myColors.Length > 0) { color = myColors[Random.Range(0, myColors.Length)]; } color.a *= myColorAlphaMult; Vector3 randomInsideUnit = Random.insideUnitSphere; Vector3 pos = starfieldCenter + randomInsideUnit.normalized * myMinDistance + randomInsideUnit * (myMaxDistance - myMinDistance); emitParams.startColor = color; emitParams.position = pos; emitParams.startSize = myStarSize; myStarfieldPS.Emit(emitParams, 1); } Random.state = previousState; }
public void PlayDeathEffect() { /* * GameObject deathPaint = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Death_Paint"), transform.position, Quaternion.identity); * GameObject deathPaintHat = MonoBehaviour.Instantiate(Resources.Load<GameObject>("Death_Paint"), hat.transform.position, Quaternion.identity); * deathPaintHat.transform.localScale = Vector3.one * 5f; * deathPaint.transform.parent = transform.root; * deathPaintHat.transform.parent = transform.root; */ //hat Vector3 spawnPosition; if (hat.isCurrentlyAttached || hat.isBeingAttached) { spawnPosition = transform.position - (Vector3.one * 0.7f); } else { spawnPosition = hat.transform.position; } var firstBlastEmitParams = new ParticleSystem.EmitParams(); VFXManager.instance.EmitAtPosition("Hat_Explosion", firstBlastEmitParams, 1, spawnPosition + Vector3.up * 1.5f, true); /* * var deathWind = new ParticleSystem.EmitParams(); * deathWind.startSize3D = new Vector3(Random.Range(80, 100), Random.Range(30, 50), 1); * VFXManager.instance.EmitAtPosition("Death_Wind", deathWind, 1, spawnPosition, true); */ var deathSkullEmitParams = new ParticleSystem.EmitParams(); deathSkullEmitParams.velocity = new Vector3(0, 2, 0); VFXManager.instance.EmitAtPosition("Death_Skull", deathSkullEmitParams, 1, hat.transform.position + Vector3.up * 2.5f, false); //char VFXManager.instance.EmitAtPosition("Death_Insignia_Explosion", 1, transform.position + Vector3.up, false); }
// Token: 0x0600047D RID: 1149 RVA: 0x000243F4 File Offset: 0x000225F4 private void OnParticleCollision(GameObject other) { if (this.m_chance < 100f && UnityEngine.Random.Range(0f, 100f) > this.m_chance) { return; } int num = this.part.GetCollisionEvents(other, this.collisionEvents); for (int i = 0; i < num; i++) { ParticleCollisionEvent particleCollisionEvent = this.collisionEvents[i]; Vector3 eulerAngles = Quaternion.LookRotation(particleCollisionEvent.normal).eulerAngles; eulerAngles.x = -eulerAngles.x + 180f; eulerAngles.y = -eulerAngles.y; eulerAngles.z = (float)UnityEngine.Random.Range(0, 360); ParticleSystem.EmitParams emitParams = default(ParticleSystem.EmitParams); emitParams.position = particleCollisionEvent.intersection; emitParams.rotation3D = eulerAngles; emitParams.velocity = -particleCollisionEvent.normal * 0.001f; this.m_decalSystem.Emit(emitParams, 1); } }
void Start() { OnValidate(); animatorOverrideController = new AnimatorOverrideController(animator.runtimeAnimatorController); animator.runtimeAnimatorController = animatorOverrideController; clipOverrides = new AnimationClipOverrides(animatorOverrideController.overridesCount); animatorOverrideController.GetOverrides(clipOverrides); emitParams = new ParticleSystem.EmitParams(); if (equipOnStart) { weapon.Equip(character.mainWeapon, true); secondHand.Equip(character.SecondaryWeapon, true); head.Equip(character.head, true); shield.Equip(character.shield, true); body.Equip(character.body, true); backpack.Equip(character.backpack, true); } attacking = false; AnimationParameterRefresh(); }
public override void Update() { // For each GameObject that fits the constraint... constraint.ForEachGameObject((egoComponent, runParticleComponent, movement) => { if (movement.onGround && Mathf.Abs(movement.velocity.x) > 0.1f) { var emitParams = new ParticleSystem.EmitParams(); var sh = runParticleComponent.ps.shape; Vector3 rotation = sh.rotation; Mathf.Sign(movement.velocity.x); rotation.x = Mathf.Lerp(-16.5f, 198f, Mathf.Sign(movement.velocity.x)); sh.rotation = rotation; runParticleComponent.ps.startSpeed = Mathf.Abs(movement.velocity.x) * runParticleComponent.intensity; runParticleComponent.ps.Emit(emitParams, 1); } }); }
void Update() { direction.x = transform.position.x - lastPosition.x; direction.y = transform.position.y - lastPosition.y; //get the angle of the throw float angle = Mathf.Atan2(-direction.normalized.y, direction.normalized.x) * Mathf.Rad2Deg; //add 180 to compensate for the initial offset angle += 180; var fireEmitParams = new ParticleSystem.EmitParams(); fireEmitParams.rotation3D = new Vector3(0, 0, angle); foreach (ParticleSystem ps in systems) { ps.Emit(fireEmitParams, 1); } lastPosition = transform.position; }
void Update() { //_shapeIndex += EmissionShapeSwitchSpeed * Time.deltaTime; //if( _shapeIndex > EmissionShapes.Length-1 ) _shapeIndex -= (EmissionShapes.Length-1); if (!Playing) { return; } _timeToEmission -= Time.deltaTime; if (_timeToEmission <= 0f) { _timeToEmission = EmissionPeriod - _timeToEmission; int particlesCount = (int)(ParticlesPerGrid * FilledCells.Count); if (particlesCount <= 0) { particlesCount = 1; } for (int c = 0; c < particlesCount; ++c) { // TODO rotations! convert points with rotations! use UV matrix? Vector2 randCellPos = FilledCells[UnityEngine.Random.Range(0, FilledCells.Count)]; float x = (UnityEngine.Random.Range(randCellPos.x, randCellPos.x + GridSize / 100.0f) - _dXDy.x) * ParentObject.transform.localScale.x; float y = (UnityEngine.Random.Range(randCellPos.y, randCellPos.y + GridSize / 100.0f) - _dXDy.y) * ParentObject.transform.localScale.y; Vector3 pos = new Vector3(x, y, 0); Vector3 veloc = new Vector3(UnityEngine.Random.Range(-1.0f, 1.0f) * _particleSystem.startSpeed, UnityEngine.Random.Range(-1.0f, 1.0f) * _particleSystem.startSpeed, 0); ParticleSystem.EmitParams emitParams = new ParticleSystem.EmitParams(); emitParams.velocity = veloc; emitParams.position = pos; emitParams.startSize = _particleSystem.startSize; emitParams.startLifetime = _particleSystem.startLifetime; emitParams.startColor = _particleSystem.startColor; _particleSystem.Emit(emitParams, ParticleEmissionCount); } } }
public void EmitAtPosition(ParticleSystem system, int numberOfParticles, Vector3 position, bool retainShape = false, Transform relativeTo = null) { if (system == null) { return; } // Any parameters we assign in emitParams will override the current system's when we call Emit. // Here we will override the position and velocity. All other parameters will use the behavior defined in the Inspector. var emitParams = new ParticleSystem.EmitParams(); emitParams.position = position; emitParams.applyShapeToPosition = retainShape; system.Emit(emitParams, numberOfParticles); if (relativeTo != null) { var main = system.main; main.simulationSpace = ParticleSystemSimulationSpace.Custom; main.customSimulationSpace = relativeTo; } }
public void drawStars(float scale) { scaling = scale; pSys.Clear(); starObject = new Star[200000]; Star temp; Stars starsInJson = JsonUtility.FromJson<Stars>(jsonFile.text); hipToIdPairs = new int[200000]; Debug.Log(hipToIdPairs.Length); foreach (Star star in starsInJson.stars) { if (star.hip != 0) { hipToIdPairs[star.hip] = star.id; } temp = new Star(); temp.id = star.id; temp.hip = star.hip; temp.proper = star.proper; temp.mag = star.mag; temp.x = star.x * scale; temp.y = star.y * scale; temp.z = star.z * scale; starObject[star.id] = temp; p = new ParticleSystem.EmitParams(); p.position = new Vector3(star.x * scale, star.y * scale, star.z * scale); p.startLifetime = 100000; p.velocity = Vector3.zero; p.startSize = .01f * star.mag; p.startColor = Color.white; if (star.id == 0) { p.startColor = Color.yellow; } pSys.Emit(p, 1); } GameObject.Find("Constellation-Manager").GetComponent<ConstellationManager>().loadConstellation(constellationSelection); GameObject.Find("NavBall").GetComponent<Navball>().setCourse(courseSelection); }
private void OnCollisionEnter2D(Collision2D collision) { var sps = GetComponent <ParticleSystem>().subEmitters.GetSubEmitterSystem(0); var emitparams = new ParticleSystem.EmitParams() { position = GetComponent <Transform>().position, applyShapeToPosition = true, }; sps.Emit(emitparams, 50); var currentVelocity = body.velocity; if (Mathf.Abs(currentVelocity.y) < 0.001f) { body.velocity = new Vector2(currentVelocity.x, currentVelocity.y - transform.position.y / 10); } if (Mathf.Abs(currentVelocity.x) < 0.001f) { body.velocity = new Vector2(currentVelocity.x - transform.position.x / 10, currentVelocity.y); } }