:github_url: hide .. _class_GLTFAccessor: GLTFAccessor ============ **Hereda:** :ref:`Resource` **<** :ref:`RefCounted` **<** :ref:`Object` Representa un accesor glTF. .. rst-class:: classref-introduction-group Descripción ---------------------- GLTFAccessor is a data structure representing a glTF ``accessor`` that would be found in the ``"accessors"`` array. A buffer is a blob of binary data. A buffer view is a slice of a buffer. An accessor is a typed interpretation of the data in a buffer view. Most custom data stored in glTF does not need accessors, only buffer views (see :ref:`GLTFBufferView`). Accessors are for more advanced use cases such as interleaved mesh data encoded for the GPU. .. rst-class:: classref-introduction-group Tutoriales -------------------- - `Buffers, BufferViews y Accessors en la especificación Khronos glTF `__ - :doc:`Carga y guardado de archivos en tiempo de ejecución <../tutorials/io/runtime_file_loading_and_saving>` .. rst-class:: classref-reftable-group Propiedades ---------------------- .. table:: :widths: auto +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`GLTFAccessorType` | :ref:`accessor_type` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`buffer_view` | ``-1`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`byte_offset` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`GLTFComponentType` | :ref:`component_type` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`count` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`PackedFloat64Array` | :ref:`max` | ``PackedFloat64Array()`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`PackedFloat64Array` | :ref:`min` | ``PackedFloat64Array()`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`bool` | :ref:`normalized` | ``false`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`sparse_count` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`sparse_indices_buffer_view` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`sparse_indices_byte_offset` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`GLTFComponentType` | :ref:`sparse_indices_component_type` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`sparse_values_buffer_view` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`sparse_values_byte_offset` | ``0`` | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ | :ref:`int` | :ref:`type` | | +---------------------------------------------------------------+-------------------------------------------------------------------------------------------------+--------------------------+ .. rst-class:: classref-reftable-group Métodos -------------- .. table:: :widths: auto +-----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`GLTFAccessor` | :ref:`from_dictionary`\ (\ dictionary\: :ref:`Dictionary`\ ) |static| | +-----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Dictionary` | :ref:`to_dictionary`\ (\ ) |const| | +-----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Enumeraciones -------------------------- .. _enum_GLTFAccessor_GLTFAccessorType: .. rst-class:: classref-enumeration enum **GLTFAccessorType**: :ref:`🔗` .. _class_GLTFAccessor_constant_TYPE_SCALAR: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_SCALAR** = ``0`` Tipo de accessor "SCALAR". Para el modelo de objeto glTF, esto puede utilizarse para mapear a un único valor float, int o bool, o a un array de floats. .. _class_GLTFAccessor_constant_TYPE_VEC2: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_VEC2** = ``1`` Tipo de accessor "VEC2". Para el modelo de objeto glTF, esto se mapea a "float2", representado en el JSON de glTF como un array de dos floats. .. _class_GLTFAccessor_constant_TYPE_VEC3: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_VEC3** = ``2`` Tipo de accessor "VEC3". Para el modelo de objeto glTF, esto se mapea a "float3", representado en el JSON de glTF como un array de tres floats. .. _class_GLTFAccessor_constant_TYPE_VEC4: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_VEC4** = ``3`` Tipo de accessor "VEC4". Para el modelo de objeto glTF, esto se mapea a "float4", representado en el JSON de glTF como un array de cuatro floats. .. _class_GLTFAccessor_constant_TYPE_MAT2: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_MAT2** = ``4`` Tipo de accessor "MAT2". Para el modelo de objeto glTF, esto se mapea a "float2x2", representado en el JSON de glTF como un array de cuatro floats. .. _class_GLTFAccessor_constant_TYPE_MAT3: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_MAT3** = ``5`` Tipo de accessor "MAT3". Para el modelo de objeto glTF, esto se mapea a "float3x3", representado en el JSON de glTF como un array de nueve floats. .. _class_GLTFAccessor_constant_TYPE_MAT4: .. rst-class:: classref-enumeration-constant :ref:`GLTFAccessorType` **TYPE_MAT4** = ``6`` Tipo de accessor "MAT4". Para el modelo de objeto glTF, esto se mapea a "float4x4", representado en el JSON de glTF como un array de dieciséis floats. .. rst-class:: classref-item-separator ---- .. _enum_GLTFAccessor_GLTFComponentType: .. rst-class:: classref-enumeration enum **GLTFComponentType**: :ref:`🔗` .. _class_GLTFAccessor_constant_COMPONENT_TYPE_NONE: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_NONE** = ``0`` Tipo de componente "NONE". Este no es un tipo de componente válido, y se utiliza para indicar que el tipo de componente no está establecido. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_SIGNED_BYTE: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_SIGNED_BYTE** = ``5120`` Tipo de componente "BYTE". El valor es ``0x1400`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros con signo de 1 byte u 8 bits. Esta es una parte fundamental de la especificación glTF. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_UNSIGNED_BYTE: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_UNSIGNED_BYTE** = ``5121`` Tipo de componente "UNSIGNED_BYTE". El valor es ``0x1401`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros sin signo de 1 byte u 8 bits. Esta es una parte fundamental de la especificación glTF. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_SIGNED_SHORT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_SIGNED_SHORT** = ``5122`` Tipo de componente "SHORT". El valor es ``0x1402`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros con signo de 2 bytes o 16 bits. Esta es una parte fundamental de la especificación glTF. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_UNSIGNED_SHORT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_UNSIGNED_SHORT** = ``5123`` Tipo de componente "UNSIGNED_SHORT". El valor es ``0x1403`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros sin signo de 2 bytes o 16 bits. Esta es una parte fundamental de la especificación glTF. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_SIGNED_INT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_SIGNED_INT** = ``5124`` Tipo de componente "INT". El valor es ``0x1404`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros con signo de 4 bytes o 32 bits. Esta NO es una parte fundamental de la especificación glTF, y puede que no sea compatible con todos los importadores de glTF. Puede ser utilizado por algunas extensiones, incluyendo ``KHR_interactivity``. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_UNSIGNED_INT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_UNSIGNED_INT** = ``5125`` Tipo de componente "UNSIGNED_INT". El valor es ``0x1405`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros sin signo de 4 bytes o 32 bits. Esta es una parte fundamental de la especificación glTF. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_SINGLE_FLOAT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_SINGLE_FLOAT** = ``5126`` Tipo de componente "FLOAT". El valor es ``0x1406`` que proviene de OpenGL. Esto indica que los datos se almacenan en números de punto flotante de 4 bytes o 32 bits. Esta es una parte fundamental de la especificación glTF. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_DOUBLE_FLOAT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_DOUBLE_FLOAT** = ``5130`` Tipo de componente "DOUBLE". El valor es ``0x140A`` que proviene de OpenGL. Esto indica que los datos se almacenan en números de punto flotante de 8 bytes o 64 bits. Esta NO es una parte fundamental de la especificación glTF, y puede que no sea compatible con todos los importadores de glTF. Puede ser utilizado por algunas extensiones, incluyendo ``KHR_interactivity``. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_HALF_FLOAT: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_HALF_FLOAT** = ``5131`` Tipo de componente "HALF_FLOAT". El valor es ``0x140B`` que proviene de OpenGL. Esto indica que los datos se almacenan en números de punto flotante de 2 bytes o 16 bits. Esta NO es una parte fundamental de la especificación glTF, y puede que no sea compatible con todos los importadores de glTF. Puede ser utilizado por algunas extensiones, incluyendo ``KHR_interactivity``. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_SIGNED_LONG: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_SIGNED_LONG** = ``5134`` Tipo de componente "LONG". El valor es ``0x140E`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros con signo de 8 bytes o 64 bits. Esta NO es una parte fundamental de la especificación glTF, y puede que no sea compatible con todos los importadores de glTF. Puede ser utilizado por algunas extensiones, incluyendo ``KHR_interactivity``. .. _class_GLTFAccessor_constant_COMPONENT_TYPE_UNSIGNED_LONG: .. rst-class:: classref-enumeration-constant :ref:`GLTFComponentType` **COMPONENT_TYPE_UNSIGNED_LONG** = ``5135`` Tipo de componente "UNSIGNED_LONG". El valor es ``0x140F`` que proviene de OpenGL. Esto indica que los datos se almacenan en enteros sin signo de 8 bytes o 64 bits. Esta NO es una parte fundamental de la especificación glTF, y puede que no sea compatible con todos los importadores de glTF. Puede ser utilizado por algunas extensiones, incluyendo ``KHR_interactivity``. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descripciones de Propiedades -------------------------------------------------------- .. _class_GLTFAccessor_property_accessor_type: .. rst-class:: classref-property :ref:`GLTFAccessorType` **accessor_type** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_accessor_type**\ (\ value\: :ref:`GLTFAccessorType`\ ) - :ref:`GLTFAccessorType` **get_accessor_type**\ (\ ) El tipo de accessor glTF, como un enum. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_buffer_view: .. rst-class:: classref-property :ref:`int` **buffer_view** = ``-1`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_buffer_view**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_buffer_view**\ (\ ) El índice de la vista de búfer a la que hace referencia este accessor. Si es ``-1``, este accessor no hace referencia a ninguna vista de búfer. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_byte_offset: .. rst-class:: classref-property :ref:`int` **byte_offset** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_byte_offset**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_byte_offset**\ (\ ) El offset relativo al inicio de la vista de búfer en bytes. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_component_type: .. rst-class:: classref-property :ref:`GLTFComponentType` **component_type** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_component_type**\ (\ value\: :ref:`GLTFComponentType`\ ) - :ref:`GLTFComponentType` **get_component_type**\ (\ ) El tipo de componente glTF como un enum. Véase :ref:`GLTFComponentType` para ver los valores posibles. Dentro de la especificación central de glTF, un valor de 5125 o "UNSIGNED_INT" no debe utilizarse para ningún accessor al que no haga referencia mesh.primitive.indices. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_count: .. rst-class:: classref-property :ref:`int` **count** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_count**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_count**\ (\ ) El número de elementos a los que hace referencia este accessor. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_max: .. rst-class:: classref-property :ref:`PackedFloat64Array` **max** = ``PackedFloat64Array()`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_max**\ (\ value\: :ref:`PackedFloat64Array`\ ) - :ref:`PackedFloat64Array` **get_max**\ (\ ) Valor máximo de cada componente en este accessor. **Note:** The returned array is *copied* and any changes to it will not update the original property value. See :ref:`PackedFloat64Array` for more details. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_min: .. rst-class:: classref-property :ref:`PackedFloat64Array` **min** = ``PackedFloat64Array()`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_min**\ (\ value\: :ref:`PackedFloat64Array`\ ) - :ref:`PackedFloat64Array` **get_min**\ (\ ) Valor mínimo de cada componente en este accessor. **Note:** The returned array is *copied* and any changes to it will not update the original property value. See :ref:`PackedFloat64Array` for more details. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_normalized: .. rst-class:: classref-property :ref:`bool` **normalized** = ``false`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_normalized**\ (\ value\: :ref:`bool`\ ) - :ref:`bool` **get_normalized**\ (\ ) Especifica si los valores de datos enteros se normalizan antes de su uso. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_sparse_count: .. rst-class:: classref-property :ref:`int` **sparse_count** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_sparse_count**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_sparse_count**\ (\ ) Número de valores de accessor que se desvían almacenados en el array disperso. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_sparse_indices_buffer_view: .. rst-class:: classref-property :ref:`int` **sparse_indices_buffer_view** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_sparse_indices_buffer_view**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_sparse_indices_buffer_view**\ (\ ) El índice de la vista de búfer con índices dispersos. La vista de búfer a la que se hace referencia NO DEBE tener definidas sus propiedades target o byteStride. La vista de búfer y el byteOffset opcional DEBEN estar alineados con la longitud de bytes de componentType. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_sparse_indices_byte_offset: .. rst-class:: classref-property :ref:`int` **sparse_indices_byte_offset** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_sparse_indices_byte_offset**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_sparse_indices_byte_offset**\ (\ ) El offset relativo al inicio de la vista de búfer en bytes. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_sparse_indices_component_type: .. rst-class:: classref-property :ref:`GLTFComponentType` **sparse_indices_component_type** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_sparse_indices_component_type**\ (\ value\: :ref:`GLTFComponentType`\ ) - :ref:`GLTFComponentType` **get_sparse_indices_component_type**\ (\ ) El tipo de datos del componente de índices como un enum. Los valores posibles son 5121 para "UNSIGNED_BYTE", 5123 para "UNSIGNED_SHORT" y 5125 para "UNSIGNED_INT". .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_sparse_values_buffer_view: .. rst-class:: classref-property :ref:`int` **sparse_values_buffer_view** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_sparse_values_buffer_view**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_sparse_values_buffer_view**\ (\ ) El índice de la vista de búfer con valores dispersos. La vista de búfer a la que se hace referencia NO DEBE tener definidas sus propiedades target o byteStride. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_sparse_values_byte_offset: .. rst-class:: classref-property :ref:`int` **sparse_values_byte_offset** = ``0`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_sparse_values_byte_offset**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_sparse_values_byte_offset**\ (\ ) El desplazamiento relativo al inicio de bufferView en bytes. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_property_type: .. rst-class:: classref-property :ref:`int` **type** :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_type**\ (\ value\: :ref:`int`\ ) - :ref:`int` **get_type**\ (\ ) **Obsoleto:** Use :ref:`accessor_type` instead. El tipo de accessor glTF, como un :ref:`int`. Los valores posibles son ``0`` para "SCALAR", ``1`` para "VEC2", ``2`` para "VEC3", ``3`` para "VEC4", ``4`` para "MAT2", ``5`` para "MAT3" y ``6`` para "MAT4". .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descripciones de Métodos ------------------------------------------------ .. _class_GLTFAccessor_method_from_dictionary: .. rst-class:: classref-method :ref:`GLTFAccessor` **from_dictionary**\ (\ dictionary\: :ref:`Dictionary`\ ) |static| :ref:`🔗` Creates a new GLTFAccessor instance by parsing the given :ref:`Dictionary`. .. rst-class:: classref-item-separator ---- .. _class_GLTFAccessor_method_to_dictionary: .. rst-class:: classref-method :ref:`Dictionary` **to_dictionary**\ (\ ) |const| :ref:`🔗` Serializes this GLTFAccessor instance into a :ref:`Dictionary`. .. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)` .. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)` .. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)` .. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)` .. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)` .. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)` .. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)` .. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)` .. |void| replace:: :abbr:`void (Sin valor de retorno.)`