Unity引擎开发：物理引擎与碰撞检测_（11）.布娃娃系统与角色物理

布娃娃系统与角色物理

在虚拟现实游戏中，角色的物理行为和互动是提升游戏真实感和沉浸感的关键因素之一。布娃娃系统（Ragdoll System）是一种动态模拟角色身体各部分运动的技术，它通过物理引擎来实现角色在受到外力作用时的自然反应。本节将详细介绍布娃娃系统的工作原理，以及如何在Unity引擎中实现和优化布娃娃系统，包括角色物理的基础知识、布娃娃系统的配置、关节约束的使用、碰撞检测的优化等。

角色物理的基础知识

在Unity中，角色物理的实现依赖于物理引擎。物理引擎负责处理刚体（Rigidbody）、碰撞体（Collider）和关节（Joint）等物理组件的交互。了解这些基本概念是实现布娃娃系统的基础。

刚体（Rigidbody）

刚体是物理引擎中最基本的组件，用于使游戏对象受到物理作用力的影响，例如重力、摩擦力和碰撞力。刚体组件可以控制物体的质量、阻尼、重力等属性。在布娃娃系统中，每个角色的身体部分都需要一个刚体组件。

创建刚体

在Unity中，可以通过以下步骤为角色的身体部分添加刚体组件：

1. 选择角色的身体部分（例如头部、躯干、四肢等）。

2. 在Inspector面板中点击“Add Component”按钮。

3. 选择“Physics”下的“Rigidbody”。

// 为角色的身体部分添加刚体组件

using UnityEngine;



public class AddRigidbody : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        AddRigidbodyComponent(head);

        AddRigidbodyComponent(torso);

        AddRigidbodyComponent(leftArm);

        AddRigidbodyComponent(rightArm);

        AddRigidbodyComponent(leftLeg);

        AddRigidbodyComponent(rightLeg);

    }



    void AddRigidbodyComponent(GameObject bodyPart)

    {

        if (bodyPart != null)

        {

            Rigidbody rb = bodyPart.AddComponent<Rigidbody>();

            rb.mass = 1.0f; // 设置质量

            rb.drag = 0.5f; // 设置线性阻尼

            rb.angularDrag = 0.5f; // 设置角阻尼

            rb.useGravity = true; // 启用重力

        }

    }

}

碰撞体（Collider）

碰撞体用于定义物体的物理形状，使物体能够与其他物体发生碰撞。常见的碰撞体类型包括BoxCollider、SphereCollider、CapsuleCollider等。在布娃娃系统中，每个身体部分都需要一个合适的碰撞体来模拟其物理形状。

创建碰撞体

在Unity中，可以通过以下步骤为角色的身体部分添加碰撞体：

1. 选择角色的身体部分。

2. 在Inspector面板中点击“Add Component”按钮。

3. 选择“Physics”下的合适碰撞体类型（例如BoxCollider、SphereCollider、CapsuleCollider）。

// 为角色的身体部分添加碰撞体

using UnityEngine;



public class AddCollider : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        AddColliderComponent(head, ColliderType.Sphere);

        AddColliderComponent(torso, ColliderType.Box);

        AddColliderComponent(leftArm, ColliderType.Capsule);

        AddColliderComponent(rightArm, ColliderType.Capsule);

        AddColliderComponent(leftLeg, ColliderType.Capsule);

        AddColliderComponent(rightLeg, ColliderType.Capsule);

    }



    void AddColliderComponent(GameObject bodyPart, ColliderType type)

    {

        if (bodyPart != null)

        {

            switch (type)

            {

                case ColliderType.Box:

                    bodyPart.AddComponent<BoxCollider>();

                    break;

                case ColliderType.Sphere:

                    bodyPart.AddComponent<SphereCollider>();

                    break;

                case ColliderType.Capsule:

                    bodyPart.AddComponent<CapsuleCollider>();

                    break;

            }

        }

    }



    public enum ColliderType

    {

        Box,

        Sphere,

        Capsule

    }

}

