void SpawnSingleElementDupes(EZParallaxObjectElement targetElement, Camera actualCamera, float screenWidth)
{
DupeChainHandle dupeChainParent;
if(targetElement.dupeChainObject == null)
{
dupeChainParent = new DupeChainHandle();
dupeChainParent.targetGameObject = new GameObject();
dupeChainParent.targetGameObject.name = "EZP " + targetElement.name + " Dupe Handle";
Transform origParent = targetElement.parallaxObject.parent;
targetElement.parallaxObject.parent = dupeChainParent.targetGameObject.transform;
dupeChainParent.targetGameObject.transform.parent = origParent;
targetElement.dupeChainObject = dupeChainParent;
if(m_dupeChainHandles != null)
{
DupeChainHandle[] tempDCArray = new DupeChainHandle[m_dupeChainHandles.Length + 1];
for(int i = 0; i < m_dupeChainHandles.Length; i++)
{
tempDCArray[i] = m_dupeChainHandles[i];
}
tempDCArray[m_dupeChainHandles.Length] = dupeChainParent;
m_dupeChainHandles = tempDCArray;
}
else
{
m_dupeChainHandles = new DupeChainHandle[1];
m_dupeChainHandles[0] = dupeChainParent;
}
}
else
{
dupeChainParent = targetElement.dupeChainObject;
}
float targetElementScreenWidth = targetElement.elementScreenSpaceExtentX * 2;
Vector2 targetCenterPosScreenPt = actualCamera.WorldToScreenPoint(targetElement.parallaxObject.position);
//Create an array of randomized offsets and use that array to figure out how wide the initial positioning needs to be, then draw from that array when spawning the individual elements.
List<float> randomOffsetsList = new List<float>();
int maxDupes = 0;
if (targetElement.randomSpawnX)
{
//Goof check
if(targetElement.initialSpawnDistanceMinX > targetElement.initialSpawnDistanceMaxX)
{
Debug.Log ("WARNING -- For your " + targetElement.name + " element, your minimum random spawn distance is greater than your maximum random spawn distance. Swapping your minimum for your maximum.");
float swapVar = targetElement.initialSpawnDistanceMinX;
targetElement.initialSpawnDistanceMinX = targetElement.initialSpawnDistanceMaxX;
targetElement.initialSpawnDistanceMaxX = swapVar;
}
float minScreenSpcOffset = targetCenterPosScreenPt.x - actualCamera.WorldToScreenPoint(targetElement.parallaxObject.position - new Vector3( targetElement.spawnDistanceMinX, 0, targetElement.parallaxObject.position.z)).x;
int greatestMaxDupesX = Mathf.CeilToInt( ( screenWidth * 3 )/ (targetElementScreenWidth + minScreenSpcOffset)) + 2; // * 3 screenwidth and +2 for buffer objects
for(int k = 0; k < greatestMaxDupesX; k++)
{
float randomOffset = Random.Range(targetElement.spawnDistanceMinX, targetElement.spawnDistanceMaxX);
randomOffsetsList.Add(randomOffset);
m_rndDistArray[m_randomSpawnCtr, m_rndDistStartIndex + k] = randomOffset;
}
maxDupes = greatestMaxDupesX;
m_rndElementGroupSize[m_randomSpawnCtr] = maxDupes; //Does not include the original object that was spawned from
m_rndDistArrayIndex[m_randomSpawnCtr] = m_rndDistStartIndex + maxDupes - 1; //Subtract 1 to make room for the initial index shift when the character starts moving, pos or neg
targetElement.spawnGroupIndex = m_randomSpawnCtr;
m_randomSpawnCtr++;
if(m_rndElementGroupSize[m_randomSpawnCtr - 1] >= m_randomOffsetHistorySize)
{
Debug.Log ("An EZParallax element object named " + targetElement.name + " needs to spawn more objects than there are slots in the random offset history! Raise your history size to greater than " + maxDupes + " to resolve this problem. Aborting the creation of duplicate objects for " + targetElement.name + ".");
return;
}
}
else
{
targetElement.initialSpawnDistanceScreenX = targetElement.spawnDistanceScreenX;
targetElement.initialLeftSpawnDistanceScreenSpaceX = targetElement.spawnDistanceScreenX;
targetElement.initialRightSpawnDistanceScreenSpaceX = targetElement.spawnDistanceScreenX;
maxDupes = Mathf.CeilToInt( ( screenWidth * 3 ) / ( targetElementScreenWidth + targetElement.spawnDistanceScreenX ) ) + 2; // +2 buffer objects
targetElement.spawnGroupIndex = 0;
}
int numRightDupes = Mathf.Min( Mathf.CeilToInt( ( (screenWidth * 1.5f) - targetCenterPosScreenPt.x) / targetElementScreenWidth), maxDupes);
if(numRightDupes < 0)
{
numRightDupes = 0;
}
int numLeftDupes = maxDupes - numRightDupes;
if(numLeftDupes < 0)
{
numLeftDupes = 0;
}
//Spawn all objects on the left side
EZParallaxObjectElement dupeTargetElement = targetElement;
EZParallaxObjectElement previousElement = targetElement;
for ( int j = 0; j < numLeftDupes; ++j )
{
if(dupeTargetElement.dupeElementLeft != null)
{
dupeTargetElement = dupeTargetElement.dupeElementLeft;
continue;
}
Vector3 objectOffsetVector;
if(dupeTargetElement.randomSpawnX)
{
int offsetIndex = numLeftDupes - 1 - j;
objectOffsetVector = new Vector3(randomOffsetsList[offsetIndex] + dupeTargetElement.meshWidth, 0, 0);
dupeTargetElement.initialLeftSpawnDistanceX = randomOffsetsList[offsetIndex];
dupeTargetElement.initialLeftSpawnDistanceScreenSpaceX = targetCenterPosScreenPt.x - actualCamera.WorldToScreenPoint(dupeTargetElement.parallaxObject.position - (new Vector3(randomOffsetsList[offsetIndex], 0, dupeTargetElement.parallaxObject.position.z))).x;
}
else
{
objectOffsetVector = new Vector3(targetElement.spawnDistanceX + dupeTargetElement.meshWidth, 0, 0);
dupeTargetElement.initialLeftSpawnDistanceX = dupeTargetElement.initialSpawnDistanceX;
dupeTargetElement.initialLeftSpawnDistanceScreenSpaceX = dupeTargetElement.initialSpawnDistanceScreenX;
}
Transform leftDupeObject = (Transform)(Instantiate(dupeTargetElement.parallaxObject, dupeTargetElement.parallaxObject.position - objectOffsetVector, dupeTargetElement.parallaxObject.rotation) );
leftDupeObject.transform.parent = dupeTargetElement.parallaxObject.parent;
dupeTargetElement.dupeElementLeft = AddNewParallaxingElement(leftDupeObject);
dupeTargetElement.dupeElementLeft.Initialize();
dupeTargetElement.dupeElementLeft.initialRightSpawnDistanceX = dupeTargetElement.leftSpawnDistanceX;
dupeTargetElement.dupeElementLeft.initialRightSpawnDistanceScreenSpaceX = dupeTargetElement.leftSpawnDistanceScreenSpaceX;
dupeTargetElement = dupeTargetElement.dupeElementLeft;
dupeTargetElement.isMotorized = targetElement.isMotorized;
dupeTargetElement.initialMotorSpeed = targetElement.initialMotorSpeed;
dupeTargetElement.randomSpawnX = targetElement.randomSpawnX;
dupeTargetElement.spawnGroupIndex = targetElement.spawnGroupIndex;
dupeTargetElement.privateParallaxSpeedScalarX = targetElement.privateParallaxSpeedScalarX;
dupeTargetElement.privateParallaxSpeedScalarY = targetElement.privateParallaxSpeedScalarY;
dupeTargetElement.isDupe = true;
dupeTargetElement.dupeChainObject = dupeChainParent;
dupeTargetElement.dupeElementRight = previousElement;
previousElement = dupeTargetElement;
}
if(randomOffsetsList.Count > 0)
{
randomOffsetsList.RemoveRange(0, numLeftDupes);
}
//Spawn all objects on the right side
dupeTargetElement = targetElement;
previousElement = targetElement;
for ( int k = 0; k < numRightDupes; ++k )
{
if(dupeTargetElement.dupeElementRight != null)
{
dupeTargetElement = dupeTargetElement.dupeElementRight;
continue;
}
Vector3 objectOffsetVector;
if(dupeTargetElement.randomSpawnX)
{
objectOffsetVector = new Vector3(randomOffsetsList[k] + dupeTargetElement.meshWidth, 0, 0);
dupeTargetElement.initialRightSpawnDistanceX = randomOffsetsList[k];
dupeTargetElement.initialRightSpawnDistanceScreenSpaceX = targetCenterPosScreenPt.x - actualCamera.GetComponent<Camera>().WorldToScreenPoint(dupeTargetElement.parallaxObject.position - (new Vector3(randomOffsetsList[k], 0, dupeTargetElement.parallaxObject.position.z))).x;
}
else
{
objectOffsetVector = new Vector3(targetElement.spawnDistanceX + dupeTargetElement.meshWidth, 0, 0);
dupeTargetElement.initialRightSpawnDistanceX = dupeTargetElement.spawnDistanceX;
dupeTargetElement.initialRightSpawnDistanceScreenSpaceX = dupeTargetElement.spawnDistanceScreenX;
}
Transform rightDupeObject = (Transform)(Instantiate(dupeTargetElement.parallaxObject, dupeTargetElement.parallaxObject.position + objectOffsetVector, dupeTargetElement.parallaxObject.rotation) );
rightDupeObject.transform.parent = dupeTargetElement.parallaxObject.parent;
dupeTargetElement.dupeElementRight = AddNewParallaxingElement(rightDupeObject);
dupeTargetElement.dupeElementRight.Initialize();
dupeTargetElement.dupeElementRight.initialLeftSpawnDistanceX = dupeTargetElement.rightSpawnDistanceX;
dupeTargetElement.dupeElementRight.initialLeftSpawnDistanceScreenSpaceX = dupeTargetElement.rightSpawnDistanceScreenSpaceX;
dupeTargetElement = dupeTargetElement.dupeElementRight;
dupeTargetElement.isMotorized = targetElement.isMotorized;
dupeTargetElement.initialMotorSpeed = targetElement.initialMotorSpeed;
dupeTargetElement.randomSpawnX = targetElement.randomSpawnX;
dupeTargetElement.spawnGroupIndex = targetElement.spawnGroupIndex;
dupeTargetElement.privateParallaxSpeedScalarX = targetElement.privateParallaxSpeedScalarX;
dupeTargetElement.privateParallaxSpeedScalarY = targetElement.privateParallaxSpeedScalarY;
dupeTargetElement.dupeChainObject = dupeChainParent;
dupeTargetElement.isDupe = true;
dupeTargetElement.dupeElementLeft = previousElement;
previousElement = dupeTargetElement;
}
}
//Use this function to remove a SINGLE chain of elements spawned from a single EZP element. I.e., maybe you have wrapping clouds, and you want to remove all of them from the scene. Pass in any...
//...of your cloud element's transforms, and all the sibling clouds generated by EZP will be removed from the scene, along with the original transform/elemnent being passed.
public void PurgeSingleDupeChain(Transform targetTransform)
{
EZParallaxObjectElement targetElement = null;
for(int i = 0; i < m_parallaxElements.Length; i++)
{
if(m_parallaxElements[i].parallaxObject == targetTransform)
{
targetElement = m_parallaxElements[i];
}
}
if(targetElement == null)
{
Debug.Log("The call to PurgeSingleDupeChain could not find the target transform. Aborting purge.");
return;
}
if(targetElement.randomSpawnX)
{
int spawnGroupIdx = targetElement.spawnGroupIndex;
//Make all storage and history items related to this randomized object chain 0, so that people viewing the data will be able to identify cleared slots in the array, while still keeping array structure intact.
for(int i = 0; i < m_rndDistArray.GetLength(0); i++)
{
m_rndDistArray[spawnGroupIdx, i] = 0.0f;
}
m_rndDistArrayIndex[spawnGroupIdx] = 0;
m_rndElementGroupSize[spawnGroupIdx] = 0;
}
List<EZParallaxObjectElement> tempElementArray = new List<EZParallaxObjectElement>(m_parallaxElements);
IList<EZParallaxObjectElement> elemsToRemove = new List<EZParallaxObjectElement>();
elemsToRemove.Add (targetElement);
EZParallaxObjectElement newTargetElement;
//Are there elements to the left in the chain?
if(targetElement.dupeElementLeft != null)
{
newTargetElement = targetElement.dupeElementLeft;
elemsToRemove.Add (newTargetElement);
//Get all elements to the left of our target element in the chain.
while(newTargetElement.dupeElementLeft != null)
{
newTargetElement = newTargetElement.dupeElementLeft;
elemsToRemove.Add (newTargetElement);
}
}
//Are there elements to the right?
if(targetElement.dupeElementRight != null)
{
newTargetElement = targetElement.dupeElementRight;
elemsToRemove.Add (newTargetElement);
//Get all elements to the left of our target element in the chain.
while(newTargetElement.dupeElementRight != null)
{
newTargetElement = newTargetElement.dupeElementRight;
elemsToRemove.Add (newTargetElement);
}
}
//Purge.
for(int i = 0; i < elemsToRemove.Count; i++)
{
tempElementArray.Remove (elemsToRemove[i]);
SetNullChainItems(elemsToRemove[i]);
GameObject.Destroy(elemsToRemove[i].parallaxObject.gameObject);
}
DupeChainHandle[] tempHandleArray = new DupeChainHandle[m_dupeChainHandles.Length - 1];
int tempIdxCtr = 0;
bool foundObj = false;
for(int i = 0; i < m_dupeChainHandles.Length; i++)
{
if(m_dupeChainHandles[i].targetGameObject.transform.FindChild(targetTransform.gameObject.name) != null)
{
GameObject.Destroy(m_dupeChainHandles[i].targetGameObject);
m_dupeChainHandles[i] = null;
foundObj = true;
}
else
{
tempHandleArray[tempIdxCtr] = m_dupeChainHandles[i];
tempIdxCtr++;
}
}
if(foundObj)
{
m_dupeChainHandles = tempHandleArray;
}
m_parallaxElements = tempElementArray.ToArray();
SqueezeElementsArray();
}
