Exemple #1
0
    protected override void OnSelectExit(XRBaseInteractor interactor)
    {
        if (interactor is XRDirectInteractor)
        {
            SavedTransform savedTransform = null;
            if (m_SavedTransforms.TryGetValue(interactor, out savedTransform))
            {
                interactor.attachTransform.localPosition = savedTransform.OriginalPosition;
                interactor.attachTransform.localRotation = savedTransform.OriginalRotation;

                m_SavedTransforms.Remove(interactor);
            }
        }

        base.OnSelectExit(interactor);
    }
Exemple #2
0
    protected override void OnSelectEnter(XRBaseInteractor interactor)
    {
        if (interactor is XRDirectInteractor)
        {
            SavedTransform savedTransform = new SavedTransform();

            savedTransform.OriginalPosition = interactor.attachTransform.localPosition;
            savedTransform.OriginalRotation = interactor.attachTransform.localRotation;

            m_SavedTransforms[interactor] = savedTransform;


            bool haveAttach = attachTransform != null;

            interactor.attachTransform.position = haveAttach ? attachTransform.position : m_Rb.worldCenterOfMass;
            interactor.attachTransform.rotation = haveAttach ? attachTransform.rotation : m_Rb.rotation;
        }

        base.OnSelectEnter(interactor);
    }
Exemple #3
0
    private void Build()
    {
        for (int i = 0; i < currentPath.Length; i++)
        {
            switch (currentPath[i])
            {
            case 'F':
            {
                initialPosition = transform.position;
                bool isLeaf = false;

                //sets current object as branch or blossom
                GameObject currentObject;
                if (currentPath[(i + 1) % currentPath.Length] == 'X' || currentPath[(i + 3) % currentPath.Length] == 'F' && currentPath[(i + 4) % currentPath.Length] == 'X')
                {
                    currentObject = Instantiate(blossom);
                    isLeaf        = true;
                }
                else
                {
                    currentObject = Instantiate(branch);
                }

                //set parent
                currentObject.transform.SetParent(tree.transform);

                //set position and rotation
                currentObject.transform.SetPositionAndRotation(transform.position, transform.rotation);
                //set shape
                float length;

                if (isLeaf)
                {
                    length = Random.Range(minPetalLength, maxPetalLength) * 0.1f;
                    currentObject.transform.localScale = new Vector3(length, length, length);
                }
                else
                {
                    length = Random.Range(minBranchLength, maxBranchLength);
                    currentObject.transform.localScale = new Vector3(width, length, width);
                    transform.Translate(Vector3.up * length * 2f);
                }
            }
            break;

            case 'X':
                break;

            case '-':
                transform.Rotate(Vector3.forward * angle * (1f + variance / 100f * randomRotations[i % randomRotations.Length]));
                break;

            case '+':
                transform.Rotate(Vector3.back * angle * (1f + variance / 100f * randomRotations[i % randomRotations.Length]));
                break;

            case '*':
                transform.Rotate(Vector3.left * angle * (1f + variance / 100f * randomRotations[i % randomRotations.Length]));
                break;

            case '/':
                transform.Rotate(Vector3.right * angle * (1f + variance / 100f * randomRotations[i % randomRotations.Length]));
                break;

            case '[':
                savedTransforms.Push(new SavedTransform {
                    position = transform.position,
                    rotation = transform.rotation
                });
                width           *= widthScale;
                minBranchLength *= lengthScale;
                maxBranchLength *= lengthScale;
                break;

            case ']':
                SavedTransform saved = savedTransforms.Pop();
                width             /= widthScale;
                minBranchLength   /= lengthScale;
                maxBranchLength   /= lengthScale;
                transform.position = saved.position;
                transform.rotation = saved.rotation;
                break;

            default:
                Debug.LogError("Not a Valid Key: " + currentPath[i]);
                break;
            }
        }
    }
