public BuildingData(Building origin)
{
_random = new Unity.Mathematics.Random(1);
_tenants = origin._tenants;
floors = origin.floors;
PowerUsage = 0;
}
public void Execute(Entity entity, int index, ref DustParticle d0, ref Translation t0, ref NonUniformScale n0, ref Rotation r0, ref Seed seed)
{
if (d0.Life <= 0)
{
EntityCommandBuffer.DestroyEntity(index, entity);
return;
}
var rand = new Unity.Mathematics.Random(seed.Value);
var f1 = rand.NextFloat(1, 2);
var q1 = rand.NextQuaternionRotation();
r0.Value = q1;
d0.Life -= deltaTime * f1;
t0.Value.y += deltaTime * d0.FloatUpRate * f1;
t0.Value.x += deltaTime * d0.FloatUpRate * rand.NextFloat(-1, 3);
t0.Value.z += deltaTime * d0.FloatUpRate * rand.NextFloat(-1, 4);
if (n0.Value.x <= 0 || n0.Value.y <= 0 || n0.Value.z <= 0)
{
return;
}
n0.Value -= maths.one * deltaTime * d0.ScaleDownRate * f1;
}
public Data(MBuilding building)
{
_random = new Unity.Mathematics.Random(1);
_tenants = building.floors * _random.NextInt(20, 500);
PowerUsage = 0;
Debug.Log(_tenants);
}
static void FilterSmallNumbersTestCase(uint seed, int length, FilterSmallNumbers scalar, FilterSmallNumbers simd)
{
var rng = new Unity.Mathematics.Random(seed);
var inputs = new float[length];
var outputsScalar = new float[length];
var outputsSimd = new float[length];
for (int i = 0; i < length; i++)
{
inputs[i] = rng.NextFloat() * 3;
}
int outLengthScalar, outLengthSimd;
fixed(float *inputPtr = inputs)
{
fixed(float *outputPtr = outputsScalar)
scalar(inputPtr, length, outputPtr, out outLengthScalar);
fixed(float *outputPtr = outputsSimd)
simd(inputPtr, length, outputPtr, out outLengthSimd);
}
Assert.AreEqual(outLengthScalar, outLengthSimd, $"SIMD version failed with seed {seed} with input length {length}: Different number of results");
for (int i = 0; i < outLengthScalar; i++)
{
Assert.AreEqual(outputsScalar[i], outputsSimd[i], $"SIMD version failed with seed {seed} with input length {length}: Different output at index {i}");
}
}
public void Update()
{
var random = new Unity.Mathematics.Random(1);
for (var i = 0; i < _tenants; i++)
{
PowerUsage += random.NextInt(12, 24);
}
}
public UpdateChunkJob(ValueWithNeighbors <Chunk> chunkWithNeighbors, uint frameCount, Unity.Mathematics.Random random, CommandBuilder drawingCommands, float2 chunkPosition, float chunkScale, float simulationStep)
{
this.chunkWithNeighbors = chunkWithNeighbors;
this.frameCount = frameCount;
this.random = random;
this.drawingCommands = drawingCommands;
this.chunkPosition = chunkPosition;
this.chunkScale = chunkScale;
this.simulationStep = simulationStep;
}
protected override JobHandle OnUpdate(JobHandle deps)
{
var seed = (uint)Random.Range(0, 1000000);
var random = new Unity.Mathematics.Random(seed);
var job = new TurretRotationJob
{
delta = Time.deltaTime,
accuracy = ROTATION_EPSILON,
rnd = random
};
return(job.Schedule(this, deps));
}
public void Execute(Entity entity, int index, ref DustTrail trail, ref CartoonBody c1, ref LocalToWorld l0)
{
trail.m_CurrentTime += deltaTime;
var coinflip = new Unity.Mathematics.Random(12345);
var outcome = coinflip.NextInt(0, 1);
if (trail.m_CurrentTime > trail.Rate || outcome.Equals(1))
{
if (!PlayerInput.Move.Equals(float2.zero))
{
var rand = new Unity.Mathematics.Random(12345);
float f1 = (float)rand.NextInt(-2, 2);
var intRand = rand.NextInt(trail.MinAmount, trail.MaxAmount + 5);
for (int i = 0; i < intRand; i++)
{
var dust = CommandBuffer.Instantiate(index, trail.DustPrefabEntity);
var PositionOffset = new float3(0, -0.5f, 0);
CommandBuffer.SetComponent(index, dust, new Translation {
Value = l0.Position + PositionOffset
});
var localToWorld = new LocalToWorld
{
Value = float4x4.TRS(new float3(l0.Position + PositionOffset),
quaternion.LookRotationSafe(l0.Forward, math.up()),
new float3(0.30f, 0.30f, 0.30f))
};
CommandBuffer.SetComponent(index, dust, new LocalToWorld
{
Value = localToWorld.Value
});
var seed = rand.NextUInt(1, 100) + (uint)i;
CommandBuffer.AddComponent(index, dust, new Seed {
Value = seed
});
}
trail.m_CurrentTime = 0;
}
}
}
void Start()
{
if (_GameOfLifeTexture == null)
{
return;
}
_TextureWidth = _GameOfLifeTexture.width;
_Pixels = new NativeArray <float>(_TextureWidth * _TextureWidth, Allocator.Persistent);
_ColorsNative = new NativeArray <Color>(_TextureWidth * _TextureWidth, Allocator.Persistent);
_Colors = new Color[_Pixels.Length];
_Tex = new Texture2D(_GameOfLifeTexture.width, _GameOfLifeTexture.height, TextureFormat.RGBA32, false);
for (int x = 0; x < _Pixels.Length; x++)
{
_Pixels[x] = Random.Range(0, 1f);
}
var size = (int)math.pow(2, _MapSize);
_Random = new Unity.Mathematics.Random((uint)(DateTime.Now.Ticks));
_Map = new MapData(size, size);
_MoveDirectionIndexOffset = new NativeArray <int>(8, Allocator.Persistent);
_MoveDirectionIndexOffset[0] = size;
_MoveDirectionIndexOffset[1] = 1 + size;
_MoveDirectionIndexOffset[2] = 1;
_MoveDirectionIndexOffset[3] = 1 - size;
_MoveDirectionIndexOffset[4] = -size;
_MoveDirectionIndexOffset[5] = -1 - size;
_MoveDirectionIndexOffset[6] = -1;
_MoveDirectionIndexOffset[7] = -1 + size;
var directionsJob = new GenerateDirectionsJob()
{
Map = _Map
};
var handle = directionsJob.Schedule(_Map.tiles.Length, 64);
var generateJob = new GenerateRandomLifeJob()
{
tiles = _Map.tiles,
random = _Random
};
handle = generateJob.Schedule(_Map.tiles.Length, 64, handle);
handle.Complete();
}
static void RunningSumTestCase(uint seed, int length, RunningSum scalar, RunningSum simd)
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed);
var arrayScalar = new int[length];
var arraySimd = new int[length];
for (int i = 0; i < length; i++)
arrayScalar[i] = arraySimd[i] = rng.NextInt();
fixed(int *outputPtr = arrayScalar)
scalar(outputPtr, length);
fixed(int *outputPtr = arraySimd)
simd(outputPtr, length);
for (int i = 0; i < length; i++)
{
Assert.AreEqual(arrayScalar[i], arraySimd[i], $"SIMD version failed with seed {seed} with input length {length}: Different output at index {i}");
}
}
static void MatrixVectorMultiplyTestCase(uint seed, int length, MatrixVectorMultiply scalar, MatrixVectorMultiply simd)
{
Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed);
var matrix = new float4x4(rng.NextFloat4(), rng.NextFloat4(), rng.NextFloat4(), rng.NextFloat4());
var vectorsScalar = new float4[length];
var vectorsSimd = new float4[length];
for (int i = 0; i < length; i++)
vectorsScalar[i] = vectorsSimd[i] = rng.NextFloat4();
fixed(float4 *outputPtr = vectorsScalar)
scalar(&matrix, outputPtr, length);
fixed(float4 *outputPtr = vectorsSimd)
simd(&matrix, outputPtr, length);
for (int i = 0; i < length; i++)
{
bool almostEqual = math.all(
math.abs(vectorsScalar[i] - vectorsSimd[i]) < new float4(0.01f)
);
Assert.IsTrue(almostEqual, $"SIMD version failed with seed {seed} with input length {length}: Different output at index {i}");
}
}
protected override void OnCreate()
{
m_random = new Unity.Mathematics.Random(546);
}
protected override void OnCreate()
{
m_endSimulationEntityCommandBufferSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <EndSimulationEntityCommandBufferSystem>();
m_random = new Unity.Mathematics.Random(546);
base.OnCreate();
}
private void Awake()
{
random = new Unity.Mathematics.Random((uint)new System.Random().Next());
}