关节（Joint）

关节用于连接两个刚体，使它们能够相对运动。在布娃娃系统中，关节是模拟角色身体各部分连接的关键组件。常见的关节类型包括HingeJoint、FixedJoint、CharacterJoint等。

创建关节

在Unity中，可以通过以下步骤为角色的身体部分添加关节：

1. 选择需要连接的身体部分。

2. 在Inspector面板中点击“Add Component”按钮。

3. 选择“Physics”下的合适关节类型（例如HingeJoint、FixedJoint、CharacterJoint）。

// 为角色的身体部分添加关节

using UnityEngine;



public class AddJoint : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        AddJointComponent(head, torso, JointType.Hinge);

        AddJointComponent(leftArm, torso, JointType.Hinge);

        AddJointComponent(rightArm, torso, JointType.Hinge);

        AddJointComponent(leftLeg, torso, JointType.Hinge);

        AddJointComponent(rightLeg, torso, JointType.Hinge);

    }



    void AddJointComponent(GameObject bodyPart, GameObject connectedBodyPart, JointType type)

    {

        if (bodyPart != null && connectedBodyPart != null)

        {

            Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

            Rigidbody connectedRb = connectedBodyPart.GetComponent<Rigidbody>();



            if (rb != null && connectedRb != null)

            {

                switch (type)

                {

                    case JointType.Hinge:

                        HingeJoint hingeJoint = bodyPart.AddComponent<HingeJoint>();

                        hingeJoint.connectedBody = connectedRb;

                        hingeJoint.axis = new Vector3(0, 1, 0); // 设置旋转轴

                        hingeJoint.anchor = bodyPart.transform.position; // 设置锚点

                        break;

                    case JointType.Fixed:

                        FixedJoint fixedJoint = bodyPart.AddComponent<FixedJoint>();

                        fixedJoint.connectedBody = connectedRb;

                        break;

                    case JointType.Character:

                        CharacterJoint characterJoint = bodyPart.AddComponent<CharacterJoint>();

                        characterJoint.connectedBody = connectedRb;

                        characterJoint.axis = new Vector3(0, 1, 0); // 设置旋转轴

                        characterJoint.anchor = bodyPart.transform.position; // 设置锚点

                        break;

                }

            }

        }

    }



    public enum JointType

    {

        Hinge,

        Fixed,

        Character

    }

}

布娃娃系统的配置

布娃娃系统的配置涉及刚体、碰撞体和关节的设置，以确保角色在受到外力作用时能够自然地运动和反应。

刚体设置

刚体的设置包括质量、阻尼、重力等属性。这些属性的合理设置能够影响角色的物理行为，使其更加真实。

质量设置

质量是决定物体受力后运动状态的重要因素。不同身体部分的质量设置应有所不同，以模拟真实的人体重量分布。

// 设置刚体的质量

using UnityEngine;



public class SetRigidbodyMass : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        SetMass(head, 5.0f);

        SetMass(torso, 20.0f);

        SetMass(leftArm, 10.0f);

        SetMass(rightArm, 10.0f);

        SetMass(leftLeg, 15.0f);

        SetMass(rightLeg, 15.0f);

    }



    void SetMass(GameObject bodyPart, float mass)

    {

        if (bodyPart != null)

        {

            Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

            if (rb != null)

            {

                rb.mass = mass;

            }

        }

    }

}

阻尼设置

阻尼设置包括线性阻尼和角阻尼，用于模拟物体在运动过程中的阻力。合理设置阻尼可以使角色的运动更加平滑和自然。

// 设置刚体的阻尼

using UnityEngine;



public class SetRigidbodyDamping : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        SetDamping(head, 0.5f, 0.5f);

        SetDamping(torso, 0.3f, 0.3f);

        SetDamping(leftArm, 0.4f, 0.4f);

        SetDamping(rightArm, 0.4f, 0.4f);

        SetDamping(leftLeg, 0.6f, 0.6f);

        SetDamping(rightLeg, 0.6f, 0.6f);

    }



    void SetDamping(GameObject bodyPart, float linearDamping, float angularDamping)

    {

        if (bodyPart != null)

        {

            Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

            if (rb != null)

            {

                rb.drag = linearDamping;

                rb.angularDrag = angularDamping;

            }

        }

    }

}

