Package com.badlogic.gdx.graphics

Class Mesh

  • All Implemented Interfaces:
    Disposable
    public class Mesh
extends java.lang.Object
implements Disposable

    A Mesh holds vertices composed of attributes specified by a VertexAttributes instance. The vertices are held either in VRAM in form of vertex buffer objects or in RAM in form of vertex arrays. The former variant is more performant and is preferred over vertex arrays if hardware supports it.

    Meshes are automatically managed. If the OpenGL context is lost all vertex buffer objects get invalidated and must be reloaded when the context is recreated. This only happens on Android when a user switches to another application or receives an incoming call. A managed Mesh will be reloaded automagically so you don't have to do this manually.

    A Mesh consists of vertices and optionally indices which specify which vertices define a triangle. Each vertex is composed of attributes such as position, normal, color or texture coordinate. Note that not all of this attributes must be given, except for position which is non-optional. Each attribute has an alias which is used when rendering a Mesh in OpenGL ES 2.0. The alias is used to bind a specific vertex attribute to a shader attribute. The shader source and the alias of the attribute must match exactly for this to work.

    • Constructor Detail

      • Mesh

        public Mesh​(boolean isStatic,
            int maxVertices,
            int maxIndices,
            VertexAttribute... attributes)
        Creates a new Mesh with the given attributes.
        Parameters:
        isStatic - whether this mesh is static or not. Allows for internal optimizations.
        maxVertices - the maximum number of vertices this mesh can hold
        maxIndices - the maximum number of indices this mesh can hold
        attributes - the VertexAttributes. Each vertex attribute defines one property of a vertex such as position, normal or texture coordinate

      • Mesh

        public Mesh​(boolean isStatic,
            int maxVertices,
            int maxIndices,
            VertexAttributes attributes)
        Creates a new Mesh with the given attributes.
        Parameters:
        isStatic - whether this mesh is static or not. Allows for internal optimizations.
        maxVertices - the maximum number of vertices this mesh can hold
        maxIndices - the maximum number of indices this mesh can hold
        attributes - the VertexAttributes. Each vertex attribute defines one property of a vertex such as position, normal or texture coordinate

      • Mesh

        public Mesh​(boolean staticVertices,
            boolean staticIndices,
            int maxVertices,
            int maxIndices,
            VertexAttributes attributes)
        Creates a new Mesh with the given attributes. Adds extra optimizations for dynamic (frequently modified) meshes.
        Parameters:
        staticVertices - whether vertices of this mesh are static or not. Allows for internal optimizations.
        staticIndices - whether indices of this mesh are static or not. Allows for internal optimizations.
        maxVertices - the maximum number of vertices this mesh can hold
        maxIndices - the maximum number of indices this mesh can hold
        attributes - the VertexAttributes. Each vertex attribute defines one property of a vertex such as position, normal or texture coordinate

      • Mesh

        public Mesh​(Mesh.VertexDataType type,
            boolean isStatic,
            int maxVertices,
            int maxIndices,
            VertexAttribute... attributes)
        Creates a new Mesh with the given attributes. This is an expert method with no error checking. Use at your own risk.
        Parameters:
        type - the Mesh.VertexDataType to be used, VBO or VA.
        isStatic - whether this mesh is static or not. Allows for internal optimizations.
        maxVertices - the maximum number of vertices this mesh can hold
        maxIndices - the maximum number of indices this mesh can hold
        attributes - the VertexAttributes. Each vertex attribute defines one property of a vertex such as position, normal or texture coordinate

      • Mesh

        public Mesh​(Mesh.VertexDataType type,
            boolean isStatic,
            int maxVertices,
            int maxIndices,
            VertexAttributes attributes)
        Creates a new Mesh with the given attributes. This is an expert method with no error checking. Use at your own risk.
        Parameters:
        type - the Mesh.VertexDataType to be used, VBO or VA.
        isStatic - whether this mesh is static or not. Allows for internal optimizations.
        maxVertices - the maximum number of vertices this mesh can hold
        maxIndices - the maximum number of indices this mesh can hold
        attributes - the VertexAttributes.

    • Method Detail

      • enableInstancedRendering

        public Mesh enableInstancedRendering​(boolean isStatic,
                                     int maxInstances,
                                     VertexAttribute... attributes)

      • disableInstancedRendering

        public Mesh disableInstancedRendering()

      • setInstanceData

        public Mesh setInstanceData​(float[] instanceData,
                            int offset,
                            int count)
        Sets the instance data of this Mesh. The attributes are assumed to be given in float format.
        Parameters:
        instanceData - the instance data.
        offset - the offset into the vertices array
        count - the number of floats to use
        Returns:
        the mesh for invocation chaining.

      • setInstanceData

        public Mesh setInstanceData​(float[] instanceData)
        Sets the instance data of this Mesh. The attributes are assumed to be given in float format.
        Parameters:
        instanceData - the instance data.
        Returns:
        the mesh for invocation chaining.

      • setInstanceData

        public Mesh setInstanceData​(java.nio.FloatBuffer instanceData,
                            int count)
        Sets the instance data of this Mesh. The attributes are assumed to be given in float format.
        Parameters:
        instanceData - the instance data.
        count - the number of floats to use
        Returns:
        the mesh for invocation chaining.

      • setInstanceData

        public Mesh setInstanceData​(java.nio.FloatBuffer instanceData)
        Sets the instance data of this Mesh. The attributes are assumed to be given in float format.
        Parameters:
        instanceData - the instance data.
        Returns:
        the mesh for invocation chaining.

      • updateInstanceData

        public Mesh updateInstanceData​(int targetOffset,
                               float[] source)
        Update (a portion of) the instance data. Does not resize the backing buffer.
        Parameters:
        targetOffset - the offset in number of floats of the mesh part.
        source - the instance data to update the mesh part with

      • updateInstanceData

        public Mesh updateInstanceData​(int targetOffset,
                               float[] source,
                               int sourceOffset,
                               int count)
        Update (a portion of) the instance data. Does not resize the backing buffer.
        Parameters:
        targetOffset - the offset in number of floats of the mesh part.
        source - the instance data to update the mesh part with
        sourceOffset - the offset in number of floats within the source array
        count - the number of floats to update

      • updateInstanceData

        public Mesh updateInstanceData​(int targetOffset,
                               java.nio.FloatBuffer source)
        Update (a portion of) the instance data. Does not resize the backing buffer.
        Parameters:
        targetOffset - the offset in number of floats of the mesh part.
        source - the instance data to update the mesh part with

      • updateInstanceData

        public Mesh updateInstanceData​(int targetOffset,
                               java.nio.FloatBuffer source,
                               int sourceOffset,
                               int count)
        Update (a portion of) the instance data. Does not resize the backing buffer.
        Parameters:
        targetOffset - the offset in number of floats of the mesh part.
        source - the instance data to update the mesh part with
        sourceOffset - the offset in number of floats within the source array
        count - the number of floats to update

      • setVertices

        public Mesh setVertices​(float[] vertices)
        Sets the vertices of this Mesh. The attributes are assumed to be given in float format.
        Parameters:
        vertices - the vertices.
        Returns:
        the mesh for invocation chaining.

      • isInstanced

        public boolean isInstanced()
        Returns:
        Indicates whether this mesh uses instancing.

      • setVertices

        public Mesh setVertices​(float[] vertices,
                        int offset,
                        int count)
        Sets the vertices of this Mesh. The attributes are assumed to be given in float format.
        Parameters:
        vertices - the vertices.
        offset - the offset into the vertices array
        count - the number of floats to use
        Returns:
        the mesh for invocation chaining.

      • updateVertices

        public Mesh updateVertices​(int targetOffset,
                           float[] source)
        Update (a portion of) the vertices. Does not resize the backing buffer.
        Parameters:
        targetOffset - the offset in number of floats of the mesh part.
        source - the vertex data to update the mesh part with

      • updateVertices

        public Mesh updateVertices​(int targetOffset,
                           float[] source,
                           int sourceOffset,
                           int count)
        Update (a portion of) the vertices. Does not resize the backing buffer.
        Parameters:
        targetOffset - the offset in number of floats of the mesh part.
        source - the vertex data to update the mesh part with
        sourceOffset - the offset in number of floats within the source array
        count - the number of floats to update

      • getVertices

        public float[] getVertices​(float[] vertices)
        Copies the vertices from the Mesh to the float array. The float array must be large enough to hold all the Mesh's vertices.
        Parameters:
        vertices - the array to copy the vertices to

      • getVertices

        public float[] getVertices​(int srcOffset,
                           float[] vertices)
        Copies the the remaining vertices from the Mesh to the float array. The float array must be large enough to hold the remaining vertices.
        Parameters:
        srcOffset - the offset (in number of floats) of the vertices in the mesh to copy
        vertices - the array to copy the vertices to

      • getVertices

        public float[] getVertices​(int srcOffset,
                           int count,
                           float[] vertices)
        Copies the specified vertices from the Mesh to the float array. The float array must be large enough to hold count vertices.
        Parameters:
        srcOffset - the offset (in number of floats) of the vertices in the mesh to copy
        count - the amount of floats to copy
        vertices - the array to copy the vertices to

      • getVertices

        public float[] getVertices​(int srcOffset,
                           int count,
                           float[] vertices,
                           int destOffset)
        Copies the specified vertices from the Mesh to the float array. The float array must be large enough to hold destOffset+count vertices.
        Parameters:
        srcOffset - the offset (in number of floats) of the vertices in the mesh to copy
        count - the amount of floats to copy
        vertices - the array to copy the vertices to
        destOffset - the offset (in floats) in the vertices array to start copying

      • setIndices

        public Mesh setIndices​(short[] indices)
        Sets the indices of this Mesh
        Parameters:
        indices - the indices
        Returns:
        the mesh for invocation chaining.

      • setIndices

        public Mesh setIndices​(short[] indices,
                       int offset,
                       int count)
        Sets the indices of this Mesh.
        Parameters:
        indices - the indices
        offset - the offset into the indices array
        count - the number of indices to copy
        Returns:
        the mesh for invocation chaining.

      • getIndices

        public void getIndices​(short[] indices)
        Copies the indices from the Mesh to the short array. The short array must be large enough to hold all the Mesh's indices.
        Parameters:
        indices - the array to copy the indices to

      • getIndices

        public void getIndices​(short[] indices,
                       int destOffset)
        Copies the indices from the Mesh to the short array. The short array must be large enough to hold destOffset + all the Mesh's indices.
        Parameters:
        indices - the array to copy the indices to
        destOffset - the offset in the indices array to start copying

      • getIndices

        public void getIndices​(int srcOffset,
                       short[] indices,
                       int destOffset)
        Copies the remaining indices from the Mesh to the short array. The short array must be large enough to hold destOffset + all the remaining indices.
        Parameters:
        srcOffset - the zero-based offset of the first index to fetch
        indices - the array to copy the indices to
        destOffset - the offset in the indices array to start copying

      • getIndices

        public void getIndices​(int srcOffset,
                       int count,
                       short[] indices,
                       int destOffset)
        Copies the indices from the Mesh to the short array. The short array must be large enough to hold destOffset + count indices.
        Parameters:
        srcOffset - the zero-based offset of the first index to fetch
        count - the total amount of indices to copy
        indices - the array to copy the indices to
        destOffset - the offset in the indices array to start copying

      • getNumIndices

        public int getNumIndices()
        Returns:
        the number of defined indices

      • getNumVertices

        public int getNumVertices()
        Returns:
        the number of defined vertices

      • getMaxVertices

        public int getMaxVertices()
        Returns:
        the maximum number of vertices this mesh can hold

      • getMaxIndices

        public int getMaxIndices()
        Returns:
        the maximum number of indices this mesh can hold

      • getVertexSize

        public int getVertexSize()
        Returns:
        the size of a single vertex in bytes

      • setAutoBind

        public void setAutoBind​(boolean autoBind)
        Sets whether to bind the underlying VertexArray or VertexBufferObject automatically on a call to one of the render methods. Usually you want to use autobind. Manual binding is an expert functionality. There is a driver bug on the MSM720xa chips that will fuck up memory if you manipulate the vertices and indices of a Mesh multiple times while it is bound. Keep this in mind.
        Parameters:
        autoBind - whether to autobind meshes.

      • bind

        public void bind​(ShaderProgram shader)
        Binds the underlying VertexBufferObject and IndexBufferObject if indices where given. Use this with OpenGL ES 2.0 and when auto-bind is disabled.
        Parameters:
        shader - the shader (does not bind the shader)

      • bind

        public void bind​(ShaderProgram shader,
                 int[] locations,
                 int[] instanceLocations)
        Binds the underlying VertexBufferObject and IndexBufferObject if indices where given. Use this with OpenGL ES 2.0 and when auto-bind is disabled.
        Parameters:
        shader - the shader (does not bind the shader)
        locations - array containing the vertex attribute locations.
        instanceLocations - array containing the instance attribute locations.

      • unbind

        public void unbind​(ShaderProgram shader)
        Unbinds the underlying VertexBufferObject and IndexBufferObject is indices were given. Use this with OpenGL ES 1.x and when auto-bind is disabled.
        Parameters:
        shader - the shader (does not unbind the shader)

      • unbind

        public void unbind​(ShaderProgram shader,
                   int[] locations,
                   int[] instanceLocations)
        Unbinds the underlying VertexBufferObject and IndexBufferObject is indices were given. Use this with OpenGL ES 1.x and when auto-bind is disabled.
        Parameters:
        shader - the shader (does not unbind the shader)
        locations - array containing the vertex attribute locations.
        instanceLocations - array containing the instance attribute locations.

      • render

        public void render​(ShaderProgram shader,
                   int primitiveType)

        Renders the mesh using the given primitive type. If indices are set for this mesh then getNumIndices() / #vertices per primitive primitives are rendered. If no indices are set then getNumVertices() / #vertices per primitive are rendered.

        This method will automatically bind each vertex attribute as specified at construction time via VertexAttributes to the respective shader attributes. The binding is based on the alias defined for each VertexAttribute.

        This method must only be called after the ShaderProgram.bind() method has been called!

        This method is intended for use with OpenGL ES 2.0 and will throw an IllegalStateException when OpenGL ES 1.x is used.

        Parameters:
        primitiveType - the primitive type

      • render

        public void render​(ShaderProgram shader,
                   int primitiveType,
                   int offset,
                   int count)

        Renders the mesh using the given primitive type. offset specifies the offset into either the vertex buffer or the index buffer depending on whether indices are defined. count specifies the number of vertices or indices to use thus count / #vertices per primitive primitives are rendered.

        This method will automatically bind each vertex attribute as specified at construction time via VertexAttributes to the respective shader attributes. The binding is based on the alias defined for each VertexAttribute.

        This method must only be called after the ShaderProgram.bind() method has been called!

        This method is intended for use with OpenGL ES 2.0 and will throw an IllegalStateException when OpenGL ES 1.x is used.

        Parameters:
        shader - the shader to be used
        primitiveType - the primitive type
        offset - the offset into the vertex or index buffer
        count - number of vertices or indices to use

      • render

        public void render​(ShaderProgram shader,
                   int primitiveType,
                   int offset,
                   int count,
                   boolean autoBind)

        Renders the mesh using the given primitive type. offset specifies the offset into either the vertex buffer or the index buffer depending on whether indices are defined. count specifies the number of vertices or indices to use thus count / #vertices per primitive primitives are rendered.

        This method will automatically bind each vertex attribute as specified at construction time via VertexAttributes to the respective shader attributes. The binding is based on the alias defined for each VertexAttribute.

        This method must only be called after the ShaderProgram.bind() method has been called!

        This method is intended for use with OpenGL ES 2.0 and will throw an IllegalStateException when OpenGL ES 1.x is used.

        Parameters:
        shader - the shader to be used
        primitiveType - the primitive type
        offset - the offset into the vertex or index buffer
        count - number of vertices or indices to use
        autoBind - overrides the autoBind member of this Mesh

      • dispose

        public void dispose()
        Frees all resources associated with this Mesh
        Specified by:
        dispose in interface Disposable

      • getVertexAttribute

        public VertexAttribute getVertexAttribute​(int usage)
        Returns the first VertexAttribute having the given VertexAttributes.Usage.
        Parameters:
        usage - the Usage.
        Returns:
        the VertexAttribute or null if no attribute with that usage was found.

      • getVertexAttributes

        public VertexAttributes getVertexAttributes()
        Returns:
        the vertex attributes of this Mesh

      • getInstancedAttributes

        public VertexAttributes getInstancedAttributes()
        Returns:
        the instanced attributes of this Mesh if any

      • getVerticesBuffer

        @Deprecated
