Acceder a las propiedades de Godot gdnative Rust definidas en el editor.

15 Jun, 2023 Programación 0

Como traductor de español que traduce documentos de TI, traduzca lo siguiente al español. No traduzca el código ni la salida en formato Markdown.

Para aprender sobre el motor, estoy intentando realizar un proyecto muy simple: generar de forma procedural una esfera utilizando el editor y los enlaces de Rust nativos GD. Estoy intentando seguir este tutorial que utiliza GDScript y convertir el código a Rust.

Tengo problemas para averiguar cómo acceder a una propiedad definida en el editor. Llevo una semana leyendo la documentación y buscando en la web, pero algo me escapa y no soy capaz de entender cómo proceder.

Lo que quiero hacer es acceder a la propiedad “mesh”, de tipo ArrayMesh, igual que en el tutorial que he enlazado antes, y unir a ella las matrices que he generado para los vértices, es decir, unir esas matrices a ArrayMesh. Aquí está mi escena:

[Escena cargada=4 formato=2]

[ext_resource path=”res://procedural_earth.gdnlib” type=”GDNativeLibrary” id=1]

[sub_resource type=”ArrayMesh” id=4]

[sub_resource type=”NativeScript” id=3]
resource_name = “ProcEarth”
class_name = “ProcEarth”
library = ExtResource( 1 )

[node name=”Earth” type=”Spatial”]

[node name=”Sphere” type=”MeshInstance” parent=”.”]
mesh = SubResource( 4 )
script = SubResource( 3 )

[node name=”Camera” type=”Camera” parent=”.”]
transform = Transform( 0.572229, -0.327396, 0.751909, 0, 0.916856, 0.399217, -0.820094, -0.228443, 0.524651, 4.71648, 2.5, 3.45846 )
current = true

La estructura ArrayMesh que me interesa se llama “mesh” en la escena anterior y es parte del nodo llamado “Sphere” (mencionándolo solo por claridad).

Tengo el siguiente código Rust:

#[derive(NativeClass)]
#[inherit(MeshInstance)]
#[register_with(register_properties)]
struct ProcEarth {
// …
}

impl ProcEarth {

// ...

#[export]
fn _ready(&mut self, owner: &MeshInstance) {

   let mut arr = VariantArray::new_shared();
   // ...
   let blend_shapes = VariantArray::new_shared();
   owner.add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, arr, blend_shapes, 0);

}
}

Pero eso no funciona ya que el error que obtengo es: “No se encontró ningún método llamado ‘add_surface_from_arrays’ para la referencia ‘&gdnative::gdnative_bindings::MeshInstance’ en el alcance actual”.

¿Alguien sabe cómo podría acceder en el código Rust a esa propiedad del editor para establecer correctamente mi ArrayMesh? ¿Hay algún tutorial, artículo o video que lo ejemplifique?

Cualquier ayuda es altamente apreciada ya que actualmente estoy atascado en esta técnica y no puedo avanzar en mi aprendizaje.

Estoy usando la versión de Godot v3.4.stable.official con el gdnative 0.9.3 en Linux.

davy.ai

June 15, 2023 at 9:25 pm

Para acceder a la propiedad mesh en el código Rust, se pueden usar los métodos get_node y get proporcionados por la clase Node para recuperar el nodo MeshInstance y el recurso ArrayMesh respectivamente. Aquí hay un ejemplo de código:

#[derive(NativeClass)]
#[inherit(Node)]
struct ProcEarth {
    mesh_instance: Option<><meshinstance>>,
}

#[methods]
impl ProcEarth {
    fn new(_owner: &Node) -> Self {
        Self {
            mesh_instance: None,
        }
    }

    #[export]
    fn _ready(&mut self, owner: TRef<node>) {
        // Obtener el nodo MeshInstance
        if let Some(mesh_instance) = owner.get_node("Sphere/MeshInstance")
            .and_then(|node| node.cast::<meshinstance>())
        {
            self.mesh_instance = Some(mesh_instance);
        }
    }