关节设置

关节的设置包括连接刚体、旋转轴、锚点等属性。合理的关节设置能够确保角色各部分之间的自然连接和运动。

HingeJoint设置

HingeJoint用于模拟铰链关节，例如肘关节和膝关节。通过设置旋转轴和锚点，可以控制关节的运动范围和方向。

// 设置HingeJoint

using UnityEngine;



public class SetHingeJoint : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        SetHingeJoint(head, torso, new Vector3(0, 1, 0));

        SetHingeJoint(leftArm, torso, new Vector3(1, 0, 0));

        SetHingeJoint(rightArm, torso, new Vector3(-1, 0, 0));

        SetHingeJoint(leftLeg, torso, new Vector3(0, 0, 1));

        SetHingeJoint(rightLeg, torso, new Vector3(0, 0, -1));

    }



    void SetHingeJoint(GameObject bodyPart, GameObject connectedBodyPart, Vector3 axis)

    {

        if (bodyPart != null && connectedBodyPart != null)

        {

            Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

            Rigidbody connectedRb = connectedBodyPart.GetComponent<Rigidbody>();



            if (rb != null && connectedRb != null)

            {

                HingeJoint hingeJoint = bodyPart.GetComponent<HingeJoint>();

                if (hingeJoint == null)

                {

                    hingeJoint = bodyPart.AddComponent<HingeJoint>();

                }



                hingeJoint.connectedBody = connectedRb;

                hingeJoint.axis = axis;

                hingeJoint.anchor = bodyPart.transform.position;

            }

        }

    }

}

CharacterJoint设置

CharacterJoint用于模拟更复杂的关节，例如肩关节和髋关节。通过设置旋转轴和锚点，可以控制关节的多自由度运动。

// 设置CharacterJoint

using UnityEngine;



public class SetCharacterJoint : MonoBehaviour

{

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        SetCharacterJoint(head, torso, new Vector3(0, 1, 0));

        SetCharacterJoint(leftArm, torso, new Vector3(1, 0, 0));

        SetCharacterJoint(rightArm, torso, new Vector3(-1, 0, 0));

        SetCharacterJoint(leftLeg, torso, new Vector3(0, 0, 1));

        SetCharacterJoint(rightLeg, torso, new Vector3(0, 0, -1));

    }



    void SetCharacterJoint(GameObject bodyPart, GameObject connectedBodyPart, Vector3 axis)

    {

        if (bodyPart != null && connectedBodyPart != null)

        {

            Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

            Rigidbody connectedRb = connectedBodyPart.GetComponent<Rigidbody>();



            if (rb != null && connectedRb != null)

            {

                CharacterJoint characterJoint = bodyPart.GetComponent<CharacterJoint>();

                if (characterJoint == null)

                {

                    characterJoint = bodyPart.AddComponent<CharacterJoint>();

                }



                characterJoint.connectedBody = connectedRb;

                characterJoint.axis = axis;

                characterJoint.anchor = bodyPart.transform.position;

            }

        }

    }

}

布娃娃系统的激活与控制

布娃娃系统的激活和控制是根据游戏逻辑来决定何时启用和关闭物理模拟的关键。在虚拟现实游戏中，布娃娃系统通常在角色受到攻击或摔倒时启用。

激活布娃娃系统

可以通过禁用和启用刚体组件的控制来激活布娃娃系统。在角色受到攻击或摔倒时，禁用动画控制器并启用刚体组件。

// 激活布娃娃系统

using UnityEngine;



public class ActivateRagdoll : MonoBehaviour

{

    public GameObject[] bodyParts;

    public Animator animator;



    void OnTriggerEnter(Collider other)

