Unity3d人物头顶坐标 取得在场景中头顶坐标

最新推荐文章于 2023-11-21 15:52:42 发布
最新推荐文章于 2023-11-21 15:52:42 发布
阅读量1.5k 收藏
点赞数
分类专栏： unity3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013628121/article/details/99737270
版权
本文介绍了一种在Unity中获取人物模型尺寸的方法，包括头顶、中部和底部坐标。通过遍历模型的所有渲染器组件，计算出包围盒的最高点、中心点和最低点，适用于动画播放时的尺寸变化调整。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 红色球标识头顶,黄色中部,黑色底部,蓝色是包围盒8个点,红线是包围盒范围

第二版

实现步奏

获取 物体下的所有Renderer,然后通过Renderer.bounds 外扩包围盒  找到 最高上\ 中 \最低的下 这3个点
缺点 播放动画时  外扩包围盒 随着动画 缩放  top点会上下移动 , 比如抬手动画
注意:
Renderer 包含了所有  SkinnedMeshRenderer 和 MeshFilter 
Renderer .bounds 外扩包围盒 已经是世界坐标了,

using System;
using System.Linq;
using UnityEngine;
public struct meshBoundsPoint
{
    public meshBoundsPoint(Vector3 top, Vector3 center, Vector3 bottom)
    {
        this.top = top;
        this.center = center;
        this.bottom = bottom;
    }
    public meshBoundsPoint(Bounds bounds)
    {
        center = bounds.center;
        var hight_y = bounds.size.y;
        var topPoint = center;
        topPoint.y += hight_y * 0.5f;
        var bottomPoint = center;
        bottomPoint.y -= hight_y * 0.5f;
        top = topPoint;
        bottom = bottomPoint;
    }
    public Vector3 top;
    public Vector3 center;
    public Vector3 bottom;
}

public enum meshBoundsType
{
    top = 0,
    center,
    bottom,
}

public class ModelSizeGet : MonoBehaviour
{
    public static meshBoundsPoint GetSize(Transform transform)
    {
        Renderer[] renders = transform.GetComponentsInChildren<Renderer>();
        var arr = new meshBoundsPoint[renders.Length];
        int i = -1;
        foreach (var render in renders)
        {
            arr[++i] = new meshBoundsPoint(render.bounds);
            // DrawWorldBoundLine(bounds, Color.white, 0.1f);
        }
        var order = arr.OrderByDescending(x => x.top.y);
        var maxY = order.First().top;
        var order2 = arr.OrderByDescending(x => x.bottom.y);
        var minY = order2.Last().bottom;
        float hight = maxY.y - minY.y;
        var centerPos = minY;
        centerPos.y = minY.y + hight * 0.5f;
        maxY.x = minY.x;
        maxY.z = minY.z;
        return new meshBoundsPoint(maxY,centerPos,minY);
    }

    public   static Vector3 GetSize(Transform transform,meshBoundsType mp)
    {
        var pos = GetSize(transform);
        switch (mp)
        {
            case meshBoundsType.top:
                return pos.top;
                break;
            case meshBoundsType.center:
                return pos.center;
                break;
            case meshBoundsType.bottom:
                return pos.bottom;
                break;
            default:
                throw new ArgumentOutOfRangeException("mp", mp, null);
        }
    }