Exemple #4
0
    // Generate the L-tree
    public void Generate()
    {
        // Destroy the existing tree
        foreach (GameObject o in tree)
        {
            Destroy(o);
        }
        tree.Clear();

        // Reset the position of the LSystemGenerator
        transform.position = Vector3.zero;
        transform.rotation = Quaternion.identity;

        string axiomString     = axiom.text;
        string fRuleString     = fRule.text;
        string xRuleString     = xRule.text;
        float  angleFloat      = angle.value;
        float  lengthFloat     = length.value;
        float  lengthLeafFloat = lengthLeaf.value;
        float  widthFloat      = width.value;
        float  widthLeafFloat  = widthLeaf.value;
        int    stepInt         = Convert.ToInt32(step.text);

        current = axiomString;

        // Loops a number of times equal to the number of steps
        for (int i = 0; i < stepInt; i++)
        {
            // Algorithm replaces characters with their rule results or default value for each character
            StringBuilder sb = new StringBuilder();
            foreach (char c in current)
            {
                sb.Append(c == 'F' ? fRuleString : c == 'X' ? xRuleString : c.ToString());
            }

            current = sb.ToString();
        }

        foreach (char c in current)
        {
            // Each character does something specific
            switch (c)
            {
            // On 'F' save the starting position and move up by the value of length. Instantiate and draw a branch, with a preset width, from the start position to the current position
            case 'F':
                Vector3 startPos = transform.position;
                transform.Translate(Vector3.up * lengthFloat);
                GameObject branchObj = Instantiate(branch);
                tree.Add(branchObj);
                LineRenderer lr = branchObj.GetComponent <LineRenderer>();
                lr.startWidth = widthFloat;
                lr.SetPosition(0, startPos);
                lr.SetPosition(1, transform.position);
                break;

            // On 'X' do nothing
            case 'X':
                break;

            // On '+' rotate right by the preset angle
            case '+':
                transform.Rotate(Vector3.forward * angleFloat);
                break;

            // On '-' rotate left by the preset angle
            case '-':
                transform.Rotate(Vector3.back * angleFloat);
                break;

            // On '[' save the current position and rotation of the LSystemGenerator to the stack
            case '[':
                savedTransformStack.Push(new SavedTransform()
                {
                    position = transform.position,
                    rotation = transform.rotation
                });
                break;

            // On ']' instantiate and draw a leaf at the end of the branch. Then pop the most recent position and rotation from the stack and move the LSystemGenerator back to it
            case ']':
                Vector3 startPosLeaf = transform.position;
                transform.Translate(Vector3.up * lengthLeafFloat);
                GameObject leafObj = Instantiate(leaf);
                tree.Add(leafObj);
                LineRenderer lr2 = leafObj.GetComponent <LineRenderer>();
                lr2.startWidth = widthLeafFloat;
                lr2.SetPosition(0, startPosLeaf);
                lr2.SetPosition(1, transform.position);
                SavedTransform st = savedTransformStack.Pop();
                transform.position = st.position;
                transform.rotation = st.rotation;
                break;

            // Throw an exception if any other invalid symbol is used
            default:
                throw new InvalidOperationException("Incorrect Character Entered");
            }
        }
    }
    private IEnumerator Generate()
    {
        currentPath = axiom;

        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < iterations; i++)
        {
            char[] currentPathChars = currentPath.ToCharArray();
            for (int j = 0; j < currentPathChars.Length; j++)
            {
                stringBuilder.Append(rules.ContainsKey(currentPathChars[j]) ? rules[currentPathChars[j]] : currentPathChars[j].ToString());
            }
            currentPath   = stringBuilder.ToString();
            stringBuilder = new StringBuilder();
        }

        for (int k = 0; k < currentPath.Length; k++)
        {
            switch (currentPath[k])
            {
            case 'F':
                bool isLeaf = false;

                GameObject currentElement;
                if (currentPath[(k + 1) % currentPath.Length] == 'X' || currentPath[(k + 3) % currentPath.Length] == 'F' && currentPath[(k + 4) % currentPath.Length] == 'X')
                {
                    isLeaf = true;
                }

                if (isLeaf)
                {
                    currentElement   = Instantiate(leaf, currentPosition, currentRotation);
                    currentPosition += currentRotation * Vector3.up * Random.Range(minLeafLength, maxLeafLength);
                }
                else
                {
                    currentElement   = Instantiate(branch, currentPosition, currentRotation);
                    currentPosition += currentRotation * Vector3.up * Random.Range(minBranchLength, maxBranchLength);
                }
                currentElement.transform.SetParent(tree.transform);

                // TreeElement currentTreeElement = currentElement.GetComponent<TreeElement>();
                // currentTreeElement.lineRenderer.startWidth = width;
                // currentTreeElement.lineRenderer.endWidth = width;
                // currentTreeElement.lineRenderer.sharedMaterial = currentTreeElement.material;
                break;

            case 'X':
                break;

            case '+':
                currentRotation.eulerAngles += Vector3.forward * angle * (1f + variance / 100f * randomRotations[k % randomRotations.Length]);
                // currentRotation.eulerAngles += Vector3.forward * angle;
                // transform.Rotate(Vector3.forward * angle);
                break;

            case '-':
                currentRotation.eulerAngles += Vector3.back * angle * (1f + variance / 100f * randomRotations[k % randomRotations.Length]);
                // currentRotation.eulerAngles += Vector3.back * angle;
                // transform.Rotate(Vector3.back * angle);
                break;

            // case '*':
            //  transform.Rotate(Vector3.up * 120f * (1f + variance / 100f * randomRotations[k%randomRotations.Length]));
            //      break;

            // case '/':
            //  transform.Rotate(Vector3.down * 120f * (1f + variance / 100f * randomRotations[k%randomRotations.Length]));
            //  break;

            case '[':
                savedTransforms.Push(
                    new SavedTransform()
                {
                    position = currentPosition,
                    rotation = currentRotation
                }
                    );
                break;

            case ']':
                SavedTransform savedTransform = savedTransforms.Pop();

                currentPosition = savedTransform.position;
                currentRotation = savedTransform.rotation;
                break;
            }
            Debug.Log(currentPath[k]);
            Debug.Log(currentPosition);
            Debug.Log(currentRotation.eulerAngles);
            yield return(null);
        }
    }
