//depending on level I can filter //but for each level how to set the parameters //speed goes to 0 to whatever //basically select from an array of posible speed {1,2,3,4,5} but stay same sometimes //what about z rotation. //but if I keep resetting them then it will look like nothing.... //need an IProcessComponentData //need a separate job to control the movespeed and z rotation. //each object gets an init speed at a harmonic ratio so drawn from a hat. //each objects gets an init rand speed for whole range of speeds available //each object gets an init z rot at a harmonic ratio so drawn from hat //each object gets a random z rot //distance affects speed of d1 components. //random walk of frequency range base speed multiplayer for d2 d3 components - TODO IN THIS METHOD //what about harmonicity of d1 components? // //You then introduce random perturbation //how? //add a random value to the speed //no way to keep track of which entities have public void Execute(int i) { float baseSpeedMultiplyer; float harmonicity; float radius; if (depths[i].depth == 1) { baseSpeedMultiplyer = d1BaseSpeedMultiplyer; harmonicity = d1Harmonicity; radius = ringRevolve[i].radius * d1Radius; } else if (depths[i].depth == 2) { baseSpeedMultiplyer = d2BaseSpeedMultiplyer; harmonicity = d2Harmonicity; radius = ringRevolve[i].radius * d2Radius; } else { baseSpeedMultiplyer = d3BaseSpeedMultiplyer; harmonicity = d3Harmonicity; radius = ringRevolve[i].radius * d3Radius; } float newMoveSpeed = (math.lerp(ringRevolve[i].initRandSpeed, ringRevolve[i].initSpeed, harmonicity)) * baseSpeedMultiplyer; float newZRotSpeed = (math.lerp(ringRevolve[i].initRandZRotSpeed, ringRevolve[i].initZRotSpeed, harmonicity)) * baseSpeedMultiplyer; //ring rotation //float zRotation = (ringRevolve[i].zRotation + (dt * ringRevolve[i].initZRotSpeed)) % 360; //modulo from 0 360 float zRotation = (ringRevolve[i].zRotation + (dt * newZRotSpeed)) % 360; //modulo from 0 360 //float t = ringRevolve[i].t + (dt * moveSpeeds[i].speed); float t = ringRevolve[i].t + (dt * newMoveSpeed); float offsetT = t + (0.01f * i) + ringRevolve[i].initOffset; float cosVal = math.cos(offsetT); float sinVal = math.sin(offsetT); //TODO : CHANGE THE RADIUS float x = cosVal * radius; float y = 0; float z = sinVal * radius; //float x = ringRevolve[i].center.x + (cosVal * ringRevolve[i].radius); //float y = ringRevolve[i].center.y; //float z = ringRevolve[i].center.z + (sinVal * ringRevolve[i].radius); //math.sin(offsetT) //get //points[i] = ringRotation * points[i]; //float zRot = ringRevolve[] + math.sin(offsetT); //convert to 360 Quaternion rotation = Quaternion.Euler(0f, 0f, zRotation); ringRevolve[i] = new RingRevolve { t = t, //center = ringRevolve[i].center, radius = ringRevolve[i].radius, initOffset = ringRevolve[i].initOffset, zRotation = zRotation, initSpeed = ringRevolve[i].initSpeed, initRandSpeed = ringRevolve[i].initRandSpeed, initZRotSpeed = ringRevolve[i].initZRotSpeed, initRandZRotSpeed = ringRevolve[i].initRandZRotSpeed, //zSpeed = ringRevolve[i].zSpeed }; //float3 newPosition = ringRevolve[i].zRotation * new Vector3(x, y, z); positions[i] = new Position { Value = rotation * new float3(x, y, z) }; }
protected override void OnUpdate() { var uniqueTypes = new List <InitWorld>(10); //make ten unique type? attachArch = GameManagerGreg.instance.attachArchetype; EntityManager.GetAllUniqueSharedComponentData(uniqueTypes); //bc shared component data may have non-blittable types and thus need a list not a nativeContainer int spawnInstanceCount = 0; //how many spawn instances are there? //Debug.Log("on Update"); //Debug.Log(uniqueTypes.Count); for (int sharedIndex = 0; sharedIndex != uniqueTypes.Count; sharedIndex++) { //Debug.Log(sharedIndex); var spawner = uniqueTypes[sharedIndex]; m_MainGroup.SetFilter(spawner); var entities = m_MainGroup.GetEntityArray(); Debug.Log(entities.Length); spawnInstanceCount += entities.Length; } //i'm not sure what this does....? Debug.Log(spawnInstanceCount); if (spawnInstanceCount == 0) //if no spawn instances then stop { return; } //instantiate an spawnInstance var spawnInstances = new NativeArray <InitWorldSpawnInstance>(spawnInstanceCount, Allocator.Temp); //native array of components { int spawnIndex = 0; for (int sharedIndex = 0; sharedIndex != uniqueTypes.Count; sharedIndex++) //for each { var spawner = uniqueTypes[sharedIndex]; m_MainGroup.SetFilter(spawner); var entities = m_MainGroup.GetEntityArray(); var positions = m_MainGroup.GetComponentDataArray <Position>(); //var radii = m_MainGroup.GetComponentDataArray<RingRadius>(); for (int entityIndex = 0; entityIndex < entities.Length; entityIndex++) { var spawnInstance = new InitWorldSpawnInstance(); spawnInstance.sourceEntity = entities[entityIndex]; spawnInstance.spawnerIndex = sharedIndex; spawnInstance.position = positions[entityIndex].Value; //spawnInstance.radius = radii[entityIndex].Value; spawnInstances[spawnIndex] = spawnInstance; spawnIndex++; } } } //init speed of harmonic ratios float[] initSpeedArray = new float[4] { 1, 2, 4, 8 }; for (int q = 0; q < initSpeedArray.Length; q++) { initSpeedArray[q] = (initSpeedArray[q] * math.pow(2, -2)); //initSpeedArray[q] = 1; } for (int spawnIndex = 0; spawnIndex < spawnInstances.Length; spawnIndex++) { int spawnerIndex = spawnInstances[spawnIndex].spawnerIndex; var spawner = uniqueTypes[spawnerIndex]; var entities = new NativeArray <Entity>(spawner.ringsPerSystem * spawner.objsPerRing, Allocator.Temp); var prefab = spawner.prefab; float radius = spawner.radius; float3 center = spawnInstances[spawnIndex].position; var sourceEntity = spawnInstances[spawnIndex].sourceEntity; EntityManager.Instantiate(prefab, entities); //vars for settings rings float zRot = 0; float increment = 180 / spawner.ringsPerSystem; //increment is 2*pi / numPartitions float ringIncrement = Mathf.PI * 2.0f / spawner.objsPerRing; //increment is 2*pi / numPartitions for (int i = 0; i < spawner.ringsPerSystem; i++) { float angle = 0; var ringPositions = new NativeArray <float3>(spawner.objsPerRing, Allocator.Temp); Quaternion rotation = Quaternion.Euler(0f, 0f, zRot); GeneratePoints.GenerateWorldRing(center, radius, rotation, ref ringPositions); //zRot = zRot + increment; //for each ring do what? //grab a dummy archetype of rotation. //set the source rotation. the parent rotation. so sourceEntity //I dont think that'll work bc its only parented after the update in transformupdatesystem //float initZRotSpeed = initSpeedArray[UnityEngine.Random.Range(0, initSpeedArray.Length)]; //float initZRotSpeed = 1; float initZRotSpeed = 4 * initSpeedArray[UnityEngine.Random.Range(0, initSpeedArray.Length)]; for (int j = 0; j < spawner.objsPerRing; j++) { var position = new Position { Value = ringPositions[j] }; EntityManager.SetComponentData(entities[(i * spawner.objsPerRing) + j], position); //set position and add in other variables //var rotationSpeed = new RotationSpeed //{ // Value = UnityEngine.Random.Range(-1f, 1f) //}; //Debug.Log(rotationSpeed.Value); //EntityManager.SetComponentData(entities[(i * spawner.objsPerRing) + j], rotationSpeed); EntityManager.SetComponentData(entities[(i * spawner.objsPerRing) + j], new MoveSpeed { speed = UnityEngine.Random.Range(-.1f, .1f) }); //make the values change depending on depth level //how to set move speed float initMoveSpeed = initSpeedArray[UnityEngine.Random.Range(0, initSpeedArray.Length)]; var initOffset = new RingRevolve { //center = new float3(0, 0, 0), initOffset = angle, radius = spawner.radius, zRotation = zRot, initSpeed = initMoveSpeed, initRandSpeed = UnityEngine.Random.Range(-2f, 2f), initZRotSpeed = initZRotSpeed, initRandZRotSpeed = UnityEngine.Random.Range(-2f, 2f), }; EntityManager.SetComponentData(entities[(i * spawner.objsPerRing) + j], initOffset); angle = angle + ringIncrement; var attachEntity = EntityManager.CreateEntity(attachArch); EntityManager.SetComponentData(attachEntity, new Attach { Child = entities[(i * spawner.objsPerRing) + j], Parent = sourceEntity }); } zRot = zRot + increment; //increment z ringPositions.Dispose(); //zRot = zRot+increment; } /* * for (int i = 0; i < count; i++) * { * var position = new Position * { * Value = spawnPositions[i] * }; * * var attachEntity = EntityManager.CreateEntity(attachArch); * //EntityManager.AddComponent(SpawnAttach, new Attach()); * EntityManager.SetComponentData(attachEntity, new Attach * { * Child = entities[i], * Parent = sourceEntity * }); * * EntityManager.SetComponentData(entities[i], position); * } */ EntityManager.RemoveComponent <InitWorld>(sourceEntity); //ringPositions.Dispose(); entities.Dispose(); } spawnInstances.Dispose(); }