    public static void DrawLocalBoundLine(Bounds bounds, Transform sourceTran, Color color = default(Color), float duration = float.MaxValue)
    {
        Vector3[] points = new Vector3[8];

        var width_x = bounds.size.x * sourceTran.lossyScale.x;
        var hight_y = bounds.size.y * sourceTran.lossyScale.y;
        var length_z = bounds.size.z * sourceTran.lossyScale.z;

        var LeftBottomPoint = sourceTran.TransformPoint(bounds.min);
        var rightUpPoint = sourceTran.TransformPoint(bounds.max);
        var centerPoint = sourceTran.TransformPoint(bounds.center);
        var topPoint = new Vector3(centerPoint.x, centerPoint.y + hight_y / 2, centerPoint.z);
        var bottomPoint = new Vector3(centerPoint.x, centerPoint.y - hight_y / 2, centerPoint.z);

        points[0] = LeftBottomPoint + Vector3.right * width_x;
        points[1] = LeftBottomPoint + Vector3.up * hight_y;
        points[2] = LeftBottomPoint + Vector3.forward * length_z;

        points[3] = rightUpPoint - Vector3.right * width_x;
        points[4] = rightUpPoint - Vector3.up * hight_y;
        points[5] = rightUpPoint - Vector3.forward * length_z;

        points[6] = LeftBottomPoint;
        points[7] = rightUpPoint;



        Debug.DrawLine(LeftBottomPoint, points[0], color, duration);
        Debug.DrawLine(LeftBottomPoint, points[1], color, duration);
        Debug.DrawLine(LeftBottomPoint, points[2], color, duration);

        Debug.DrawLine(rightUpPoint, points[3], color, duration);
        Debug.DrawLine(rightUpPoint, points[4], color, duration);
        Debug.DrawLine(rightUpPoint, points[5], color, duration);

        Debug.DrawLine(points[1], points[3], color, duration);
        Debug.DrawLine(points[2], points[4], color, duration);
        Debug.DrawLine(points[0], points[5], color, duration);

        Debug.DrawLine(points[2], points[3], color, duration);
        Debug.DrawLine(points[0], points[4], color, duration);
        Debug.DrawLine(points[1], points[5], color, duration);


        //Debug.DrawLine(topPoint, centerPoint, color, duration);
        //Debug.DrawLine(bottomPoint, centerPoint, color, duration);

        //foreach (var item in points)
        //{
        //    DrawPoint(item, color, duration);
        //}

    }


    public static void DrawWorldBoundLine(Bounds bounds, Color color = default(Color), float duration = float.MaxValue)
    {
        Vector3[] points = new Vector3[8];

        var width_x = bounds.size.x ;
        var hight_y = bounds.size.y ;
        var length_z = bounds.size.z ;

        var LeftBottomPoint = bounds.min;
        var rightUpPoint = bounds.max;
        var centerPoint = bounds.center;
        var topPoint = new Vector3(centerPoint.x, centerPoint.y + hight_y / 2, centerPoint.z);
        var bottomPoint = new Vector3(centerPoint.x, centerPoint.y - hight_y * 0.5f, centerPoint.z);

        points[0] = LeftBottomPoint + Vector3.right * width_x;
        points[1] = LeftBottomPoint + Vector3.up * hight_y;
        points[2] = LeftBottomPoint + Vector3.forward * length_z;

        points[3] = rightUpPoint - Vector3.right * width_x;
        points[4] = rightUpPoint - Vector3.up * hight_y;
        points[5] = rightUpPoint - Vector3.forward * length_z;

        points[6] = LeftBottomPoint;
        points[7] = rightUpPoint;



        Debug.DrawLine(LeftBottomPoint, points[0], color, duration);
        Debug.DrawLine(LeftBottomPoint, points[1], color, duration);
        Debug.DrawLine(LeftBottomPoint, points[2], color, duration);

        Debug.DrawLine(rightUpPoint, points[3], color, duration);
        Debug.DrawLine(rightUpPoint, points[4], color, duration);
        Debug.DrawLine(rightUpPoint, points[5], color, duration);

        Debug.DrawLine(points[1], points[3], color, duration);
        Debug.DrawLine(points[2], points[4], color, duration);
        Debug.DrawLine(points[0], points[5], color, duration);

        Debug.DrawLine(points[2], points[3], color, duration);
        Debug.DrawLine(points[0], points[4], color, duration);
        Debug.DrawLine(points[1], points[5], color, duration);


        //Debug.DrawLine(topPoint, centerPoint, color, duration);
        //Debug.DrawLine(bottomPoint, centerPoint, color, duration);

        //foreach (var item in points)
        //{
        //    DrawPoint(item, color, duration);
        //}

    }

    public static Transform DrawPoint(Vector3 pos, Color color = default(Color), float duration = float.MaxValue)
    {
        var scale = 0.08f;
        var temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        temp.transform.position = pos;
        temp.transform.localScale = new Vector3(scale, scale, scale);
        temp.GetComponent<Renderer>().material.color = color;
        var light = temp.AddComponent<Light>();
        light.type = LightType.Point;
        light.color = color;
       GameObject.Destroy(temp.GetComponent<Collider>());
        GameObject.Destroy(temp, duration);
        return temp.transform;
    }