    {

        if (other.CompareTag("Enemy"))

        {

            ActivateRagdollSystem();

        }

    }



    void ActivateRagdollSystem()

    {

        if (animator != null)

        {

            animator.enabled = false; // 禁用动画控制器

        }



        foreach (GameObject bodyPart in bodyParts)

        {

            if (bodyPart != null)

            {

                Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

                if (rb != null)

                {

                    rb.isKinematic = false; // 启用物理模拟

                }

            }

        }

    }

}

控制布娃娃系统

在布娃娃系统激活后，可以通过物理引擎来控制角色的身体部分。例如，可以对刚体施加力来模拟角色被击飞的效果。

// 控制布娃娃系统

using UnityEngine;



public class ControlRagdoll : MonoBehaviour

{

    public GameObject[] bodyParts;

    public float forceMagnitude = 1000.0f;



    void ApplyForce(Vector3 forceDirection)

    {

        foreach (GameObject bodyPart in bodyParts)

        {

            if (bodyPart != null)

            {

                Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

                if (rb != null)

                {

                    rb.AddForce(forceDirection * forceMagnitude, ForceMode.Impulse); // 施加力

                }

            }

        }

    }

}

碰撞检测的优化

在虚拟现实游戏中，碰撞检测的性能优化是非常重要的。布娃娃系统中的碰撞检测可能会涉及多个碰撞体和关节，因此需要采取一些优化措施来确保游戏的流畅运行。

使用Layer和LayerMask

通过使用Layer和LayerMask，可以优化碰撞检测的性能。将角色的身体部分和环境物体分配到不同的Layer，并在碰撞检测中使用LayerMask来过滤不需要检测的物体。

// 使用Layer和LayerMask优化碰撞检测

using UnityEngine;



public class LayerCollisionOptimization : MonoBehaviour

{

    public GameObject[] bodyParts;

    public int collisionLayer = 8; // 碰撞层ID



    void Start()

    {

        SetCollisionLayer(bodyParts, collisionLayer);

    }



    void SetCollisionLayer(GameObject[] bodyParts, int layer)

    {

        foreach (GameObject bodyPart in bodyParts)

        {

            if (bodyPart != null)

            {

                bodyPart.layer = layer;

                Collider collider = bodyPart.GetComponent<Collider>();

                if (collider != null)

                {

                    collider.gameObject.layer = layer;

                }

            }

        }

    }



    void OnTriggerEnter(Collider other)

    {

        if (other.CompareTag("Enemy") && (1 << other.gameObject.layer & (1 << collisionLayer)) != 0)

        {

            ActivateRagdollSystem();

        }

    }



    void ActivateRagdollSystem()

    {

        foreach (GameObject bodyPart in bodyParts)

        {

            if (bodyPart != null)

            {

                Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

                if (rb != null)

                {

                    rb.isKinematic = false;

                }

            }

        }

    }

}

减少碰撞体的数量

通过减少碰撞体的数量，可以进一步优化碰撞检测的性能。例如，可以使用复合碰撞体（Compound Collider）来减少单个碰撞体的数量。

// 使用复合碰撞体减少碰撞体数量

using UnityEngine;



public class CompoundColliderOptimization : MonoBehaviour

{

    public GameObject character;

    public GameObject head;

    public GameObject torso;

    public GameObject leftArm;

    public GameObject rightArm;

    public GameObject leftLeg;

    public GameObject rightLeg;



    void Start()

    {

        CreateCompoundCollider();

    }



    void CreateCompoundCollider()

    {

        if (character != null)

        {

            MeshCollider meshCollider = character.AddComponent<MeshCollider>();

            meshCollider.sharedMesh = character.GetComponent<MeshFilter>().sharedMesh;



            head.GetComponent<Collider>().isTrigger = true;

            torso.GetComponent<Collider>().isTrigger = true;

            leftArm.GetComponent<Collider>().isTrigger = true;

            rightArm.GetComponent<Collider>().isTrigger = true;

            leftLeg.GetComponent<Collider>().isTrigger = true;

            rightLeg.GetComponent<Collider>().isTrigger = true;

        }

    }

}