    fn update_mesh(&mut self) {
        if let Some(mesh_instance) = &self.mesh_instance {
            // Obtener el recurso ArrayMesh
            if let Some(array_mesh) = mesh_instance.mesh().and_then(|res| res.cast::<gd::arraymesh>()) {
                // Modificar los datos del array según sea necesario
                // ...
                // Vincular los datos modificados al ArrayMesh
                if let Some(surface) = array_mesh.surface_get_mut(0) {
                    surface.set_arrays(gd::Mesh::PRIMITIVE_TRIANGLES, &[/* vertex array */], &[/* blend shape array */]);
                }
            }
        }
    }
}

En este ejemplo, se define una clase ProcEarth que almacena una referencia al nodo MeshInstance y la usa para acceder a la propiedad mesh. En el método _ready, se recupera el nodo MeshInstance usando el método get_node y se almacena en el campo mesh_instance. En el método update_mesh (no se muestra en el código), se recupera el recurso ArrayMesh usando el método mesh de MeshInstance y se modifican los datos del array según sea necesario antes de vincularlos al ArrayMesh usando el método set_arrays de la clase Surface.

Tenga en cuenta que el ejemplo de código asume que el nodo Sphere y el nodo MeshInstance son hijos directos del nodo ProcEarth. Es posible que deba ajustar las cadenas de ruta de nodo para que coincidan con la jerarquía de su escena.

Answer

davy.ai

June 15, 2023 at 9:25 pm
Para acceder a la propiedad mesh en el código Rust, se pueden usar los métodos get_node y get proporcionados por la clase Node para recuperar el nodo MeshInstance y el recurso ArrayMesh respectivamente. Aquí hay un ejemplo de código:
```
#[derive(NativeClass)]
#[inherit(Node)]
struct ProcEarth {
    mesh_instance: Option<><meshinstance>>,
}

#[methods]
impl ProcEarth {
    fn new(_owner: &Node) -> Self {
        Self {
            mesh_instance: None,
        }
    }

    #[export]
    fn _ready(&mut self, owner: TRef<node>) {
        // Obtener el nodo MeshInstance
        if let Some(mesh_instance) = owner.get_node("Sphere/MeshInstance")
            .and_then(|node| node.cast::<meshinstance>())
        {
            self.mesh_instance = Some(mesh_instance);
        }
    }

    fn update_mesh(&mut self) {
        if let Some(mesh_instance) = &self.mesh_instance {
            // Obtener el recurso ArrayMesh
            if let Some(array_mesh) = mesh_instance.mesh().and_then(|res| res.cast::<gd::arraymesh>()) {
                // Modificar los datos del array según sea necesario
                // ...
                // Vincular los datos modificados al ArrayMesh
                if let Some(surface) = array_mesh.surface_get_mut(0) {
                    surface.set_arrays(gd::Mesh::PRIMITIVE_TRIANGLES, &[/* vertex array */], &[/* blend shape array */]);
                }
            }
        }
    }
}
```
En este ejemplo, se define una clase ProcEarth que almacena una referencia al nodo MeshInstance y la usa para acceder a la propiedad mesh. En el método _ready, se recupera el nodo MeshInstance usando el método get_node y se almacena en el campo mesh_instance. En el método update_mesh (no se muestra en el código), se recupera el recurso ArrayMesh usando el método mesh de MeshInstance y se modifican los datos del array según sea necesario antes de vincularlos al ArrayMesh usando el método set_arrays de la clase Surface.

Tenga en cuenta que el ejemplo de código asume que el nodo Sphere y el nodo MeshInstance son hijos directos del nodo ProcEarth. Es posible que deba ajustar las cadenas de ruta de nodo para que coincidan con la jerarquía de su escena.

Comments are closed.

es.davy.ai

¿Tienes una pregunta?

Acceder a las propiedades de Godot gdnative Rust definidas en el editor.

Answer

davy.ai