    void OnDrawGizmos()
    {
        DrawGizmos(new Color(0, 0, 0, 0.2f));
    }
    void OnDrawGizmosSelected() { DrawGizmos(new Color(0, 0, 1, .2f)); }
    void DrawGizmos(Color col)
    {
        Gizmos.color = col;
        Renderer[] renders = transform.GetComponentsInChildren<Renderer>();
        foreach (var render in renders)
        {
            Gizmos.DrawCube(render.bounds.center, render.bounds.size);

        }
    }


    void Update()
    {
        var pos = GetSize(transform);
        DrawPoint(pos.top, Color.red, 0.1f);
        DrawPoint(pos.center, Color.green, 0.1f);
        DrawPoint(pos.bottom, Color.blue, 0.1f);
    }

}

 

 

 

第一版

实现步奏

取该物体上的所有SkinnedMeshRenderer组件,然后从取得模型数组中找出顶点最多的模型,就是人物身体模型,因为人物身体模型顶点面片肯定是最多,然后通过模型取得包围盒,然后就把包围盒从模型坐标转成世界坐标.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

/// <summary>
/// 通过包围盒取得人物在场景中头顶中间底部坐标
/// </summary>
public class ESize : MonoBehaviour
{
    /// <summary>
    /// 是否开启辅助画线画点
    /// </summary>
    public bool isDrawPointLine = false;

    public float width_x;
    public float hight_y;
    public float length_z;

    public Vector3 topPoint = Vector3.zero;
    public Vector3 centerPoint = Vector3.zero;
    public Vector3 bottomPoint = Vector3.zero;
    public Vector3 LeftBottomPoint = Vector3.zero;
    public Vector3 rightUpPoint = Vector3.zero;

    public Transform topTran;
    public Transform bottomTran;
    public Transform centerTran;


    public Transform rootBone;
    public Bounds bounds = new Bounds();
    public Transform boundsTransform;

    public Transform cubeTransform;

    Vector3[] points = new Vector3[8];
    /// <summary>
    /// 找到身体的 bounds
    ///因为模型中有好多部件 比如眼睛 武器等 但是我们只要人物身体都模型，因为人物身体模型顶点面片肯定是最多, 比武器这些多
    /// </summary>
    /// <returns></returns>
    void FindBodyBounds()
    {
        Object[] arr;

        arr = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();//人物角色模型用SkinnedMeshRenderer 而普通模型用 MeshFilter
        if (arr == null || arr.Length == 0)
        {
            arr = gameObject.GetComponentsInChildren<MeshFilter>();
        }
        if (arr == null || arr.Length == 0)
        {
            Debug.LogError(gameObject.name = ", no  Find Bounds");
        }



        if (arr != null)
        {
            int maxCount = 0;
            foreach (var item in arr)
            {
                if (item is SkinnedMeshRenderer)
                {
                    var i = (SkinnedMeshRenderer)item;
                    if (i.sharedMesh.vertices.Length > maxCount)
                    {
                        maxCount = i.sharedMesh.vertices.Length;
                        bounds = i.sharedMesh.bounds;
                        rootBone = i.rootBone;
                        boundsTransform = i.gameObject.transform;

                      //  Debug.Log("物体名称：" + i.gameObject.name + ",顶点坐标数量 :" + i.sharedMesh.vertices.Length + ",三角形序列数量 :" + i.sharedMesh.triangles.Length + ",纹理数量 :" + i.sharedMesh.uv.Length + ",法线数量 :" + i.sharedMesh.normals.Length);
                    }

                }
                else if (item is MeshFilter)
                {
                    var i = (MeshFilter)item;

                    if (i != null && i.mesh != null)
                    {
                        if (i.mesh.vertices.Length > maxCount)
                        {

                            maxCount = i.mesh.vertices.Length;
                            bounds = i.mesh.bounds;
                            boundsTransform = i.gameObject.transform;
                           // Debug.Log("物体名称：" + i.gameObject.name + ",顶点坐标数量 :" + i.sharedMesh.vertices.Length + ",三角形序列数量 :" + i.sharedMesh.triangles.Length + ",纹理数量 :" + i.sharedMesh.uv.Length + ",法线数量 :" + i.sharedMesh.normals.Length);
                        }
                    }
                    else
                    {
                        Debug.LogError(i.gameObject.name = ", no  Find MeshFilter");

                    }



                }
            }
        }
        if(bounds==null || boundsTransform == null)
        {
            Debug.LogError(gameObject.name = ", no  Find MeshFilter");
        }
    }