Exemple #6
0
    public void Generate(GameObject tree)
    {
        currentPath = axiom;
        StringBuilder stringBuilder = new StringBuilder();

        TreeRoot currentTreeRoot   = tree.GetComponent <TreeRoot>();
        int      currentGrowthStep = currentTreeRoot.growthStep;

        for (int i = 0; i < iterations; i++)
        {
            char[] currentPathChars = currentPath.ToCharArray();
            for (int j = 0; j < currentPathChars.Length; j++)
            {
                stringBuilder.Append(rules.ContainsKey(currentPathChars[j]) ? rules[currentPathChars[j]] : currentPathChars[j].ToString());
            }

            currentPath   = stringBuilder.ToString();
            stringBuilder = new StringBuilder();
        }

        bool previousWasLeaf = false;

        tempBranchParent = new GameObject("Fresh Branch");

        for (int k = 0; k < currentPath.Length; k++)
        {
            switch (currentPath[k])
            {
            // F == forward
            case 'F':
                initialPosition = transform.position;
                bool isLeaf = false;

                if (initialPosition == Vector3.zero)
                {
                    branchRoot = new GameObject("Root " + k);
                    branchRoot.transform.SetParent(tree.transform);
                }

                GameObject currentElement;

                bool nextIsLeaf  = currentPath[k + 1] % currentPath.Length == 'X';
                bool aheadIsLeaf = aheadIsLeaf = currentPath[(k + 3) % currentPath.Length] % currentPath.Length == 'F' && currentPath[(k + 4) % currentPath.Length] % currentPath.Length == 'X';

                if (nextIsLeaf || aheadIsLeaf)
                {
                    currentElement = Instantiate(leaf, transform.position, transform.rotation);
                    isLeaf         = true;
                }
                else
                {
                    currentElement = Instantiate(branch, transform.position, transform.rotation);
                }

                if (previousWasLeaf && !isLeaf)
                {
                    // time to start a new branch
                    tempBranchParent = new GameObject("Fresh Branch " + k);
                }
                tempBranchParent.transform.SetParent(branchRoot.transform);

                currentElement.transform.SetParent(tempBranchParent.transform);

                TreeElement currentTreeElement = currentElement.GetComponent <TreeElement>();

                float length = 0f;
                if (isLeaf)
                {
                    length = Random.Range(minLeafLength, maxLeafLength);
                    transform.Translate(Vector3.up * 1f * length);
                }
                else
                {
                    length = Random.Range(minBranchLength, maxBranchLength);
                    transform.Translate(Vector3.up * 1f * length);
                }

                currentTreeElement.lineRenderer.SetPosition(1, new Vector3(0, length, 0));
                currentTreeElement.lineRenderer.startWidth     = currentTreeElement.lineRenderer.startWidth * width;
                currentTreeElement.lineRenderer.endWidth       = currentTreeElement.lineRenderer.endWidth * width;
                currentTreeElement.lineRenderer.sharedMaterial = currentTreeElement.material;

                previousWasLeaf = isLeaf;
                break;

            // axiom, nothing happens
            case 'X':
                break;

            case '+':
                transform.Rotate(Vector3.forward * angle2d * (1f + variance / 100f * Random.Range(-1f, 1f)));
                break;

            case '-':
                transform.Rotate(Vector3.back * angle2d * (1f + variance / 100f * Random.Range(-1f, 1f)));
                break;

            case '*':
                transform.Rotate(Vector3.up * angle3d * (1f + variance / 100f * Random.Range(-1f, 1f)));
                break;

            case '/':
                transform.Rotate(Vector3.down * angle3d * (1f + variance / 100f * Random.Range(-1f, 1f)));
                break;

            case '[':
                savedTransforms.Push(new SavedTransform()
                {
                    position = transform.position,
                    rotation = transform.rotation
                });
                break;

            case ']':
                SavedTransform stack = savedTransforms.Pop();
                transform.position = stack.position;
                transform.rotation = stack.rotation;
                break;
            }
        }
    }
    private void DrawAlt()
    {
        for (int k = 0; k < currentPath.Length; k++)
        {
            switch (currentPath[k])
            {
            // 'F' Means a straight line-- continue on.
            case 'F':
                initalPosition = transform.position;

                GameObject treeSegment;

                bool isLeaf = false;
                if (currentPath[k + 1] % currentPath.Length == 'X' || currentPath[k + 3] % currentPath.Length == 'F' && currentPath[k + 4] % currentPath.Length == 'X')
                {
                    treeSegment = Instantiate(leaf);
                    isLeaf      = true;
                }
                else
                {
                    treeSegment = Instantiate(branch);
                }
                //treeSegment.transform.SetParent(gameObject.transform);
                //transform.position = initalPosition;
                treeSegment.transform.SetParent(gameObject.transform, false);
                transform.Translate(Vector3.up * maxBranchLength);
                //this.SetParent(treeSegment.transform, transform.parent);
                //GameObject treeSegment = Instantiate(branch);
                if (isLeaf)
                {
                    transform.Translate(Vector3.up * Random.Range(minLeafLength, maxLeafLength));
                    treeSegment.GetComponent <LineRenderer>().SetPosition(0, initalPosition);
                    treeSegment.GetComponent <LineRenderer>().SetPosition(1, transform.position);
                    treeSegment.GetComponent <LineRenderer>().startWidth = leafWidth;
                    treeSegment.GetComponent <LineRenderer>().endWidth   = 0;
                    //treeSegment.GetComponent<LineRenderer>().SetColors(leafColor, leafColor);
                    treeSegment.GetComponent <LineRenderer>().startColor = leafColor;
                    treeSegment.GetComponent <LineRenderer>().endColor   = leafColor;
                }
                else
                {
                    transform.Translate(Vector3.up * Random.Range(minBranchLength, maxBranchLength));
                    treeSegment.GetComponent <LineRenderer>().SetPosition(0, initalPosition);
                    treeSegment.GetComponent <LineRenderer>().SetPosition(1, transform.position);
                    treeSegment.GetComponent <LineRenderer>().startWidth = branchWidth;
                    treeSegment.GetComponent <LineRenderer>().endWidth   = branchWidth;
                    treeSegment.GetComponent <LineRenderer>().startColor = branchColor;
                    treeSegment.GetComponent <LineRenderer>().endColor   = branchColor;
                }
                break;

            case 'X':     // Do nothing, its just part of the algorithm
                break;

            case '+':     // Rotate clockwise
                transform.Rotate(Vector3.back * angle * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '-':     // Rotate counter-clockwise
                transform.Rotate(Vector3.forward * angle * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '*':
                transform.Rotate(Vector3.up * 120f * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '/':
                transform.Rotate(Vector3.down * 120f * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '[':     // Save current transform to stack
                savedTransforms.Push(new SavedTransform()
                {
                    position = transform.position,
                    rotation = transform.rotation
                });
                break;

            case ']':     // Pop saved transform from stack
                SavedTransform savedTransform = savedTransforms.Pop();
                transform.position = savedTransform.position;
                transform.rotation = savedTransform.rotation;
                break;
            }
        }
    }
    private void Draw()
    {
        for (int k = 0; k < currentPath.Length; k++)
        {
            switch (currentPath[k])
            {
            // 'F' Means a straight line-- continue on. In this particular implementation, it uses a fancy algorith to
            case 'F':
                initalPosition = transform.position;
                // By default, elements are NOT leaves
                bool isLeaf = false;

                GameObject currentElement;
                // I have no idea how this works, but it determines if the next element to draw should be a leaf or a branch.
                if (currentPath[k + 1] % currentPath.Length == 'X' || currentPath[k + 3] % currentPath.Length == 'F' && currentPath[k + 4] % currentPath.Length == 'X')
                {
                    currentElement = Instantiate(leaf);
                    isLeaf         = true;
                }
                else
                {
                    currentElement = Instantiate(branch);
                }

                // Make the newest element drawn inherit from the tree prefab (???)
                currentElement.transform.SetParent(tree.transform);

                TreeElement currentTreeElement = currentElement.GetComponent <TreeElement>();

                if (isLeaf)
                {
                    transform.Translate(Vector3.up * 2f * Random.Range(minLeafLength, maxLeafLength));
                    currentTreeElement.GetComponent <LineRenderer>().startWidth = 0;
                    currentTreeElement.GetComponent <LineRenderer>().endWidth   = leafWidth;
                    leafCount++;
                }
                else
                {
                    transform.Translate(Vector3.up * 2f * Random.Range(minBranchLength, maxBranchLength));
                    currentTreeElement.lineRenderer.startWidth = branchWidth;
                    currentTreeElement.lineRenderer.endWidth   = branchWidth;
                    branchCount++;
                }
                currentTreeElement.lineRenderer.SetPosition(0, initalPosition);
                currentTreeElement.lineRenderer.SetPosition(1, transform.position);
                currentTreeElement.lineRenderer.sharedMaterial = currentTreeElement.material;
                break;

            case 'X':
                break;

            case '+':
                transform.Rotate(Vector3.forward * angle * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '-':
                transform.Rotate(Vector3.back * angle * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '*':
                transform.Rotate(Vector3.up * 120f * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '/':
                transform.Rotate(Vector3.down * 120f * (1f + variance / 10f * randomRotations[k % randomRotations.Length]));
                break;

            case '[':
                SavedTransform savedTransformPush = new SavedTransform();
                savedTransformPush.position = transform.position;
                savedTransformPush.rotation = transform.rotation;
                savedTransforms.Push(savedTransformPush);
                break;

            case ']':
                SavedTransform savedTransformPop = savedTransforms.Pop();

                transform.position = savedTransformPop.position;
                transform.rotation = savedTransformPop.rotation;
                break;
            }
        }
        Debug.Log("leafCount : " + leafCount + " , branchCount : " + branchCount);
    }
Exemple #9
0
    public void Generate()
    {
        CancelAnimation();
        allLines      = new List <TreeElement>();
        boundsMinMaxX = new Vector2(float.MaxValue, float.MinValue);
        boundsMinMaxY = new Vector2(float.MaxValue, float.MinValue);

        Destroy(tree);
        tree = Instantiate(treeParent);

        //------------PART ONE - GROWING OF THE STRING/PATH--------------------------------
        //We are starting out to setting our currentString that is going to be our
        //"growing path" to our start position (the axiom)
        currentString = axiom;

        //We are using System.Text to make use of a stringbuilder
        StringBuilder stringBuilder = new StringBuilder();

        //We are looping through our iterations as we are repeating the process that many times.
        for (int i = 0; i < iterations; i++)
        {
            //We are then getting an array consisting of all the chars in our currentString,
            //because we want to loop over them.To check if our current set of rules contains
            //this char, if it does we want to apply our rules.
            //This is how our stirng will grow.
            char[] currentStringChars = currentString.ToCharArray();
            for (int j = 0; j < currentStringChars.Length; j++)
            {
                stringBuilder.Append(rules.ContainsKey(currentStringChars[j]) ? rules[currentStringChars[j]] : currentStringChars[j].ToString());
            }

            currentString = stringBuilder.ToString();
            stringBuilder = new StringBuilder();
        }
        //------------PART TWO - DRAWING OF THE LINES--------------------------------
        //We are starting out by looping over every character in our currentString
        //to then apply our instructions to each of them and draw the lines approprietly
        for (int k = 0; k < currentString.Length; k++)
        {
            switch (currentString[k])
            {
            case 'F':
                //Positioning Changes - Moving our Object up/Forwards
                initialPosition = transform.position;
                bool isLeaf = false;

                GameObject currentElement;
                //Since every F - so therefore every move forward is represented in a new Tree Element we need to decide
                //if this new Element should be a Leaf or a Branch.
                if (currentString[k + 1] % currentString.Length == 'X' || currentString[k + 3] % currentString.Length == 'F' &&
                    currentString[k + 4] % currentString.Length == 'X')
                {
                    currentElement = Instantiate(leaf);
                    isLeaf         = true;
                }
                else
                {
                    currentElement = Instantiate(branch);
                }

                currentElement.transform.SetParent(tree.transform);

                //Getting the currentTreeElement so that we can access the linerenderer
                TreeElement currentTreeElement = currentElement.GetComponent <TreeElement>();

                //Setting the LineRenderers start and endpoint aswell as its thiccness and color
                currentTreeElement.lineRenderer.SetPosition(0, initialPosition);

                if (isLeaf)
                {
                    transform.Translate(Vector3.up * 2f * Random.Range(minLeafLength, maxLeafLength));
                }
                else
                {
                    transform.Translate(Vector3.up * 2f * Random.Range(minlength, maxLength));
                }
                currentTreeElement.lineRenderer.SetPosition(1, transform.position);
                if (isLeaf)
                {
                    currentTreeElement.lineRenderer.startWidth = width * 2f;
                    currentTreeElement.lineRenderer.endWidth   = width / 4f;
                    currentTreeElement.isLeaf = true;
                }
                else
                {
                    currentTreeElement.lineRenderer.startWidth = width;
                    currentTreeElement.lineRenderer.endWidth   = width;
                }

                currentTreeElement.lineRenderer.sharedMaterial = currentTreeElement.lineMaterial;
                allLines.Add(currentTreeElement);
                break;

            case 'X':
                break;

            //For +,-,* and / we want to rotate in differenct directions.
            //We are using our Array of Random Directions here.
            case '+':
                transform.Rotate(Vector3.back * angle * (1 + variance / 100 * randomRotations[k % randomRotations.Length]));
                break;

            case '-':
                transform.Rotate(Vector3.forward * angle * (1 + variance / 100 * randomRotations[k % randomRotations.Length]));
                break;

            case '*':
                transform.Rotate(Vector3.up * 120f * (1f + variance / 100f * randomRotations[k % randomRotations.Length]));
                break;

            case '/':
                transform.Rotate(Vector3.down * 120f * (1f + variance / 100f * randomRotations[k % randomRotations.Length]));
                break;

            //Now, for the spikey bracket we are saving the current position and placing it at
            //the top of our Stack. The best way to explain this process is the following:
            //If we are trying to draw a tree on paper, which has multiple end points, as it has different branches and such
            //We will need to lift the pen off the paper every now and then. So what we are doing is we are saving
            //the position were we want to draw a branch at a later point. And then once we finished the current branch we were
            //working on we are going back to that saved position to add our new branch there.
            case '[':
                transformStack.Push(new SavedTransform(transform.position, transform.rotation));
                break;

            //We are getting the last saved transform from our strack and apply it to our gameobject.
            //to then continue from this position.
            case ']':
                SavedTransform savedTransform = transformStack.Pop();

                transform.position = savedTransform.Position;
                transform.rotation = savedTransform.Rotation;
                break;
            }

            //Calculating the bounds to make sure that our newly generated tree can be displayed
            boundsMinMaxX.x = Mathf.Min(transform.position.x, boundsMinMaxX.x);
            boundsMinMaxX.y = Mathf.Max(transform.position.x, boundsMinMaxX.y);
            boundsMinMaxY.x = Mathf.Min(transform.position.y, boundsMinMaxY.x);
            boundsMinMaxY.y = Mathf.Max(transform.position.y, boundsMinMaxY.y);
        }

        //Applying the calculated bounds minimum and maximum in comparison to the rect to our camera for scaling the viewport to our tree.
        float   aspect     = (float)Screen.width / Screen.height;
        Vector3 treeCentre = new Vector3(boundsMinMaxX.x + boundsMinMaxX.y, boundsMinMaxY.x + boundsMinMaxY.y) * .5f;
        float   treeHeight = boundsMinMaxY.y - boundsMinMaxY.x;
        float   treeWidth  = boundsMinMaxX.y - boundsMinMaxX.x;
        float   treeSize   = Mathf.Max(treeHeight, treeWidth * aspect);

        Camera.main.orthographic     = true;
        Camera.main.orthographicSize = treeSize * .5f + 1.5f;

        Camera.main.transform.position = treeCentre + Vector3.back + Vector3.left * Camera.main.orthographicSize * aspect * .5f;
    }
Exemple #10
0
 /// <summary>
 /// Reset to the time drag started.
 /// </summary>
 public void ResetPosition(SavedTransform savedTransform)
 {
     transform.position   = preTransform.position;
     transform.rotation   = preTransform.rotation;
     transform.localScale = preTransform.scale;
 }