布娃娃系统的高级应用

布娃娃系统的高级应用包括动态调整关节限制、物理效果的混合和自定义关节行为等。这些高级应用可以进一步提升角色的物理表现和游戏的真实感。

动态调整关节限制

在某些情况下，可能需要动态调整关节的限制，例如角色被击中后，某些关节的运动范围会增加。通过编写脚本，可以实现关节限制的动态调整。

// 动态调整关节限制

using UnityEngine;



public class DynamicJointLimit : MonoBehaviour

{

    public HingeJoint headJoint;

    public HingeJoint leftArmJoint;

    public HingeJoint rightArmJoint;

    public HingeJoint leftLegJoint;

    public HingeJoint rightLegJoint;



    void OnTriggerEnter(Collider other)

    {

        if (other.CompareTag("Enemy"))

        {

            AdjustJointLimits(headJoint, -45, 45);

            AdjustJointLimits(leftArmJoint, -90, 90);

            AdjustJointLimits(rightArmJoint, -90, 90);

            AdjustJointLimits(leftLegJoint, -45, 45);

            AdjustJointLimits(rightLegJoint, -45, 45);

        }

    }



    void AdjustJointLimits(HingeJoint joint, float minLimit, float maxLimit)

    {

        if (joint != null)

        {

            JointLimits limits = joint.limits;

            limits.min = minLimit;

            limits.max = maxLimit;

            joint.limits = limits;

        }

    }

}

物理效果的混合

在虚拟现实游戏中，布娃娃系统的物理效果可以与动画效果混合，以达到更自然的运动效果。例如，当角色被击中时，可以短暂地启用布娃娃系统，同时保持动画控制器的部分控制。

// 物理效果的混合

using UnityEngine;



public class RagdollBlend : MonoBehaviour

{

    public GameObject[] bodyParts;

    public Animator animator;

    public float blendTime = 0.5f; // 混合时间



    void OnTriggerEnter(Collider other)

    {

        if (other.CompareTag("Enemy"))

        {

            StartCoroutine(BlendRagdoll());

        }

    }



    IEnumerator BlendRagdoll()

    {

        float elapsedTime = 0.0f;



        // 启用布娃娃系统

        foreach (GameObject bodyPart in bodyParts)

        {

            if (bodyPart != null)

            {

                Rigidbody rb = bodyPart.GetComponent<Rigidbody>();

                if (rb != null)

                {

                    rb.isKinematic = false;

                }

            }

        }



        while (elapsedTime < blendTime)

        {

            elapsedTime += Time.deltaTime;

            float blendFactor = elapsedTime / blendTime;



            if (animator != null)

            {

                animator.CrossFade("Ragdoll", blendFactor); // 混合到布娃娃动画

            }



            yield return null;

        }



        // 完全启用布娃娃系统

        if (animator != null)

        {

            animator.enabled = false;

        }

    }

}

自定义关节行为

在某些高级应用中，可能需要自定义关节的行为，例如实现特定的约束或运动模式。通过编写自定义的关节脚本，可以实现这些高级功能。

// 自定义关节行为

using UnityEngine;



public class CustomJoint : MonoBehaviour

{

    public Rigidbody bodyPart;

    public Rigidbody connectedBodyPart;

    public Vector3 axis;

    public float minAngle = -45.0f;

    public float maxAngle = 45.0f;



    void FixedUpdate()

    {

        if (bodyPart != null && connectedBodyPart != null)

        {

            // 计算当前角度

            Vector3 currentAngle = bodyPart.rotation.eulerAngles - connectedBodyPart.rotation.eulerAngles;

            float angle = Vector3.Dot(currentAngle, axis);



            // 检查角度限制

            if (angle < minAngle || angle > maxAngle)

            {

                // 应用限制力

                Vector3 limitForce = -axis * (angle - (minAngle + maxAngle) / 2) * 10.0f;

                bodyPart.AddForceAtPosition(limitForce, bodyPart.position, ForceMode.Force);

            }

        }

    }

}