    void CalculationPoint()
    {

        LeftBottomPoint = transform.TransformPoint(bounds.min);
        rightUpPoint = transform.TransformPoint(bounds.max);
        centerPoint = transform.TransformPoint(bounds.center);

        width_x = bounds.size.x * boundsTransform.lossyScale.x;
        hight_y = bounds.size.y * boundsTransform.lossyScale.y;
        length_z = bounds.size.z * boundsTransform.lossyScale.z;

        topPoint = centerPoint;
        topPoint.y += hight_y/2;

        bottomPoint = centerPoint;
        bottomPoint.y -= hight_y / 2;
        if(Terrain.activeTerrain)
        {
            var Terrain_hight = Terrain.activeTerrain.SampleHeight(bottomPoint);
            bottomPoint.y = Terrain_hight + 0.2f;
        }



       // Debug.Log("物体名称：" + boundsTransform.name +
            //",长 :" + length_z +
            //",宽：" + +width_x +
            //",高：" + hight_y +

            //     ",topPoint" + topPoint +
            //          ",centerPoint" + centerPoint +
            //               ",bottomPoint" + bottomPoint
            //);

        points[0] = LeftBottomPoint + Vector3.right * width_x;
        points[1] = LeftBottomPoint + Vector3.up * hight_y;
        points[2] = LeftBottomPoint + Vector3.forward * length_z;

        points[3] = rightUpPoint - Vector3.right * width_x;
        points[4] = rightUpPoint - Vector3.up * hight_y;
        points[5] = rightUpPoint - Vector3.forward * length_z;

        points[6] = LeftBottomPoint;
        points[7] = rightUpPoint;

        //如果轴向不对的话,这时候就需要旋转,不规范模型,懒得不计算包围盒的8个点，只计算上中下了-----------------
        if (true)
        {

            if(rootBone==null)
            {
                var hight = 1.65f;
                var nav = gameObject.GetComponent<NavMeshAgent>();
                if (nav)
                {
                    hight = nav.height;
                }
                if (Terrain.activeTerrain)
                {
                    var Terrain_hight = Terrain.activeTerrain.SampleHeight(boundsTransform.position);
                    bottomPoint.y = Terrain_hight + 0.2f;
                    topPoint.y += hight;
                    centerPoint.y += hight / 2;
                }
                else
                {
                    bottomPoint = boundsTransform.position;
                    topPoint = centerPoint;
                    topPoint.y += hight;
                    centerPoint.y += hight / 2;
                }

            }
            else
            {
                TryGet();
            }

          
        }
    }

    void TryGet()
    {//如果轴向不对的话,这时候就需要旋转,不规范模型,懒得不计算包围盒的8个点，只计算上中下了-----------------
        var temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
        cubeTransform = temp.transform;
        temp.transform.position = centerPoint;
        temp.transform.localScale = new Vector3(width_x, hight_y, length_z);
        temp.GetComponent<Renderer>().material.color = new Color(0, 1, 0, 1f / 255f);
        Destroy(temp.GetComponent<Collider>());
        Destroy(temp.GetComponent<MeshRenderer>());


        if (boundsTransform.localEulerAngles != Vector3.zero)
        {
            cubeTransform.localEulerAngles = boundsTransform.localEulerAngles;
            var upDirect = cubeTransform.up.normalized;

            if (rootBone != null)
            {
                centerPoint = cubeTransform.position = rootBone.position;

                var y = hight_y;
                var x = width_x;
                var z = length_z;
                if (upDirect.y == 1.0f)//y轴正直向上。
                {
                    return;
                }
                else if (upDirect.x == -1f)//=-1,x轴垂直的朝上，=1,x轴垂直的朝下
                {
                    y = width_x;
                    x = hight_y;
                }
                else if (upDirect.z == -1f)//z轴朝上
                {
                    y = length_z;
                    z = hight_y;
                }

                topPoint = centerPoint;
                topPoint.y += y / 2;

                bottomPoint = centerPoint;
                bottomPoint.y -= y / 2;

                temp.name = boundsTransform.name + ",x :" + x + ",y：" + +y + ",z：" + z;

                points[6] = bottomPoint;
                points[7] = topPoint;
                //Debug.LogError("cube.up.normalized" + cubeTransform.up.normalized);
            }
        }
    }