public java.nio.FloatBuffer getVerticesBuffer()
        Deprecated.
        use getVerticesBuffer(boolean) instead
        Returns:
        the backing FloatBuffer holding the vertices. Does not have to be a direct buffer on Android!

      • getVerticesBuffer

        public java.nio.FloatBuffer getVerticesBuffer​(boolean forWriting)

      • calculateBoundingBox

        public BoundingBox calculateBoundingBox()
        Calculates the BoundingBox of the vertices contained in this mesh. In case no vertices are defined yet a GdxRuntimeException is thrown. This method creates a new BoundingBox instance.
        Returns:
        the bounding box.

      • calculateBoundingBox

        public void calculateBoundingBox​(BoundingBox bbox)
        Calculates the BoundingBox of the vertices contained in this mesh. In case no vertices are defined yet a GdxRuntimeException is thrown.
        Parameters:
        bbox - the bounding box to store the result in.

      • calculateBoundingBox

        public BoundingBox calculateBoundingBox​(BoundingBox out,
                                        int offset,
                                        int count)
        Calculate the BoundingBox of the specified part.
        Parameters:
        out - the bounding box to store the result in.
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the value specified by out.

      • calculateBoundingBox

        public BoundingBox calculateBoundingBox​(BoundingBox out,
                                        int offset,
                                        int count,
                                        Matrix4 transform)
        Calculate the BoundingBox of the specified part.
        Parameters:
        out - the bounding box to store the result in.
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the value specified by out.

      • extendBoundingBox

        public BoundingBox extendBoundingBox​(BoundingBox out,
                                     int offset,
                                     int count)
        Extends the specified BoundingBox with the specified part.
        Parameters:
        out - the bounding box to store the result in.
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the value specified by out.

      • extendBoundingBox

        public BoundingBox extendBoundingBox​(BoundingBox out,
                                     int offset,
                                     int count,
                                     Matrix4 transform)
        Extends the specified BoundingBox with the specified part.
        Parameters:
        out - the bounding box to store the result in.
        offset - the start of the part.
        count - the size of the part.
        Returns:
        the value specified by out.

      • calculateRadiusSquared

        public float calculateRadiusSquared​(float centerX,
                                    float centerY,
                                    float centerZ,
                                    int offset,
                                    int count,
                                    Matrix4 transform)
        Calculates the squared radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        centerX - The X coordinate of the center of the bounding sphere
        centerY - The Y coordinate of the center of the bounding sphere
        centerZ - The Z coordinate of the center of the bounding sphere
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the squared radius of the bounding sphere.

      • calculateRadius

        public float calculateRadius​(float centerX,
                             float centerY,
                             float centerZ,
                             int offset,
                             int count,
                             Matrix4 transform)
        Calculates the radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        centerX - The X coordinate of the center of the bounding sphere
        centerY - The Y coordinate of the center of the bounding sphere
        centerZ - The Z coordinate of the center of the bounding sphere
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the radius of the bounding sphere.

      • calculateRadius

        public float calculateRadius​(Vector3 center,
                             int offset,
                             int count,
                             Matrix4 transform)
        Calculates the squared radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        center - The center of the bounding sphere
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the squared radius of the bounding sphere.

      • calculateRadius

        public float calculateRadius​(float centerX,
                             float centerY,
                             float centerZ,
                             int offset,
                             int count)
        Calculates the squared radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        centerX - The X coordinate of the center of the bounding sphere
        centerY - The Y coordinate of the center of the bounding sphere
        centerZ - The Z coordinate of the center of the bounding sphere
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the squared radius of the bounding sphere.

      • calculateRadius

        public float calculateRadius​(Vector3 center,
                             int offset,
                             int count)
        Calculates the squared radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        center - The center of the bounding sphere
        offset - the start index of the part.
        count - the amount of indices the part contains.
        Returns:
        the squared radius of the bounding sphere.

      • calculateRadius

        public float calculateRadius​(float centerX,
                             float centerY,
                             float centerZ)
        Calculates the squared radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        centerX - The X coordinate of the center of the bounding sphere
        centerY - The Y coordinate of the center of the bounding sphere
        centerZ - The Z coordinate of the center of the bounding sphere
        Returns:
        the squared radius of the bounding sphere.

      • calculateRadius

        public float calculateRadius​(Vector3 center)
        Calculates the squared radius of the bounding sphere around the specified center for the specified part.
        Parameters:
        center - The center of the bounding sphere
        Returns:
        the squared radius of the bounding sphere.

      • getIndicesBuffer

        @Deprecated
