C# UnityEngine.RectTransform类代码示例

        void Awake()
        {
            _resizedPanel = (ResizeParent ? transform.parent : transform) as RectTransform;

            var maximalSizeMargin = 10;
            _maximalSize = new Vector2(Screen.width - maximalSizeMargin, Screen.height - maximalSizeMargin);
        }

				public State(RectTransform rect) {

					this.anchorMin = rect.anchorMin;
					this.anchorMax = rect.anchorMax;
					this.to = rect.anchoredPosition;

				}

    // Use this for initialization
    void Start()
    {
        timescaleButtonImage = GameObject.Find("Timescale Button").GetComponent<Image>();
        buttonTargetColor = Color.white;
        timescaleInfoTransform = transform.GetComponent<RectTransform>();

        hiddenPos = timescaleInfoTransform.position;
        visiblePos = timescaleInfoTransform.position + new Vector3(340,0,0);
        timescaleInfoTransform.position = hiddenPos;

        activeColor = Color.white;
        inactiveColor = new Color(1,1,1,0.1f);

        nextUpgradeColorVisible 	= new Color(0,1,0,1);
        nextUpgradeColorTransparent = new Color(0,1,0,0.05f);

        timescaleImages = new RawImage[9];
        timescaleImages[0] = transform.Find("Current Timescale").Find("Timescale Bar").Find("1").GetComponent<RawImage>();
        timescaleImages[1] = transform.Find("Current Timescale").Find("Timescale Bar").Find("2").GetComponent<RawImage>();
        timescaleImages[2] = transform.Find("Current Timescale").Find("Timescale Bar").Find("3").GetComponent<RawImage>();
        timescaleImages[3] = transform.Find("Current Timescale").Find("Timescale Bar").Find("4").GetComponent<RawImage>();
        timescaleImages[4] = transform.Find("Current Timescale").Find("Timescale Bar").Find("5").GetComponent<RawImage>();
        timescaleImages[5] = transform.Find("Current Timescale").Find("Timescale Bar").Find("6").GetComponent<RawImage>();
        timescaleImages[6] = transform.Find("Current Timescale").Find("Timescale Bar").Find("7").GetComponent<RawImage>();
        timescaleImages[7] = transform.Find("Current Timescale").Find("Timescale Bar").Find("8").GetComponent<RawImage>();
        timescaleImages[8] = transform.Find("Current Timescale").Find("Timescale Bar").Find("9").GetComponent<RawImage>();

        ClearTimescale();
    }

 internal static void CalculateAnchorSnapValues(Transform parentSpace, Transform self, RectTransform gui, int minmaxX, int minmaxY)
 {
   for (int mainAxis = 0; mainAxis < 2; ++mainAxis)
   {
     RectTransformSnapping.s_SnapGuides[mainAxis].Clear();
     parentSpace.GetComponent<RectTransform>().GetWorldCorners(RectTransformSnapping.s_Corners);
     for (int index = 0; index < RectTransformSnapping.kSidesAndMiddle.Length; ++index)
     {
       float alongMainAxis = RectTransformSnapping.kSidesAndMiddle[index];
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(alongMainAxis, new Vector3[2]
       {
         RectTransformSnapping.GetInterpolatedCorner(RectTransformSnapping.s_Corners, mainAxis, alongMainAxis, 0.0f),
         RectTransformSnapping.GetInterpolatedCorner(RectTransformSnapping.s_Corners, mainAxis, alongMainAxis, 1f)
       }));
     }
     foreach (Transform transform in parentSpace)
     {
       if (!((Object) transform == (Object) self))
       {
         RectTransform component = transform.GetComponent<RectTransform>();
         if ((bool) ((Object) component))
         {
           RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(component.anchorMin[mainAxis], new Vector3[0]));
           RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(component.anchorMax[mainAxis], new Vector3[0]));
         }
       }
     }
     int num = mainAxis != 0 ? minmaxY : minmaxX;
     if (num == 0)
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(gui.anchorMax[mainAxis], new Vector3[0]));
     if (num == 1)
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(gui.anchorMin[mainAxis], new Vector3[0]));
   }
 }

    public bool Add(RectTransform child, bool forceAdd = false)
    {
        bool canAdd = child.rect.width <= AvailableWidth;

        if (!canAdd && !forceAdd)
        {
            return false;
        }

        UpdateHeightForChild(child);

        if (canAdd)
        {
            child.SetParent(transform, false);
            child.SetAsLastSibling();

            CurrentWidth += child.rect.width;
        }
        else
        {
            GameObject containerObject = new GameObject("LineForceContainer");
            RectTransform containerTransformRect = containerObject.AddComponent<RectTransform>();
            containerTransformRect.SetParent(transform, false);
            containerTransformRect.SetAsLastSibling();

            LayoutElement containerLayoutElement = containerObject.AddComponent<LayoutElement>();
            containerLayoutElement.preferredWidth = AvailableWidth;
            containerLayoutElement.preferredHeight = child.rect.height;

            CurrentWidth += containerLayoutElement.preferredWidth;
        }
        return true;
    }

    public void UpdatePosition(RectTransform goToObject)
    {
        if (goToObject == null) return;

        gotoX = goToObject.rect.xMin - (goToObject.rect.width / 2);
        gotoY = goToObject.position.y + 0.2f;
    }

