Пример #1
0
        internal void SetTexturesCoincident(IEnumerable <int> vertices)
        {
            var lookup = sharedTextureLookup;

            SharedVertex.SetCoincident(ref lookup, vertices);
            SetSharedTextures(lookup);
        }
Пример #2
0
        void GeometryWithPoints(Vector3[] points)
        {
            // Wrap in faces
            Face[] f = new Face[points.Length / 4];

            for (int i = 0; i < points.Length; i += 4)
            {
                f[i / 4] = new Face(new int[6]
                {
                    i + 0, i + 1, i + 2,
                    i + 1, i + 3, i + 2
                },
                                    0,
                                    AutoUnwrapSettings.tile,
                                    0,
                                    -1,
                                    -1,
                                    false);
            }

            Clear();
            positions        = points;
            m_Faces          = f;
            m_SharedVertices = SharedVertex.GetSharedVerticesWithPositions(points);
            InvalidateSharedVertexLookup();
            ToMesh();
            Refresh();
        }
 internal void SetSharedTextures(IEnumerable<KeyValuePair<int, int>> indexes)
 {
     if (indexes == null)
         throw new ArgumentNullException("indexes");
     m_SharedTextures = SharedVertex.ToSharedVertices(indexes);
     InvalidateSharedTextureLookup();
 }
Пример #4
0
        /// <summary>
        /// Sets the passed vertices as being considered coincident by the ProBuilderMesh.
        /// </summary>
        /// <remarks>
        /// Note that it is up to the caller to ensure that the passed vertices are indeed sharing a position.
        /// </remarks>
        /// <param name="vertices">Returns a list of vertices to be associated as coincident.</param>
        public void SetVerticesCoincident(IEnumerable <int> vertices)
        {
            var        lookup     = sharedVertexLookup;
            List <int> coincident = new List <int>();

            GetCoincidentVertices(vertices, coincident);
            SharedVertex.SetCoincident(ref lookup, coincident);
            SetSharedVertices(lookup);
        }
Пример #5
0
 /// <summary>
 /// Copy constructor.
 /// </summary>
 /// <param name="sharedVertex">The array to copy.</param>
 public SharedVertex(SharedVertex sharedVertex)
 {
     if (sharedVertex == null)
     {
         throw new ArgumentNullException("sharedVertex");
     }
     m_Vertices = new int[sharedVertex.Count];
     Array.Copy(sharedVertex.m_Vertices, m_Vertices, m_Vertices.Length);
 }
Пример #6
0
        internal void AddSharedVertex(SharedVertex vertex)
        {
            if (vertex == null)
            {
                throw new ArgumentNullException("vertex");
            }

            m_SharedVertices = m_SharedVertices.Add(vertex);
            InvalidateSharedVertexLookup();
        }
Пример #7
0
 static SharedVertex[] ToSharedVertices(List <List <int> > list)
 {
     if (list == null)
     {
         throw new ArgumentNullException("list");
     }
     SharedVertex[] arr = new SharedVertex[list.Count];
     for (int i = 0; i < arr.Length; i++)
     {
         arr[i] = new SharedVertex(list[i]);
     }
     return(arr);
 }
Пример #8
0
        /// <summary>
        /// Clear all mesh attributes and reinitialize with new positions and face collections.
        /// </summary>
        /// <param name="vertices">Vertex positions array.</param>
        /// <param name="faces">Faces array.</param>
        public void RebuildWithPositionsAndFaces(IEnumerable <Vector3> vertices, IEnumerable <Face> faces)
        {
            if (vertices == null)
            {
                throw new ArgumentNullException("vertices");
            }

            Clear();
            m_Positions      = vertices.ToArray();
            m_Faces          = faces.ToArray();
            m_SharedVertices = SharedVertex.GetSharedVerticesWithPositions(m_Positions);
            InvalidateSharedVertexLookup();
            InvalidateSharedTextureLookup();
            ToMesh();
            Refresh();
        }
Пример #9
0
 /// <summary>
 /// Reset all the attribute arrays on this object.
 /// </summary>
 public void Clear()
 {
     // various editor tools expect faces & vertices to always be valid.
     // ideally we'd null everything here, but that would break a lot of existing code.
     m_Faces          = new Face[0];
     m_Positions      = new Vector3[0];
     m_Textures0      = new Vector2[0];
     m_Textures2      = null;
     m_Textures3      = null;
     m_Tangents       = null;
     m_SharedVertices = new SharedVertex[0];
     m_SharedTextures = new SharedVertex[0];
     InvalidateSharedVertexLookup();
     InvalidateSharedTextureLookup();
     m_Colors = null;
     ClearSelection();
 }
Пример #10
0
        /// <summary>
        /// Create a new array of SharedVertex objects by comparing points in the passed positions collection.
        /// </summary>
        /// <example>
        /// ```
        /// <![CDATA[var mesh = gameObject.AdComponent<ProBuilderMesh>();]]>
        /// mesh.SetPositions(myNewPositions);
        /// mesh.SetFaces(myNewFaces);
        /// mesh.SetSharedIndexes(SharedVertex.GetSharedVerticesWithPositions(myNewPositions));
        /// ```
        /// </example>
        /// <param name="positions">A collection of Vector3 positions to be tested for equality.</param>
        /// <returns>A new SharedVertex[] where each SharedIndex is a list of indexes that are sharing the same position.</returns>
        public static SharedVertex[] GetSharedVerticesWithPositions(IList <Vector3> positions)
        {
            if (positions == null)
            {
                throw new ArgumentNullException("positions");
            }

            Dictionary <IntVec3, List <int> > sorted = new Dictionary <IntVec3, List <int> >();

            for (int i = 0; i < positions.Count; i++)
            {
                List <int> ind;
                if (sorted.TryGetValue(positions[i], out ind))
                {
                    ind.Add(i);
                }
                else
                {
                    sorted.Add(new IntVec3(positions[i]), new List <int>()
                    {
                        i
                    });
                }
            }

            SharedVertex[] share = new SharedVertex[sorted.Count];

            int t = 0;

            foreach (KeyValuePair <IntVec3, List <int> > kvp in sorted)
            {
                share[t++] = new SharedVertex(kvp.Value.ToArray());
            }

            return(share);
        }