void ITMPlugin.PlayerJoined(ITMPlayer player)
{
var b = new Entity();
if (game.World.EntityManager.AddEntity("entities", "spaceshipcockpit", b) == ErrorCode.Success)
{
boat = b;
}
particleData = new ParticleData()
{
Duration = 8,
StartColor = Color.White,
EndColor = Color.White,
Size = new Vector4(0.1f, 0.1f, 0.1f, 1f),
WindFactor = 0,
};
particleData.Size = new Vector4(1f, 1f, 1f, 1f);
particleData.StartColor = particleData.EndColor = Color.Red;
dust = new Entity[100];
for (int i = 0; i < dust.Length; ++i)
{
var d = new Entity()
{
Scale = (float)(game.Random.NextDouble() * 0.1 + 0.05), Position = new Vector3(1, 1000, 1)
};
dust[i] = d;
d.ViewDirection = Vector3.Forward;
game.World.EntityManager.AddEntity("space", "dust", d);
//game.World.EntityManager.AddEntity("entities", "spaceshipcockpit", d);
}
}
// Use this for initialization
void Start()
{
particles = new ParticleSystem.Particle[particleNum];
particleDatas = new ParticleData[particleNum]; //新建粒子数据数组
particleSystem.maxParticles = particleNum;
particleSystem.Emit(particleNum);
particleSystem.GetParticles(particles);
Ndistribution nd = new Ndistribution();
// 每个粒子在初始化的时候都设定好收缩前和收缩后的粒子半径
for (int i = 0; i < particleNum; i++)
{
float angle = UnityEngine.Random.Range(0.0f, 360.0f);
float radius = (float)nd.getNormalDistribution((minRadius + maxRadius) * 0.5f, 1);
float before = radius;
float after = 0.7f * radius;
if (after < minRadius * 1.1f)
{
float midRadius = minRadius * 1.2f;
after = UnityEngine.Random.Range(UnityEngine.Random.Range(minRadius, midRadius), (minRadius * 1.1f));
}
particleDatas[i] = new ParticleData(angle, radius, before, after);
}
}
protected override void CreateData()
{
var data = new ParticleData[Count];
if (_pastData != null)
{
if (Count <= _pastData.Length)
{
System.Array.Copy(_pastData, 0, data, 0, data.Length);
}
else
{
System.Array.Copy(_pastData, 0, data, 0, _pastData.Length);
for (var i = _pastData.Length; i < data.Length; i++)
{
data[i] = _defaultData;
}
_pastData = data;
}
}
else
{
for (var i = 0; i < data.Length; i++)
{
data[i] = _defaultData;
}
_pastData = data;
}
MyGpuBuffer.SetData(data);
}
public PreviewEffect(GameObject fx)
{
if (fx == null)
{
return;
}
m_ParticleDatas = null;
target = fx;
var array = fx.gameObject.GetComponentsInChildren <ParticleSystem>();
if (array != null && array.Length > 0)
{
m_ParticleDatas = new ParticleData[array.Length];
life = 0;
for (int k = 0; k < array.Length; k++)
{
var ptlife = array[k].startLifetime + array[k].startDelay;
if (ptlife > life)
{
//获取最大粒子存活值
life = ptlife;
}
m_ParticleDatas[k] = new ParticleData(array[k], array[k].startDelay);
}
life++;
}
}
void InitializeParticle()
{
//vertexTex = material.GetTexture("_VertexTex") as Texture2D;
material.SetTexture("_VertexTex", vertexTex);
particleNum = Mathf.CeilToInt((float)particleNum / THREAD_GROUP_X) * THREAD_GROUP_X;
particleBuffer = new ComputeBuffer(particleNum, Marshal.SizeOf(typeof(ParticleData)));
vertexNum = MeshVertexTextureUtil.GetVertexNum(vertexTex);
meshSize = MeshVertexTextureUtil.GetMeshSize(vertexTex);
meshCenter = MeshVertexTextureUtil.GetMeshCenter(vertexTex);
meshTopologyNum = MeshVertexTextureUtil.GetMeshTopologyNum(vertexTex);
texelSize.x = 1f / vertexTex.width;
texelSize.y = 1f / vertexTex.height;
texelSize.z = vertexTex.width;
texelSize.w = vertexTex.height;
Debug.Log("Vertex Num " + vertexNum + " meshSize " + meshSize + " meshCenter " + meshCenter + " meshTopologyNum " + meshTopologyNum);
ParticleData[] particles = new ParticleData[particleNum];
float indexStep = (float)vertexNum / particleNum;
for (int i = 0; i < particleNum; i++)
{
particles[i] = new ParticleData(Vector3.zero, Random.insideUnitSphere * 5, indexStep * i, Color.HSVToRGB((float)i / particleNum, 0.75f, 1));
//particles[i] = new ParticleData(Random.onUnitSphere * 100f, indexStep * i, Color.red);
}
particleBuffer.SetData(particles);
}
void UpdateDetectShapes(ParticleData _particleData)
{
if (m_detectShapesHelper)
{
m_detectShapesHelper.UpdateShapes(_particleData);
}
}
/// <summary>
/// 播放一个特效
/// </summary>
/// <param name="fxname"></param>
/// <param name="loop"></param>
/// <param name="fxtype"></param>
/// <param name="parent"></param>
/// <param name="trans"></param>
/// <param name="lifetime"></param>
/// <param name="alias"></param>
/// <param name="limitry"></param>
/// <returns></returns>
public uint PlayFx(string fxname, bool loop, Transform parent = null, TransformData trans = null, float lifetime = -1, string alias = null, bool limitry = false)
{
ParticleData data = ParticleConfigManager.Instance.GetParticleData(fxname);
if (data == null)
{
GameDebug.LogError("没有找到特效: " + fxname);
return(uint.MaxValue);
}
uint instID = mLastEffectID++;
ParticleItem item = new ParticleItem();
item.localTrans = trans;
item.parent = parent;
item.Alias = alias;
item.LimitRy = limitry;
item.Loop = loop;
if (mEffects.ContainsKey(instID))
{
mEffects.Remove(instID);
}
mEffects.Add(instID, item);
BehaviourUtil.StartCoroutine(GenerateVisual(instID, fxname, item));
return(instID);
}
public void WriteParticleData(ParticleData value)
{
if (value is null || value == ParticleData.None)
{
return;
}
switch (value.ParticleType)
{
case ParticleType.Block:
WriteVarInt(value.GetDataAs <int>());
break;
case ParticleType.Dust:
var(red, green, blue, scale) = value.GetDataAs <(float, float, float, float)>();
WriteFloat(red);
WriteFloat(green);
WriteFloat(blue);
WriteFloat(scale);
break;
case ParticleType.FallingDust:
WriteVarInt(value.GetDataAs <int>());
break;
case ParticleType.Item:
WriteItemStack(value.GetDataAs <ItemStack>());
break;
}
}
public void SetParticleData(ParticleData data)
{
position = data.position;
velocity = data.velocity;
acceleration = data.acceleration;
netForce = data.netForce;
}
GameObject PlayImpl(int particleType, Transform parent, Vector3 pos, Vector3 dir)
{
if (_particles.ContainsKey(particleType) == false)
{
return(null);
}
ParticleData data = _particles[particleType];
ParticleInst newParticleInst = data.pool.Get();
if (newParticleInst.inst == null)
{
newParticleInst.inst = GameObject.Instantiate(data.prefab) as GameObject;
newParticleInst.emitters = newParticleInst.inst.GetComponentsInChildren <ParticleSystem>();
}
newParticleInst.inst.transform.SetParent(parent);
newParticleInst.inst.transform.position = pos;
newParticleInst.inst.transform.forward = dir;
newParticleInst.inst.SetActive(true);
foreach (var item in newParticleInst.emitters)
{
item.Play();
}
data.runList.Add(newParticleInst);
return(newParticleInst.inst);
}
async Task SimulatePhysics()
{
if (ids.Count == 0)
{
return;
}
//Debug.Log("1");
int[] gridData = await CreateGrid();
//Debug.Log("3");
ParticleData[] particleOutput = await ApplyPhysics(gridData);
//Debug.Log("6");
// Updating positions and removing garbage
for (int i = 0; i < particleOutput.Length; i++)
{
ParticleData data = particleOutput[i];
ParticleData p = particleData[data.id];
if (data.position.y < 0 || data.position.x < 0 || data.position.y >= HEIGHT || data.position.x >= WIDTH)
{
RemoveParticle(data.id);
}
else
{
particleData.Remove(data.id);
particleData[data.id] = data;
}
}
}
public void PullDataFromSolver(ParticleData data = ParticleData.NONE)
{
foreach (ObiConstraintBatch batch in GetBatches())
{
batch.PullDataFromSolver(this);
}
}
private void UpdateParticles(List <ParticleData> particleList, GameTime gameTime)
{
float now = (float)gameTime.TotalGameTime.TotalMilliseconds;
for (int i = particleList.Count - 1; i >= 0; i--)
{
ParticleData particle = particleList[i];
float timeAlive = now - particle.BirthTime;
if (timeAlive > particle.MaxAge)
{
particleList.RemoveAt(i);
}
else
{
float relAge = timeAlive / particle.MaxAge;
particle.Position = 0.5f * particle.Accelaration * relAge * relAge + particle.Direction * relAge + particle.OrginalPosition;
float invAge = 1.0f - relAge;
particle.ModColor = new Color(new Vector4(invAge, invAge, invAge, invAge));
Vector2 positionFromCenter = particle.Position - particle.OrginalPosition;
float distance = positionFromCenter.Length();
particle.Scaling = (50.0f + distance) / 200.0f;
particleList[i] = particle;
}
}
}
public static ParticleData ToParticleData(this ClothParticleObject obj)
{
Vector3 pos = obj.transform.position;
ParticleData p = new ParticleData(pos.x, pos.y, pos.z, obj.Mass, obj.Kinematic);
return(p);
}
public void ShowParticle(string ID, Vector3 pos)
{
ParticleData findedparticle = allParticles.Find(x => x.ID == ID);
GameObject createdparticle = Instantiate(findedparticle.particleprefab, pos, Quaternion.identity);
Destroy(createdparticle, 2f);
}
public void PushDataToSolver(ParticleData data = ParticleData.NONE)
{
if (!inSolver)
{
return;
}
// set solver constraint data:
int[] solverIndices = new int[stitches.Count * 2];
float[] stiffnesses = new float[stitches.Count];
for (int i = 0; i < stitches.Count; i++)
{
solverIndices[i * 2] = actor1.particleIndices[stitches[i].particleIndex1];
solverIndices[i * 2 + 1] = actor2.particleIndices[stitches[i].particleIndex2];
stiffnesses[i] = 0;
}
Oni.SetStitchConstraints(batch, solverIndices, stiffnesses, stitches.Count);
// set active constraints:
int[] activeConstraints = new int[stitches.Count];
for (int i = 0; i < stitches.Count; ++i)
{
activeConstraints[i] = i;
}
Oni.SetActiveConstraints(batch, activeConstraints, stitches.Count);
}
async Task <ParticleData[]> ApplyPhysics(int[] gridData)
{
int colGridWidth = (WIDTH + 2);
int colGridHeight = (HEIGHT + 2);
//Debug.Log("4");
ParticleData[] particleOutput = new ParticleData[particleData.Count];
// Extra dimensions for padding
ComputeBuffer inputGrid = new ComputeBuffer(colGridWidth * colGridHeight, 4);
ComputeBuffer particleBuffer = new ComputeBuffer(particleData.Count, 36);
int kernel2 = shader.FindKernel("Move");
inputGrid.SetData(gridData);
particleBuffer.SetData(particleData.Values.ToList());
shader.SetBuffer(kernel2, "grid", inputGrid);
shader.SetBuffer(kernel2, "particleBuffer", particleBuffer);
shader.Dispatch(kernel2, particleData.Count, 1, 1);
particleBuffer.GetData(particleOutput);
//Debug.Log("5");
inputGrid.Dispose();
particleBuffer.Dispose();
return(particleOutput);
}
Material particleRenderMat; // パーティクルをレンダリングするマテリアル
void Start()
{
// パーティクルのコンピュートバッファを作成
particleBuffer = new ComputeBuffer(NUM_PARTICLES, Marshal.SizeOf(typeof(ParticleData)));
// パーティクルの初期値を設定
var pData = new ParticleData[NUM_PARTICLES];
for (int i = 0; i < pData.Length; i++)
{
pData[i].Velocity = Random.insideUnitSphere;
pData[i].Position = Random.insideUnitSphere;
pData[i].Acceleration = Random.insideUnitSphere;
pData[i].LifeTime = lifeTime + Random.Range(-lifeTime * 0.5f, lifeTime * 0.5f);
pData[i].TimeFromRePositioning = 0;
pData[i].GeneratedNodeId = i * trailBrush.nodeNum / NUM_PARTICLES;
}
// コンピュートバッファに初期値データをセット
particleBuffer.SetData(pData);
pData = null;
// パーティクルをレンダリングするマテリアルを作成
particleRenderMat = new Material(SimpleParticleRenderShader);
particleRenderMat.hideFlags = HideFlags.HideAndDontSave;
}
// Use this for initialization
void Start()
{
particleRing.maxParticles = particleNum; //设置最大粒子数
particles = new ParticleSystem.Particle[particleNum]; //新建粒子数组
particleDatas = new ParticleData[particleNum]; //新建粒子数据数组
particleRing.Emit(particleNum); //粒子系统发射粒子
particleRing.GetParticles(particles);
//初始化粒子位置
for (int i = 0; i < particleNum; ++i)
{
float middleRadius = (maxRadius + minRadius) / 2;
float upperbound = Random.Range(middleRadius, maxRadius);
float lowerbound = Random.Range(minRadius, middleRadius);
float radius = Random.Range(lowerbound, upperbound);
float angle = Random.Range(0.0f, 360.0f);
particleDatas[i] = new ParticleData(angle, radius, radius, radius - 1.5f * (radius / minRadius));
// 随机收缩半径下界，避免收缩后成为圆线
if (particleDatas[i].shringRadius < minRadius + 0.5f)
{
float temp = Random.Range(minRadius, minRadius + 0.25f);
particleDatas[i].shringRadius = Random.Range(temp, minRadius + 0.5f);
}
}
}
//随机放置粒子
private void randomPlace()
{
for (int i = 0; i < par_count; i++)
{
float r = Random.Range(5f, 12f);
if (r % 3 == 1)
{
r = Random.Range(7f, 10f);
}
else if (r % 3 == 2)
{
r = Random.Range(8f, 9f);
}
float angle = Random.Range(0f, 360f);
float theta = angle / 180 * Mathf.PI;
float speed = Random.Range(0.5f, 1.5f);
int flag = Random.Range(0, 2);
bool clockwise = (flag == 0) ? false : true;
halo[i].position = new Vector3(r * Mathf.Cos(theta), r * Mathf.Sin(theta), 0f);
par_data[i] = new ParticleData(angle, r, speed, clockwise);
}
par_sys.SetParticles(halo, halo.Length);
}
private IEnumerator RandomSpawnMovement(ParticleData data)
{
float lastShootTime = Time.time - data.MovementDuration;
while (true)
{
if (Time.time > lastShootTime + data.MovementDuration)
{
lastShootTime = Time.time;
Vector3 pos = Random.insideUnitSphere * data.MovementDistance;
pos.y = 0f;
// Spawn
Transform tf = Instantiate(data[CurrentSubIndex]);
tf.SetParent(ShowingParticleRoot);
tf.localPosition = pos;
tf.localRotation = Quaternion.identity;
tf.localScale = Vector3.one;
float maxDuration = 0f;
ParticleSystem[] ps = tf.GetComponentsInChildren <ParticleSystem>(true);
for (int i = 0; i < ps.Length; i++)
{
maxDuration = Mathf.Max(
maxDuration,
ps[i].main.duration
);
}
Destroy(tf.gameObject, maxDuration);
}
yield return(new WaitForEndOfFrame());
}
}
void RandomlySpread()
{
float midRadius, minRate, maxRate, radius, angle, theta, time;
//初始化粒子位置；
for (int i = 0; i < count; i++)
{
// 随机每个粒子距离中心的半径，同时希望粒子集中在平均半径附近
midRadius = (maxRadius + minRadius) / 2;
minRate = Random.Range(1.0f, midRadius / minRadius);
maxRate = Random.Range(midRadius / maxRadius, 1.0f);
radius = Random.Range(minRadius * minRate, maxRadius * maxRate);
// 随机每个粒子的角度
angle = Random.Range(0.0f, 360.0f);
theta = angle / 180 * Mathf.PI;
// 随机每个粒子的游离起始时间
time = Random.Range(0.0f, 360.0f);
particleData[i] = new ParticleData(radius, angle, time);
particleArray[i].position = new Vector3(particleData[i].radius * Mathf.Cos(theta), particleData[i].radius * Mathf.Sin(theta), 0f);
}
particleSys.SetParticles(particleArray, particleArray.Length);
}
void Start()
{
// バッファ生成
this._ParticleDataBuffer = new ComputeBuffer(this._particleCount, Marshal.SizeOf(typeof(ParticleData)));
this._GPUInstancingArgsBuffer = new ComputeBuffer(1, this._GPUInstancingArgs.Length * sizeof(uint), ComputeBufferType.IndirectArguments);
var particleDataArr = new ParticleData[this._particleCount];
// set default position
for (int i = 0; i < _particleCount; i++)
{
particleDataArr[i].BasePosition = new Vector3(Random.Range(-10.0f, 10.0f), Random.Range(-10.0f, 10.0f), Random.Range(-10.0f, 10.0f));
particleDataArr[i].Albedo = new Vector3(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f));
particleDataArr[i].rotationSpeed = Random.Range(1.0f, 100.0f);
}
this._ParticleDataBuffer.SetData(particleDataArr);
particleDataArr = null;
// creat point mesh
_pointMesh = new Mesh();
_pointMesh.vertices = new Vector3[] {
new Vector3(0, 0),
};
_pointMesh.normals = new Vector3[] {
new Vector3(0, 1, 0),
};
_pointMesh.SetIndices(new int[] { 0 }, MeshTopology.Points, 0);
}
public void Draw(SpriteBatch spriteBatch)
{
for (int i = 0; i < _particleList.Count; i++)
{
ParticleData particle = _particleList[i];
spriteBatch.Draw(particle.ExplosionTexture ?? _explosionTexture, particle.Position, null, particle.ModColor, i, new Vector2(32, 32), particle.Scaling, SpriteEffects.None, 1);
}
}
public ParticleData(ParticleData left, ParticleData right, float factor)
{
position = new Vector3Data(left.position.Lerp(right.position, factor));
velocity = new Vector3Data(left.velocity.Lerp(right.velocity, factor));
rotation = Mathf.Lerp(left.rotation, right.rotation, factor);
angularVelocity = Mathf.Lerp(left.angularVelocity, right.angularVelocity, factor);
lifeTime = Mathf.Lerp(left.lifeTime, right.lifeTime, factor);
}
public Vehicle(VehiclesMod mod, VehicleDataXML data)
{
this.mod = mod;
map = mod.Map;
this.data = data;
DrawRotY = data.RotY / 180f * MathHelper.Pi;
smokeParticle = NewSmokeParticleData();
}
public ParticleData(ParticleData source)
{
position = source.position.Clone();
velocity = source.velocity.Clone();
rotation = source.rotation;
angularVelocity = source.angularVelocity;
lifeTime = source.lifeTime;
}
public void DrawParticles(Texture2D newTexture, SpriteBatch spriteBatch)
{
for (int i = 0; i < particleList.Count; i++)
{
ParticleData particle = particleList[i];
spriteBatch.Draw(newTexture, particle.Position, null, particle.ModColor, i, new Vector2(256, 256), particle.Scaling, SpriteEffects.None, 1);
}
}
public void DrawBoom(Texture2D newTexture, SpriteBatch spriteBatch)
{
for (int i = 0; i < boomList.Count; i++)
{
ParticleData boom = boomList[i];
spriteBatch.Draw(newTexture, boom.Position, null, boom.ModColor, i, new Vector2(256, 256), boom.Scaling, SpriteEffects.None, 1);
}
}
void Start()
{
if (!vectorField.hasStarted)
{
vectorField.Start();
}
particleData = new ParticleData(numParticles, vectorField.field);
particles = new Matrix4x4[numParticles];
}
public void AddParticleEffect(Vector2 position, Rectangle bounds, int particleCount, GameTime gameTime)
{
float maxAge = 20000f;
for (int i = 0; i < particleCount; ++i)
{
ParticleData particle = new ParticleData();
particle.position = position;
particle.birthTime = gameTime.TotalGameTime.Milliseconds + gameTime.TotalGameTime.Seconds * 1000;
particle.color = new Color((float)m_generator.NextDouble(), (float)m_generator.NextDouble(), (float)m_generator.NextDouble());
particle.direction = new Vector2((float)(m_generator.NextDouble() * 2f) - 1f, (float)(m_generator.NextDouble() * 2f) - 1f);
particle.maxAge = maxAge;
m_particleList.Add(particle);
}
}
private void AddExplosionParticle(Vector2 explosionPos, float explosionSize, float maxAge, GameTime gameTime)
{
ParticleData particle = new ParticleData();
particle.OrginalPosition = explosionPos;
particle.Position = particle.OrginalPosition;
particle.BirthTime = (float)gameTime.TotalGameTime.TotalMilliseconds;
particle.MaxAge = maxAge;
particle.Scaling = 0.25f;
particle.ModColor = Color.White;
//random direction
float particleDistance = (float)rand.NextDouble() * explosionSize;
Vector2 displacement = new Vector2(particleDistance, 0);
float angle = MathHelper.ToRadians(rand.Next(360));
displacement = Vector2.Transform(displacement, Matrix.CreateRotationZ(angle));
particle.Direction = displacement;
particle.Accelaration = 3.0f * particle.Direction;
particleList.Add(particle);
}
public static async Task Run(EngineContext engineContext)
{
ParticlePlugin particlePlugin;
if (!engineContext.DataContext.RenderPassPlugins.TryGetValueCast("ParticlePlugin", out particlePlugin))
return;
var count = particlePlugin.CapacityCount;
var particlesBuffer = new ParticleData[count];
var random = new Random();
for (int i = 0; i < particlesBuffer.Length; i++)
{
particlesBuffer[i] = new ParticleData
{
Position = new Vector3(1000.0f - (float)random.NextDouble() * 6000, 1500.0f - (float)random.NextDouble() * 3000.0f, 0),
Velocity = new Vector3(0, 0, 2.0f + 10.0f * (float)random.NextDouble()),
Time = 5000.0f * (float)random.NextDouble(),
Size = 1.0f + (float)random.NextDouble() * 10.0f,
Factors = new Vector3(1.0f + ((i & 255) == 0 ? (25.0f + 50.0f * (float)random.NextDouble()) : -(float)random.NextDouble() * ((i & 3) == 0 ? 2.0f : 1.0f)), 0, 0),
Opacity = 1.0f,
};
particlesBuffer[i].Position.Z = particlesBuffer[i].Velocity.Z * particlesBuffer[i].Time / 100.0f;
}
var particleUpdater = new ParticleEmitterComponent()
{
Type = ParticleEmitterType.GpuStatic,
Count = count,
Shader = new ShaderClassSource("ParticleUpdaterTest1"),
};
particleUpdater.ParticleData = particlesBuffer;
particleUpdater.ParticleElementSize = Utilities.SizeOf<ParticleData>();
// Add this particle updater to the particle engine
particlePlugin.Updaters.Add(particleUpdater);
}
public void AddExplosion(ParticleData[] PA, int MaxParticles, Vector2 ExplosionPosition, float ExplosionSize, GameTime gametime, Vector2 ImpactVelocity)
{
switch (ParticleID)
{
case 1:
for (int i = 0; i < MaxParticles; i++)
{
AddExplosionParticle1(PA, ExplosionPosition, ExplosionSize, gametime);
}
break;
case 2:
for (int i = 0; i < MaxParticles; i++)
{
AddExplosionParticle2(PA, ExplosionPosition, ExplosionSize, gametime, ImpactVelocity);
}
break;
default: break;
}
}
public void AddExplosionParticle1(ParticleData[] PA, Vector2 ExplosionPosition, float ExplosionSize, GameTime gametime)
{
ParticleData particle = new ParticleData();
particle.OrginalPosition = ExplosionPosition;
particle.Position = particle.OrginalPosition;
particle.BirthTime = (float)gametime.TotalGameTime.TotalMilliseconds;
particle.Scaling = ParticleScale;
particle.ModColor = Color.White;
float ParticleDistance = (float)random.NextDouble() * ExplosionSize;
Vector2 Displacement = new Vector2(ParticleDistance);
float angle = MathHelper.ToRadians(random.Next(360));
Displacement = Vector2.Transform(Displacement, Matrix.CreateRotationZ(angle));
particle.Direction = ParticleInitialVelocityScale * Displacement;
particle.Accelaration = -ParticleAcceleration * particle.Direction;
if (ParticleCounter == ParticleArraySize - 1)
{
ParticleCounter = 0;
}
if (particle.IsAlive)
{
ParticlesOverwritten++;
}
particle.IsAlive = true;
PA[ParticleCounter] = particle;
ParticleCounter++;
ParticlesCreated++;
}
public void AddExplosionParticle2(ParticleData[] PA, Vector2 ExplosionPosition, float ExplosionSize, GameTime gametime, Vector2 ImpactVelocity)
{
ParticleData particle = new ParticleData();
particle.IsHoming = false;
particle.OrginalPosition = ExplosionPosition;
particle.Position = particle.OrginalPosition;
particle.BirthTime = (float)gametime.TotalGameTime.TotalMilliseconds;
//particle.Scaling = ParticleScale;
particle.ModColor = Color.White;
float ParticleDistance = (float)random.NextDouble() * ExplosionSize;
Vector2 Displacement = new Vector2(ParticleDistance, 0);
Vector2 IV = ImpactVelocity;
Vector2 IVnorm = Vector2.Normalize(IV);
Vector2 CartesianIVnorm = new Vector2(0, 0);
float angle = (float)Math.Atan((IVnorm.Y / IVnorm.X));
angle = MathHelper.ToDegrees(angle);
float tanangle = Math.Abs(angle);
float angleRangeMin = 0;
float angleRangeMax = 0;
int quadrant = FindQuadrant(IVnorm);
switch (quadrant)
{
case 1:
CartesianIVnorm = new Vector2(Math.Abs(IVnorm.X), Math.Abs(IVnorm.Y));
angle = (float)Math.Atan((CartesianIVnorm.Y / CartesianIVnorm.X));
angle = MathHelper.ToDegrees(angle);
angleRangeMin = angle - ConeWidth;
angleRangeMax = angle + ConeWidth;
break;
case 2:
CartesianIVnorm = new Vector2(-Math.Abs(IVnorm.X), Math.Abs(IVnorm.Y));
angle = (float)Math.Atan((CartesianIVnorm.X / CartesianIVnorm.Y));
angle = Math.Abs(MathHelper.ToDegrees(angle));
angleRangeMin = angle + 90 - ConeWidth;
angleRangeMax = angle + 90 + ConeWidth;
break;
case 3:
CartesianIVnorm = new Vector2(-Math.Abs(IVnorm.X), -Math.Abs(IVnorm.Y));
angle = (float)Math.Atan((CartesianIVnorm.Y / CartesianIVnorm.X));
angle = MathHelper.ToDegrees(angle);
angleRangeMin = angle + 180 - ConeWidth;
angleRangeMax = angle + 180 + ConeWidth;
break;
case 4:
CartesianIVnorm = new Vector2(Math.Abs(IVnorm.X), -Math.Abs(IVnorm.Y));
angle = (float)Math.Atan((CartesianIVnorm.X / CartesianIVnorm.Y));
angle = Math.Abs(MathHelper.ToDegrees(angle));
angleRangeMin = angle + 270 - ConeWidth;
angleRangeMax = angle + 270 + ConeWidth;
break;
case 0:
if (IVnorm.X == 1 && IVnorm.Y == 0)
{
angleRangeMin = -ConeWidth;
angleRangeMax = ConeWidth;
}
else if (IVnorm.X == 0 && IVnorm.Y == -1)
{
angleRangeMin = 90 - ConeWidth;
angleRangeMax = 90 + ConeWidth;
}
else if (IVnorm.X == -1 && IVnorm.Y == 0)
{
angleRangeMin = 180 - ConeWidth;
angleRangeMax = 180 + ConeWidth;
}
else if (IVnorm.X == 0 && IVnorm.Y == 1)
{
angleRangeMin = 270 - ConeWidth;
angleRangeMax = 270 + ConeWidth;
}
break;
default: break;
}
// Generate radom angle between Min and Max, then feed to isplacment code below
float radMin = 1000 * MathHelper.ToRadians(angleRangeMin);
float radMax = 1000 * MathHelper.ToRadians(angleRangeMax);
float randomangle = random.Next((int)radMin, (int)radMax);
randomangle = randomangle / 1000;
//randomangle = MathHelper.ToRadians(randomangle);
//For now, Displacement the usual-> relative to ExplosionSize, later can change to be magnitude of IV by using Vector2.Lengt
Displacement = Vector2.Transform(Displacement, Matrix.CreateRotationZ(-randomangle));
particle.Direction = ParticleInitialVelocityScale * Displacement;
particle.Accelaration = -ParticleAcceleration * particle.Direction;
if (ParticleCounter == ParticleArraySize - 1)
{
ParticleCounter = 0;
}
if (particle.IsAlive == true)
{
ParticlesOverwritten++;
}
particle.IsAlive = true;
PA[ParticleCounter] = particle;
ParticleCounter++;
ParticlesCreated++;
}
public void DrawExplosion(ParticleData[] PA, SpriteBatch spriteBatch, GameTime gameTime)
{
if (ParticleID == 1)
{
// spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
for (int i = 0; i < ParticleArraySize; i++)
{
spriteBatch.Draw(Explosion1Sprite,
PA[i].Position,
null,
PA[i].ModColor,
0,//MathHelper.ToRadians(i),//i, to rotate smoke cloud
new Vector2(ParticleVectorX, ParticleVectorY),
PA[i].Scaling,
SpriteEffects.None,
1);
}
// spriteBatch.End();
}
else
{
// spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);
float nowdist = 0;
float p1dist = 0;
float ratio = 0;
for (int i = 0; i < ParticleArraySize; i++)
{
//ParticleData particle = PA[i];
if (PA[i].IsAlive == true)
{
spriteBatch.Draw(Explosion1Sprite,
PA[i].Position,
null,
PA[i].ModColor,
0,//MathHelper.ToRadians(i),//i, to rotate smoke cloud
new Vector2(ParticleVectorX, ParticleVectorY),
PA[i].Scaling,
SpriteEffects.None,
1);
}
}
// spriteBatch.End();
}
}
public void UpdateParticles(ParticleData[] PA, GameTime gameTime, Vector2 P1positon)
{
float now = (float)gameTime.TotalGameTime.TotalMilliseconds;
switch (ParticleID)
{
case 1:
for (int i = 0; i < ParticleArraySize; i++)
{
ParticleData particle = PA[i];
float timeAlive = now - particle.BirthTime;
particle.NowAge = timeAlive;
if (particle.NowAge > ParticleMaxAge || particle.ModColor.A < 0.1f)
{
particle.IsAlive = false;
particle.Accelaration = new Vector2(0, 0);
particle.Direction = new Vector2(0, 0);
particle.IsHoming = false;
}
else
{
float relativeAge = timeAlive / ParticleMaxAge;
particle.Position = 0.5f * particle.Accelaration * relativeAge * relativeAge + particle.Direction * relativeAge + particle.OrginalPosition;
float inverseAge = 1.0f - relativeAge;
particle.ModColor = new Color(new Vector4(inverseAge, inverseAge + 0.5f, inverseAge, inverseAge - 0.15f));
Vector2 positionFromCenter = particle.Position - particle.OrginalPosition;
float distance = positionFromCenter.Length();
particle.Scaling = (ParticleScaleFactor1 + distance) / ParticleScaleFactor2;
PA[i] = particle;
}
}
break;
case 2:
for (int i = 0; i < ParticleArraySize; i++)
{
ParticleData particle = PA[i];
if (particle.IsAlive == true)
{
float timeAlive = now - particle.BirthTime;
particle.NowAge = timeAlive;
if (!particleWindow.Contains(new Point((int)particle.Position.X, (int)particle.Position.Y)))
{
particle.IsAlive = false;
particle.Accelaration = new Vector2(0, 0);
particle.Direction = new Vector2(0, 0);
particle.BirthTime = 0;
particle.IsHoming = false;
PA[i] = particle;
ParticlesKilled++;
continue;
}
if (particle.NowAge > ParticleMaxAge + ParticleAgeOffset)
{
particle.IsAlive = false;
particle.Accelaration = new Vector2(0, 0);
particle.Direction = new Vector2(0, 0);
particle.BirthTime = 0;
particle.IsHoming = false;
PA[i] = particle;
ParticlesKilled++;
continue;
}
else
{
float distori = Vector2.Distance(particle.OrginalPosition, particle.Position);
float distplayer = Vector2.Distance(P1positon, particle.Position);
if (Math.Abs(distori) > 0 || Math.Abs(distplayer) < 200)
{
particle.IsHoming = true;
particle.Accelaration = ParticleToPlayerAccelerationScale * Vector2.Normalize(P1positon - particle.Position);
//particle.Accelaration.X = particle.Accelaration.X;
//particle.Accelaration.Y = particle.Accelaration.Y;
}
float relativeAge = timeAlive / ParticleMaxAge;
particle.Position = 0.5f * particle.Accelaration * relativeAge * relativeAge + particle.Direction * relativeAge + particle.OrginalPosition;
//float inverseAge = 1.0f - relativeAge;
//particle.ModColor = new Color(new Vector4(inverseAge, inverseAge , inverseAge, inverseAge ));
//Vector2 positionFromCenter = particle.Position - particle.OrginalPosition;
//float distance = positionFromCenter.Length();
particle.Scaling = ParticleScale;// (ParticleScaleFactor1 + distance) / ParticleScaleFactor2;
PA[i] = particle;
}
}
}
break;
default: break;
}
}