//--------------------------------------------------------------------------------------------

	void Start ()
	{
		// get handle on player script
		playerScript = GetComponent<Player> ();
		if(playerScript.chassisQuick) 
		{
			rechargeRate *= playerScript.cooldownBoost;
		}

		energyBar = GameObject.Find("EnergyBar").GetComponent<RectTransform>();
		origin = energyBar.localPosition;

		energySprites = Resources.LoadAll<Sprite>("GUI_Assets/EnergyIcons");
		energyImg = GameObject.Find("EnergyImg").GetComponent<Image>();
		blinkCoroutine = null;

		//init emp area prefab
		empAreaPrefab = Resources.Load<GameObject>("PlayerBullets/EMPArea");

		currEnergy = maxEnergy;
		isOnCooldown = false;

		//get handle on audio source for secondary ready
		readyAudio = GetComponents<AudioSource>()[1];
	}

	public void OnBeginDrag (PointerEventData eventData)
	{
		originPos = rt.position;
		fatherRT = rt.parent.GetComponent<RectTransform>();
		cg.blocksRaycasts = false;
		isDrag = true;
	}

    	void Start()
    	{
		colRectTransform = itemPrefab.GetComponent<RectTransform> ();
		containerRectTransform = gameObject.GetComponent<RectTransform> ();
		cardHeight = containerRectTransform.rect.height;
		cardWidth = colRectTransform.rect.width;
    	}

	void Awake()
	{
		foodSprites = new Sprite[foodNum];
		orderedName = new string[foodNum];
		panelRT = GameObject.FindWithTag ("Panel").GetComponent<RectTransform>() ;
		cells = new GameObject[foodNum];
	}

	void Start ()
	{
		if(canvas != null){
			scaleFactor = canvas.scaleFactor;
		}
		rect_transform = GetComponent<RectTransform>();
	}

 void Start()
 {
     tran = GetComponent <RectTransform> ();
     sizelength = Mathf.Min (tran.rect.width, tran.rect.height);
     Init ();
     print (tran.rect);
 }

    void Awake()
    {
        timeLastEnemyHitted = Time.time;
        trigger = GetComponentInChildren<BoxCollider>();
        sprite = transform.GetComponentInChildren<SpriteRenderer>();

        glitchPartPool = new ObjectPool(glitchPart);
        lives = 3;
        items = 0;

        //Instantiate the glitch fragments to avoid lag later in the game
        GameObject[] parts = new GameObject[100];
        for (int i = 0; i < 100; i++)
        {
            parts[i] = glitchPartPool.getObject();
        }
        for (int i = 0; i < 100; i++)
        {
            parts[i].SetActive(false);
        }

        boxUIActivatedRectTransform = boxUIActivated.GetComponent<RectTransform>();
        exclamationSize = boxUIActivatedRectTransform.sizeDelta;
        boxUIActivated.SetActive(false);
        guiRectTrans = gui.GetComponent<RectTransform>();
        slowFPSScript = transform.FindChild("Powers").GetComponentInChildren<SlowFPS>();
    }

    // Use this for initialization
    void Start()
    {
        Invoke("ShowContinueText", 5);

        startTime = Time.realtimeSinceStartup;

        tScaler = GameObject.Find("Time Manager").GetComponent<TimeScaler>();

        boxTransform 			= GetComponent<RectTransform>();
        backgroundTransform 	= transform.parent.GetComponent<RectTransform>();
        gradientTransform 		= transform.Find("Background Gradient").GetComponent<RectTransform>();
        topBorder			 	= transform.Find("Top Border").GetComponent<RectTransform>();
        bottomBorder 			= transform.Find("Bottom Border").GetComponent<RectTransform>();

        boxImage 				= GetComponent<RawImage>();
        backgroundImage 		= transform.parent.GetComponent<RawImage>();
        gradientImage 			= transform.Find("Background Gradient").GetComponent<RawImage>();
        topImage			 	= transform.Find("Top Border").GetComponent<RawImage>();
        bottomImage 			= transform.Find("Bottom Border").GetComponent<RawImage>();
        iconImage				= transform.Find("Info Icon").GetComponent<RawImage>();

        tutorialText			= transform.Find("Tutorial Text").GetComponent<Text>();
        continueText			= transform.Find("Continue Text").GetComponent<Text>();

        SetStartingColors();

        i = 0;
    }

 public static void SetRectAsFullScreen(ref RectTransform targetTrans)
 {
     targetTrans.anchorMin = Vector2.zero;
     targetTrans.anchorMax = Vector2.one;
     targetTrans.offsetMin = Vector2.zero;
     targetTrans.offsetMax = Vector2.zero;
 }