    void DrawBoundsPoint()
    {
        GameObject temp = null;
        float scale = 0.08f;

        //temp = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //temp.transform.position = centerPoint;
        //temp.transform.localScale = new Vector3(width_x, hight_y, length_z);
        //temp.GetComponent<Renderer>().material.color = new Color(0, 1, 0, 1f / 255f);
        //Destroy(temp.GetComponent<Collider>());
        //temp.name = boundsTransform.name + ",x :" + width_x + ",y：" + hight_y + ",z：" + length_z ;
        //Destroy(temp.GetComponent<MeshRenderer>());

        temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        temp.transform.parent = transform;
        temp.transform.localScale = new Vector3(scale, scale, scale);
        temp.transform.position = topPoint;
        temp.GetComponent<Renderer>().material.color = Color.red; //当材质球的Shader为标准时,可直接使用此方法修改颜色值
        Destroy(temp.GetComponent<Collider>());
        if (!isDrawPointLine) Destroy(temp.GetComponent<Renderer>());
        topTran = temp.transform;
        topTran.name = "topTran";

        temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        temp.transform.parent = transform;
        temp.transform.position = centerPoint;
        temp.transform.localScale = new Vector3(scale, scale, scale);
        temp.GetComponent<Renderer>().material.color = Color.yellow; //当材质球的Shader为标准时,可直接使用此方法修改颜色值
        Destroy(temp.GetComponent<Collider>());
        if (!isDrawPointLine) Destroy(temp.GetComponent<Renderer>());
        centerTran = temp.transform;
        centerTran.name = "centerTran";


        temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        temp.transform.parent = transform;
        temp.transform.position = bottomPoint;
        temp.transform.localScale = new Vector3(scale, scale, scale);
        temp.GetComponent<Renderer>().material.color = Color.black; //当材质球的Shader为标准时,可直接使用此方法修改颜色值
        Destroy(temp.GetComponent<Collider>());
        if (!isDrawPointLine) Destroy(temp.GetComponent<Renderer>());
        bottomTran = temp.transform;
        bottomTran.name = "bottomTran";


        if (isDrawPointLine)
        for (int i = 0; i < points.Length; i++)
        {

            temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            temp.name = boundsTransform.name + "]points[" + i + "]";
            temp.transform.position = points[i];
            temp.transform.localScale = new Vector3(scale, scale, scale);
            temp.GetComponent<Renderer>().material.color = Color.blue; //当材质球的Shader为标准时,可直接使用此方法修改颜色值
            Destroy(temp.GetComponent<Collider>());

        }


    }

    void DrawBoundsLine()
    {
        Color color = Color.red;
        Debug.DrawLine(LeftBottomPoint, points[0], color);
        Debug.DrawLine(LeftBottomPoint, points[1], color);
        Debug.DrawLine(LeftBottomPoint, points[2], color);

        Debug.DrawLine(rightUpPoint, points[3], color);
        Debug.DrawLine(rightUpPoint, points[4], color);
        Debug.DrawLine(rightUpPoint, points[5], color);

        Debug.DrawLine(points[1], points[3], color);
        Debug.DrawLine(points[2], points[4], color);
        Debug.DrawLine(points[0], points[5], color);

        Debug.DrawLine(points[2], points[3], color);
        Debug.DrawLine(points[0], points[4], color);
        Debug.DrawLine(points[1], points[5], color);


        Debug.DrawLine(topPoint, centerPoint, color);
        Debug.DrawLine(bottomPoint, centerPoint, color);

    }

    bool isInit = false;
    public ESize Init()
    {
        if(!isInit)
        {
            FindBodyBounds();
            CalculationPoint();

            DrawBoundsPoint();
            isInit = true;
        }
        return this;
    }

    void Start()
    {

        Init();
    }

    // Update is called once per frame
   void Update()
    {
        if (isDrawPointLine)
            DrawBoundsLine();
    }



}

 

