C# Camera.WorldToScreenPoint方法代码示例

    void applyPlanarMapping(float imageWidth, float imageHeight, float _offsetX, float _offsetY, Camera mainCamera)
    {
        Mesh mesh = GetComponent<MeshFilter> ().mesh;
        Vector3[] vertices = mesh.vertices;
        Vector2[] uvs = mesh.uv;
        int count = mesh.vertexCount;
        //Debug.Log("mask count : "+count);

        if (vertices.Length != 0) {
            for (int i = 0; i < count; i++) {
                Vector3 vertexPos = vertices[i];
                //	Debug.Log("mask applyPlanarMapping count : "+count);
                if (vertexPos == null)
                    return;
                //	Debug.Log("mask applyPlanarMapping vertexPos : ");
                if (mainCamera == null)
                    return;
                //	Debug.Log("mask applyPlanarMapping mainCamera : ");
                vertexPos = localToWorld (vertexPos, mesh);
                Vector3 screenPos = mainCamera.WorldToScreenPoint (vertexPos);

                // calcul des nouvelles coordonées de texture
                float xT = (screenPos.x + _offsetX) / imageWidth;
                float yT = (screenPos.y + _offsetY) / imageHeight;
                uvs[i] = new Vector2 (xT, yT);
            }
        }
        mesh.uv = uvs;
    }

	public static bool CheckWithinScreen (Vector2 position, Camera camera, float distance) {
		Vector3 minScreenPosition = camera.WorldToScreenPoint(new Vector2(position.x - distance, position.y - distance));
		Vector3 screenPosition = camera.WorldToScreenPoint(position);
		float distanceInScreen = Math.Abs(screenPosition.x - minScreenPosition.x);
		return !(screenPosition.x + distanceInScreen <= 0 || screenPosition.x - distanceInScreen >= camera.pixelWidth || 
		         screenPosition.y + distanceInScreen <= 0 || screenPosition.y - distanceInScreen >= camera.pixelHeight);
	}

    void Start()
    {
        graphics = gameObject.GetComponent<MeshFilter>();
        screen = graphics.mesh;
        mainCamera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<Camera>();
        math = new screenMath(width, height, screen);

        lowerLeft = mainCamera.WorldToScreenPoint(screen.vertices[math.lookup(0, 0)[0]] + transform.position);
        upperRight = mainCamera.WorldToScreenPoint(screen.vertices[math.lookup(width-1, height-1)[3]] + transform.position);
    }

 public static void DrawLine(Camera cam, Vector3 pointA, Vector3 pointB, Color color, float width)
 {
     Vector2 p1 = Vector2.zero;
      p1.x = cam.WorldToScreenPoint(pointA).x;
      p1.y = cam.pixelHeight - cam.WorldToScreenPoint(pointA).y;
      Vector2 p2 = Vector2.zero;
      p2.x = cam.WorldToScreenPoint(pointB).x;
      p2.y = cam.pixelHeight - cam.WorldToScreenPoint(pointB).y;
      DrawLine(p1,p2,color,width);
 }

 public Vector2 SpriteScreenSize(GameObject o, Camera cam = null)
 {
     if (cam == null) cam = Camera.main;
     Vector2 sdim = new Vector2();
     Renderer ren = o.GetComponent<Renderer>() as Renderer;
     if (ren)
     {
         sdim = cam.WorldToScreenPoint(ren.bounds.max) -
             cam.WorldToScreenPoint(ren.bounds.min);
     }
     return sdim;
 }

    /// <summary>
    /// Calculates the box surrounding the collider
    /// </summary>
    /// <returns>The box</returns>
    /// <param name="collider">The collider of the element</param>
    public static Rect CalculateBox(Collider collider, Camera cam)
    {
        Rect box = new Rect();
        //Calculate size of overlay based on the objects size
        Vector3 max = collider.bounds.max;
        Vector3 min = collider.bounds.min;

        Vector3 lowerTopLeft = cam.WorldToScreenPoint(new Vector3(min.x, min.y, max.z));
        Vector3 lowerTopRight = cam.WorldToScreenPoint(new Vector3(max.x, min.y, max.z));
        Vector3 lowerBottomLeft = cam.WorldToScreenPoint(new Vector3(min.x, min.y, min.z));
        Vector3 lowerBottomRight = cam.WorldToScreenPoint(new Vector3(max.x, min.y, min.z));

        Vector3 upperTopLeft = cam.WorldToScreenPoint(new Vector3(min.x, max.y, max.z));
        Vector3 upperTopRight = cam.WorldToScreenPoint(new Vector3(max.x, max.y, max.z));
        Vector3 upperBottomLeft = cam.WorldToScreenPoint(new Vector3(min.x, max.y, min.z));
        Vector3 upperBottomRight = cam.WorldToScreenPoint(new Vector3(max.x, max.y, min.z));


        box.xMin = Mathf.Min(lowerTopLeft.x, lowerTopRight.x, lowerBottomLeft.x, lowerBottomRight.x, upperTopLeft.x, upperTopRight.x, upperBottomRight.x, upperBottomLeft.x) - 5;
        box.xMax = Mathf.Max(lowerTopLeft.x, lowerTopRight.x, lowerBottomLeft.x, lowerBottomRight.x, upperTopLeft.x, upperTopRight.x, upperBottomRight.x, upperBottomLeft.x) + 5;
        box.yMin = Screen.height - Mathf.Max(lowerTopLeft.y, lowerTopRight.y, lowerBottomLeft.y, lowerBottomRight.y, upperTopLeft.y, upperTopRight.y, upperBottomRight.y, upperBottomLeft.y) - 15;
        box.yMax = Screen.height - Mathf.Min(lowerTopLeft.y, lowerTopRight.y, lowerBottomLeft.y, lowerBottomRight.y, upperTopLeft.y, upperTopRight.y, upperBottomRight.y, upperBottomLeft.y) + 5;
        return box;

    }

    public void setText(GeneralSoldier soldier, string str)
    {
        if(true)
        {
            return;
        }

        //摄像机对象
        _camera = Camera.main;

        //获取角色head模型
        headTr = soldier.gameObject.transform.Find("head");

        //得到模型head坐标
        float size_y = headTr.position.y;

        //得到模型缩放比例
        float scal_y = transform.localScale.y;

        //乘积就是高度
        playerHeight = scal_y * size_y;

        //计算世界坐标
        worldPostion = new Vector3(soldier.gameObject.transform.position.x, soldier.gameObject.transform.position.y + playerHeight, soldier.gameObject.transform.position.z);

        //根据对象头顶的3D坐标换算成它在2D屏幕中的坐标
        postion = _camera.WorldToScreenPoint(worldPostion);

        //得到真实对象头顶的2D坐标
        postion = new Vector2(postion.x, Screen.height - postion.y);

        //设置伤害
        dmgText.text = str;

        //获取画布
        GameObject canvas = GameObject.Find("Canvas");
        dmgText.transform.SetParent(canvas.transform);

        //设置锚点
        RectTransform rt = dmgText.gameObject.transform as RectTransform;
        rt.anchoredPosition = Vector2.zero;
        dmgText.gameObject.transform.localScale = Vector3.one;

        //设置坐标
        dmgText.transform.position = postion;

        //缓动
        iTween.FadeTo(gameObject, 0.1f, 1);

        iTween.ScaleTo(gameObject, new Vector3(2, 2, 2), 1);

        Hashtable hxb = new Hashtable();
        hxb.Add("position", new Vector3(dmgText.transform.position.x, dmgText.transform.position.y + 180, dmgText.transform.position.z));
        hxb.Add("time", 1.1f);
        hxb.Add("easetype", iTween.EaseType.easeOutCubic);
        hxb.Add("oncomplete", "onAnimationEnd");
        hxb.Add("oncompletetarget", this.gameObject);
        hxb.Add("oncompleteparams", this.gameObject.name);
        iTween.MoveTo(gameObject, hxb);
    }

 // Use this for initialization
 void Awake()
 {
     _camera = GameObject.Find("Main Camera").GetComponent<Camera>();
     _myTransform = transform;
     _textPos = _camera.WorldToScreenPoint(transform.position);
     _boxSize = new Vector2(80, 25);
 }

    public static bool InCamera(Camera LookCamera, GameObject go, float VisionDistance)
    {
        #region 檢查是否在指定攝影範圍內
        if (LookCamera == null)
            return false;
        Collider collider = go.GetComponent<Collider>();
        if (collider == null)
            return false;
        Plane[] planes = GeometryUtility.CalculateFrustumPlanes(LookCamera);
        bool isOnCamera = GeometryUtility.TestPlanesAABB(planes, collider.bounds);
        if (!isOnCamera)
            return false;
        #endregion 檢查是否在指定攝影範圍內


        #region 檢查是否有遮蔽物
        //這是簡陋板，只能檢查無體中新點是否有被遮擋無法判定是否有任何地方有顯示
        #region 取得看到的物體
        if (LookCamera == null)
            return false;
        Vector3 screenPoint = LookCamera.WorldToScreenPoint(go.transform.position);
        Ray ray = LookCamera.ScreenPointToRay(screenPoint);
        RaycastHit hit;
        if (!Physics.Raycast(ray, out hit, VisionDistance))
            return false;
        #endregion 取得看到的物體

        //檢查看到的物件是否是自己
        bool result = hit.transform == go.transform;
        #endregion 檢查是否有遮蔽物


        return result;
    }

    // OBTAINED FROM http://answers.unity3d.com/questions/849117/46-ui-image-follow-mouse-position.html

    #region Canvas
    /// <summary>
    /// Calulates Position for RectTransform.position from a transform.position. Does not Work with WorldSpace Canvas!
    /// </summary>
    /// <param name="_Canvas"> The Canvas parent of the RectTransform.</param>
    /// <param name="_Position">Position of in world space of the "Transform" you want the "RectTransform" to be.</param>
    /// <param name="_Cam">The Camera which is used. Note this is useful for split screen and both RenderModes of the Canvas.</param>
    /// <returns></returns>
    public static Vector3 CalculatePositionFromTransformToRectTransform(this Canvas _Canvas, Vector3 _Position, Camera _Cam)
    {
        Vector3 Return = Vector3.zero;
        if (_Canvas.renderMode == RenderMode.ScreenSpaceOverlay)
        {
            Return = _Cam.WorldToScreenPoint(_Position);
        }
        else if (_Canvas.renderMode == RenderMode.ScreenSpaceCamera)
        {
            Vector2 tempVector = Vector2.zero;
            RectTransformUtility.ScreenPointToLocalPointInRectangle(_Canvas.transform as RectTransform, _Cam.WorldToScreenPoint(_Position), _Cam, out tempVector);
            Return = _Canvas.transform.TransformPoint(tempVector);
        }

        return Return;
    }

    public static Rect GUI3D(Camera camera, Vector3 pos, float width = 100, float height = 25)
    {
        Vector2 point = camera.WorldToScreenPoint(pos);

        Rect rect = new Rect(point.x, (Screen.height - point.y), width, height);

        return rect;
    }

 public static Vector3 WorldToCanvasPosition(Vector3 pos, Canvas canvas, Camera viewCam)
 {
     RectTransform canvasRectT = canvas.GetComponent<RectTransform>();
     Vector3 screenPos = viewCam.WorldToScreenPoint(pos);
     Vector3 worldPos = Vector2.zero;
     RectTransformUtility.ScreenPointToWorldPointInRectangle(canvasRectT, screenPos, canvas.worldCamera, out worldPos);
     return worldPos;
 }

	void Awake()
	{
		mainCamera = GameObject.Find("Main Camera").GetComponent<Camera>();
		enemyStats = new EnemyStats();
		enemyStatBarCreator = GameObject.Find("EnemyStats Canvas").GetComponent<EnemyStatBarCreation>();
		enemyStatBar = enemyStatBarCreator.CreateEnemyStatBar(mainCamera.WorldToScreenPoint(transform.position));
		enemyHealthText = enemyStatBar.transform.GetChild(1).GetComponent<Text>();
		enemySpeedText = enemyStatBar.transform.GetChild(3).GetComponent<Text>();
	}

    public static Rect GetScreenRect(Vector2[] worldPoints, Camera camera)
    {
        Vector2[] screenPoints = new Vector2[worldPoints.Length];
        for (int i = 0; i < worldPoints.Length; i++)
        {
            screenPoints[i] = camera.WorldToScreenPoint(worldPoints[i]);
        }

        return BuildScreenRect(screenPoints);
    }

 void Start()
 {
     cam = Camera.mainCamera;
     foreach (Tower t in FindObjectsOfType(typeof(Tower)) as Tower[]) {
         TowerOnScreen nT = new TowerOnScreen(t);
         Vector3 tPos = cam.WorldToScreenPoint(t.transform.position);
         nT.priceRect = new Rect(tPos.x - 25, Screen.height - tPos.y, 50, 20);
         towers.Add(nT);
     }
 }