Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
ArrayMesh
Hereda: Mesh < Resource < RefCounted < Object
Tipo Mesh que provee la funcionalidad para construir una superficie desde arrays.
Descripción
El ArrayMesh se utiliza para construir un Mesh especificando los atributos como arrays.
El ejemplo más básico es la creación de un único triángulo:
var vertices = PackedVector3Array()
vertices.push_back(Vector3(0, 1, 0))
vertices.push_back(Vector3(1, 0, 0))
vertices.push_back(Vector3(0, 0, 1))
# Initialize the ArrayMesh.
var arr_mesh = ArrayMesh.new()
var arrays = []
arrays.resize(Mesh.ARRAY_MAX)
arrays[Mesh.ARRAY_VERTEX] = vertices
# Create the Mesh.
arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)
var m = MeshInstance3D.new()
m.mesh = arr_mesh
Vector3[] vertices =
[
new Vector3(0, 1, 0),
new Vector3(1, 0, 0),
new Vector3(0, 0, 1),
];
// Initialize the ArrayMesh.
var arrMesh = new ArrayMesh();
Godot.Collections.Array arrays = [];
arrays.Resize((int)Mesh.ArrayType.Max);
arrays[(int)Mesh.ArrayType.Vertex] = vertices;
// Create the Mesh.
arrMesh.AddSurfaceFromArrays(Mesh.PrimitiveType.Triangles, arrays);
var m = new MeshInstance3D();
m.Mesh = arrMesh;
El MeshInstance3D está listo para ser añadido al SceneTree para mostrarse.
Véase también ImmediateMesh, MeshDataTool y SurfaceTool para la generación de geometría procedural.
Nota: Godot usa el winding order en sentido horario para las caras frontales de los modos primitivos de triángulo.
Tutoriales
Propiedades
|
||
|
||
Métodos
Descripciones de Propiedades
BlendShapeMode blend_shape_mode = 1 🔗
void set_blend_shape_mode(value: BlendShapeMode)
BlendShapeMode get_blend_shape_mode()
El modo de blendshape.
AABB custom_aabb = AABB(0, 0, 0, 0, 0, 0) 🔗
Sobrescribe el AABB con uno definido por usuario para el uso con el tronco(frustum). Especialmente util para evitar inesperadas selecciones cuando se use un shader a vertices desplazados.
Una malla opcional que puede ser usada para renderizar sombras y el pre-pase de profundidad. Puede ser usada para aumentar el rendimiento suministrando una malla con vértices fusionados y solo datos de posición del vértice (sin normales, UVs, colores, etc.).
Nota: Esta malla debe tener exactamente las mismas posiciones de vértice que la malla fuente (incluyendo los LODs de la malla fuente, si están presentes). Si las posiciones de los vértices difieren, entonces la malla no se dibujará correctamente.
Descripciones de Métodos
void add_blend_shape(name: StringName) 🔗
Añade un nombre a una forma de mezcla que se añadira con add_surface_from_arrays(). Debe ser llamada antes que la superficie sea añadida.
void add_surface_from_arrays(primitive: PrimitiveType, arrays: Array, blend_shapes: Array[Array] = [], lods: Dictionary = {}, flags: BitField[ArrayFormat] = 0) 🔗
Crea una nueva superficie. Mesh.get_surface_count() se convertirá en el surf_idx de esta nueva superficie.
Las superficies se crean para ser renderizadas usando un primitive, que puede ser cualquiera de los valores definidos en PrimitiveType.
El argumento arrays es un arreglo de arreglos. Cada uno de los elementos Mesh.ARRAY_MAX contiene un arreglo con parte de los datos de la malla para esta superficie, según se describe en el miembro correspondiente de ArrayType, o null si no se utiliza en la superficie. Por ejemplo, arrays[0] es el arreglo de vértices. Este primer sub-arreglo de vértices siempre es obligatorio; los demás son opcionales. Agregar un arreglo de índices coloca esta superficie en "modo índice", donde los arreglos de vértices y otros se usan como fuentes de datos y el arreglo de índices define el orden de los vértices. Todos los sub-arreglos deben tener la misma longitud que el arreglo de vértices (o ser un múltiplo exacto de la longitud del arreglo de vértices, cuando múltiples elementos de un sub-arreglo corresponden a un solo vértice) o estar vacíos, excepto Mesh.ARRAY_INDEX si se utiliza.
El argumento blend_shapes es un arreglo de datos de vértices para cada blend shape. Cada elemento es un arreglo con la misma estructura que arrays, pero Mesh.ARRAY_VERTEX, Mesh.ARRAY_NORMAL y Mesh.ARRAY_TANGENT se establecen únicamente si están presentes en arrays y todas las demás entradas son null.
El argumento lods es un diccionario con claves float y valores PackedInt32Array. Cada entrada del diccionario representa un nivel LOD de la superficie, donde el valor es el arreglo Mesh.ARRAY_INDEX que se utilizará para ese nivel LOD y la clave es aproximadamente proporcional a la distancia a la que se usará el LOD. Es decir, aumentar la clave de un LOD también aumenta la distancia a la que los objetos deben estar de la cámara antes de usar ese LOD.
El argumento flags es la operación OR a nivel de bits de, según se necesite: un valor de ArrayCustomFormat desplazado a la izquierda por ARRAY_FORMAT_CUSTOMn_SHIFT para cada canal personalizado en uso, Mesh.ARRAY_FLAG_USE_DYNAMIC_UPDATE, Mesh.ARRAY_FLAG_USE_8_BONE_WEIGHTS o Mesh.ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY.
Nota: Al usar índices, se recomienda emplear únicamente puntos, líneas o triángulos.
void clear_blend_shapes() 🔗
Elimina todos las formas de mezcla de este ArrayMesh.
void clear_surfaces() 🔗
Elimina todas las superificies de este ArrayMesh.
int get_blend_shape_count() const 🔗
Devuelve el número de formas de mezcla que el ArrayMesh posee.
StringName get_blend_shape_name(index: int) const 🔗
Devuelve el nombre de la forma de mezcla de este indice.
Error lightmap_unwrap(transform: Transform3D, texel_size: float) 🔗
Performs a UV unwrap on the ArrayMesh to prepare the mesh for lightmapping.
void regen_normal_maps() 🔗
Regenera las tangentes para cada una de las superficies del ArrayMesh.
void set_blend_shape_name(index: int, name: StringName) 🔗
Establece el nombre de la blendshape en este indice.
int surface_find_by_name(name: String) const 🔗
Devuelve el indice de la primer superficie con este nombre mantenido dentro de este ArrayMesh. Si no es encontrado, -1 es devuelto.
int surface_get_array_index_len(surf_idx: int) const 🔗
Devuelve la longitud en indices del array de indices de la superificie solicitada( ver add_surface_from_arrays()).
int surface_get_array_len(surf_idx: int) const 🔗
Devuelve la longitud en vertices del array de vertice en la superficie solicitada (veradd_surface_from_arrays()).
BitField[ArrayFormat] surface_get_format(surf_idx: int) const 🔗
Devuelve la mascara de formato de la superficie solicitada (veradd_surface_from_arrays()).
String surface_get_name(surf_idx: int) const 🔗
Obtiene el nombre asignado a esta superficie.
PrimitiveType surface_get_primitive_type(surf_idx: int) const 🔗
Devuelve el tipo primitivo de la superficie solicitada (véase add_surface_from_arrays()).
void surface_remove(surf_idx: int) 🔗
Elimina la superficie en el índice dado de la Mesh, desplazando las superficies con un índice mayor hacia abajo en uno.
void surface_set_name(surf_idx: int, name: String) 🔗
Obtiene un nombre para una superficie dada.
void surface_update_attribute_region(surf_idx: int, offset: int, data: PackedByteArray) 🔗
Updates the attribute buffer of this mesh's surface with the given data. The expected data per attribute is 12 or 8 bytes (4 bytes per float, 2 floats per Vector2, and 3 floats per Vector3) depending on if the mesh is using Vector3 or Vector2 vertices. This value can be determined with RenderingServer.mesh_surface_get_format_attribute_stride().
The starting point of the updates can be changed with offset. The value of offset should be a multiple of 12 bytes in most cases to align to each attribute.
A PackedVector3Array of attribute locations can be converted into a PackedByteArray using PackedVector3Array.to_byte_array() for use in data.
void surface_update_skin_region(surf_idx: int, offset: int, data: PackedByteArray) 🔗
Updates the skin buffer of this mesh's surface with the given data. The expected data per skin is 12 or 8 bytes (4 bytes per float, 2 floats per Vector2, and 3 floats per Vector3) depending on if the mesh is using Vector3 or Vector2 vertices. This value can be determined with RenderingServer.mesh_surface_get_format_skin_stride().
The starting point of the updates can be changed with offset. The value of offset should be a multiple of 12 bytes in most cases to align to each skin.
A PackedVector3Array of skin locations can be converted into a PackedByteArray using PackedVector3Array.to_byte_array() for use in data.
void surface_update_vertex_region(surf_idx: int, offset: int, data: PackedByteArray) 🔗
Updates the vertex buffer of this mesh's surface with the given data. The expected data per vertex is 12 or 8 bytes (4 bytes per float, 2 floats per Vector2, and 3 floats per Vector3) depending on if the mesh is using Vector3 or Vector2 vertices. This value can be determined with RenderingServer.mesh_surface_get_format_vertex_stride().
The starting point of the updates can be changed with offset. The value of offset should be a multiple of 12 bytes in most cases to align to each vertex.
A PackedVector3Array of vertex locations can be converted into a PackedByteArray using PackedVector3Array.to_byte_array() for use in data.