布娃娃系统的调试与优化

在实现布娃娃系统后，调试和优化是确保系统运行稳定和流畅的关键步骤。以下是一些调试和优化的方法：

调试布娃娃系统

1. 启用调试视图：在Unity编辑器中，可以通过启用物理引擎的调试视图来观察刚体、碰撞体和关节的运行情况。

2. 日志输出：在脚本中添加日志输出，记录关节的角度、刚体的速度等信息，帮助调试问题。

3. 可视化辅助：使用Gizmos或DrawGizmos方法在场景视图中可视化关节的轴和锚点，以便更好地调整关节设置。

// 启用调试视图

using UnityEngine;



public class DebugRagdoll : MonoBehaviour

{

    public HingeJoint headJoint;

    public HingeJoint leftArmJoint;

    public HingeJoint rightArmJoint;

    public HingeJoint leftLegJoint;

    public HingeJoint rightLegJoint;



    void OnDrawGizmos()

    {

        if (headJoint != null)

        {

            Gizmos.color = Color.red;

            Gizmos.DrawLine(headJoint.transform.position, headJoint.connectedBody.transform.position);

            Gizmos.DrawLine(headJoint.transform.position, headJoint.transform.position + headJoint.axis * 0.5f);

        }



        if (leftArmJoint != null)

        {

            Gizmos.color = Color.green;

            Gizmos.DrawLine(leftArmJoint.transform.position, leftArmJoint.connectedBody.transform.position);

            Gizmos.DrawLine(leftArmJoint.transform.position, leftArmJoint.transform.position + leftArmJoint.axis * 0.5f);

        }



        if (rightArmJoint != null)

        {

            Gizmos.color = Color.blue;

            Gizmos.DrawLine(rightArmJoint.transform.position, rightArmJoint.connectedBody.transform.position);

            Gizmos.DrawLine(rightArmJoint.transform.position, rightArmJoint.transform.position + rightArmJoint.axis * 0.5f);

        }



        if (leftLegJoint != null)

        {

            Gizmos.color = Color.yellow;

            Gizmos.DrawLine(leftLegJoint.transform.position, leftLegJoint.connectedBody.transform.position);

            Gizmos.DrawLine(leftLegJoint.transform.position, leftLegJoint.transform.position + leftLegJoint.axis * 0.5f);

        }



        if (rightLegJoint != null)

        {

            Gizmos.color = Color.cyan;

            Gizmos.DrawLine(rightLegJoint.transform.position, rightLegJoint.connectedBody.transform.position);

            Gizmos.DrawLine(rightLegJoint.transform.position, rightLegJoint.transform.position + rightLegJoint.axis * 0.5f);

        }

    }

}

优化布娃娃系统

1. 减少刚体数量：通过合并刚体和使用复合碰撞体，减少物理计算的负担。

2. 调整物理时间步长：在Physics设置中，调整Fixed Timestep的值，以平衡物理模拟的精度和性能。

3. 使用优化的碰撞检测：通过使用Layer和LayerMask，减少不必要的碰撞检测。

// 优化物理时间步长

using UnityEngine;



public class OptimizePhysicsTimestep : MonoBehaviour

{

    void Start()

    {

        // 调整Fixed Timestep

        Time.fixedDeltaTime = 0.02f;

    }

}

总结

布娃娃系统是虚拟现实游戏中提升角色物理行为和互动真实感的重要技术。通过合理配置刚体、碰撞体和关节，以及优化碰撞检测和物理时间步长，可以实现更加自然和流畅的物理模拟效果。高级应用如动态调整关节限制、物理效果的混合和自定义关节行为，可以进一步提升角色的物理表现，使游戏体验更加丰富和真实。

希望本节内容能够帮助你在Unity引擎中实现和优化布娃娃系统，为你的虚拟现实游戏增添更多的互动性和沉浸感。