public java.nio.ShortBuffer getIndicesBuffer()
        Deprecated.
        use getIndicesBuffer(boolean) instead
        Returns:
        the backing shortbuffer holding the indices. Does not have to be a direct buffer on Android!

      • getIndicesBuffer

        public java.nio.ShortBuffer getIndicesBuffer​(boolean forWriting)

      • invalidateAllMeshes

        public static void invalidateAllMeshes​(Application app)
        Invalidates all meshes so the next time they are rendered new VBO handles are generated.
        Parameters:
        app -

      • clearAllMeshes

        public static void clearAllMeshes​(Application app)
        Will clear the managed mesh cache. I wouldn't use this if i was you :)

      • getManagedStatus

        public static java.lang.String getManagedStatus()

      • scale

        public void scale​(float scaleX,
                  float scaleY,
                  float scaleZ)
        Method to scale the positions in the mesh. Normals will be kept as is. This is a potentially slow operation, use with care. It will also create a temporary float[] which will be garbage collected.
        Parameters:
        scaleX - scale on x
        scaleY - scale on y
        scaleZ - scale on z

      • transform

        public void transform​(Matrix4 matrix)
        Method to transform the positions in the mesh. Normals will be kept as is. This is a potentially slow operation, use with care. It will also create a temporary float[] which will be garbage collected.
        Parameters:
        matrix - the transformation matrix

      • transform

        public void transform​(Matrix4 matrix,
                      int start,
                      int count)

      • transform

        public static void transform​(Matrix4 matrix,
                             float[] vertices,
                             int vertexSize,
                             int offset,
                             int dimensions,
                             int start,
                             int count)
        Method to transform the positions in the float array. Normals will be kept as is. This is a potentially slow operation, use with care.
        Parameters:
        matrix - the transformation matrix
        vertices - the float array
        vertexSize - the number of floats in each vertex
        offset - the offset within a vertex to the position
        dimensions - the size of the position
        start - the vertex to start with
        count - the amount of vertices to transform

      • transformUV

        public void transformUV​(Matrix3 matrix)
        Method to transform the texture coordinates in the mesh. This is a potentially slow operation, use with care. It will also create a temporary float[] which will be garbage collected.
        Parameters:
        matrix - the transformation matrix

      • transformUV

        protected void transformUV​(Matrix3 matrix,
                           int start,
                           int count)

      • transformUV

        public static void transformUV​(Matrix3 matrix,
                               float[] vertices,
                               int vertexSize,
                               int offset,
                               int start,
                               int count)
        Method to transform the texture coordinates (UV) in the float array. This is a potentially slow operation, use with care.
        Parameters:
        matrix - the transformation matrix
        vertices - the float array
        vertexSize - the number of floats in each vertex
        offset - the offset within a vertex to the texture location
        start - the vertex to start with
        count - the amount of vertices to transform

      • copy

        public Mesh copy​(boolean isStatic,
                 boolean removeDuplicates,
                 int[] usage)
        Copies this mesh optionally removing duplicate vertices and/or reducing the amount of attributes.
        Parameters:
        isStatic - whether the new mesh is static or not. Allows for internal optimizations.
        removeDuplicates - whether to remove duplicate vertices if possible. Only the vertices specified by usage are checked.
        usage - which attributes (if available) to copy
        Returns:
        the copy of this mesh

      • copy

        public Mesh copy​(boolean isStatic)
        Copies this mesh.
        Parameters:
        isStatic - whether the new mesh is static or not. Allows for internal optimizations.
        Returns:
        the copy of this mesh