为什么我的预制件的 position 在场景中掉落时会发生变化？

Question

I have a problem, I made a prefab of a cube that I want to place on a platform. The y value of my prefab is 1. However, when I try to place it on the platform the cube takes the y value of 0.5 which puts it inside of the ground. I tried to reset the transform in the prefab, the ground and the cubes but none of that worked.

Screenshots of my unity window with both the prefab and how its value is changed.

Answer 1

I'm assuming you're dragging the prefab into the Scene window without using code or anything like that.

Why does the position get modified

The reason your cube is halfway into the ground likely is due to Unity trying to have it centered on the Y axis on the ground object you have in the scene since that's likely the object you're dragging your prefabs on.

Solution 1

If you wish to drag things into the Scene window but wish to avoid the cubes going into the ground, one solution is to change the center position of the cubes. One way of doing that is by putting the cube into an empty GameObject and modify the cube's position inside it and use this GameObject as a prefab. Here's a screenshot illustrating how your modified version of the prefab would look like:

Solution 2

If wish to move a cube into the scene without any position modifications, drag it into the Hierarchy window instead.

Solution 3

Create a custom script that modifies the Y position of your cube prefab instance. OnValidate() may be something worth looking into for this solution.

Answer 2

You need to "freeze" the mesh (recalculate the vertices of the mesh) relative to the position of the transform so it fits your needs.

This is usually done in the program that generated the mesh but you could also use a simple editor script inside Unity. There are probably several very good ones if you google - but here is the code I use myself when I need to adjust or freeze a mesh.

In your case, you simply want to align the mesh at the bottom, so you can select "Min" for "Align y" (let the checkboxes beside x, y, and z be unchecked). This will put all the mesh above the transform position. (Align is a simple way of freezing without the need to first manually position the mesh as desired).

Place the following two scripts in a folder with the name "Editor" (so it can be used as a Unity editor). You will then have a new menu option in Unity "Tools - Simple Mesh Editor".

SimpleMeshEditor.cs

using UnityEditor;
using UnityEngine;

namespace com.andulfgames
{
    public class SimpleMeshEditor : EditorWindow
    {
        [MenuItem("Tools/Simple Mesh Editor")]
        public static void ShowWindow()
        {
            GetWindow<SimpleMeshEditor>(false, "Simple Mesh Editor", true);
        }

        bool freezeRotation = true;

        SimpleMeshTools.MeshAlign alignX;
        SimpleMeshTools.MeshAlign alignY;
        SimpleMeshTools.MeshAlign alignZ;

        bool freezeX = false;
        bool freezeY = false;
        bool freezeZ = false;

        bool adjustColliders = true;

        void OnGUI()
        {
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Freeze", EditorStyles.boldLabel);
            freezeRotation = EditorGUILayout.Toggle("Rotation", freezeRotation); 
            freezeX = EditorGUILayout.Toggle("x", freezeX );
            freezeY = EditorGUILayout.Toggle("y", freezeY);
            freezeZ = EditorGUILayout.Toggle("z", freezeZ);
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Align", EditorStyles.boldLabel);
            alignX = (SimpleMeshTools.MeshAlign)EditorGUILayout.EnumPopup("Align x", alignX);
            alignY = (SimpleMeshTools.MeshAlign)EditorGUILayout.EnumPopup("Align y", alignY);
            alignZ = (SimpleMeshTools.MeshAlign)EditorGUILayout.EnumPopup("Align z", alignZ);

            EditorGUILayout.Space();
            EditorGUILayout.LabelField("Colliders", EditorStyles.boldLabel);
            adjustColliders = EditorGUILayout.Toggle("Adjust colliders", adjustColliders);

            if (GUILayout.Button("UpdateMesh"))
            {
                UpdateMesh();
            }
        }


        private void UpdateMesh()
        {
            foreach (GameObject obj in Selection.gameObjects)
            {
                MeshFilter meshFilter = obj.GetComponent<MeshFilter>(); //6

                if (meshFilter != null)
                {
                    SimpleMeshTools.FreezeTransformation(obj, freezeRotation, freezeX, alignX, freezeY, alignY, freezeZ, alignZ, adjustColliders);
                }
            }
        }
    }
}

SimpleMeshEditor.cs

using UnityEditor;
using UnityEngine;
using System.Collections.Generic;

