SetIndices
Sets the index buffer for the sub-mesh.
Read time 26 minutesLast updated 4 days ago
Definition
- Type: Method
- Namespace: UnityEngine
- Assembly: UnityEngine.CoreModule
SetIndices(int[], MeshTopology, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(int[] indices, MeshTopology topology, int submesh, bool calculateBounds, int baseVertex)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(int[], MeshTopology, int, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(int[] indices, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
The Mesh LOD to modify. Use -1 to modify the entire sub-mesh. If not provided, LOD0 is modified.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(int[], int, int, MeshTopology, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(int[] indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(int[], int, int, MeshTopology, int, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(int[] indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Mesh level of detail to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(ushort[], MeshTopology, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(ushort[] indices, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(ushort[], MeshTopology, int, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(ushort[] indices, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
The Mesh LOD to modify. Use -1 to modify the entire sub-mesh. If not provided, LOD0 is modified.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(ushort[], int, int, MeshTopology, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(ushort[] indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(ushort[], int, int, MeshTopology, int, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(ushort[] indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Mesh level of detail to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices<T>(NativeArray<T>, MeshTopology, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices<T>(NativeArray<T> indices, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0) where T : struct
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices<T>(NativeArray<T>, MeshTopology, int, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices<T>(NativeArray<T> indices, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0) where T : struct
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
The Mesh LOD to modify. Use -1 to modify the entire sub-mesh. If not provided, LOD0 is modified.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices<T>(NativeArray<T>, int, int, MeshTopology, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices<T>(NativeArray<T> indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0) where T : struct
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices<T>(NativeArray<T>, int, int, MeshTopology, int, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices<T>(NativeArray<T> indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0) where T : struct
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Mesh level of detail to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(List<int>, MeshTopology, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(List<int> indices, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(List<int>, MeshTopology, int, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(List<int> indices, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
The Mesh LOD to modify. Use -1 to modify the entire sub-mesh. If not provided, LOD0 is modified.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(List<int>, int, int, MeshTopology, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(List<int> indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(List<int>, int, int, MeshTopology, int, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(List<int> indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Mesh level of detail to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(List<ushort>, MeshTopology, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(List<ushort> indices, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(List<ushort>, MeshTopology, int, int, bool, int)
Sets the index buffer for the sub-mesh.
public void SetIndices(List<ushort> indices, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
The Mesh LOD to modify. Use -1 to modify the entire sub-mesh. If not provided, LOD0 is modified.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
A sub-mesh represents a list of triangles (or indices with a different MeshTopology) that are rendered using a single Material. When the Mesh is used with a Renderer that has multiple materials, you should ensure that there is one sub-mesh per Material.
Mesh.SetTriangles and Mesh.triangles always set the Mesh to be composed of triangle faces. Use SetIndices to create a Mesh composed of lines or points.
The argument can be used to achieve meshes that are larger than 65536 vertices while using 16 bit index buffers, as long as each sub-mesh index fits within its own 65535 value range. For example, if the index buffer that is passed to SetIndices contains indices 10,11,12 and is set to 100000, then effectively vertices 100010, 100011 and 100012 will be used for rendering.
baseVertexbaseVertexNote that meshes use 16-bit Mesh.indexFormat by default, i.e. the maximum value supported in the index buffer is 65535 (even when using int[] input data). In order to use larger index buffer values, you should first set the Mesh.indexFormat to IndexFormat.UInt32.
Call Mesh.RecalculateBounds after updating all sub-meshes if you want to update the Mesh's bounding box.
SetIndices(List<ushort>, int, int, MeshTopology, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(List<ushort> indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLengthSetIndices(List<ushort>, int, int, MeshTopology, int, int, bool, int)
Sets the index buffer of a sub-mesh, using a part of the input array.
public void SetIndices(List<ushort> indices, int indicesStart, int indicesLength, MeshTopology topology, int submesh, int meshLod, bool calculateBounds = true, int baseVertex = 0)
Parameters
The array of indices that define the mesh faces.
Index of the first element to take from the input array.
Number of elements to take from the input array.
The topology of the Mesh, e.g: Triangles, Lines, Quads, Points, etc. See MeshTopology.
The sub-mesh to modify.
Mesh level of detail to modify.
Calculate the bounding box of the sub-mesh after setting the indices. Unity does this by default. Use false when you want to use the existing bounding box and reduce the CPU cost of setting the indices.
Optional vertex offset that is added to all vertex indices.
Remarks
This method behaves as if you called SetIndices with an array that is a slice of the whole array, starting at index and being of a given length. The resulting sub-mesh will have amount of vertex indices.
indicesStartindicesLengthindicesLength