Пример #1
0
        /// <summary>
        /// Copies mesh data from managed arrays into native ones.
        /// </summary>
        public static bool CopyManagedToNativeMeshData(ManagedMeshData managed, NativeMeshData native, DataFlags dataFlags)
        {
            var dataIsValid = true;

            if (!managed.HasValidData())
            {
                dataIsValid = false;
                Debug.LogError("Cannot copy data as the managed data is invalid");
            }
            if (!native.HasValidData())
            {
                Debug.LogError("Cannot copy data as the native data is invalid");
                dataIsValid = false;
            }

            if (!dataIsValid)
            {
                return(false);
            }

            if ((dataFlags & DataFlags.Vertices) != 0)
            {
                managed.Vertices.MemCpy(native.VertexBuffer);
            }
            if ((dataFlags & DataFlags.Normals) != 0)
            {
                managed.Normals.MemCpy(native.NormalBuffer);
            }
            if ((dataFlags & DataFlags.MaskVertices) != 0)
            {
                managed.Vertices.MemCpy(native.MaskVertexBuffer);
            }
            if ((dataFlags & DataFlags.Tangents) != 0)
            {
                managed.Tangents.MemCpy(native.TangentBuffer);
            }
            if ((dataFlags & DataFlags.UVs) != 0)
            {
                managed.UVs.MemCpy(native.UVBuffer);
            }
            if ((dataFlags & DataFlags.Colors) != 0)
            {
                managed.Colors.MemCpy(native.ColorBuffer);
            }
            if ((dataFlags & DataFlags.Triangles) != 0)
            {
                managed.Triangles.MemCpy(native.IndexBuffer);
            }
            if ((dataFlags & DataFlags.Bounds) != 0)
            {
                native.Bounds[0] = managed.Bounds;
            }

            return(true);
        }
Пример #2
0
        public bool Initialize(GameObject targetObject)
        {
            if (Target == null)
            {
                Target = new MeshTarget();
            }
            if (!Target.Initialize(targetObject))
            {
                return(false);
            }

            // Store the original mesh and make a copy (stored in dynamicMesh).
            // Assign the copy back to the filter so that this object has a unique mesh.
            if (!initialized)
            {
                OriginalMesh = Target.GetMesh();
                if (OriginalMesh == null)
                {
                    return(false);
                }
                DynamicMesh = GameObject.Instantiate(Target.GetMesh());
            }
            // Since this has already been initialized, make a new mesh for the dynamic mesh to reference
            // so that two Deformables aren't displaying and modifying the same mesh.
            else if (OriginalMesh != null)
            {
                DynamicMesh = GameObject.Instantiate(OriginalMesh);
            }
            else
            {
                return(false);
            }

            // Tell the mesh filter to display the dynamic mesh.
            Target.SetMesh(DynamicMesh);
            // Mark the dynamic mesh as dynamic for a hypothetical performance boost.
            // (I've heard this method doesn't do anything)
            DynamicMesh.MarkDynamic();

            Length = DynamicMesh.vertexCount;

            // Store mesh information in managed data.
            originalManaged = new ManagedMeshData(DynamicMesh);
            dynamicManaged  = new ManagedMeshData(DynamicMesh);
            // Copy the managed data into native data.
            OriginalNative = new NativeMeshData(originalManaged);
            DynamicNative  = new NativeMeshData(dynamicManaged);

            initialized = true;

            return(true);
        }
Пример #3
0
        public NativeMeshData(ManagedMeshData data, Allocator allocator = Allocator.Persistent)
        {
            VertexBuffer     = new NativeArray <float3> (data.Vertices.Length, allocator, NativeArrayOptions.UninitializedMemory);
            NormalBuffer     = new NativeArray <float3> (data.Normals.Length, allocator, NativeArrayOptions.UninitializedMemory);
            TangentBuffer    = new NativeArray <float4> (data.Tangents.Length, allocator, NativeArrayOptions.UninitializedMemory);
            UVBuffer         = new NativeArray <float2> (data.UVs.Length, allocator, NativeArrayOptions.UninitializedMemory);
            ColorBuffer      = new NativeArray <float4> (data.Colors.Length, allocator, NativeArrayOptions.UninitializedMemory);
            IndexBuffer      = new NativeArray <int>    (data.Triangles.Length, allocator, NativeArrayOptions.UninitializedMemory);
            MaskVertexBuffer = new NativeArray <float3> (data.Vertices.Length, allocator, NativeArrayOptions.UninitializedMemory);
            Bounds           = new NativeArray <bounds> (1, allocator, NativeArrayOptions.UninitializedMemory);

            DataUtils.CopyManagedToNativeMeshData(data, this, DataFlags.All);
        }