namespace com.andulfgames
{
    public static class SimpleMeshTools
    {
        public static void FreezeTransformation(GameObject gameObject,
            bool freezeRotation,
            bool freezeX, MeshAlign meshPositionX,
            bool freezeY, MeshAlign meshPositionY,
            bool freezeZ, MeshAlign meshPositionZ,
            bool adjustColliders)
        {
            MeshFilter meshFilter = gameObject.GetComponent<MeshFilter>();
            Mesh newMesh = GameObject.Instantiate<Mesh>(meshFilter.sharedMesh);
            Quaternion originalRotation = meshFilter.transform.rotation;
            // If we should not freeze the rotation we have to temporarly turn the mesh
            // back to it's identity rotation before we freeze the vertizes.
            if (!freezeRotation)
                meshFilter.transform.rotation = Quaternion.identity;


            Vector3[] vertices = newMesh.vertices;

            Vector3 freeze = new Vector3(
                freezeX ? 0 : gameObject.transform.position.x,
                freezeY ? 0 : gameObject.transform.position.y,
                freezeZ ? 0 : gameObject.transform.position.z);
            Debug.Log("Freeze: " + freeze.ToString());
            Vector3 diff = gameObject.transform.position - freeze;

            Vector3 alignMin = newMesh.bounds.min;
            Vector3 alignCenter = newMesh.bounds.center;
            Vector3 alignMax = newMesh.bounds.max;

            Vector3 align = new Vector3(
                meshPositionX == MeshAlign.KeepCurrent ? 0 :
                (meshPositionX == MeshAlign.Min ? alignMin.x :
                (meshPositionX == MeshAlign.Center ? alignCenter.x : alignMax.x)),

                meshPositionY == MeshAlign.KeepCurrent ? 0 :
                (meshPositionY == MeshAlign.Min ? alignMin.y :
                (meshPositionY == MeshAlign.Center ? alignCenter.y : alignMax.y)),

                meshPositionZ == MeshAlign.KeepCurrent ? 0 :
                (meshPositionZ == MeshAlign.Min ? alignMin.z :
                (meshPositionZ == MeshAlign.Center ? alignCenter.z : alignMax.z)));

            Debug.Log("Freeze by " + diff.ToString() + " and align by " + align.ToString() + ", in total " + (diff + align).ToString());

            Debug.Log("Adjust: " + align.ToString());

            for (int i = 0; i < vertices.Length; i++)
                vertices[i] = gameObject.transform.TransformPoint(newMesh.vertices[i]) - freeze - align;

            newMesh.vertices = vertices;

            // Note that we can't rotate box- or sphere colliders

            BoxCollider boxCollider = adjustColliders ? gameObject.GetComponent<BoxCollider>() : null;
            SphereCollider sphereCollider = adjustColliders ? gameObject.GetComponent<SphereCollider>() : null;
            CapsuleCollider capsuleCollider = adjustColliders ? gameObject.GetComponent<CapsuleCollider>() : null;

            if (adjustColliders && diff + align != Vector3.zero)
            {
                Debug.Log("Adjusting colliders by " + (diff + align).ToString());
                if (boxCollider != null)
                    boxCollider.center += diff + align;
                if (sphereCollider != null)
                    sphereCollider.center += diff + align;
                if (capsuleCollider != null)
                    capsuleCollider.center += diff + align;
            }

            if (freezeRotation && gameObject.transform.rotation != Quaternion.identity)
            {
                Debug.Log("Freezing current rotation which is " + gameObject.transform.rotation.ToString());
                if (boxCollider != null)
                    Debug.LogWarning("Can't rotate box-colliders. They are fixed with the transform.");
                if (sphereCollider != null)
                    Debug.LogWarning("Can't rotate sphere-colliders. They are fixed with the transform.");
                if (capsuleCollider != null)
                    Debug.LogWarning("Can't rotate capsule-colliders. They are fixed with the transform.");

                Vector3[] normals = newMesh.normals;
                if (normals != null)
                {
                    for (int i = 0; i < normals.Length; i++)
                        normals[i] = gameObject.transform.rotation * newMesh.normals[i];
                    newMesh.normals = normals;
                }
            }

            newMesh.RecalculateBounds();
            newMesh.RecalculateNormals();

            Mesh savedMesh = SaveMesh(newMesh, gameObject.name);
            if (savedMesh != null)
                meshFilter.sharedMesh = savedMesh;

            if (freezeRotation)
                meshFilter.transform.rotation = Quaternion.identity;
            else
                meshFilter.transform.rotation = originalRotation; // Restore

            meshFilter.transform.localScale = new Vector3(1, 1, 1);
            meshFilter.transform.position -= diff - align;
        }
    }
}