【unity小技巧】unity最完美的CharacterController 3d角色控制器，实现移动、跳跃、下蹲、奔跑、上下坡、物理碰撞效果，复制粘贴即用（2024/12/12补充）
向宇
12-16 2万+
其实一开始我是不打算写的，我感觉这种简单的功能，网上随便一搜一大堆，但是我发现网上很多都是复制粘贴，要么没有实操过，要么就是功能不全，或者毫无解释的把代码丢出来，我自以为简单的3D角色控制，我整整花了3-4天才研究明白（虽然每天只花几个小时），下面是记录我的一些思路过程，希望对你有帮助。【用unity实现100个游戏之18】从零开始制作一个类CSGO/CS2、CF第一人称FPS射击游戏——基础篇1。
Unity 3D游戏开发从入门进阶到高级
最新发布
2401_86900375的博客
01-06 2570
本文精心整理了Unity3D游戏开发相关的学习资料，涵盖入门、进阶、性能优化、面试和书籍等多个维度，旨在为Unity开发者提供全方位、高含金量的学习指南.欢迎收藏
Unity测试模型顶点坐标
01-25
测试导入unity的模型顶点坐标数据 导入模型
Unity3D Kinect 实时显示对象的头部图像
永远在身边的专栏
04-22 4005
最近在做一个Unity+Kinect 的项目，因为涉及一些姿势的识别，所以要锁定一个识别的骨架，但是用户怎么知道我锁定的骨架是谁呢？于是想到一个方法，那就是把当前的锁定的骨架的对象的头部图片展示出来，那么这样用户就知道当前检测的是谁啦~ 话不多说，先展示一下demo，最终的一个展示效果~ 有了这个想法，那么我们就来开始动手做吧，查找了一些资料，但是一输入关键词头部或者face什么的都是一些U
unity 获取和设置gameObject的坐标
热门推荐
bangshudi0384的博客
10-10 2万+
// 获取Player变量指定的对象的三围坐标 Vector3 player_postion = Player.transform.position; // 获取X,Y,Z值 float x = player_postion.x; float y = player_postion.y; float z = player_postion.z; // 设置应用了...
Unity中存在的坐标系
weixin_44876165的博客
10-22 702
在不同的情况下使用不同的坐标系更加方便，所以在Unity中有多种坐标系： 全局坐标系 World Coordinate System 局部坐标系 Local Coordinate System 屏幕坐标系 Screen Space 视口坐标系 ViewPort Space 全局坐标系     全局坐标系是用于描述场景内所有物体位置的方向的基准，也称为世界坐标系。     在Unity中创建的物体都是以全局坐标系中的坐标原点（0,0,0），来确定各自的位置的。     可以使用transform.posit
Unity开发备忘录000012：VR头部射线交互
老孙头
05-10 1808
戴上VR头盔，我们就被带进了另一个世界，常用的鼠标和键盘被我们遗忘在现实世界中了，在虚拟世界中的交互成为了一个大问题，好在Unity给我们准备了一个射线机制（这个大家不陌生，在“Unity开发备忘录000009：鼠标交互”一篇中我们用过），从而，我们找到了在VR设计中最简单的一个交互方法——头部射线交互。 Unity中的射线是一种碰撞检测机制，它是3D空间中的一点向一个方向发射的一条虚拟直线...
Unity3D之人物头顶名称与血条更新与绘制
小小姑娘
12-05 752
背景是黑色的，前面是红色的，当人物费血时红色血条减少。可以拿到模型对应三个轴向的高度，但是模型是可以缩放的，所以真实的模型高度应当是原始高度乘以缩放系数才行。做为游戏的地面，然后利用角色控制器组件创建两个模型，一个做为主角，一个作为。可以拿到模型对应三个轴向的缩放系数，因为这里我们需要模型的高度，所以忽略。人物的名称与血条的绘制方法很简单，但是我们需要解决的问题是如何在。的名称是可变的，所以我们需要动态的获取整体的显示区域。意思是拿红色血条的贴图的宽高，它将保存在返回的。世界中的人物是会移动的，它是在。
unity头顶状态制作_Unity里名字牌、血条等头顶挂件的实现
weixin_42613018的博客
01-13 814
Unity里实现人物头顶的名字牌、血条的实现，网上很多博客有提到过。这里结合自己在项目中的开发，简单总结几点。宣雨松的热门博客里有提到过直接利用Unity自身的OnGUI()实现人物血条：http://www.xuanyusong.com/archives/1032。撇开血条进度条的更新，重点关注头顶物件位置的更新。简化之，实现人物头顶的名字牌的。核心代码如下：using UnityEngine...
Unity 抬头显示 超出屏幕外跟踪标记
一点没什么技术含量的经验分享
04-10 947
游戏中经常会需要实现屏幕外标记指示的功能，这样能方便玩家快速定位目标方位，尤其在多人网络游戏中出现（守望先锋，彩虹六号，Apex英雄等等），现在用Unity快速实现
Unity3D研究院之人物头顶名称与血条更新与绘制（二十六）
chenluwolf的专栏
03-04 1867
http://www.xuanyusong.com/archives/1032       人物的名称与血条的绘制方法很简单，但是我们需要解决的问题是如何在3D世界中寻找合适的坐标。因为3D世界中的人物是会移动的，它是在3D世界中移动，并不是在2D平面中移动，但是我们需要将3D的人物坐标换算成2D平面中的坐标，继而找到人物头顶在屏幕中的2D坐标最后使用GUI将名称与血条绘制出来。
[Unity][特效][UGUI]HUD围绕角色头顶的血条特效逐渐减血逐渐加血
BuladeMian的博客，菜得抠脚，菜得真实
03-15 4069
      using System.Collections; using System.Collections.Generic; using UnityEngine; public class LookAtCameraYonly : MonoBehaviour { public Camera cameraToLookAt; void Update() ...
Unity + NGUI 实现人物头顶UI的信息展示
weixin_30535167的博客
04-04 259
1、思路： 　　(1)信息数据：需要展示属性信息 　　(2)信息的展示：负责显示UI属性信息 　　(3)UI的跟随：负责实现UI对人物的跟随 　　(4)UI的管理：负责对UI进行创建于回收，游戏中需要用到UI的地方都是与该脚本的交互。 2、将需要用到的UI资源打到一个图集中，以免出现大量人物的时候图集穿插造成不良的影响。 3、创建一个头顶UI预设，当道对应的目录下面: 为了测...
Unity中 gameObject的顶点捕捉
伟的专栏
11-17 6859
在游戏运行中可能会复制大量游戏几何体，这虽然没有减小开销，但确减少了游戏程序所占磁盘空间大小，因而利于“快速”下载。最终结果就是要在游戏空间中对这些对象进行整理，为了完成这个任务，Unity引擎为我们提供了一个非常实用的功能-----顶点捕捉(vertex snap)        按下键盘上的"V"键 ，把鼠标移动到Cube附近， 这时Unity会自动定位到离鼠标最近的那个顶点并以一个黄色小方
Kinect获取头部坐标，并画上圆圈
默茉的博客
05-08 905
#include <stdio.h> #include <iostream> #include <Kinect.h> #include <windows.h> #include<opencv2/highgui/highgui.hpp> #include<opencv2/core.hpp> #include<opencv2...
Unity 头顶图文字性能优化
873149745
11-21 462
常用解决方案： 1、创建两个Canvas，一个放所有文本Text，一个放所有Image。但这里有会有两个问题：一旦文字夹在两个Image中间，还有就是由于他们没有层级关系所以在排版对坐标上比较麻烦。新的解决方案： 我们依赖unity的高效动态合并功能。实现RichText与RichImage，实现动态合并，从而实现batches减少。如图：常规的排版，会有很多Batches。这是优化后的Batches只有3。
camera相机坐标分析
atu1111的博客
05-27 3238
camera相机坐标分析   camera位置的设置，在初始化camera时，一般都会先设置好它的3个属性，position/up/lookAt.以demo为例讲解一下这三个属性。在这之前，我们先了解一下three.js的坐标系，使用的是右手坐标系，如下图所示：   就是这么有气质的手势~~大拇指指向x轴正方向，食指指向y轴正方向，中指指向z轴正方向。   相机初始化代码如下： camera.position.x = 0; camera.position.y = 0; camera.position.z
Unity坐标系、相互转换和相对自身的方位及角度。
GarFe的博客
04-03 5440
注：鼠标位置坐标属于屏幕坐标，Input.mousePosition可以获得该位置坐标，手指触摸屏幕也为屏幕坐标，Input.GetTouch(0).position可以获得单个手指触摸屏幕坐标。以像素来定义的，以屏幕的左下角为(0，0)点，右上角为(Screen.width，Screen.height)，Z的位置是以相机的世界单位来衡量的。这个坐标系与屏幕坐标系相似，不同的是该坐标系以屏幕的左上角为(0，0)点，右下角为(Screen.width，Screen.height)。将全局坐标转换为视口坐标。
Unity UI Toolkit学习笔记-获取屏幕坐标
qq_26318597的博客
09-09 962
UIToolkit ui 屏幕坐标
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值