Пример #4
0
        /// <summary>
        /// Copies mesh data from native arrays into managed ones.
        /// </summary>
        /// <param name="onlyEssentials">If true, only vertices, normals and bounds are copied. The mask data isn't copied because is only exists in native data.</param>
        public static void CopyNativeDataToManagedData(ManagedMeshData managed, NativeMeshData native, DataFlags dataFlags)
        {
            var dataIsValid = true;

            if (!managed.HasValidData())
            {
                dataIsValid = false;
                Debug.LogError("Cannot copy data as the managed data is invalid");
            }
            if (!native.HasValidData())
            {
                Debug.LogError("Cannot copy data as the native data is invalid");
                dataIsValid = false;
            }

            if (!dataIsValid)
            {
                return;
            }

            if ((dataFlags & DataFlags.Vertices) != 0)
            {
                native.VertexBuffer.MemCpy(managed.Vertices);
            }
            if ((dataFlags & DataFlags.Normals) != 0)
            {
                native.NormalBuffer.MemCpy(managed.Normals);
            }
            if ((dataFlags & DataFlags.Tangents) != 0)
            {
                native.TangentBuffer.MemCpy(managed.Tangents);
            }
            if ((dataFlags & DataFlags.UVs) != 0)
            {
                native.UVBuffer.MemCpy(managed.UVs);
            }
            if ((dataFlags & DataFlags.Colors) != 0)
            {
                native.ColorBuffer.MemCpy(managed.Colors);
            }
            if ((dataFlags & DataFlags.Triangles) != 0)
            {
                native.IndexBuffer.CopyTo(managed.Triangles);
            }
            if ((dataFlags & DataFlags.Bounds) != 0)
            {
                managed.Bounds = native.Bounds[0];
            }
        }
Пример #5
0
        public static bool CopyManagedDataToMesh(ManagedMeshData from, Mesh to, DataFlags dataFlags)
        {
            if (!from.HasValidData())
            {
                Debug.LogError("Cannot copy data as some of it is invalid");
                return(false);
            }
            if (to == null)
            {
                Debug.LogError("Cannot copy data to null mesh");
                return(false);
            }

            // Send managed data to mesh.
            if ((dataFlags & DataFlags.Vertices) != 0)
            {
                to.vertices = from.Vertices;
            }
            if ((dataFlags & DataFlags.Normals) != 0)
            {
                to.normals = from.Normals;
            }
            if ((dataFlags & DataFlags.Tangents) != 0)
            {
                to.tangents = from.Tangents;
            }
            if ((dataFlags & DataFlags.UVs) != 0)
            {
                to.uv = from.UVs;
            }
            if ((dataFlags & DataFlags.Colors) != 0)
            {
                to.colors = from.Colors;
            }
            if ((dataFlags & DataFlags.Triangles) != 0)
            {
                to.triangles = from.Triangles;
            }
            if ((dataFlags & DataFlags.Bounds) != 0)
            {
                to.bounds = from.Bounds;
            }

            return(true);
        }
Пример #6
0
 public static bool CopyToNativeData(this ManagedMeshData from, NativeMeshData to, DataFlags dataFlags) => CopyManagedToNativeMeshData(from, to, dataFlags);
Пример #7
0
 public static bool CopyToMesh(ManagedMeshData from, Mesh to, DataFlags dataFlags) => CopyManagedDataToMesh(from, to, dataFlags);
Пример #8
0
 public static bool CopyToManagedData(this NativeMeshData from, ManagedMeshData to, DataFlags dataFlags) => CopyNativeDataToManagedData(to, from, dataFlags);
Пример #9
0
        public bool Initialize(GameObject targetObject)
        {
            if (Target == null)
            {
                Target = new MeshTarget();
            }
            if (!Target.Initialize(targetObject))
            {
                return(false);
            }

            // Store the original mesh and make a copy (stored in DynamicMesh).
            // Assign the copy back to the filter so that this object has a unique mesh.
            if (!initialized)
            {
                OriginalMesh = Target.GetMesh();

                if (OriginalMesh == null)
                {
                    return(false);
                }

                if (!OriginalMesh.isReadable)
                {
                    Debug.LogError($"The mesh '{OriginalMesh.name}' must have read/write permissions enabled.", OriginalMesh);
                    return(false);
                }

                DynamicMesh = GameObject.Instantiate(Target.GetMesh());
            }
            // Since this has already been initialized, make a new mesh for the dynamic mesh to reference
            // so that two Deformables aren't displaying and modifying the same mesh.
            else if (OriginalMesh != null)
            {
                DynamicMesh = GameObject.Instantiate(OriginalMesh);
            }
            else if (DynamicMesh != null)
            {
                Debug.Log($"Original mesh is missing. Attempting to create one from dynamic mesh ({DynamicMesh.name}) and original managed mesh data.", targetObject);
                OriginalMesh = GameObject.Instantiate(DynamicMesh);
                try
                {
                    OriginalMesh.vertices  = originalManaged.Vertices;
                    OriginalMesh.normals   = originalManaged.Normals;
                    OriginalMesh.tangents  = originalManaged.Tangents;
                    OriginalMesh.uv        = originalManaged.UVs;
                    OriginalMesh.colors    = originalManaged.Colors;
                    OriginalMesh.triangles = originalManaged.Triangles;
                    OriginalMesh.bounds    = originalManaged.Bounds;
                }
                catch (NullReferenceException)
                {
                    Debug.LogError($"Attempted to recreate original mesh (from {DynamicMesh.name}), but the data was not valid. Please assign a new mesh.", targetObject);
                    return(false);
                }

                Debug.Log($"Original mesh was recreated from {DynamicMesh.name}. This is not ideal, but prevents stuff from breaking when an original mesh is deleted. The best solution is to find and reassign the original mesh.", targetObject);
            }
            else
            {
                return(false);
            }

            // Tell the mesh filter to display the dynamic mesh.
            Target.SetMesh(DynamicMesh);
            // Mark the dynamic mesh as dynamic for a hypothetical performance boost.
            // (I've heard this method doesn't do anything)
            DynamicMesh.MarkDynamic();

            Length = DynamicMesh.vertexCount;

            // Store mesh information in managed data.
            originalManaged = new ManagedMeshData(DynamicMesh);
            dynamicManaged  = new ManagedMeshData(DynamicMesh);
            // Copy the managed data into native data.
            OriginalNative = new NativeMeshData(originalManaged);
            DynamicNative  = new NativeMeshData(dynamicManaged);

            initialized = true;

            return(true);
        }
Пример #10
0
        public bool Initialize(GameObject targetObject)
        {
            if (Target == null)
            {
                Target = new MeshTarget();
            }
            if (!Target.Initialize(targetObject))
            {
                return(false);
            }

            // Store the original mesh and make a copy (stored in DynamicMesh).
            // Assign the copy back to the filter so that this object has a unique mesh.
            if (!initialized)
            {
                OriginalMesh = Target.GetMesh();

                if (OriginalMesh == null)
                {
                    return(false);
                }

                if (!OriginalMesh.isReadable)
                {
                    Debug.LogError($"The mesh '{OriginalMesh.name}' must have read/write permissions enabled.", OriginalMesh);
                    return(false);
                }

                DynamicMesh = GameObject.Instantiate(Target.GetMesh());
            }
            // Since this has already been initialized, make a new mesh for the dynamic mesh to reference
            // so that two Deformables aren't displaying and modifying the same mesh.
            else if (OriginalMesh != null)
            {
                DynamicMesh = GameObject.Instantiate(OriginalMesh);
            }
            else if (DynamicMesh != null)
            {
                Debug.Log($"Original mesh is missing. Recreating one from dynamic mesh (\"{DynamicMesh.name}\"). This is not ideal, but prevents stuff from breaking when an original mesh is deleted. The best solution is to find and reassign the original mesh.", targetObject);
                OriginalMesh = GameObject.Instantiate(DynamicMesh);
                return(false);
            }
            else
            {
                return(false);
            }

            // Tell the mesh filter to display the dynamic mesh.
            Target.SetMesh(DynamicMesh);
            // Mark the dynamic mesh as dynamic for a hypothetical performance boost.
            // (I've heard this method doesn't do anything)
            DynamicMesh.MarkDynamic();

            Length = DynamicMesh.vertexCount;

            // Store the native data.
            OriginalNative = new NativeMeshData(DynamicMesh);
            DynamicNative  = new NativeMeshData(DynamicMesh);

#if !UNITY_2019_3_OR_NEWER
            OriginalManaged = new ManagedMeshData(DynamicMesh);
            DynamicManaged  = new ManagedMeshData(DynamicMesh);
#endif

            initialized = true;

            return(true);
        }
Пример #11
0
 public void Initialize(Mesh mesh)
 {
     Data = new ManagedMeshData(mesh);
 }